/* * Core maple bus functionality * * Copyright (C) 2007 - 2009 Adrian McMenamin * Copyright (C) 2001 - 2008 Paul Mundt * Copyright (C) 2000 - 2001 YAEGASHI Takeshi * Copyright (C) 2001 M. R. Brown * * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. */#include <linux/init.h>#include <linux/kernel.h>#include <linux/device.h>#include <linux/interrupt.h>#include <linux/list.h>#include <linux/io.h>#include <linux/slab.h>#include <linux/maple.h>#include <linux/dma-mapping.h>#include <linux/delay.h>#include <linux/module.h>#include <asm/cacheflush.h>#include <asm/dma.h>#include <asm/io.h>#include <mach/dma.h>#include <mach/sysasic.h> MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");MODULE_DESCRIPTION("Maple bus driver for Dreamcast");MODULE_LICENSE("GPL v2"); static void maple_dma_handler(struct work_struct *work);static void maple_vblank_handler(struct work_struct *work); static DECLARE_WORK(maple_dma_process, maple_dma_handler);static DECLARE_WORK(maple_vblank_process, maple_vblank_handler); static LIST_HEAD(maple_waitq);static LIST_HEAD(maple_sentq); /* mutex to protect queue of waiting packets */static DEFINE_MUTEX(maple_wlist_lock); static struct maple_driver maple_unsupported_device;static struct device maple_bus;static int subdevice_map[MAPLE_PORTS];static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr;static unsigned long maple_pnp_time;static int started, scanning, fullscan;static struct kmem_cache *maple_queue_cache; struct maple_device_specify { int port; int unit;}; static bool checked[MAPLE_PORTS];static bool empty[MAPLE_PORTS];static struct maple_device *baseunits[MAPLE_PORTS];static const struct bus_type maple_bus_type; /** * maple_driver_register - register a maple driver * @drv: maple driver to be registered. * * Registers the passed in @drv, while updating the bus type. * Devices with matching function IDs will be automatically probed. */int maple_driver_register(struct maple_driver *drv){ if (!drv) return -EINVAL; drv->drv.bus = &maple_bus_type; return driver_register(&drv->drv);}EXPORT_SYMBOL_GPL(maple_driver_register); /** * maple_driver_unregister - unregister a maple driver. * @drv: maple driver to unregister. * * Cleans up after maple_driver_register(). To be invoked in the exit * path of any module drivers. */void maple_driver_unregister(struct maple_driver *drv){ driver_unregister(&drv->drv);}EXPORT_SYMBOL_GPL(maple_driver_unregister); /* set hardware registers to enable next round of dma */static void maple_dma_reset(void){ __raw_writel(MAPLE_MAGIC, MAPLE_RESET); /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */ __raw_writel(1, MAPLE_TRIGTYPE); /* * Maple system register * bits 31 - 16 timeout in units of 20nsec * bit 12 hard trigger - set 0 to keep responding to VBLANK * bits 9 - 8 set 00 for 2 Mbps, 01 for 1 Mbps * bits 3 - 0 delay (in 1.3ms) between VBLANK and start of DMA * max delay is 11 */ __raw_writel(MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), MAPLE_SPEED); __raw_writel(virt_to_phys(maple_sendbuf), MAPLE_DMAADDR); __raw_writel(1, MAPLE_ENABLE);} /** * maple_getcond_callback - setup handling MAPLE_COMMAND_GETCOND * @dev: device responding * @callback: handler callback * @interval: interval in jiffies between callbacks * @function: the function code for the device */void maple_getcond_callback(struct maple_device *dev, void (*callback) (struct mapleq *mq), unsigned long interval, unsigned long function){ dev->callback = callback; dev->interval = interval; dev->function = cpu_to_be32(function); dev->when = jiffies;}EXPORT_SYMBOL_GPL(maple_getcond_callback); static int maple_dma_done(void){ return (__raw_readl(MAPLE_STATE) & 1) == 0;} static void maple_release_device(struct device *dev){ struct maple_device *mdev; struct mapleq *mq; mdev = to_maple_dev(dev); mq = mdev->mq; kmem_cache_free(maple_queue_cache, mq->recvbuf); kfree(mq); kfree(mdev);} /** * maple_add_packet - add a single instruction to the maple bus queue * @mdev: maple device * @function: function on device being queried * @command: maple command to add * @length: length of command string (in 32 bit words) * @data: remainder of command string */int maple_add_packet(struct maple_device *mdev, u32 function, u32 command, size_t length, void *data){ int ret = 0; void *sendbuf = NULL; if (length) { sendbuf = kcalloc(length, 4, GFP_KERNEL); if (!sendbuf) { ret = -ENOMEM; goto out; } ((__be32 *)sendbuf)[0] = cpu_to_be32(function); } mdev->mq->command = command; mdev->mq->length = length; if (length > 1) memcpy(sendbuf + 4, data, (length - 1) * 4); mdev->mq->sendbuf = sendbuf; mutex_lock(&maple_wlist_lock); list_add_tail(&mdev->mq->list, &maple_waitq); mutex_unlock(&maple_wlist_lock);out: return ret;}EXPORT_SYMBOL_GPL(maple_add_packet); static struct mapleq *maple_allocq(struct maple_device *mdev){ struct mapleq *mq; mq = kzalloc_obj(*mq); if (!mq) goto failed_nomem; INIT_LIST_HEAD(&mq->list); mq->dev = mdev; mq->recvbuf = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL); if (!mq->recvbuf) goto failed_p2; mq->recvbuf->buf = &((mq->recvbuf->bufx)[0]); return mq; failed_p2: kfree(mq);failed_nomem: dev_err(&mdev->dev, "could not allocate memory for device (%d, %d)\n", mdev->port, mdev->unit); return NULL;} static struct maple_device *maple_alloc_dev(int port, int unit){ struct maple_device *mdev; /* zero this out to avoid kobj subsystem * thinking it has already been registered */ mdev = kzalloc_obj(*mdev); if (!mdev) return NULL; mdev->port = port; mdev->unit = unit; mdev->mq = maple_allocq(mdev); if (!mdev->mq) { kfree(mdev); return NULL; } mdev->dev.bus = &maple_bus_type; mdev->dev.parent = &maple_bus; init_waitqueue_head(&mdev->maple_wait); return mdev;} static void maple_free_dev(struct maple_device *mdev){ kmem_cache_free(maple_queue_cache, mdev->mq->recvbuf); kfree(mdev->mq); kfree(mdev);} /* process the command queue into a maple command block * terminating command has bit 32 of first long set to 0 */static void maple_build_block(struct mapleq *mq){ int port, unit, from, to, len; unsigned long *lsendbuf = mq->sendbuf; port = mq->dev->port & 3; unit = mq->dev->unit; len = mq->length; from = port << 6; to = (port << 6) | (unit > 0 ? (1 << (unit - 1)) & 0x1f : 0x20); *maple_lastptr &= 0x7fffffff; maple_lastptr = maple_sendptr; *maple_sendptr++ = (port << 16) | len | 0x80000000; *maple_sendptr++ = virt_to_phys(mq->recvbuf->buf); *maple_sendptr++ = mq->command | (to << 8) | (from << 16) | (len << 24); while (len-- > 0) *maple_sendptr++ = *lsendbuf++;} /* build up command queue */static void maple_send(void){ int i, maple_packets = 0; struct mapleq *mq, *nmq; if (!maple_dma_done()) return; /* disable DMA */ __raw_writel(0, MAPLE_ENABLE); if (!list_empty(&maple_sentq)) goto finish; mutex_lock(&maple_wlist_lock); if (list_empty(&maple_waitq)) { mutex_unlock(&maple_wlist_lock); goto finish; } maple_lastptr = maple_sendbuf; maple_sendptr = maple_sendbuf; list_for_each_entry_safe(mq, nmq, &maple_waitq, list) { maple_build_block(mq); list_del_init(&mq->list); list_add_tail(&mq->list, &maple_sentq); if (maple_packets++ > MAPLE_MAXPACKETS) break; } mutex_unlock(&maple_wlist_lock); if (maple_packets > 0) { for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++) __flush_purge_region(maple_sendbuf + i * PAGE_SIZE, PAGE_SIZE); } finish: maple_dma_reset();} /* check if there is a driver registered likely to match this device */static int maple_check_matching_driver(struct device_driver *driver, void *devptr){ struct maple_driver *maple_drv; struct maple_device *mdev; mdev = devptr; maple_drv = to_maple_driver(driver); if (mdev->devinfo.function & cpu_to_be32(maple_drv->function)) return 1; return 0;} static void maple_detach_driver(struct maple_device *mdev){ device_unregister(&mdev->dev);} /* process initial MAPLE_COMMAND_DEVINFO for each device or port */static void maple_attach_driver(struct maple_device *mdev){ char *p, *recvbuf; unsigned long function; int matched, error; recvbuf = mdev->mq->recvbuf->buf; /* copy the data as individual elements in * case of memory optimisation */ memcpy(&mdev->devinfo.function, recvbuf + 4, 4); memcpy(&mdev->devinfo.function_data[0], recvbuf + 8, 12); memcpy(&mdev->devinfo.area_code, recvbuf + 20, 1); memcpy(&mdev->devinfo.connector_direction, recvbuf + 21, 1); memcpy(&mdev->devinfo.product_name[0], recvbuf + 22, 30); memcpy(&mdev->devinfo.standby_power, recvbuf + 112, 2); memcpy(&mdev->devinfo.max_power, recvbuf + 114, 2); memcpy(mdev->product_name, mdev->devinfo.product_name, 30); mdev->product_name[30] = '\0'; memcpy(mdev->product_licence, mdev->devinfo.product_licence, 60); mdev->product_licence[60] = '\0'; for (p = mdev->product_name + 29; mdev->product_name <= p; p--) if (*p == ' ') *p = '\0'; else break; for (p = mdev->product_licence + 59; mdev->product_licence <= p; p--) if (*p == ' ') *p = '\0'; else break; function = be32_to_cpu(mdev->devinfo.function); dev_info(&mdev->dev, "detected %s: function 0x%lX: at (%d, %d)\n", mdev->product_name, function, mdev->port, mdev->unit); if (function > 0x200) { /* Do this silently - as not a real device */ function = 0; mdev->driver = &maple_unsupported_device; dev_set_name(&mdev->dev, "%d:0.port", mdev->port); } else { matched = bus_for_each_drv(&maple_bus_type, NULL, mdev, maple_check_matching_driver); if (matched == 0) { /* Driver does not exist yet */ dev_info(&mdev->dev, "no driver found\n"); mdev->driver = &maple_unsupported_device; } dev_set_name(&mdev->dev, "%d:0%d.%lX", mdev->port, mdev->unit, function); } mdev->function = function; mdev->dev.release = &maple_release_device; atomic_set(&mdev->busy, 0); error = device_register(&mdev->dev); if (error) { dev_warn(&mdev->dev, "could not register device at" " (%d, %d), with error 0x%X\n", mdev->unit, mdev->port, error); maple_free_dev(mdev); mdev = NULL; return; }} /* * if device has been registered for the given * port and unit then return 1 - allows identification * of which devices need to be attached or detached */static int check_maple_device(struct device *device, void *portptr){ struct maple_device_specify *ds; struct maple_device *mdev; ds = portptr; mdev = to_maple_dev(device); if (mdev->port == ds->port && mdev->unit == ds->unit) return 1; return 0;} static int setup_maple_commands(struct device *device, void *ignored){ int add; struct maple_device *mdev = to_maple_dev(device); if (mdev->interval > 0 && atomic_read(&mdev->busy) == 0 && time_after(jiffies, mdev->when)) { /* bounce if we cannot add */ add = maple_add_packet(mdev, be32_to_cpu(mdev->devinfo.function), MAPLE_COMMAND_GETCOND, 1, NULL); if (!add) mdev->when = jiffies + mdev->interval; } else { if (time_after(jiffies, maple_pnp_time)) /* Ensure we don't have block reads and devinfo * calls interfering with one another - so flag the * device as busy */ if (atomic_read(&mdev->busy) == 0) { atomic_set(&mdev->busy, 1); maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO, 0, NULL); } } return 0;} /* VBLANK bottom half - implemented via workqueue */static void maple_vblank_handler(struct work_struct *work){ int x, locking; struct maple_device *mdev; if (!maple_dma_done()) return; __raw_writel(0, MAPLE_ENABLE); if (!list_empty(&maple_sentq)) goto finish; /* * Set up essential commands - to fetch data and * check devices are still present */ bus_for_each_dev(&maple_bus_type, NULL, NULL, setup_maple_commands); if (time_after(jiffies, maple_pnp_time)) { /* * Scan the empty ports - bus is flakey and may have * mis-reported emptyness */ for (x = 0; x < MAPLE_PORTS; x++) { if (checked[x] && empty[x]) { mdev = baseunits[x]; if (!mdev) break; atomic_set(&mdev->busy, 1); locking = maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO, 0, NULL); if (!locking) break; } } maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL; } finish: maple_send();} /* handle devices added via hotplugs - placing them on queue for DEVINFO */static void maple_map_subunits(struct maple_device *mdev, int submask){ int retval, k, devcheck; struct maple_device *mdev_add; struct maple_device_specify ds; ds.port = mdev->port; for (k = 0; k < 5; k++) { ds.unit = k + 1;Lines 1–500 of 888. Load more
/* * Core maple bus functionality * * Copyright (C) 2007 - 2009 Adrian McMenamin * Copyright (C) 2001 - 2008 Paul Mundt * Copyright (C) 2000 - 2001 YAEGASHI Takeshi * Copyright (C) 2001 M. R. Brown * * This file is subject to the terms and conditions of the GNU General Public * License. See the file "COPYING" in the main directory of this archive * for more details. */ #include <linux/init.h> #include <linux/kernel.h> #include <linux/device.h> #include <linux/interrupt.h> #include <linux/list.h> #include <linux/io.h> #include <linux/slab.h> #include <linux/maple.h> #include <linux/dma-mapping.h> #include <linux/delay.h> #include <linux/module.h> #include <asm/cacheflush.h> #include <asm/dma.h> #include <asm/io.h> #include <mach/dma.h> #include <mach/sysasic.h> MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>"); MODULE_DESCRIPTION("Maple bus driver for Dreamcast"); MODULE_LICENSE("GPL v2"); static void maple_dma_handler(struct work_struct *work); static void maple_vblank_handler(struct work_struct *work); static DECLARE_WORK(maple_dma_process, maple_dma_handler); static DECLARE_WORK(maple_vblank_process, maple_vblank_handler); static LIST_HEAD(maple_waitq); static LIST_HEAD(maple_sentq); /* mutex to protect queue of waiting packets */ static DEFINE_MUTEX(maple_wlist_lock); static struct maple_driver maple_unsupported_device; static struct device maple_bus; static int subdevice_map[MAPLE_PORTS]; static unsigned long *maple_sendbuf, *maple_sendptr, *maple_lastptr; static unsigned long maple_pnp_time; static int started, scanning, fullscan; static struct kmem_cache *maple_queue_cache; struct maple_device_specify { int port; int unit; }; static bool checked[MAPLE_PORTS]; static bool empty[MAPLE_PORTS]; static struct maple_device *baseunits[MAPLE_PORTS]; static const struct bus_type maple_bus_type; /** * maple_driver_register - register a maple driver * @drv: maple driver to be registered. * * Registers the passed in @drv, while updating the bus type. * Devices with matching function IDs will be automatically probed. */ int maple_driver_register(struct maple_driver *drv) { if (!drv) return -EINVAL; drv->drv.bus = &maple_bus_type; return driver_register(&drv->drv); } EXPORT_SYMBOL_GPL(maple_driver_register); /** * maple_driver_unregister - unregister a maple driver. * @drv: maple driver to unregister. * * Cleans up after maple_driver_register(). To be invoked in the exit * path of any module drivers. */ void maple_driver_unregister(struct maple_driver *drv) { driver_unregister(&drv->drv); } EXPORT_SYMBOL_GPL(maple_driver_unregister); /* set hardware registers to enable next round of dma */ static void maple_dma_reset(void) { __raw_writel(MAPLE_MAGIC, MAPLE_RESET); /* set trig type to 0 for software trigger, 1 for hardware (VBLANK) */ __raw_writel(1, MAPLE_TRIGTYPE); /* * Maple system register * bits 31 - 16 timeout in units of 20nsec * bit 12 hard trigger - set 0 to keep responding to VBLANK * bits 9 - 8 set 00 for 2 Mbps, 01 for 1 Mbps * bits 3 - 0 delay (in 1.3ms) between VBLANK and start of DMA * max delay is 11 */ __raw_writel(MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), MAPLE_SPEED); __raw_writel(virt_to_phys(maple_sendbuf), MAPLE_DMAADDR); __raw_writel(1, MAPLE_ENABLE); } /** * maple_getcond_callback - setup handling MAPLE_COMMAND_GETCOND * @dev: device responding * @callback: handler callback * @interval: interval in jiffies between callbacks * @function: the function code for the device */ void maple_getcond_callback(struct maple_device *dev, void (*callback) (struct mapleq *mq), unsigned long interval, unsigned long function) { dev->callback = callback; dev->interval = interval; dev->function = cpu_to_be32(function); dev->when = jiffies; } EXPORT_SYMBOL_GPL(maple_getcond_callback); static int maple_dma_done(void) { return (__raw_readl(MAPLE_STATE) & 1) == 0; } static void maple_release_device(struct device *dev) { struct maple_device *mdev; struct mapleq *mq; mdev = to_maple_dev(dev); mq = mdev->mq; kmem_cache_free(maple_queue_cache, mq->recvbuf); kfree(mq); kfree(mdev); } /** * maple_add_packet - add a single instruction to the maple bus queue * @mdev: maple device * @function: function on device being queried * @command: maple command to add * @length: length of command string (in 32 bit words) * @data: remainder of command string */ int maple_add_packet(struct maple_device *mdev, u32 function, u32 command, size_t length, void *data) { int ret = 0; void *sendbuf = NULL; if (length) { sendbuf = kcalloc(length, 4, GFP_KERNEL); if (!sendbuf) { ret = -ENOMEM; goto out; } ((__be32 *)sendbuf)[0] = cpu_to_be32(function); } mdev->mq->command = command; mdev->mq->length = length; if (length > 1) memcpy(sendbuf + 4, data, (length - 1) * 4); mdev->mq->sendbuf = sendbuf; mutex_lock(&maple_wlist_lock); list_add_tail(&mdev->mq->list, &maple_waitq); mutex_unlock(&maple_wlist_lock); out: return ret; } EXPORT_SYMBOL_GPL(maple_add_packet); static struct mapleq *maple_allocq(struct maple_device *mdev) { struct mapleq *mq; mq = kzalloc_obj(*mq); if (!mq) goto failed_nomem; INIT_LIST_HEAD(&mq->list); mq->dev = mdev; mq->recvbuf = kmem_cache_zalloc(maple_queue_cache, GFP_KERNEL); if (!mq->recvbuf) goto failed_p2; mq->recvbuf->buf = &((mq->recvbuf->bufx)[0]); return mq; failed_p2: kfree(mq); failed_nomem: dev_err(&mdev->dev, "could not allocate memory for device (%d, %d)\n", mdev->port, mdev->unit); return NULL; } static struct maple_device *maple_alloc_dev(int port, int unit) { struct maple_device *mdev; /* zero this out to avoid kobj subsystem * thinking it has already been registered */ mdev = kzalloc_obj(*mdev); if (!mdev) return NULL; mdev->port = port; mdev->unit = unit; mdev->mq = maple_allocq(mdev); if (!mdev->mq) { kfree(mdev); return NULL; } mdev->dev.bus = &maple_bus_type; mdev->dev.parent = &maple_bus; init_waitqueue_head(&mdev->maple_wait); return mdev; } static void maple_free_dev(struct maple_device *mdev) { kmem_cache_free(maple_queue_cache, mdev->mq->recvbuf); kfree(mdev->mq); kfree(mdev); } /* process the command queue into a maple command block * terminating command has bit 32 of first long set to 0 */ static void maple_build_block(struct mapleq *mq) { int port, unit, from, to, len; unsigned long *lsendbuf = mq->sendbuf; port = mq->dev->port & 3; unit = mq->dev->unit; len = mq->length; from = port << 6; to = (port << 6) | (unit > 0 ? (1 << (unit - 1)) & 0x1f : 0x20); *maple_lastptr &= 0x7fffffff; maple_lastptr = maple_sendptr; *maple_sendptr++ = (port << 16) | len | 0x80000000; *maple_sendptr++ = virt_to_phys(mq->recvbuf->buf); *maple_sendptr++ = mq->command | (to << 8) | (from << 16) | (len << 24); while (len-- > 0) *maple_sendptr++ = *lsendbuf++; } /* build up command queue */ static void maple_send(void) { int i, maple_packets = 0; struct mapleq *mq, *nmq; if (!maple_dma_done()) return; /* disable DMA */ __raw_writel(0, MAPLE_ENABLE); if (!list_empty(&maple_sentq)) goto finish; mutex_lock(&maple_wlist_lock); if (list_empty(&maple_waitq)) { mutex_unlock(&maple_wlist_lock); goto finish; } maple_lastptr = maple_sendbuf; maple_sendptr = maple_sendbuf; list_for_each_entry_safe(mq, nmq, &maple_waitq, list) { maple_build_block(mq); list_del_init(&mq->list); list_add_tail(&mq->list, &maple_sentq); if (maple_packets++ > MAPLE_MAXPACKETS) break; } mutex_unlock(&maple_wlist_lock); if (maple_packets > 0) { for (i = 0; i < (1 << MAPLE_DMA_PAGES); i++) __flush_purge_region(maple_sendbuf + i * PAGE_SIZE, PAGE_SIZE); } finish: maple_dma_reset(); } /* check if there is a driver registered likely to match this device */ static int maple_check_matching_driver(struct device_driver *driver, void *devptr) { struct maple_driver *maple_drv; struct maple_device *mdev; mdev = devptr; maple_drv = to_maple_driver(driver); if (mdev->devinfo.function & cpu_to_be32(maple_drv->function)) return 1; return 0; } static void maple_detach_driver(struct maple_device *mdev) { device_unregister(&mdev->dev); } /* process initial MAPLE_COMMAND_DEVINFO for each device or port */ static void maple_attach_driver(struct maple_device *mdev) { char *p, *recvbuf; unsigned long function; int matched, error; recvbuf = mdev->mq->recvbuf->buf; /* copy the data as individual elements in * case of memory optimisation */ memcpy(&mdev->devinfo.function, recvbuf + 4, 4); memcpy(&mdev->devinfo.function_data[0], recvbuf + 8, 12); memcpy(&mdev->devinfo.area_code, recvbuf + 20, 1); memcpy(&mdev->devinfo.connector_direction, recvbuf + 21, 1); memcpy(&mdev->devinfo.product_name[0], recvbuf + 22, 30); memcpy(&mdev->devinfo.standby_power, recvbuf + 112, 2); memcpy(&mdev->devinfo.max_power, recvbuf + 114, 2); memcpy(mdev->product_name, mdev->devinfo.product_name, 30); mdev->product_name[30] = '\0'; memcpy(mdev->product_licence, mdev->devinfo.product_licence, 60); mdev->product_licence[60] = '\0'; for (p = mdev->product_name + 29; mdev->product_name <= p; p--) if (*p == ' ') *p = '\0'; else break; for (p = mdev->product_licence + 59; mdev->product_licence <= p; p--) if (*p == ' ') *p = '\0'; else break; function = be32_to_cpu(mdev->devinfo.function); dev_info(&mdev->dev, "detected %s: function 0x%lX: at (%d, %d)\n", mdev->product_name, function, mdev->port, mdev->unit); if (function > 0x200) { /* Do this silently - as not a real device */ function = 0; mdev->driver = &maple_unsupported_device; dev_set_name(&mdev->dev, "%d:0.port", mdev->port); } else { matched = bus_for_each_drv(&maple_bus_type, NULL, mdev, maple_check_matching_driver); if (matched == 0) { /* Driver does not exist yet */ dev_info(&mdev->dev, "no driver found\n"); mdev->driver = &maple_unsupported_device; } dev_set_name(&mdev->dev, "%d:0%d.%lX", mdev->port, mdev->unit, function); } mdev->function = function; mdev->dev.release = &maple_release_device; atomic_set(&mdev->busy, 0); error = device_register(&mdev->dev); if (error) { dev_warn(&mdev->dev, "could not register device at" " (%d, %d), with error 0x%X\n", mdev->unit, mdev->port, error); maple_free_dev(mdev); mdev = NULL; return; } } /* * if device has been registered for the given * port and unit then return 1 - allows identification * of which devices need to be attached or detached */ static int check_maple_device(struct device *device, void *portptr) { struct maple_device_specify *ds; struct maple_device *mdev; ds = portptr; mdev = to_maple_dev(device); if (mdev->port == ds->port && mdev->unit == ds->unit) return 1; return 0; } static int setup_maple_commands(struct device *device, void *ignored) { int add; struct maple_device *mdev = to_maple_dev(device); if (mdev->interval > 0 && atomic_read(&mdev->busy) == 0 && time_after(jiffies, mdev->when)) { /* bounce if we cannot add */ add = maple_add_packet(mdev, be32_to_cpu(mdev->devinfo.function), MAPLE_COMMAND_GETCOND, 1, NULL); if (!add) mdev->when = jiffies + mdev->interval; } else { if (time_after(jiffies, maple_pnp_time)) /* Ensure we don't have block reads and devinfo * calls interfering with one another - so flag the * device as busy */ if (atomic_read(&mdev->busy) == 0) { atomic_set(&mdev->busy, 1); maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO, 0, NULL); } } return 0; } /* VBLANK bottom half - implemented via workqueue */ static void maple_vblank_handler(struct work_struct *work) { int x, locking; struct maple_device *mdev; if (!maple_dma_done()) return; __raw_writel(0, MAPLE_ENABLE); if (!list_empty(&maple_sentq)) goto finish; /* * Set up essential commands - to fetch data and * check devices are still present */ bus_for_each_dev(&maple_bus_type, NULL, NULL, setup_maple_commands); if (time_after(jiffies, maple_pnp_time)) { /* * Scan the empty ports - bus is flakey and may have * mis-reported emptyness */ for (x = 0; x < MAPLE_PORTS; x++) { if (checked[x] && empty[x]) { mdev = baseunits[x]; if (!mdev) break; atomic_set(&mdev->busy, 1); locking = maple_add_packet(mdev, 0, MAPLE_COMMAND_DEVINFO, 0, NULL); if (!locking) break; } } maple_pnp_time = jiffies + MAPLE_PNP_INTERVAL; } finish: maple_send(); } /* handle devices added via hotplugs - placing them on queue for DEVINFO */ static void maple_map_subunits(struct maple_device *mdev, int submask) { int retval, k, devcheck; struct maple_device *mdev_add; struct maple_device_specify ds; ds.port = mdev->port; for (k = 0; k < 5; k++) { ds.unit = k + 1;