drivers/vlynq/vlynq.c

   1 /*
   2  * Copyright (C) 2006, 2007 Eugene Konev <ejka@openwrt.org>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Parts of the VLYNQ specification can be found here:
  19  * http://www.ti.com/litv/pdf/sprue36a
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/types.h>
  24 #include <linux/kernel.h>
  25 #include <linux/string.h>
  26 #include <linux/device.h>
  27 #include <linux/module.h>
  28 #include <linux/errno.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/delay.h>
  32 #include <linux/io.h>
  33 #include <linux/slab.h>
  34 #include <linux/irq.h>
  35
  36 #include <linux/vlynq.h>
  37
  38 #define VLYNQ_CTRL_PM_ENABLE            0x80000000
  39 #define VLYNQ_CTRL_CLOCK_INT            0x00008000
  40 #define VLYNQ_CTRL_CLOCK_DIV(x)         (((x) & 7) << 16)
  41 #define VLYNQ_CTRL_INT_LOCAL            0x00004000
  42 #define VLYNQ_CTRL_INT_ENABLE           0x00002000
  43 #define VLYNQ_CTRL_INT_VECTOR(x)        (((x) & 0x1f) << 8)
  44 #define VLYNQ_CTRL_INT2CFG              0x00000080
  45 #define VLYNQ_CTRL_RESET                0x00000001
  46
  47 #define VLYNQ_CTRL_CLOCK_MASK          (0x7 << 16)
  48
  49 #define VLYNQ_INT_OFFSET                0x00000014
  50 #define VLYNQ_REMOTE_OFFSET             0x00000080
  51
  52 #define VLYNQ_STATUS_LINK               0x00000001
  53 #define VLYNQ_STATUS_LERROR             0x00000080
  54 #define VLYNQ_STATUS_RERROR             0x00000100
  55
  56 #define VINT_ENABLE                     0x00000100
  57 #define VINT_TYPE_EDGE                  0x00000080
  58 #define VINT_LEVEL_LOW                  0x00000040
  59 #define VINT_VECTOR(x)                  ((x) & 0x1f)
  60 #define VINT_OFFSET(irq)                (8 * ((irq) % 4))
  61
  62 #define VLYNQ_AUTONEGO_V2               0x00010000
  63
  64 struct vlynq_regs {
  65         u32 revision;
  66         u32 control;
  67         u32 status;
  68         u32 int_prio;
  69         u32 int_status;
  70         u32 int_pending;
  71         u32 int_ptr;
  72         u32 tx_offset;
  73         struct vlynq_mapping rx_mapping[4];
  74         u32 chip;
  75         u32 autonego;
  76         u32 unused[6];
  77         u32 int_device[8];
  78 };
  79
  80 #ifdef CONFIG_VLYNQ_DEBUG
  81 static void vlynq_dump_regs(struct vlynq_device *dev)
  82 {
  83         int i;
  84
  85         printk(KERN_DEBUG "VLYNQ local=%p remote=%p\n",
  86                         dev->local, dev->remote);
  87         for (i = 0; i < 32; i++) {
  88                 printk(KERN_DEBUG "VLYNQ: local %d: %08x\n",
  89                         i + 1, ((u32 *)dev->local)[i]);
  90                 printk(KERN_DEBUG "VLYNQ: remote %d: %08x\n",
  91                         i + 1, ((u32 *)dev->remote)[i]);
  92         }
  93 }
  94
  95 static void vlynq_dump_mem(u32 *base, int count)
  96 {
  97         int i;
  98
  99         for (i = 0; i < (count + 3) / 4; i++) {
 100                 if (i % 4 == 0)
 101                         printk(KERN_DEBUG "\nMEM[0x%04x]:", i * 4);
 102                 printk(KERN_DEBUG " 0x%08x", *(base + i));
 103         }
 104         printk(KERN_DEBUG "\n");
 105 }
 106 #endif
 107
 108 /* Check the VLYNQ link status with a given device */
 109 static int vlynq_linked(struct vlynq_device *dev)
 110 {
 111         int i;
 112
 113         for (i = 0; i < 100; i++)
 114                 if (readl(&dev->local->status) & VLYNQ_STATUS_LINK)
 115                         return 1;
 116                 else
 117                         cpu_relax();
 118
 119         return 0;
 120 }
 121
 122 static void vlynq_reset(struct vlynq_device *dev)
 123 {
 124         writel(readl(&dev->local->control) | VLYNQ_CTRL_RESET,
 125                         &dev->local->control);
 126
 127         /* Wait for the devices to finish resetting */
 128         msleep(5);
 129
 130         /* Remove reset bit */
 131         writel(readl(&dev->local->control) & ~VLYNQ_CTRL_RESET,
 132                         &dev->local->control);
 133
 134         /* Give some time for the devices to settle */
 135         msleep(5);
 136 }
 137
 138 static void vlynq_irq_unmask(struct irq_data *d)
 139 {
 140         struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
 141         int virq;
 142         u32 val;
 143
 144         BUG_ON(!dev);
 145         virq = d->irq - dev->irq_start;
 146         val = readl(&dev->remote->int_device[virq >> 2]);
 147         val |= (VINT_ENABLE | virq) << VINT_OFFSET(virq);
 148         writel(val, &dev->remote->int_device[virq >> 2]);
 149 }
 150
 151 static void vlynq_irq_mask(struct irq_data *d)
 152 {
 153         struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
 154         int virq;
 155         u32 val;
 156
 157         BUG_ON(!dev);
 158         virq = d->irq - dev->irq_start;
 159         val = readl(&dev->remote->int_device[virq >> 2]);
 160         val &= ~(VINT_ENABLE << VINT_OFFSET(virq));
 161         writel(val, &dev->remote->int_device[virq >> 2]);
 162 }
 163
 164 static int vlynq_irq_type(struct irq_data *d, unsigned int flow_type)
 165 {
 166         struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
 167         int virq;
 168         u32 val;
 169
 170         BUG_ON(!dev);
 171         virq = d->irq - dev->irq_start;
 172         val = readl(&dev->remote->int_device[virq >> 2]);
 173         switch (flow_type & IRQ_TYPE_SENSE_MASK) {
 174         case IRQ_TYPE_EDGE_RISING:
 175         case IRQ_TYPE_EDGE_FALLING:
 176         case IRQ_TYPE_EDGE_BOTH:
 177                 val |= VINT_TYPE_EDGE << VINT_OFFSET(virq);
 178                 val &= ~(VINT_LEVEL_LOW << VINT_OFFSET(virq));
 179                 break;
 180         case IRQ_TYPE_LEVEL_HIGH:
 181                 val &= ~(VINT_TYPE_EDGE << VINT_OFFSET(virq));
 182                 val &= ~(VINT_LEVEL_LOW << VINT_OFFSET(virq));
 183                 break;
 184         case IRQ_TYPE_LEVEL_LOW:
 185                 val &= ~(VINT_TYPE_EDGE << VINT_OFFSET(virq));
 186                 val |= VINT_LEVEL_LOW << VINT_OFFSET(virq);
 187                 break;
 188         default:
 189                 return -EINVAL;
 190         }
 191         writel(val, &dev->remote->int_device[virq >> 2]);
 192         return 0;
 193 }
 194
 195 static void vlynq_local_ack(struct irq_data *d)
 196 {
 197         struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
 198         u32 status = readl(&dev->local->status);
 199
 200         pr_debug("%s: local status: 0x%08x\n",
 201                        dev_name(&dev->dev), status);
 202         writel(status, &dev->local->status);
 203 }
 204
 205 static void vlynq_remote_ack(struct irq_data *d)
 206 {
 207         struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
 208         u32 status = readl(&dev->remote->status);
 209
 210         pr_debug("%s: remote status: 0x%08x\n",
 211                        dev_name(&dev->dev), status);
 212         writel(status, &dev->remote->status);
 213 }
 214
 215 static irqreturn_t vlynq_irq(int irq, void *dev_id)
 216 {
 217         struct vlynq_device *dev = dev_id;
 218         u32 status;
 219         int virq = 0;
 220
 221         status = readl(&dev->local->int_status);
 222         writel(status, &dev->local->int_status);
 223
 224         if (unlikely(!status))
 225                 spurious_interrupt();
 226
 227         while (status) {
 228                 if (status & 1)
 229                         do_IRQ(dev->irq_start + virq);
 230                 status >>= 1;
 231                 virq++;
 232         }
 233
 234         return IRQ_HANDLED;
 235 }
 236
 237 static struct irq_chip vlynq_irq_chip = {
 238         .name = "vlynq",
 239         .irq_unmask = vlynq_irq_unmask,
 240         .irq_mask = vlynq_irq_mask,
 241         .irq_set_type = vlynq_irq_type,
 242 };
 243
 244 static struct irq_chip vlynq_local_chip = {
 245         .name = "vlynq local error",
 246         .irq_unmask = vlynq_irq_unmask,
 247         .irq_mask = vlynq_irq_mask,
 248         .irq_ack = vlynq_local_ack,
 249 };
 250
 251 static struct irq_chip vlynq_remote_chip = {
 252         .name = "vlynq local error",
 253         .irq_unmask = vlynq_irq_unmask,
 254         .irq_mask = vlynq_irq_mask,
 255         .irq_ack = vlynq_remote_ack,
 256 };
 257
 258 static int vlynq_setup_irq(struct vlynq_device *dev)
 259 {
 260         u32 val;
 261         int i, virq;
 262
 263         if (dev->local_irq == dev->remote_irq) {
 264                 printk(KERN_ERR
 265                        "%s: local vlynq irq should be different from remote\n",
 266                        dev_name(&dev->dev));
 267                 return -EINVAL;
 268         }
 269
 270         /* Clear local and remote error bits */
 271         writel(readl(&dev->local->status), &dev->local->status);
 272         writel(readl(&dev->remote->status), &dev->remote->status);
 273
 274         /* Now setup interrupts */
 275         val = VLYNQ_CTRL_INT_VECTOR(dev->local_irq);
 276         val |= VLYNQ_CTRL_INT_ENABLE | VLYNQ_CTRL_INT_LOCAL |
 277                 VLYNQ_CTRL_INT2CFG;
 278         val |= readl(&dev->local->control);
 279         writel(VLYNQ_INT_OFFSET, &dev->local->int_ptr);
 280         writel(val, &dev->local->control);
 281
 282         val = VLYNQ_CTRL_INT_VECTOR(dev->remote_irq);
 283         val |= VLYNQ_CTRL_INT_ENABLE;
 284         val |= readl(&dev->remote->control);
 285         writel(VLYNQ_INT_OFFSET, &dev->remote->int_ptr);
 286         writel(val, &dev->remote->int_ptr);
 287         writel(val, &dev->remote->control);
 288
 289         for (i = dev->irq_start; i <= dev->irq_end; i++) {
 290                 virq = i - dev->irq_start;
 291                 if (virq == dev->local_irq) {
 292                         irq_set_chip_and_handler(i, &vlynq_local_chip,
 293                                                  handle_level_irq);
 294                         irq_set_chip_data(i, dev);
 295                 } else if (virq == dev->remote_irq) {
 296                         irq_set_chip_and_handler(i, &vlynq_remote_chip,
 297                                                  handle_level_irq);
 298                         irq_set_chip_data(i, dev);
 299                 } else {
 300                         irq_set_chip_and_handler(i, &vlynq_irq_chip,
 301                                                  handle_simple_irq);
 302                         irq_set_chip_data(i, dev);
 303                         writel(0, &dev->remote->int_device[virq >> 2]);
 304                 }
 305         }
 306
 307         if (request_irq(dev->irq, vlynq_irq, IRQF_SHARED, "vlynq", dev)) {
 308                 printk(KERN_ERR "%s: request_irq failed\n",
 309                                         dev_name(&dev->dev));
 310                 return -EAGAIN;
 311         }
 312
 313         return 0;
 314 }
 315
 316 static void vlynq_device_release(struct device *dev)
 317 {
 318         struct vlynq_device *vdev = to_vlynq_device(dev);
 319         kfree(vdev);
 320 }
 321
 322 static int vlynq_device_match(struct device *dev,
 323                               struct device_driver *drv)
 324 {
 325         struct vlynq_device *vdev = to_vlynq_device(dev);
 326         struct vlynq_driver *vdrv = to_vlynq_driver(drv);
 327         struct vlynq_device_id *ids = vdrv->id_table;
 328
 329         while (ids->id) {
 330                 if (ids->id == vdev->dev_id) {
 331                         vdev->divisor = ids->divisor;
 332                         vlynq_set_drvdata(vdev, ids);
 333                         printk(KERN_INFO "Driver found for VLYNQ "
 334                                 "device: %08x\n", vdev->dev_id);
 335                         return 1;
 336                 }
 337                 printk(KERN_DEBUG "Not using the %08x VLYNQ device's driver"
 338                         " for VLYNQ device: %08x\n", ids->id, vdev->dev_id);
 339                 ids++;
 340         }
 341         return 0;
 342 }
 343
 344 static int vlynq_device_probe(struct device *dev)
 345 {
 346         struct vlynq_device *vdev = to_vlynq_device(dev);
 347         struct vlynq_driver *drv = to_vlynq_driver(dev->driver);
 348         struct vlynq_device_id *id = vlynq_get_drvdata(vdev);
 349         int result = -ENODEV;
 350
 351         if (drv->probe)
 352                 result = drv->probe(vdev, id);
 353         if (result)
 354                 put_device(dev);
 355         return result;
 356 }
 357
 358 static int vlynq_device_remove(struct device *dev)
 359 {
 360         struct vlynq_driver *drv = to_vlynq_driver(dev->driver);
 361
 362         if (drv->remove)
 363                 drv->remove(to_vlynq_device(dev));
 364
 365         return 0;
 366 }
 367
 368 int __vlynq_register_driver(struct vlynq_driver *driver, struct module *owner)
 369 {
 370         driver->driver.name = driver->name;
 371         driver->driver.bus = &vlynq_bus_type;
 372         return driver_register(&driver->driver);
 373 }
 374 EXPORT_SYMBOL(__vlynq_register_driver);
 375
 376 void vlynq_unregister_driver(struct vlynq_driver *driver)
 377 {
 378         driver_unregister(&driver->driver);
 379 }
 380 EXPORT_SYMBOL(vlynq_unregister_driver);
 381
 382 /*
 383  * A VLYNQ remote device can clock the VLYNQ bus master
 384  * using a dedicated clock line. In that case, both the
 385  * remove device and the bus master should have the same
 386  * serial clock dividers configured. Iterate through the
 387  * 8 possible dividers until we actually link with the
 388  * device.
 389  */
 390 static int __vlynq_try_remote(struct vlynq_device *dev)
 391 {
 392         int i;
 393
 394         vlynq_reset(dev);
 395         for (i = dev->dev_id ? vlynq_rdiv2 : vlynq_rdiv8; dev->dev_id ?
 396                         i <= vlynq_rdiv8 : i >= vlynq_rdiv2;
 397                 dev->dev_id ? i++ : i--) {
 398
 399                 if (!vlynq_linked(dev))
 400                         break;
 401
 402                 writel((readl(&dev->remote->control) &
 403                                 ~VLYNQ_CTRL_CLOCK_MASK) |
 404                                 VLYNQ_CTRL_CLOCK_INT |
 405                                 VLYNQ_CTRL_CLOCK_DIV(i - vlynq_rdiv1),
 406                                 &dev->remote->control);
 407                 writel((readl(&dev->local->control)
 408                                 & ~(VLYNQ_CTRL_CLOCK_INT |
 409                                 VLYNQ_CTRL_CLOCK_MASK)) |
 410                                 VLYNQ_CTRL_CLOCK_DIV(i - vlynq_rdiv1),
 411                                 &dev->local->control);
 412
 413                 if (vlynq_linked(dev)) {
 414                         printk(KERN_DEBUG
 415                                 "%s: using remote clock divisor %d\n",
 416                                 dev_name(&dev->dev), i - vlynq_rdiv1 + 1);
 417                         dev->divisor = i;
 418                         return 0;
 419                 } else {
 420                         vlynq_reset(dev);
 421                 }
 422         }
 423
 424         return -ENODEV;
 425 }
 426
 427 /*
 428  * A VLYNQ remote device can be clocked by the VLYNQ bus
 429  * master using a dedicated clock line. In that case, only
 430  * the bus master configures the serial clock divider.
 431  * Iterate through the 8 possible dividers until we
 432  * actually get a link with the device.
 433  */
 434 static int __vlynq_try_local(struct vlynq_device *dev)
 435 {
 436         int i;
 437
 438         vlynq_reset(dev);
 439
 440         for (i = dev->dev_id ? vlynq_ldiv2 : vlynq_ldiv8; dev->dev_id ?
 441                         i <= vlynq_ldiv8 : i >= vlynq_ldiv2;
 442                 dev->dev_id ? i++ : i--) {
 443
 444                 writel((readl(&dev->local->control) &
 445                                 ~VLYNQ_CTRL_CLOCK_MASK) |
 446                                 VLYNQ_CTRL_CLOCK_INT |
 447                                 VLYNQ_CTRL_CLOCK_DIV(i - vlynq_ldiv1),
 448                                 &dev->local->control);
 449
 450                 if (vlynq_linked(dev)) {
 451                         printk(KERN_DEBUG
 452                                 "%s: using local clock divisor %d\n",
 453                                 dev_name(&dev->dev), i - vlynq_ldiv1 + 1);
 454                         dev->divisor = i;
 455                         return 0;
 456                 } else {
 457                         vlynq_reset(dev);
 458                 }
 459         }
 460
 461         return -ENODEV;
 462 }
 463
 464 /*
 465  * When using external clocking method, serial clock
 466  * is supplied by an external oscillator, therefore we
 467  * should mask the local clock bit in the clock control
 468  * register for both the bus master and the remote device.
 469  */
 470 static int __vlynq_try_external(struct vlynq_device *dev)
 471 {
 472         vlynq_reset(dev);
 473         if (!vlynq_linked(dev))
 474                 return -ENODEV;
 475
 476         writel((readl(&dev->remote->control) &
 477                         ~VLYNQ_CTRL_CLOCK_INT),
 478                         &dev->remote->control);
 479
 480         writel((readl(&dev->local->control) &
 481                         ~VLYNQ_CTRL_CLOCK_INT),
 482                         &dev->local->control);
 483
 484         if (vlynq_linked(dev)) {
 485                 printk(KERN_DEBUG "%s: using external clock\n",
 486                         dev_name(&dev->dev));
 487                         dev->divisor = vlynq_div_external;
 488                 return 0;
 489         }
 490
 491         return -ENODEV;
 492 }
 493
 494 static int __vlynq_enable_device(struct vlynq_device *dev)
 495 {
 496         int result;
 497         struct plat_vlynq_ops *ops = dev->dev.platform_data;
 498
 499         result = ops->on(dev);
 500         if (result)
 501                 return result;
 502
 503         switch (dev->divisor) {
 504         case vlynq_div_external:
 505         case vlynq_div_auto:
 506                 /* When the device is brought from reset it should have clock
 507                  * generation negotiated by hardware.
 508                  * Check which device is generating clocks and perform setup
 509                  * accordingly */
 510                 if (vlynq_linked(dev) && readl(&dev->remote->control) &
 511                    VLYNQ_CTRL_CLOCK_INT) {
 512                         if (!__vlynq_try_remote(dev) ||
 513                                 !__vlynq_try_local(dev)  ||
 514                                 !__vlynq_try_external(dev))
 515                                 return 0;
 516                 } else {
 517                         if (!__vlynq_try_external(dev) ||
 518                                 !__vlynq_try_local(dev)    ||
 519                                 !__vlynq_try_remote(dev))
 520                                 return 0;
 521                 }
 522                 break;
 523         case vlynq_ldiv1:
 524         case vlynq_ldiv2:
 525         case vlynq_ldiv3:
 526         case vlynq_ldiv4:
 527         case vlynq_ldiv5:
 528         case vlynq_ldiv6:
 529         case vlynq_ldiv7:
 530         case vlynq_ldiv8:
 531                 writel(VLYNQ_CTRL_CLOCK_INT |
 532                         VLYNQ_CTRL_CLOCK_DIV(dev->divisor -
 533                         vlynq_ldiv1), &dev->local->control);
 534                 writel(0, &dev->remote->control);
 535                 if (vlynq_linked(dev)) {
 536                         printk(KERN_DEBUG
 537                                 "%s: using local clock divisor %d\n",
 538                                 dev_name(&dev->dev),
 539                                 dev->divisor - vlynq_ldiv1 + 1);
 540                         return 0;
 541                 }
 542                 break;
 543         case vlynq_rdiv1:
 544         case vlynq_rdiv2:
 545         case vlynq_rdiv3:
 546         case vlynq_rdiv4:
 547         case vlynq_rdiv5:
 548         case vlynq_rdiv6:
 549         case vlynq_rdiv7:
 550         case vlynq_rdiv8:
 551                 writel(0, &dev->local->control);
 552                 writel(VLYNQ_CTRL_CLOCK_INT |
 553                         VLYNQ_CTRL_CLOCK_DIV(dev->divisor -
 554                         vlynq_rdiv1), &dev->remote->control);
 555                 if (vlynq_linked(dev)) {
 556                         printk(KERN_DEBUG
 557                                 "%s: using remote clock divisor %d\n",
 558                                 dev_name(&dev->dev),
 559                                 dev->divisor - vlynq_rdiv1 + 1);
 560                         return 0;
 561                 }
 562                 break;
 563         }
 564
 565         ops->off(dev);
 566         return -ENODEV;
 567 }
 568
 569 int vlynq_enable_device(struct vlynq_device *dev)
 570 {
 571         struct plat_vlynq_ops *ops = dev->dev.platform_data;
 572         int result = -ENODEV;
 573
 574         result = __vlynq_enable_device(dev);
 575         if (result)
 576                 return result;
 577
 578         result = vlynq_setup_irq(dev);
 579         if (result)
 580                 ops->off(dev);
 581
 582         dev->enabled = !result;
 583         return result;
 584 }
 585 EXPORT_SYMBOL(vlynq_enable_device);
 586
 587
 588 void vlynq_disable_device(struct vlynq_device *dev)
 589 {
 590         struct plat_vlynq_ops *ops = dev->dev.platform_data;
 591
 592         dev->enabled = 0;
 593         free_irq(dev->irq, dev);
 594         ops->off(dev);
 595 }
 596 EXPORT_SYMBOL(vlynq_disable_device);
 597
 598 int vlynq_set_local_mapping(struct vlynq_device *dev, u32 tx_offset,
 599                             struct vlynq_mapping *mapping)
 600 {
 601         int i;
 602
 603         if (!dev->enabled)
 604                 return -ENXIO;
 605
 606         writel(tx_offset, &dev->local->tx_offset);
 607         for (i = 0; i < 4; i++) {
 608                 writel(mapping[i].offset, &dev->local->rx_mapping[i].offset);
 609                 writel(mapping[i].size, &dev->local->rx_mapping[i].size);
 610         }
 611         return 0;
 612 }
 613 EXPORT_SYMBOL(vlynq_set_local_mapping);
 614
 615 int vlynq_set_remote_mapping(struct vlynq_device *dev, u32 tx_offset,
 616                              struct vlynq_mapping *mapping)
 617 {
 618         int i;
 619
 620         if (!dev->enabled)
 621                 return -ENXIO;
 622
 623         writel(tx_offset, &dev->remote->tx_offset);
 624         for (i = 0; i < 4; i++) {
 625                 writel(mapping[i].offset, &dev->remote->rx_mapping[i].offset);
 626                 writel(mapping[i].size, &dev->remote->rx_mapping[i].size);
 627         }
 628         return 0;
 629 }
 630 EXPORT_SYMBOL(vlynq_set_remote_mapping);
 631
 632 int vlynq_set_local_irq(struct vlynq_device *dev, int virq)
 633 {
 634         int irq = dev->irq_start + virq;
 635         if (dev->enabled)
 636                 return -EBUSY;
 637
 638         if ((irq < dev->irq_start) || (irq > dev->irq_end))
 639                 return -EINVAL;
 640
 641         if (virq == dev->remote_irq)
 642                 return -EINVAL;
 643
 644         dev->local_irq = virq;
 645
 646         return 0;
 647 }
 648 EXPORT_SYMBOL(vlynq_set_local_irq);
 649
 650 int vlynq_set_remote_irq(struct vlynq_device *dev, int virq)
 651 {
 652         int irq = dev->irq_start + virq;
 653         if (dev->enabled)
 654                 return -EBUSY;
 655
 656         if ((irq < dev->irq_start) || (irq > dev->irq_end))
 657                 return -EINVAL;
 658
 659         if (virq == dev->local_irq)
 660                 return -EINVAL;
 661
 662         dev->remote_irq = virq;
 663
 664         return 0;
 665 }
 666 EXPORT_SYMBOL(vlynq_set_remote_irq);
 667
 668 static int vlynq_probe(struct platform_device *pdev)
 669 {
 670         struct vlynq_device *dev;
 671         struct resource *regs_res, *mem_res, *irq_res;
 672         int len, result;
 673
 674         regs_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
 675         if (!regs_res)
 676                 return -ENODEV;
 677
 678         mem_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem");
 679         if (!mem_res)
 680                 return -ENODEV;
 681
 682         irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "devirq");
 683         if (!irq_res)
 684                 return -ENODEV;
 685
 686         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 687         if (!dev) {
 688                 printk(KERN_ERR
 689                        "vlynq: failed to allocate device structure\n");
 690                 return -ENOMEM;
 691         }
 692
 693         dev->id = pdev->id;
 694         dev->dev.bus = &vlynq_bus_type;
 695         dev->dev.parent = &pdev->dev;
 696         dev_set_name(&dev->dev, "vlynq%d", dev->id);
 697         dev->dev.platform_data = pdev->dev.platform_data;
 698         dev->dev.release = vlynq_device_release;
 699
 700         dev->regs_start = regs_res->start;
 701         dev->regs_end = regs_res->end;
 702         dev->mem_start = mem_res->start;
 703         dev->mem_end = mem_res->end;
 704
 705         len = resource_size(regs_res);
 706         if (!request_mem_region(regs_res->start, len, dev_name(&dev->dev))) {
 707                 printk(KERN_ERR "%s: Can't request vlynq registers\n",
 708                        dev_name(&dev->dev));
 709                 result = -ENXIO;
 710                 goto fail_request;
 711         }
 712
 713         dev->local = ioremap(regs_res->start, len);
 714         if (!dev->local) {
 715                 printk(KERN_ERR "%s: Can't remap vlynq registers\n",
 716                        dev_name(&dev->dev));
 717                 result = -ENXIO;
 718                 goto fail_remap;
 719         }
 720
 721         dev->remote = (struct vlynq_regs *)((void *)dev->local +
 722                                             VLYNQ_REMOTE_OFFSET);
 723
 724         dev->irq = platform_get_irq_byname(pdev, "irq");
 725         dev->irq_start = irq_res->start;
 726         dev->irq_end = irq_res->end;
 727         dev->local_irq = dev->irq_end - dev->irq_start;
 728         dev->remote_irq = dev->local_irq - 1;
 729
 730         if (device_register(&dev->dev))
 731                 goto fail_register;
 732         platform_set_drvdata(pdev, dev);
 733
 734         printk(KERN_INFO "%s: regs 0x%p, irq %d, mem 0x%p\n",
 735                dev_name(&dev->dev), (void *)dev->regs_start, dev->irq,
 736                (void *)dev->mem_start);
 737
 738         dev->dev_id = 0;
 739         dev->divisor = vlynq_div_auto;
 740         result = __vlynq_enable_device(dev);
 741         if (result == 0) {
 742                 dev->dev_id = readl(&dev->remote->chip);
 743                 ((struct plat_vlynq_ops *)(dev->dev.platform_data))->off(dev);
 744         }
 745         if (dev->dev_id)
 746                 printk(KERN_INFO "Found a VLYNQ device: %08x\n", dev->dev_id);
 747
 748         return 0;
 749
 750 fail_register:
 751         iounmap(dev->local);
 752 fail_remap:
 753 fail_request:
 754         release_mem_region(regs_res->start, len);
 755         kfree(dev);
 756         return result;
 757 }
 758
 759 static int vlynq_remove(struct platform_device *pdev)
 760 {
 761         struct vlynq_device *dev = platform_get_drvdata(pdev);
 762
 763         device_unregister(&dev->dev);
 764         iounmap(dev->local);
 765         release_mem_region(dev->regs_start,
 766                            dev->regs_end - dev->regs_start + 1);
 767
 768         kfree(dev);
 769
 770         return 0;
 771 }
 772
 773 static struct platform_driver vlynq_platform_driver = {
 774         .driver.name = "vlynq",
 775         .probe = vlynq_probe,
 776         .remove = vlynq_remove,
 777 };
 778
 779 struct bus_type vlynq_bus_type = {
 780         .name = "vlynq",
 781         .match = vlynq_device_match,
 782         .probe = vlynq_device_probe,
 783         .remove = vlynq_device_remove,
 784 };
 785 EXPORT_SYMBOL(vlynq_bus_type);
 786
 787 static int vlynq_init(void)
 788 {
 789         int res = 0;
 790
 791         res = bus_register(&vlynq_bus_type);
 792         if (res)
 793                 goto fail_bus;
 794
 795         res = platform_driver_register(&vlynq_platform_driver);
 796         if (res)
 797                 goto fail_platform;
 798
 799         return 0;
 800
 801 fail_platform:
 802         bus_unregister(&vlynq_bus_type);
 803 fail_bus:
 804         return res;
 805 }
 806
 807 static void vlynq_exit(void)
 808 {
 809         platform_driver_unregister(&vlynq_platform_driver);
 810         bus_unregister(&vlynq_bus_type);
 811 }
 812
 813 module_init(vlynq_init);
 814 module_exit(vlynq_exit);