drivers/sh/maple/maple.c

   1 /*
   2  * Core maple bus functionality
   3  *
   4  *  Copyright (C) 2007, 2008 Adrian McMenamin
   5  *
   6  * Based on 2.4 code by:
   7  *
   8  *  Copyright (C) 2000-2001 YAEGASHI Takeshi
   9  *  Copyright (C) 2001 M. R. Brown
  10  *  Copyright (C) 2001 Paul Mundt
  11  *
  12  * and others.
  13  *
  14  * This file is subject to the terms and conditions of the GNU General Public
  15  * License.  See the file "COPYING" in the main directory of this archive
  16  * for more details.
  17  */
  18 #include <linux/init.h>
  19 #include <linux/kernel.h>
  20 #include <linux/device.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/list.h>
  23 #include <linux/io.h>
  24 #include <linux/slab.h>
  25 #include <linux/maple.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/delay.h>
  28 #include <asm/cacheflush.h>
  29 #include <asm/dma.h>
  30 #include <asm/io.h>
  31 #include <mach/dma.h>
  32 #include <mach/sysasic.h>
  33
  34 MODULE_AUTHOR("Yaegshi Takeshi, Paul Mundt, M.R. Brown, Adrian McMenamin");
  35 MODULE_DESCRIPTION("Maple bus driver for Dreamcast");
  36 MODULE_LICENSE("GPL v2");
  37 MODULE_SUPPORTED_DEVICE("{{SEGA, Dreamcast/Maple}}");
  38
  39 static void maple_dma_handler(struct work_struct *work);
  40 static void maple_vblank_handler(struct work_struct *work);
  41
  42 static DECLARE_WORK(maple_dma_process, maple_dma_handler);
  43 static DECLARE_WORK(maple_vblank_process, maple_vblank_handler);
  44
  45 static LIST_HEAD(maple_waitq);
  46 static LIST_HEAD(maple_sentq);
  47
  48 /* mutex to protect queue of waiting packets */
  49 static DEFINE_MUTEX(maple_wlist_lock);
  50
  51 static struct maple_driver maple_dummy_driver;
  52 static struct device maple_bus;
  53 static int subdevice_map[MAPLE_PORTS];
  54 static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr;
  55 static unsigned long maple_pnp_time;
  56 static int started, scanning, fullscan;
  57 static struct kmem_cache *maple_queue_cache;
  58
  59 struct maple_device_specify {
  60         int port;
  61         int unit;
  62 };
  63
  64 static bool checked[4];
  65 static struct maple_device *baseunits[4];
  66
  67 /**
  68  *  maple_driver_register - register a device driver
  69  *  automatically makes the driver bus a maple bus
  70  *  @drv: the driver to be registered
  71  */
  72 int maple_driver_register(struct device_driver *drv)
  73 {
  74         if (!drv)
  75                 return -EINVAL;
  76         drv->bus = &maple_bus_type;
  77         return driver_register(drv);
  78 }
  79 EXPORT_SYMBOL_GPL(maple_driver_register);
  80
  81 /* set hardware registers to enable next round of dma */
  82 static void maplebus_dma_reset(void)
  83 {
  84         ctrl_outl(MAPLE_MAGIC, MAPLE_RESET);
  85         /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */
  86         ctrl_outl(1, MAPLE_TRIGTYPE);
  87         ctrl_outl(MAPLE_2MBPS | MAPLE_TIMEOUT(50000), MAPLE_SPEED);
  88         ctrl_outl(PHYSADDR(maple_sendbuf), MAPLE_DMAADDR);
  89         ctrl_outl(1, MAPLE_ENABLE);
  90 }
  91
  92 /**
  93  * maple_getcond_callback - setup handling MAPLE_COMMAND_GETCOND
  94  * @dev: device responding
  95  * @callback: handler callback
  96  * @interval: interval in jiffies between callbacks
  97  * @function: the function code for the device
  98  */
  99 void maple_getcond_callback(struct maple_device *dev,
 100                         void (*callback) (struct mapleq *mq),
 101                         unsigned long interval, unsigned long function)
 102 {
 103         dev->callback = callback;
 104         dev->interval = interval;
 105         dev->function = cpu_to_be32(function);
 106         dev->when = jiffies;
 107 }
 108 EXPORT_SYMBOL_GPL(maple_getcond_callback);
 109
 110 static int maple_dma_done(void)
 111 {
 112         return (ctrl_inl(MAPLE_STATE) & 1) == 0;
 113 }
 114
 115 static void maple_release_device(struct device *dev)
 116 {
 117         struct maple_device *mdev;
 118         struct mapleq *mq;
 119         if (!dev)
 120                 return;
 121         mdev = to_maple_dev(dev);
 122         mq = mdev->mq;
 123         if (mq) {
 124                 if (mq->recvbufdcsp)
 125                         kmem_cache_free(maple_queue_cache, mq->recvbufdcsp);
 126                 kfree(mq);
 127                 mq = NULL;
 128         }
 129         kfree(mdev);
 130 }
 131
 132 /*
 133  * maple_add_packet - add a single instruction to the queue
 134  * @mdev - maple device
 135  * @function - function on device being queried
 136  * @command - maple command to add
 137  * @length - length of command string (in 32 bit words)
 138  * @data - remainder of command string
 139  */
 140 int maple_add_packet(struct maple_device *mdev, u32 function, u32 command,
 141         size_t length, void *data)
 142 {
 143         int locking, ret = 0;
 144         void *sendbuf = NULL;
 145
 146         mutex_lock(&maple_wlist_lock);
 147         /* bounce if device already locked */
 148         locking = mutex_is_locked(&mdev->mq->mutex);
 149         if (locking) {
 150                 ret = -EBUSY;
 151                 goto out;
 152         }
 153
 154         mutex_lock(&mdev->mq->mutex);
 155
 156         if (length) {
 157                 sendbuf = kmalloc(length * 4, GFP_KERNEL);
 158                 if (!sendbuf) {
 159                         mutex_unlock(&mdev->mq->mutex);
 160                         ret = -ENOMEM;
 161                         goto out;
 162                 }
 163                 ((__be32 *)sendbuf)[0] = cpu_to_be32(function);
 164         }
 165
 166         mdev->mq->command = command;
 167         mdev->mq->length = length;
 168         if (length > 1)
 169                 memcpy(sendbuf + 4, data, (length - 1) * 4);
 170         mdev->mq->sendbuf = sendbuf;
 171
 172         list_add(&mdev->mq->list, &maple_waitq);
 173 out:
 174         mutex_unlock(&maple_wlist_lock);
 175         return ret;
 176 }
 177 EXPORT_SYMBOL_GPL(maple_add_packet);
 178
 179 /*
 180  * maple_add_packet_sleeps - add a single instruction to the queue
 181  *  - waits for lock to be free
 182  * @mdev - maple device
 183  * @function - function on device being queried
 184  * @command - maple command to add
 185  * @length - length of command string (in 32 bit words)
 186  * @data - remainder of command string
 187  */
 188 int maple_add_packet_sleeps(struct maple_device *mdev, u32 function,
 189         u32 command, size_t length, void *data)
 190 {
 191         int locking, ret = 0;
 192         void *sendbuf = NULL;
 193
 194         locking = mutex_lock_interruptible(&mdev->mq->mutex);
 195         if (locking) {
 196                 ret = -EIO;
 197                 goto out;
 198         }
 199
 200         if (length) {
 201                 sendbuf = kmalloc(length * 4, GFP_KERNEL);
 202                 if (!sendbuf) {
 203                         mutex_unlock(&mdev->mq->mutex);
 204                         ret = -ENOMEM;
 205                         goto out;
 206                 }
 207                 ((__be32 *)sendbuf)[0] = cpu_to_be32(function);
 208         }
 209
 210         mdev->mq->command = command;
 211         mdev->mq->length = length;
 212         if (length > 1)
 213                 memcpy(sendbuf + 4, data, (length - 1) * 4);
 214         mdev->mq->sendbuf = sendbuf;
 215
 216         mutex_lock(&maple_wlist_lock);
 217         list_add(&mdev->mq->list, &maple_waitq);
 218         mutex_unlock(&maple_wlist_lock);
 219 out:
 220         return ret;
 221 }
 222 EXPORT_SYMBOL_GPL(maple_add_packet_sleeps);
 223
 224 static struct mapleq *maple_allocq(struct maple_device *mdev)
 225 {
 226         struct mapleq *mq;
 227
 228         mq = kmalloc(sizeof(*mq), GFP_KERNEL);
 229         if (!mq)
 230                 goto failed_nomem;
 231
 232         mq->dev = mdev;
 233         mq->recvbufdcsp = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL);
 234         mq->recvbuf = (void *) P2SEGADDR(mq->recvbufdcsp);
 235         if (!mq->recvbuf)
 236                 goto failed_p2;
 237         /*
 238          * most devices do not need the mutex - but
 239          * anything that injects block reads or writes
 240          * will rely on it
 241          */
 242         mutex_init(&mq->mutex);
 243
 244         return mq;
 245
 246 failed_p2:
 247         kfree(mq);
 248 failed_nomem:
 249         return NULL;
 250 }
 251
 252 static struct maple_device *maple_alloc_dev(int port, int unit)
 253 {
 254         struct maple_device *mdev;
 255
 256         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
 257         if (!mdev)
 258                 return NULL;
 259
 260         mdev->port = port;
 261         mdev->unit = unit;
 262         mdev->mq = maple_allocq(mdev);
 263
 264         if (!mdev->mq) {
 265                 kfree(mdev);
 266                 return NULL;
 267         }
 268         mdev->dev.bus = &maple_bus_type;
 269         mdev->dev.parent = &maple_bus;
 270         return mdev;
 271 }
 272
 273 static void maple_free_dev(struct maple_device *mdev)
 274 {
 275         if (!mdev)
 276                 return;
 277         if (mdev->mq) {
 278                 if (mdev->mq->recvbufdcsp)
 279                         kmem_cache_free(maple_queue_cache,
 280                                 mdev->mq->recvbufdcsp);
 281                 kfree(mdev->mq);
 282         }
 283         kfree(mdev);
 284 }
 285
 286 /* process the command queue into a maple command block
 287  * terminating command has bit 32 of first long set to 0
 288  */
 289 static void maple_build_block(struct mapleq *mq)
 290 {
 291         int port, unit, from, to, len;
 292         unsigned long *lsendbuf = mq->sendbuf;
 293
 294         port = mq->dev->port & 3;
 295         unit = mq->dev->unit;
 296         len = mq->length;
 297         from = port << 6;
 298         to = (port << 6) | (unit > 0 ? (1 << (unit - 1)) & 0x1f : 0x20);
 299
 300         *maple_lastptr &= 0x7fffffff;
 301         maple_lastptr = maple_sendptr;
 302
 303         *maple_sendptr++ = (port << 16) | len | 0x80000000;
 304         *maple_sendptr++ = PHYSADDR(mq->recvbuf);
 305         *maple_sendptr++ =
 306             mq->command | (to << 8) | (from << 16) | (len << 24);
 307         while (len-- > 0)
 308                 *maple_sendptr++ = *lsendbuf++;
 309 }
 310
 311 /* build up command queue */
 312 static void maple_send(void)
 313 {
 314         int i, maple_packets = 0;
 315         struct mapleq *mq, *nmq;
 316
 317         if (!list_empty(&maple_sentq))
 318                 return;
 319         mutex_lock(&maple_wlist_lock);
 320         if (list_empty(&maple_waitq) || !maple_dma_done()) {
 321                 mutex_unlock(&maple_wlist_lock);
 322                 return;
 323         }
 324         mutex_unlock(&maple_wlist_lock);
 325         maple_lastptr = maple_sendbuf;
 326         maple_sendptr = maple_sendbuf;
 327         mutex_lock(&maple_wlist_lock);
 328         list_for_each_entry_safe(mq, nmq, &maple_waitq, list) {
 329                 maple_build_block(mq);
 330                 list_move(&mq->list, &maple_sentq);
 331                 if (maple_packets++ > MAPLE_MAXPACKETS)
 332                         break;
 333         }
 334         mutex_unlock(&maple_wlist_lock);
 335         if (maple_packets > 0) {
 336                 for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++)
 337                         dma_cache_sync(0, maple_sendbuf + i * PAGE_SIZE,
 338                                        PAGE_SIZE, DMA_BIDIRECTIONAL);
 339         }
 340 }
 341
 342 /* check if there is a driver registered likely to match this device */
 343 static int check_matching_maple_driver(struct device_driver *driver,
 344                                         void *devptr)
 345 {
 346         struct maple_driver *maple_drv;
 347         struct maple_device *mdev;
 348
 349         mdev = devptr;
 350         maple_drv = to_maple_driver(driver);
 351         if (mdev->devinfo.function & cpu_to_be32(maple_drv->function))
 352                 return 1;
 353         return 0;
 354 }
 355
 356 static void maple_detach_driver(struct maple_device *mdev)
 357 {
 358         if (!mdev)
 359                 return;
 360         device_unregister(&mdev->dev);
 361         mdev = NULL;
 362 }
 363
 364 /* process initial MAPLE_COMMAND_DEVINFO for each device or port */
 365 static void maple_attach_driver(struct maple_device *mdev)
 366 {
 367         char *p, *recvbuf;
 368         unsigned long function;
 369         int matched, retval;
 370
 371         recvbuf = mdev->mq->recvbuf;
 372         /* copy the data as individual elements in
 373         * case of memory optimisation */
 374         memcpy(&mdev->devinfo.function, recvbuf + 4, 4);
 375         memcpy(&mdev->devinfo.function_data[0], recvbuf + 8, 12);
 376         memcpy(&mdev->devinfo.area_code, recvbuf + 20, 1);
 377         memcpy(&mdev->devinfo.connector_direction, recvbuf + 21, 1);
 378         memcpy(&mdev->devinfo.product_name[0], recvbuf + 22, 30);
 379         memcpy(&mdev->devinfo.product_licence[0], recvbuf + 52, 60);
 380         memcpy(&mdev->devinfo.standby_power, recvbuf + 112, 2);
 381         memcpy(&mdev->devinfo.max_power, recvbuf + 114, 2);
 382         memcpy(mdev->product_name, mdev->devinfo.product_name, 30);
 383         mdev->product_name[30] = '\0';
 384         memcpy(mdev->product_licence, mdev->devinfo.product_licence, 60);
 385         mdev->product_licence[60] = '\0';
 386
 387         for (p = mdev->product_name + 29; mdev->product_name <= p; p--)
 388                 if (*p == ' ')
 389                         *p = '\0';
 390                 else
 391                         break;
 392         for (p = mdev->product_licence + 59; mdev->product_licence <= p; p--)
 393                 if (*p == ' ')
 394                         *p = '\0';
 395                 else
 396                         break;
 397
 398         printk(KERN_INFO "Maple device detected: %s\n",
 399                 mdev->product_name);
 400         printk(KERN_INFO "Maple device: %s\n", mdev->product_licence);
 401
 402         function = be32_to_cpu(mdev->devinfo.function);
 403
 404         if (function > 0x200) {
 405                 /* Do this silently - as not a real device */
 406                 function = 0;
 407                 mdev->driver = &maple_dummy_driver;
 408                 sprintf(mdev->dev.bus_id, "%d:0.port", mdev->port);
 409         } else {
 410                 printk(KERN_INFO
 411                         "Maple bus at (%d, %d): Function 0x%lX\n",
 412                         mdev->port, mdev->unit, function);
 413
 414                 matched =
 415                         bus_for_each_drv(&maple_bus_type, NULL, mdev,
 416                                 check_matching_maple_driver);
 417
 418                 if (matched == 0) {
 419                         /* Driver does not exist yet */
 420                         printk(KERN_INFO
 421                                 "No maple driver found.\n");
 422                         mdev->driver = &maple_dummy_driver;
 423                 }
 424                 sprintf(mdev->dev.bus_id, "%d:0%d.%lX", mdev->port,
 425                         mdev->unit, function);
 426         }
 427         mdev->function = function;
 428         mdev->dev.release = &maple_release_device;
 429         retval = device_register(&mdev->dev);
 430         if (retval) {
 431                 printk(KERN_INFO
 432                 "Maple bus: Attempt to register device"
 433                 " (%x, %x) failed.\n",
 434                 mdev->port, mdev->unit);
 435                 maple_free_dev(mdev);
 436                 mdev = NULL;
 437                 return;
 438         }
 439 }
 440
 441 /*
 442  * if device has been registered for the given
 443  * port and unit then return 1 - allows identification
 444  * of which devices need to be attached or detached
 445  */
 446 static int detach_maple_device(struct device *device, void *portptr)
 447 {
 448         struct maple_device_specify *ds;
 449         struct maple_device *mdev;
 450
 451         ds = portptr;
 452         mdev = to_maple_dev(device);
 453         if (mdev->port == ds->port && mdev->unit == ds->unit)
 454                 return 1;
 455         return 0;
 456 }
 457
 458 static int setup_maple_commands(struct device *device, void *ignored)
 459 {
 460         int add;
 461         struct maple_device *maple_dev = to_maple_dev(device);
 462
 463         if ((maple_dev->interval > 0)
 464             && time_after(jiffies, maple_dev->when)) {
 465                 /* bounce if we cannot lock */
 466                 add = maple_add_packet(maple_dev,
 467                         be32_to_cpu(maple_dev->devinfo.function),
 468                         MAPLE_COMMAND_GETCOND, 1, NULL);
 469                 if (!add)
 470                         maple_dev->when = jiffies + maple_dev->interval;
 471         } else {
 472                 if (time_after(jiffies, maple_pnp_time))
 473                         /* This will also bounce */
 474                         maple_add_packet(maple_dev, 0,
 475                                 MAPLE_COMMAND_DEVINFO, 0, NULL);
 476         }
 477         return 0;
 478 }
 479
 480 /* VBLANK bottom half - implemented via workqueue */
 481 static void maple_vblank_handler(struct work_struct *work)
 482 {
 483         if (!list_empty(&maple_sentq) || !maple_dma_done())
 484                 return;
 485
 486         ctrl_outl(0, MAPLE_ENABLE);
 487
 488         bus_for_each_dev(&maple_bus_type, NULL, NULL,
 489                          setup_maple_commands);
 490
 491         if (time_after(jiffies, maple_pnp_time))
 492                 maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL;
 493
 494         mutex_lock(&maple_wlist_lock);
 495         if (!list_empty(&maple_waitq) && list_empty(&maple_sentq)) {
 496                 mutex_unlock(&maple_wlist_lock);
 497                 maple_send();
 498         } else {
 499                 mutex_unlock(&maple_wlist_lock);
 500         }
 501
 502         maplebus_dma_reset();
 503 }
 504
 505 /* handle devices added via hotplugs - placing them on queue for DEVINFO*/
 506 static void maple_map_subunits(struct maple_device *mdev, int submask)
 507 {
 508         int retval, k, devcheck;
 509         struct maple_device *mdev_add;
 510         struct maple_device_specify ds;
 511
 512         ds.port = mdev->port;
 513         for (k = 0; k < 5; k++) {
 514                 ds.unit = k + 1;
 515                 retval =
 516                     bus_for_each_dev(&maple_bus_type, NULL, &ds,
 517                                      detach_maple_device);
 518                 if (retval) {
 519                         submask = submask >> 1;
 520                         continue;
 521                 }
 522                 devcheck = submask & 0x01;
 523                 if (devcheck) {
 524                         mdev_add = maple_alloc_dev(mdev->port, k + 1);
 525                         if (!mdev_add)
 526                                 return;
 527                         maple_add_packet(mdev_add, 0, MAPLE_COMMAND_DEVINFO,
 528                                 0, NULL);
 529                         /* mark that we are checking sub devices */
 530                         scanning = 1;
 531                 }
 532                 submask = submask >> 1;
 533         }
 534 }
 535
 536 /* mark a device as removed */
 537 static void maple_clean_submap(struct maple_device *mdev)
 538 {
 539         int killbit;
 540
 541         killbit = (mdev->unit > 0 ? (1 << (mdev->unit - 1)) & 0x1f : 0x20);
 542         killbit = ~killbit;
 543         killbit &= 0xFF;
 544         subdevice_map[mdev->port] = subdevice_map[mdev->port] & killbit;
 545 }
 546
 547 /* handle empty port or hotplug removal */
 548 static void maple_response_none(struct maple_device *mdev,
 549                                 struct mapleq *mq)
 550 {
 551         if (mdev->unit != 0) {
 552                 list_del(&mq->list);
 553                 maple_clean_submap(mdev);
 554                 printk(KERN_INFO
 555                        "Maple bus device detaching at (%d, %d)\n",
 556                        mdev->port, mdev->unit);
 557                 maple_detach_driver(mdev);
 558                 return;
 559         }
 560         if (!started || !fullscan) {
 561                 if (checked[mdev->port] == false) {
 562                         checked[mdev->port] = true;
 563                         printk(KERN_INFO "No maple devices attached"
 564                                 " to port %d\n", mdev->port);
 565                 }
 566                 return;
 567         }
 568         maple_clean_submap(mdev);
 569 }
 570
 571 /* preprocess hotplugs or scans */
 572 static void maple_response_devinfo(struct maple_device *mdev,
 573                                    char *recvbuf)
 574 {
 575         char submask;
 576         if (!started || (scanning == 2) || !fullscan) {
 577                 if ((mdev->unit == 0) && (checked[mdev->port] == false)) {
 578                         checked[mdev->port] = true;
 579                         maple_attach_driver(mdev);
 580                 } else {
 581                         if (mdev->unit != 0)
 582                                 maple_attach_driver(mdev);
 583                 }
 584                 return;
 585         }
 586         if (mdev->unit == 0) {
 587                 submask = recvbuf[2] & 0x1F;
 588                 if (submask ^ subdevice_map[mdev->port]) {
 589                         maple_map_subunits(mdev, submask);
 590                         subdevice_map[mdev->port] = submask;
 591                 }
 592         }
 593 }
 594
 595 static void maple_port_rescan(void)
 596 {
 597         int i;
 598         struct maple_device *mdev;
 599
 600         fullscan = 1;
 601         for (i = 0; i < MAPLE_PORTS; i++) {
 602                 if (checked[i] == false) {
 603                         fullscan = 0;
 604                         mdev = baseunits[i];
 605                         /*
 606                          *  test lock in case scan has failed
 607                          *  but device is still locked
 608                          */
 609                         if (mutex_is_locked(&mdev->mq->mutex))
 610                                 mutex_unlock(&mdev->mq->mutex);
 611                         maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO,
 612                                 0, NULL);
 613                 }
 614         }
 615 }
 616
 617 /* maple dma end bottom half - implemented via workqueue */
 618 static void maple_dma_handler(struct work_struct *work)
 619 {
 620         struct mapleq *mq, *nmq;
 621         struct maple_device *dev;
 622         char *recvbuf;
 623         enum maple_code code;
 624
 625         if (!maple_dma_done())
 626                 return;
 627         ctrl_outl(0, MAPLE_ENABLE);
 628         if (!list_empty(&maple_sentq)) {
 629                 list_for_each_entry_safe(mq, nmq, &maple_sentq, list) {
 630                         recvbuf = mq->recvbuf;
 631                         code = recvbuf[0];
 632                         dev = mq->dev;
 633                         kfree(mq->sendbuf);
 634                         mutex_unlock(&mq->mutex);
 635                         list_del_init(&mq->list);
 636
 637                         switch (code) {
 638                         case MAPLE_RESPONSE_NONE:
 639                                 maple_response_none(dev, mq);
 640                                 break;
 641
 642                         case MAPLE_RESPONSE_DEVINFO:
 643                                 maple_response_devinfo(dev, recvbuf);
 644                                 break;
 645
 646                         case MAPLE_RESPONSE_DATATRF:
 647                                 if (dev->callback)
 648                                         dev->callback(mq);
 649                                 break;
 650
 651                         case MAPLE_RESPONSE_FILEERR:
 652                         case MAPLE_RESPONSE_AGAIN:
 653                         case MAPLE_RESPONSE_BADCMD:
 654                         case MAPLE_RESPONSE_BADFUNC:
 655                                 printk(KERN_DEBUG
 656                                        "Maple non-fatal error 0x%X\n",
 657                                        code);
 658                                 break;
 659
 660                         case MAPLE_RESPONSE_ALLINFO:
 661                                 printk(KERN_DEBUG
 662                                        "Maple - extended device information"
 663                                         " not supported\n");
 664                                 break;
 665
 666                         case MAPLE_RESPONSE_OK:
 667                                 break;
 668
 669                         default:
 670                                 break;
 671                         }
 672                 }
 673                 /* if scanning is 1 then we have subdevices to check */
 674                 if (scanning == 1) {
 675                         maple_send();
 676                         scanning = 2;
 677                 } else
 678                         scanning = 0;
 679                 /*check if we have actually tested all ports yet */
 680                 if (!fullscan)
 681                         maple_port_rescan();
 682                 /* mark that we have been through the first scan */
 683                 if (started == 0)
 684                         started = 1;
 685         }
 686         maplebus_dma_reset();
 687 }
 688
 689 static irqreturn_t maplebus_dma_interrupt(int irq, void *dev_id)
 690 {
 691         /* Load everything into the bottom half */
 692         schedule_work(&maple_dma_process);
 693         return IRQ_HANDLED;
 694 }
 695
 696 static irqreturn_t maplebus_vblank_interrupt(int irq, void *dev_id)
 697 {
 698         schedule_work(&maple_vblank_process);
 699         return IRQ_HANDLED;
 700 }
 701
 702 static int maple_set_dma_interrupt_handler(void)
 703 {
 704         return request_irq(HW_EVENT_MAPLE_DMA, maplebus_dma_interrupt,
 705                 IRQF_SHARED, "maple bus DMA", &maple_dummy_driver);
 706 }
 707
 708 static int maple_set_vblank_interrupt_handler(void)
 709 {
 710         return request_irq(HW_EVENT_VSYNC, maplebus_vblank_interrupt,
 711                 IRQF_SHARED, "maple bus VBLANK", &maple_dummy_driver);
 712 }
 713
 714 static int maple_get_dma_buffer(void)
 715 {
 716         maple_sendbuf =
 717             (void *) __get_free_pages(GFP_KERNEL | __GFP_ZERO,
 718                                       MAPLE_DMA_PAGES);
 719         if (!maple_sendbuf)
 720                 return -ENOMEM;
 721         return 0;
 722 }
 723
 724 static int match_maple_bus_driver(struct device *devptr,
 725                                   struct device_driver *drvptr)
 726 {
 727         struct maple_driver *maple_drv;
 728         struct maple_device *maple_dev;
 729
 730         maple_drv = container_of(drvptr, struct maple_driver, drv);
 731         maple_dev = container_of(devptr, struct maple_device, dev);
 732         /* Trap empty port case */
 733         if (maple_dev->devinfo.function == 0xFFFFFFFF)
 734                 return 0;
 735         else if (maple_dev->devinfo.function &
 736                  cpu_to_be32(maple_drv->function))
 737                 return 1;
 738         return 0;
 739 }
 740
 741 static int maple_bus_uevent(struct device *dev,
 742                             struct kobj_uevent_env *env)
 743 {
 744         return 0;
 745 }
 746
 747 static void maple_bus_release(struct device *dev)
 748 {
 749 }
 750
 751 static struct maple_driver maple_dummy_driver = {
 752         .drv = {
 753                 .name = "maple_dummy_driver",
 754                 .bus = &maple_bus_type,
 755         },
 756 };
 757
 758 struct bus_type maple_bus_type = {
 759         .name = "maple",
 760         .match = match_maple_bus_driver,
 761         .uevent = maple_bus_uevent,
 762 };
 763 EXPORT_SYMBOL_GPL(maple_bus_type);
 764
 765 static struct device maple_bus = {
 766         .bus_id = "maple",
 767         .release = maple_bus_release,
 768 };
 769
 770 static int __init maple_bus_init(void)
 771 {
 772         int retval, i;
 773         struct maple_device *mdev[MAPLE_PORTS];
 774         ctrl_outl(0, MAPLE_STATE);
 775
 776         retval = device_register(&maple_bus);
 777         if (retval)
 778                 goto cleanup;
 779
 780         retval = bus_register(&maple_bus_type);
 781         if (retval)
 782                 goto cleanup_device;
 783
 784         retval = driver_register(&maple_dummy_driver.drv);
 785         if (retval)
 786                 goto cleanup_bus;
 787
 788         /* allocate memory for maple bus dma */
 789         retval = maple_get_dma_buffer();
 790         if (retval) {
 791                 printk(KERN_INFO
 792                        "Maple bus: Failed to allocate Maple DMA buffers\n");
 793                 goto cleanup_basic;
 794         }
 795
 796         /* set up DMA interrupt handler */
 797         retval = maple_set_dma_interrupt_handler();
 798         if (retval) {
 799                 printk(KERN_INFO
 800                        "Maple bus: Failed to grab maple DMA IRQ\n");
 801                 goto cleanup_dma;
 802         }
 803
 804         /* set up VBLANK interrupt handler */
 805         retval = maple_set_vblank_interrupt_handler();
 806         if (retval) {
 807                 printk(KERN_INFO "Maple bus: Failed to grab VBLANK IRQ\n");
 808                 goto cleanup_irq;
 809         }
 810
 811         maple_queue_cache =
 812             kmem_cache_create("maple_queue_cache", 0x400, 0,
 813                               SLAB_POISON|SLAB_HWCACHE_ALIGN, NULL);
 814
 815         if (!maple_queue_cache)
 816                 goto cleanup_bothirqs;
 817
 818         INIT_LIST_HEAD(&maple_waitq);
 819         INIT_LIST_HEAD(&maple_sentq);
 820
 821         /* setup maple ports */
 822         for (i = 0; i < MAPLE_PORTS; i++) {
 823                 checked[i] = false;
 824                 mdev[i] = maple_alloc_dev(i, 0);
 825                 baseunits[i] = mdev[i];
 826                 if (!mdev[i]) {
 827                         while (i-- > 0)
 828                                 maple_free_dev(mdev[i]);
 829                         goto cleanup_cache;
 830                 }
 831                 maple_add_packet(mdev[i], 0, MAPLE_COMMAND_DEVINFO, 0, NULL);
 832                 subdevice_map[i] = 0;
 833         }
 834
 835         /* setup maplebus hardware */
 836         maplebus_dma_reset();
 837         /* initial detection */
 838         maple_send();
 839         maple_pnp_time = jiffies;
 840         printk(KERN_INFO "Maple bus core now registered.\n");
 841
 842         return 0;
 843
 844 cleanup_cache:
 845         kmem_cache_destroy(maple_queue_cache);
 846
 847 cleanup_bothirqs:
 848         free_irq(HW_EVENT_VSYNC, 0);
 849
 850 cleanup_irq:
 851         free_irq(HW_EVENT_MAPLE_DMA, 0);
 852
 853 cleanup_dma:
 854         free_pages((unsigned long) maple_sendbuf, MAPLE_DMA_PAGES);
 855
 856 cleanup_basic:
 857         driver_unregister(&maple_dummy_driver.drv);
 858
 859 cleanup_bus:
 860         bus_unregister(&maple_bus_type);
 861
 862 cleanup_device:
 863         device_unregister(&maple_bus);
 864
 865 cleanup:
 866         printk(KERN_INFO "Maple bus registration failed\n");
 867         return retval;
 868 }
 869 /* Push init to later to ensure hardware gets detected */
 870 fs_initcall(maple_bus_init);