diff options
| author |   Koen Kooi <koen@openembedded.org> | 2009-09-25 11:13:34 +0200 |
|---|---|---|
| committer | Koen Kooi <koen@openembedded.org> | 2009-09-25 11:13:34 +0200 |
| commit | 6cbee2d68d949ac9946473c6fa8f1d4f2fe9c022 (patch) | |
| tree | 98f3fd7129ef942615722caddbd9ad6817c03f85 /recipes/linux/linux-omap-pm-2.6.29 | |
| parent | c03341eb967210fbbd0cc7fd5cbb4fc081317d88 (diff) | |
| download | openembedded-6cbee2d68d949ac9946473c6fa8f1d4f2fe9c022.tar.gz | |
linux-omap-pm 2.6.29: add omap3-touchbook support
Diffstat (limited to 'recipes/linux/linux-omap-pm-2.6.29')
31 files changed, 99837 insertions, 0 deletions
diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-mma7455l.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-mma7455l.patch new file mode 100644 index 0000000000..f6d522e352 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-mma7455l.patch @@ -0,0 +1,677 @@ +From 0b60175d1b7db1301e2ad3ad4d64fb0c8d121c0a Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Sat, 11 Apr 2009 13:05:21 -0700 +Subject: [PATCH] MMA7455L driver. + +--- + drivers/input/misc/Kconfig | 9 + + drivers/input/misc/Makefile | 1 + + drivers/input/misc/mma7455l.c | 614 +++++++++++++++++++++++++++++++++++++++++ + include/linux/mma7455l.h | 11 + + 4 files changed, 635 insertions(+), 0 deletions(-) + +diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig +index 6fa9e38..05dca18 100644 +--- a/drivers/input/misc/Kconfig ++++ b/drivers/input/misc/Kconfig +@@ -237,4 +237,13 @@ config INPUT_PCF50633_PMU + Say Y to include support for delivering PMU events via input + layer on NXP PCF50633. + ++config INPUT_MMA7455L ++ tristate "Freescale MMA7455L 3-axis accelerometer" ++ depends on SPI_MASTER ++ help ++ SPI driver for the Freescale MMA7455L 3-axis accelerometer. ++ ++ The userspace interface is a 3-axis (X/Y/Z) relative movement ++ Linux input device, reporting REL_[XYZ] events. ++ + endif +diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile +index 2fabcdb..e355d82 100644 +--- a/drivers/input/misc/Makefile ++++ b/drivers/input/misc/Makefile +@@ -23,3 +23,4 @@ obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON) += twl4030-pwrbutton.o + obj-$(CONFIG_INPUT_APANEL) += apanel.o + obj-$(CONFIG_INPUT_SGI_BTNS) += sgi_btns.o + obj-$(CONFIG_INPUT_PCF50633_PMU) += pcf50633-input.o ++obj-$(CONFIG_INPUT_MMA7455L) += mma7455l.o +diff --git a/drivers/input/misc/mma7455l.c b/drivers/input/misc/mma7455l.c +new file mode 100644 +index 0000000..b33c513 +--- /dev/null ++++ b/drivers/input/misc/mma7455l.c +@@ -0,0 +1,614 @@ ++/* Linux kernel driver for the Freescale MMA7455L 3-axis accelerometer ++ * ++ * Copyright (C) 2009 by Always Innovating, Inc. ++ * Author: Gregoire Gentil <gregoire@gentil.com> ++ * Author: Tim Yamin <plasm@roo.me.uk> ++ * All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License as ++ * published by the Free Software Foundation; either version 2 of ++ * the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, ++ * MA 02111-1307 USA ++ * ++ */ ++ ++/* ++ * What this driver doesn't yet support: ++ * ++ * - I2C ++ * - INT2 handling ++ * - Pulse detection (and the sysctls to control it) ++ * - 10-bit measurement ++ */ ++ ++#include <linux/kernel.h> ++#include <linux/types.h> ++#include <linux/module.h> ++#include <linux/device.h> ++#include <linux/platform_device.h> ++#include <linux/delay.h> ++#include <linux/input.h> ++#include <linux/irq.h> ++#include <linux/interrupt.h> ++#include <linux/sysfs.h> ++#include <linux/gpio.h> ++ ++#include <linux/mma7455l.h> ++#include <linux/spi/spi.h> ++ ++#define MMA7455L_WHOAMI_MAGIC 0x55 ++ ++enum mma7455l_reg { ++ MMA7455L_REG_XOUTL = 0x00, ++ MMA7455L_REG_XOUTH = 0x01, ++ MMA7455L_REG_YOUTL = 0x02, ++ MMA7455L_REG_YOUTH = 0x03, ++ MMA7455L_REG_ZOUTL = 0x04, ++ MMA7455L_REG_ZOUTH = 0x05, ++ MMA7455L_REG_XOUT8 = 0x06, ++ MMA7455L_REG_YOUT8 = 0x07, ++ MMA7455L_REG_ZOUT8 = 0x08, ++ MMA7455L_REG_STATUS = 0x09, ++ MMA7455L_REG_DETSRC = 0x0a, ++ MMA7455L_REG_TOUT = 0x0b, ++ MMA7455L_REG_RESERVED1 = 0x0c, ++ MMA7455L_REG_I2CAD = 0x0d, ++ MMA7455L_REG_USRINF = 0x0e, ++ MMA7455L_REG_WHOAMI = 0x0f, ++ MMA7455L_REG_XOFFL = 0x10, ++ MMA7455L_REG_XOFFH = 0x11, ++ MMA7455L_REG_YOFFL = 0x12, ++ MMA7455L_REG_YOFFH = 0x13, ++ MMA7455L_REG_ZOFFL = 0x14, ++ MMA7455L_REG_ZOFFH = 0x15, ++ MMA7455L_REG_MCTL = 0x16, ++ MMA7455L_REG_INTRST = 0x17, ++ MMA7455L_REG_CTL1 = 0x18, ++ MMA7455L_REG_CTL2 = 0x19, ++ MMA7455L_REG_LDTH = 0x1a, ++ MMA7455L_REG_PDTH = 0x1b, ++ MMA7455L_REG_PW = 0x1c, ++ MMA7455L_REG_LT = 0x1d, ++ MMA7455L_REG_TW = 0x1e, ++ MMA7455L_REG_RESERVED2 = 0x1f, ++}; ++ ++enum mma7455l_reg_status { ++ MMA7455L_STATUS_XDA = 0x08, ++ MMA7455L_STATUS_YDA = 0x10, ++ MMA7455L_STATUS_ZDA = 0x20, ++}; ++ ++enum mma7455l_mode { ++ MMA7455L_MODE_STANDBY = 0, ++ MMA7455L_MODE_MEASUREMENT = 1, ++ MMA7455L_MODE_LEVELDETECTION = 0x42, /* Set DRPD to on */ ++ MMA7455L_MODE_PULSEDETECTION = 0x43, /* Set DRPD to on */ ++ MMA7455L_MODE_MASK = 0x43, ++}; ++ ++enum mma7455l_gselect { ++ MMA7455L_GSELECT_8 = 0x0, ++ MMA7455L_GSELECT_2 = 0x4, ++ MMA7455L_GSELECT_4 = 0x8, ++ MMA7455L_GSELECT_MASK = 0xC, ++}; ++ ++/* FIXME */ ++#define MMA7455L_F_FS 0x0020 /* ADC full scale */ ++ ++struct mma7455l_info { ++ struct spi_device *spi_dev; ++ struct input_dev *input_dev; ++ struct mutex lock; ++ struct delayed_work work; ++ ++ u8 mode; ++ u8 gSelect; ++ ++ u8 flags; ++ u8 working; ++}; ++ ++/* lowlevel register access functions */ ++ ++#define WRITE_BIT (1 << 7) ++#define ADDR_SHIFT 1 ++ ++static inline u_int8_t __reg_read(struct mma7455l_info *mma, u_int8_t reg) ++{ ++ int rc; ++ u_int8_t cmd; ++ ++ cmd = ((reg & 0x3f) << ADDR_SHIFT); ++ rc = spi_w8r8(mma->spi_dev, cmd); ++ ++ return rc; ++} ++ ++static u_int8_t reg_read(struct mma7455l_info *mma, u_int8_t reg) ++{ ++ u_int8_t ret; ++ ++ mutex_lock(&mma->lock); ++ ret = __reg_read(mma, reg); ++ mutex_unlock(&mma->lock); ++ ++ return ret; ++} ++ ++static s16 __reg_read_10(struct mma7455l_info *mma, u8 reg1, u8 reg2) ++{ ++ u8 v1, v2; ++ ++ v1 = __reg_read(mma, reg1); ++ v2 = __reg_read(mma, reg2); ++ ++ return (v2 & 0x4) << 13 | (v2 & 0x3) << 8 | v1; ++} ++ ++static inline int __reg_write(struct mma7455l_info *mma, u_int8_t reg, u_int8_t val) ++{ ++ u_int8_t buf[2]; ++ ++ buf[0] = ((reg & 0x3f) << ADDR_SHIFT) | WRITE_BIT; ++ buf[1] = val; ++ ++ return spi_write(mma->spi_dev, buf, sizeof(buf)); ++} ++ ++static int reg_write(struct mma7455l_info *mma, u_int8_t reg, u_int8_t val) ++{ ++ int ret; ++ ++ mutex_lock(&mma->lock); ++ ret = __reg_write(mma, reg, val); ++ mutex_unlock(&mma->lock); ++ ++ return ret; ++} ++ ++static s16 __reg_write_10(struct mma7455l_info *mma, u8 reg1, u8 reg2, s16 value) ++{ ++ int ret; ++ u8 v1, v2; ++ ++ v1 = value & 0xFF; ++ if(value < 0) ++ v2 = ((value >> 8) & 0x3) | 0x4; ++ else ++ v2 = 0; ++ ++ ret = __reg_write(mma, reg1, v1); ++ ret = __reg_write(mma, reg2, v2); ++ return ret; ++} ++ ++static void mma7455l_work(struct work_struct *work) ++{ ++ struct mma7455l_info *mma = ++ container_of(work, struct mma7455l_info, work.work); ++ ++ s8 val; ++ mma->working = 1; ++ ++ /* FIXME: 10 bit accuracy? */ ++ if (!(mma->flags & MMA7455L_STATUS_XDA)) { ++ val = reg_read(mma, MMA7455L_REG_XOUT8); ++ input_report_abs(mma->input_dev, ABS_X, val); ++ } ++ if (!(mma->flags & MMA7455L_STATUS_YDA)) { ++ val = reg_read(mma, MMA7455L_REG_YOUT8); ++ input_report_abs(mma->input_dev, ABS_Y, val); ++ } ++ if (!(mma->flags & MMA7455L_STATUS_ZDA)) { ++ val = reg_read(mma, MMA7455L_REG_ZOUT8); ++ input_report_abs(mma->input_dev, ABS_Z, val); ++ } ++ ++ mma->working = 0; ++ input_sync(mma->input_dev); ++ put_device(&mma->spi_dev->dev); ++ ++ /* Enable IRQ and clear out interrupt */ ++ reg_write(mma, MMA7455L_REG_INTRST, 0x3); ++ reg_write(mma, MMA7455L_REG_INTRST, 0x0); ++ enable_irq(mma->spi_dev->irq); ++} ++ ++static void mma7455l_schedule_work(struct mma7455l_info *mma) ++{ ++ int status; ++ ++ get_device(&mma->spi_dev->dev); ++ status = schedule_delayed_work(&mma->work, HZ / 10); ++} ++ ++static irqreturn_t mma7455l_interrupt(int irq, void *_mma) ++{ ++ struct mma7455l_info *mma = _mma; ++ mma7455l_schedule_work(mma); ++ ++ /* Disable any further interrupts until we have processed ++ * the current one */ ++ disable_irq(mma->spi_dev->irq); ++ return IRQ_HANDLED; ++} ++ ++/* sysfs */ ++ ++static void get_mode(struct mma7455l_info *mma, u8 *mode, u8 *gSelect) ++{ ++ u8 tmp = reg_read(mma, MMA7455L_REG_MCTL); ++ ++ *mode = tmp & MMA7455L_MODE_MASK; ++ *gSelect = tmp & MMA7455L_GSELECT_MASK; ++} ++ ++static void set_mode(struct mma7455l_info *mma, u8 mode, u8 gSelect) ++{ ++ reg_write(mma, MMA7455L_REG_MCTL, mode | gSelect); ++} ++ ++static void update_mode(struct mma7455l_info *mma, u8 mode, u8 gSelect) ++{ ++ mma->mode = mode; ++ mma->gSelect = gSelect; ++ ++ reg_write(mma, MMA7455L_REG_MCTL, mma->mode | mma->gSelect); ++} ++ ++static ssize_t show_measure(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ s8 x, y, z; ++ u8 old_Mode, old_gSelect; ++ ++ get_mode(mma, &old_Mode, &old_gSelect); ++ set_mode(mma, MMA7455L_MODE_MEASUREMENT, MMA7455L_GSELECT_2); ++ ++ while (reg_read(mma, MMA7455L_REG_STATUS) == 0) { ++ msleep(10); ++ } ++ ++ x = reg_read(mma, MMA7455L_REG_XOUT8); ++ y = reg_read(mma, MMA7455L_REG_YOUT8); ++ z = reg_read(mma, MMA7455L_REG_ZOUT8); ++ ++ set_mode(mma, old_Mode, old_gSelect); ++ return sprintf(buf, "%d %d %d\n", x, y, z); ++} ++ ++static ssize_t show_mode(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ switch(mma->mode) ++ { ++ case MMA7455L_MODE_STANDBY: ++ return sprintf(buf, "Standby\n"); ++ break; ++ case MMA7455L_MODE_MEASUREMENT: ++ return sprintf(buf, "Measurement\n"); ++ break; ++ case MMA7455L_MODE_LEVELDETECTION: ++ return sprintf(buf, "Level Detection\n"); ++ break; ++ case MMA7455L_MODE_PULSEDETECTION: ++ return sprintf(buf, "Pulse Detection\n"); ++ break; ++ } ++ ++ return sprintf(buf, "Unknown mode!\n"); ++} ++ ++static ssize_t show_gSelect(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ switch(mma->gSelect) ++ { ++ case MMA7455L_GSELECT_8: ++ return sprintf(buf, "8\n"); ++ break; ++ case MMA7455L_GSELECT_4: ++ return sprintf(buf, "4\n"); ++ break; ++ case MMA7455L_GSELECT_2: ++ return sprintf(buf, "2\n"); ++ break; ++ } ++ ++ return sprintf(buf, "Unknown gSelect!\n"); ++} ++ ++static ssize_t show_level_threshold(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", reg_read(mma, MMA7455L_REG_LDTH)); ++} ++ ++static ssize_t show_calibration(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ s16 x, y, z; ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ mutex_lock(&mma->lock); ++ x = __reg_read_10(mma, MMA7455L_REG_XOFFL, MMA7455L_REG_XOFFH); ++ y = __reg_read_10(mma, MMA7455L_REG_YOFFL, MMA7455L_REG_YOFFH); ++ z = __reg_read_10(mma, MMA7455L_REG_ZOFFL, MMA7455L_REG_ZOFFH); ++ mutex_unlock(&mma->lock); ++ ++ return sprintf(buf, "%d %d %d\n", x, y, z); ++} ++ ++static ssize_t write_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ if (!strncmp(buf, "Standby", count)) ++ update_mode(mma, MMA7455L_MODE_STANDBY, mma->gSelect); ++ else if (!strncmp(buf, "Measurement", count)) ++ update_mode(mma, MMA7455L_MODE_MEASUREMENT, mma->gSelect); ++ else if (!strncmp(buf, "Level Detection", count)) ++ update_mode(mma, MMA7455L_MODE_LEVELDETECTION, mma->gSelect); ++ else if (!strncmp(buf, "Pulse Detection", count)) ++ update_mode(mma, MMA7455L_MODE_PULSEDETECTION, mma->gSelect); ++ ++ return count; ++} ++ ++static ssize_t write_gSelect(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ++{ ++ unsigned long v; ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ if(strict_strtoul(buf, 10, &v) == 0) ++ { ++ switch(v) ++ { ++ case 8: ++ update_mode(mma, mma->mode, MMA7455L_GSELECT_8); ++ break; ++ case 4: ++ update_mode(mma, mma->mode, MMA7455L_GSELECT_4); ++ break; ++ case 2: ++ update_mode(mma, mma->mode, MMA7455L_GSELECT_2); ++ break; ++ default: ++ return -EINVAL; ++ break; ++ } ++ return count; ++ } ++ ++ return -EINVAL; ++} ++ ++static ssize_t write_level_threshold(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ++{ ++ unsigned long v; ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ if(strict_strtoul(buf, 10, &v) == 0) ++ { ++ if(v <= 0xFF) { ++ reg_write(mma, MMA7455L_REG_LDTH, v); ++ return count; ++ } else ++ return -EINVAL; ++ } ++ ++ return -EINVAL; ++} ++ ++static ssize_t write_calibration(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ++{ ++ int x, y, z; ++ struct mma7455l_info *mma = dev_get_drvdata(dev); ++ ++ if (sscanf(buf, "%d %d %d", &x, &y, &z) == 3) ++ { ++ mutex_lock(&mma->lock); ++ __reg_write_10(mma, MMA7455L_REG_XOFFL, MMA7455L_REG_XOFFH, x); ++ __reg_write_10(mma, MMA7455L_REG_YOFFL, MMA7455L_REG_YOFFH, y); ++ __reg_write_10(mma, MMA7455L_REG_ZOFFL, MMA7455L_REG_ZOFFH, z); ++ mutex_unlock(&mma->lock); ++ ++ return count; ++ } ++ ++ return -EINVAL; ++} ++ ++static DEVICE_ATTR(measure, S_IRUGO, show_measure, NULL); ++static DEVICE_ATTR(mode, S_IRUGO | S_IWUGO, show_mode, write_mode); ++static DEVICE_ATTR(gSelect, S_IRUGO | S_IWUGO, show_gSelect, write_gSelect); ++static DEVICE_ATTR(level_threshold, S_IRUGO | S_IWUGO, show_level_threshold, write_level_threshold); ++static DEVICE_ATTR(calibration, S_IRUGO | S_IWUGO, show_calibration, write_calibration); ++ ++static struct attribute *mma7455l_sysfs_entries[] = { ++ &dev_attr_measure.attr, ++ &dev_attr_mode.attr, ++ &dev_attr_gSelect.attr, ++ &dev_attr_level_threshold.attr, ++ &dev_attr_calibration.attr, ++ NULL ++}; ++ ++static struct attribute_group mma7455l_attr_group = { ++ .attrs = mma7455l_sysfs_entries, ++}; ++ ++/* input device handling and driver core interaction */ ++static int mma7455l_input_open(struct input_dev *inp) ++{ ++ struct mma7455l_info *mma = input_get_drvdata(inp); ++ if(mma->mode == MMA7455L_MODE_STANDBY) ++ update_mode(mma, MMA7455L_MODE_MEASUREMENT, mma->gSelect); ++ ++ return 0; ++} ++ ++static void mma7455l_input_close(struct input_dev *inp) ++{ ++ struct mma7455l_info *mma = input_get_drvdata(inp); ++ update_mode(mma, MMA7455L_MODE_STANDBY, MMA7455L_GSELECT_2); ++} ++ ++static int __devinit mma7455l_probe(struct spi_device *spi) ++{ ++ int rc; ++ struct mma7455l_info *mma; ++ struct mma7455l_platform_data *pdata = spi->dev.platform_data; ++ u_int8_t wai; ++ ++ mma = kzalloc(sizeof(*mma), GFP_KERNEL); ++ if (!mma) ++ return -ENOMEM; ++ ++ mutex_init(&mma->lock); ++ INIT_DELAYED_WORK(&mma->work, mma7455l_work); ++ mma->spi_dev = spi; ++ mma->flags = mma->working = 0; ++ ++ spi_set_drvdata(spi, mma); ++ ++ rc = spi_setup(spi); ++ if (rc < 0) { ++ printk(KERN_ERR "mma7455l error durign spi_setup of mma7455l driver\n"); ++ dev_set_drvdata(&spi->dev, NULL); ++ kfree(mma); ++ return rc; ++ } ++ ++ wai = reg_read(mma, MMA7455L_REG_WHOAMI); ++ if (wai != MMA7455L_WHOAMI_MAGIC) { ++ printk(KERN_ERR "mma7455l unknown whoami signature 0x%02x\n", wai); ++ dev_set_drvdata(&spi->dev, NULL); ++ kfree(mma); ++ return -ENODEV; ++ } ++ ++ rc = request_irq(mma->spi_dev->irq, mma7455l_interrupt, IRQF_TRIGGER_HIGH, ++ "mma7455l", mma); ++ if (rc < 0) { ++ dev_err(&spi->dev, "mma7455l error requesting IRQ %d\n", ++ mma->spi_dev->irq); ++ /* FIXME */ ++ return rc; ++ } ++ ++ rc = sysfs_create_group(&spi->dev.kobj, &mma7455l_attr_group); ++ if (rc) { ++ dev_err(&spi->dev, "error creating sysfs group\n"); ++ return rc; ++ } ++ ++ /* initialize input layer details */ ++ mma->input_dev = input_allocate_device(); ++ if (!mma->input_dev) { ++ dev_err(&spi->dev, "mma7455l Unable to allocate input device\n"); ++ /* FIXME */ ++ } ++ ++ set_bit(EV_ABS, mma->input_dev->evbit); ++ set_bit(ABS_X, mma->input_dev->absbit); ++ set_bit(ABS_Y, mma->input_dev->absbit); ++ set_bit(ABS_Z, mma->input_dev->absbit); ++ ++ input_set_drvdata(mma->input_dev, mma); ++ mma->input_dev->name = "MMA7455L"; ++ mma->input_dev->open = mma7455l_input_open; ++ mma->input_dev->close = mma7455l_input_close; ++ ++ rc = input_register_device(mma->input_dev); ++ if(!rc) ++ { ++ update_mode(mma, MMA7455L_MODE_STANDBY, MMA7455L_GSELECT_2); ++ ++ mutex_lock(&mma->lock); ++ __reg_write_10(mma, MMA7455L_REG_XOFFL, MMA7455L_REG_XOFFH, pdata->calibration_x); ++ __reg_write_10(mma, MMA7455L_REG_YOFFL, MMA7455L_REG_YOFFH, pdata->calibration_y); ++ __reg_write_10(mma, MMA7455L_REG_ZOFFL, MMA7455L_REG_ZOFFH, pdata->calibration_z); ++ mutex_unlock(&mma->lock); ++ ++ return 0; ++ } ++ ++ input_free_device(mma->input_dev); ++ return rc; ++} ++ ++static int __devexit mma7455l_remove(struct spi_device *spi) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(&spi->dev); ++ ++ sysfs_remove_group(&spi->dev.kobj, &mma7455l_attr_group); ++ input_unregister_device(mma->input_dev); ++ dev_set_drvdata(&spi->dev, NULL); ++ kfree(mma); ++ ++ return 0; ++} ++ ++#ifdef CONFIG_PM ++static int mma7455l_suspend(struct spi_device *spi, pm_message_t message) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(&spi->dev); ++ get_mode(mma, &mma->mode, &mma->gSelect); ++ set_mode(mma, MMA7455L_MODE_STANDBY, MMA7455L_GSELECT_2); ++ ++ return 0; ++} ++ ++static int mma7455l_resume(struct spi_device *spi) ++{ ++ struct mma7455l_info *mma = dev_get_drvdata(&spi->dev); ++ update_mode(mma, mma->mode, mma->gSelect); ++ ++ return 0; ++} ++#else ++#define mma7455l_suspend NULL ++#define mma7455l_resume NULL ++#endif ++ ++static struct spi_driver mma7455l_driver = { ++ .driver = { ++ .name = "mma7455l", ++ .owner = THIS_MODULE, ++ }, ++ ++ .probe = mma7455l_probe, ++ .remove = __devexit_p(mma7455l_remove), ++ .suspend = mma7455l_suspend, ++ .resume = mma7455l_resume, ++}; ++ ++static int __init mma7455l_init(void) ++{ ++ return spi_register_driver(&mma7455l_driver); ++} ++ ++static void __exit mma7455l_exit(void) ++{ ++ spi_unregister_driver(&mma7455l_driver); ++} ++ ++MODULE_AUTHOR("Gregoire Gentil <gregoire@gentil.com>"); ++MODULE_LICENSE("GPL"); ++ ++module_init(mma7455l_init); ++module_exit(mma7455l_exit); +diff --git a/include/linux/mma7455l.h b/include/linux/mma7455l.h +new file mode 100644 +index 0000000..12ab50a +--- /dev/null ++++ b/include/linux/mma7455l.h +@@ -0,0 +1,11 @@ ++#ifndef _LINUX_MMA7455L_H ++#define _LINUX_MMA7455L_H ++ ++struct mma7455l_platform_data { ++ /* Calibration offsets */ ++ s16 calibration_x; ++ s16 calibration_y; ++ s16 calibration_z; ++}; ++ ++#endif /* _LINUX_MMA7455L_H */ + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-touchscreen-mux-spi.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-touchscreen-mux-spi.patch new file mode 100644 index 0000000000..57bb4196dd --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/accelerometer-touchscreen-mux-spi.patch @@ -0,0 +1,64 @@ +--- a/arch/arm/mach-omap2/devices.c 2009-02-17 21:15:12.000000000 -0800 ++++ b/arch/arm/mach-omap2/devices.c 2009-02-17 22:30:26.000000000 -0800 +@@ -15,6 +15,7 @@ + #include <linux/platform_device.h> + #include <linux/io.h> + #include <linux/clk.h> ++#include <linux/spi/spi_gpio.h> + + #include <mach/hardware.h> + #include <asm/mach-types.h> +@@ -347,6 +348,37 @@ + .platform_data = &omap2_mcspi4_config, + }, + }; ++ ++static struct spi_gpio_platform_data spi3_gpio_platform_data = { ++ .miso = 132, ++ .mosi = 131, ++ .sck = 130, ++ .num_chipselect = 1, ++}; ++ ++static struct platform_device spi3_gpio = { ++ .name = "spi_gpio", ++ .id = 3, ++ .dev = { ++ .platform_data = &spi3_gpio_platform_data, ++ }, ++}; ++ ++static struct spi_gpio_platform_data spi4_gpio_platform_data = { ++ .miso = 159, ++ .mosi = 158, ++ .sck = 156, ++ .num_chipselect = 1, ++}; ++ ++static struct platform_device spi4_gpio = { ++ .name = "spi_gpio", ++ .id = 4, ++ .dev = { ++ .platform_data = &spi4_gpio_platform_data, ++ }, ++}; ++ + #endif + + static void omap_init_mcspi(void) +--- a/drivers/input/touchscreen/ads7846.c 2009-04-07 10:04:12.000000000 -0700 ++++ b/drivers/input/touchscreen/ads7846.c 2009-04-11 12:39:51.000000000 -0700 +@@ -887,13 +919,6 @@ + return 0; + } + +- err = gpio_request(pdata->gpio_pendown, "ads7846_pendown"); +- if (err) { +- dev_err(&spi->dev, "failed to request pendown GPIO%d\n", +- pdata->gpio_pendown); +- return err; +- } +- + ts->gpio_pendown = pdata->gpio_pendown; + return 0; + } diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-1.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-1.patch new file mode 100644 index 0000000000..3b54e71791 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-1.patch @@ -0,0 +1,35 @@ +aufs2 kbuild patch for linux-2.6.29 + +diff --git a/fs/Kconfig b/fs/Kconfig +index 93945dd..75156dd 100644 +--- a/fs/Kconfig ++++ b/fs/Kconfig +@@ -222,6 +222,7 @@ source "fs/qnx4/Kconfig" + source "fs/romfs/Kconfig" + source "fs/sysv/Kconfig" + source "fs/ufs/Kconfig" ++source "fs/aufs/Kconfig" + + endif # MISC_FILESYSTEMS + +diff --git a/fs/Makefile b/fs/Makefile +index dc20db3..a4e9a65 100644 +--- a/fs/Makefile ++++ b/fs/Makefile +@@ -124,3 +124,4 @@ obj-$(CONFIG_DEBUG_FS) += debugfs/ + obj-$(CONFIG_OCFS2_FS) += ocfs2/ + obj-$(CONFIG_BTRFS_FS) += btrfs/ + obj-$(CONFIG_GFS2_FS) += gfs2/ ++obj-$(CONFIG_AUFS_FS) += aufs/ +diff --git a/include/linux/Kbuild b/include/linux/Kbuild +index 106c3ba..d0c7262 100644 +--- a/include/linux/Kbuild ++++ b/include/linux/Kbuild +@@ -34,6 +34,7 @@ header-y += atmppp.h + header-y += atmsap.h + header-y += atmsvc.h + header-y += atm_zatm.h ++header-y += aufs_type.h + header-y += auto_fs4.h + header-y += ax25.h + header-y += b1lli.h diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-2.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-2.patch new file mode 100644 index 0000000000..bc3d5d8795 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-2.patch @@ -0,0 +1,285 @@ +aufs2 standalone patch for linux-2.6.29 + +diff --git a/fs/namei.c b/fs/namei.c +index bbc15c2..f446c65 100644 +--- a/fs/namei.c ++++ b/fs/namei.c +@@ -335,6 +335,9 @@ int deny_write_access(struct file * file) + + return 0; + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(deny_write_access); ++#endif + + /** + * path_get - get a reference to a path +@@ -1196,7 +1199,7 @@ out: + * needs parent already locked. Doesn't follow mounts. + * SMP-safe. + */ +-static struct dentry *lookup_hash(struct nameidata *nd) ++struct dentry *lookup_hash(struct nameidata *nd) + { + int err; + +@@ -1205,8 +1208,11 @@ static struct dentry *lookup_hash(struct nameidata *nd) + return ERR_PTR(err); + return __lookup_hash(&nd->last, nd->path.dentry, nd); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(lookup_hash); ++#endif + +-static int __lookup_one_len(const char *name, struct qstr *this, ++int __lookup_one_len(const char *name, struct qstr *this, + struct dentry *base, int len) + { + unsigned long hash; +@@ -1227,6 +1233,9 @@ static int __lookup_one_len(const char *name, struct qstr *this, + this->hash = end_name_hash(hash); + return 0; + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(__lookup_one_len); ++#endif + + /** + * lookup_one_len - filesystem helper to lookup single pathname component +diff --git a/fs/namespace.c b/fs/namespace.c +index 06f8e63..dcdc4ff 100644 +--- a/fs/namespace.c ++++ b/fs/namespace.c +@@ -37,6 +37,9 @@ + + /* spinlock for vfsmount related operations, inplace of dcache_lock */ + __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock); ++#if defined(CONFIG_AUFS_FS_MODULE) && defined(CONFIG_AUFS_EXPORT) ++EXPORT_SYMBOL(vfsmount_lock); ++#endif + + static int event; + static DEFINE_IDA(mnt_id_ida); +diff --git a/fs/open.c b/fs/open.c +index a3a78ce..7d70245 100644 +--- a/fs/open.c ++++ b/fs/open.c +@@ -220,6 +220,9 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs, + mutex_unlock(&dentry->d_inode->i_mutex); + return err; + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(do_truncate); ++#endif + + static long do_sys_truncate(const char __user *pathname, loff_t length) + { +diff --git a/fs/splice.c b/fs/splice.c +index 4ed0ba4..a110d76 100644 +--- a/fs/splice.c ++++ b/fs/splice.c +@@ -888,8 +888,8 @@ EXPORT_SYMBOL(generic_splice_sendpage); + /* + * Attempt to initiate a splice from pipe to file. + */ +-static long do_splice_from(struct pipe_inode_info *pipe, struct file *out, +- loff_t *ppos, size_t len, unsigned int flags) ++long do_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags) + { + int ret; + +@@ -908,13 +908,16 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out, + + return out->f_op->splice_write(pipe, out, ppos, len, flags); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(do_splice_from); ++#endif + + /* + * Attempt to initiate a splice from a file to a pipe. + */ +-static long do_splice_to(struct file *in, loff_t *ppos, +- struct pipe_inode_info *pipe, size_t len, +- unsigned int flags) ++long do_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) + { + int ret; + +@@ -930,6 +933,9 @@ static long do_splice_to(struct file *in, loff_t *ppos, + + return in->f_op->splice_read(in, ppos, pipe, len, flags); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(do_splice_to); ++#endif + + /** + * splice_direct_to_actor - splices data directly between two non-pipes +diff --git a/fs/super.c b/fs/super.c +index 6ce5014..95eefb9 100644 +--- a/fs/super.c ++++ b/fs/super.c +@@ -287,6 +287,9 @@ int fsync_super(struct super_block *sb) + __fsync_super(sb); + return sync_blockdev(sb->s_bdev); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(fsync_super); ++#endif + + /** + * generic_shutdown_super - common helper for ->kill_sb() +diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h +index 23bf02f..49e5b47 100644 +--- a/include/linux/lockdep.h ++++ b/include/linux/lockdep.h +@@ -58,7 +58,7 @@ enum lock_usage_bit + #define LOCKF_USED_IN_IRQ_READ \ + (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ) + +-#define MAX_LOCKDEP_SUBCLASSES 8UL ++#define MAX_LOCKDEP_SUBCLASSES 12UL + + /* + * Lock-classes are keyed via unique addresses, by embedding the +diff --git a/include/linux/namei.h b/include/linux/namei.h +index fc2e035..182d43b 100644 +--- a/include/linux/namei.h ++++ b/include/linux/namei.h +@@ -75,6 +75,9 @@ extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry + extern struct file *nameidata_to_filp(struct nameidata *nd, int flags); + extern void release_open_intent(struct nameidata *); + ++extern struct dentry *lookup_hash(struct nameidata *nd); ++extern int __lookup_one_len(const char *name, struct qstr *this, ++ struct dentry *base, int len); + extern struct dentry *lookup_one_len(const char *, struct dentry *, int); + extern struct dentry *lookup_one_noperm(const char *, struct dentry *); + +diff --git a/include/linux/splice.h b/include/linux/splice.h +index 528dcb9..5123bc6 100644 +--- a/include/linux/splice.h ++++ b/include/linux/splice.h +@@ -71,4 +71,10 @@ extern ssize_t splice_to_pipe(struct pipe_inode_info *, + extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *, + splice_direct_actor *); + ++extern long do_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags); ++extern long do_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags); ++ + #endif +diff --git a/security/device_cgroup.c b/security/device_cgroup.c +index 3aacd0f..76c8876 100644 +--- a/security/device_cgroup.c ++++ b/security/device_cgroup.c +@@ -507,6 +507,9 @@ acc_check: + + return -EPERM; + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(devcgroup_inode_permission); ++#endif + + int devcgroup_inode_mknod(int mode, dev_t dev) + { +diff --git a/security/security.c b/security/security.c +index c3586c0..f8798f8 100644 +--- a/security/security.c ++++ b/security/security.c +@@ -389,6 +389,9 @@ int security_path_mkdir(struct path *path, struct dentry *dentry, int mode) + return 0; + return security_ops->path_mkdir(path, dentry, mode); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_mkdir); ++#endif + + int security_path_rmdir(struct path *path, struct dentry *dentry) + { +@@ -396,6 +399,9 @@ int security_path_rmdir(struct path *path, struct dentry *dentry) + return 0; + return security_ops->path_rmdir(path, dentry); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_rmdir); ++#endif + + int security_path_unlink(struct path *path, struct dentry *dentry) + { +@@ -403,6 +409,9 @@ int security_path_unlink(struct path *path, struct dentry *dentry) + return 0; + return security_ops->path_unlink(path, dentry); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_unlink); ++#endif + + int security_path_symlink(struct path *path, struct dentry *dentry, + const char *old_name) +@@ -411,6 +420,9 @@ int security_path_symlink(struct path *path, struct dentry *dentry, + return 0; + return security_ops->path_symlink(path, dentry, old_name); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_symlink); ++#endif + + int security_path_link(struct dentry *old_dentry, struct path *new_dir, + struct dentry *new_dentry) +@@ -419,6 +431,9 @@ int security_path_link(struct dentry *old_dentry, struct path *new_dir, + return 0; + return security_ops->path_link(old_dentry, new_dir, new_dentry); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_link); ++#endif + + int security_path_rename(struct path *old_dir, struct dentry *old_dentry, + struct path *new_dir, struct dentry *new_dentry) +@@ -429,6 +444,9 @@ int security_path_rename(struct path *old_dir, struct dentry *old_dentry, + return security_ops->path_rename(old_dir, old_dentry, new_dir, + new_dentry); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_rename); ++#endif + + int security_path_truncate(struct path *path, loff_t length, + unsigned int time_attrs) +@@ -437,6 +455,9 @@ int security_path_truncate(struct path *path, loff_t length, + return 0; + return security_ops->path_truncate(path, length, time_attrs); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_path_truncate); ++#endif + #endif + + int security_inode_create(struct inode *dir, struct dentry *dentry, int mode) +@@ -506,6 +527,9 @@ int security_inode_readlink(struct dentry *dentry) + return 0; + return security_ops->inode_readlink(dentry); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_inode_readlink); ++#endif + + int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd) + { +@@ -520,6 +544,9 @@ int security_inode_permission(struct inode *inode, int mask) + return 0; + return security_ops->inode_permission(inode, mask); + } ++#ifdef CONFIG_AUFS_FS_MODULE ++EXPORT_SYMBOL(security_inode_permission); ++#endif + + int security_inode_setattr(struct dentry *dentry, struct iattr *attr) + { diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-3.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-3.patch new file mode 100644 index 0000000000..34a035a037 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-3.patch @@ -0,0 +1,23604 @@ +diff -Naur a/Documentation/ABI/testing/debugfs-aufs b/Documentation/ABI/testing/debugfs-aufs +--- a/Documentation/ABI/testing/debugfs-aufs 1969-12-31 16:00:00.000000000 -0800 ++++ b/Documentation/ABI/testing/debugfs-aufs 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,40 @@ ++What: /debug/aufs/si_<id>/ ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ Under /debug/aufs, a directory named si_<id> is created ++ per aufs mount, where <id> is a unique id generated ++ internally. ++ ++What: /debug/aufs/si_<id>/xib ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ It shows the consumed blocks by xib (External Inode Number ++ Bitmap), its block size and file size. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see ++ Documentation/filesystems/aufs/aufs.5 in detail. ++ ++What: /debug/aufs/si_<id>/xino0, xino1 ... xinoN ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ It shows the consumed blocks by xino (External Inode Number ++ Translation Table), its link count, block size and file ++ size. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see ++ Documentation/filesystems/aufs/aufs.5 in detail. ++ ++What: /debug/aufs/si_<id>/xigen ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ It shows the consumed blocks by xigen (External Inode ++ Generation Table), its block size and file size. ++ If CONFIG_AUFS_EXPORT is disabled, this entry will not ++ be created. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see ++ Documentation/filesystems/aufs/aufs.5 in detail. +diff -Naur a/Documentation/ABI/testing/sysfs-aufs b/Documentation/ABI/testing/sysfs-aufs +--- a/Documentation/ABI/testing/sysfs-aufs 1969-12-31 16:00:00.000000000 -0800 ++++ b/Documentation/ABI/testing/sysfs-aufs 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,25 @@ ++What: /sys/fs/aufs/si_<id>/ ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ Under /sys/fs/aufs, a directory named si_<id> is created ++ per aufs mount, where <id> is a unique id generated ++ internally. ++ ++What: /sys/fs/aufs/si_<id>/br0, br1 ... brN ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ It shows the abolute path of a member directory (which ++ is called branch) in aufs, and its permission. ++ ++What: /sys/fs/aufs/si_<id>/xi_path ++Date: March 2009 ++Contact: J. R. Okajima <hooanon05@yahoo.co.jp> ++Description: ++ It shows the abolute path of XINO (External Inode Number ++ Bitmap, Translation Table and Generation Table) file ++ even if it is the default path. ++ When the aufs mount option 'noxino' is specified, it ++ will be empty. About XINO files, see ++ Documentation/filesystems/aufs/aufs.5 in detail. +diff -Naur a/fs/aufs/aufs.h b/fs/aufs/aufs.h +--- a/fs/aufs/aufs.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/aufs.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,51 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * all header files ++ */ ++ ++#ifndef __AUFS_H__ ++#define __AUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include "debug.h" ++ ++#include "branch.h" ++#include "cpup.h" ++#include "dcsub.h" ++#include "dbgaufs.h" ++#include "dentry.h" ++#include "dir.h" ++#include "file.h" ++#include "fstype.h" ++#include "inode.h" ++#include "loop.h" ++#include "module.h" ++#include "opts.h" ++#include "rwsem.h" ++#include "spl.h" ++#include "super.h" ++#include "sysaufs.h" ++#include "vfsub.h" ++#include "whout.h" ++#include "wkq.h" ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_H__ */ +diff -Naur a/fs/aufs/branch.c b/fs/aufs/branch.c +--- a/fs/aufs/branch.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/branch.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,956 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * branch management ++ */ ++ ++#include <linux/file.h> ++#include "aufs.h" ++ ++/* ++ * free a single branch ++ */ ++static void au_br_do_free(struct au_branch *br) ++{ ++ int i; ++ struct au_wbr *wbr; ++ ++ if (br->br_xino.xi_file) ++ fput(br->br_xino.xi_file); ++ mutex_destroy(&br->br_xino.xi_nondir_mtx); ++ ++ AuDebugOn(atomic_read(&br->br_count)); ++ ++ wbr = br->br_wbr; ++ if (wbr) { ++ for (i = 0; i < AuBrWh_Last; i++) ++ dput(wbr->wbr_wh[i]); ++ AuDebugOn(atomic_read(&wbr->wbr_wh_running)); ++ au_rwsem_destroy(&wbr->wbr_wh_rwsem); ++ } ++ ++ /* some filesystems acquire extra lock */ ++ lockdep_off(); ++ mntput(br->br_mnt); ++ lockdep_on(); ++ ++ kfree(wbr); ++ kfree(br); ++} ++ ++/* ++ * frees all branches ++ */ ++void au_br_free(struct au_sbinfo *sbinfo) ++{ ++ aufs_bindex_t bmax; ++ struct au_branch **br; ++ ++ bmax = sbinfo->si_bend + 1; ++ br = sbinfo->si_branch; ++ while (bmax--) ++ au_br_do_free(*br++); ++} ++ ++/* ++ * find the index of a branch which is specified by @br_id. ++ */ ++int au_br_index(struct super_block *sb, aufs_bindex_t br_id) ++{ ++ aufs_bindex_t bindex, bend; ++ ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex <= bend; bindex++) ++ if (au_sbr_id(sb, bindex) == br_id) ++ return bindex; ++ return -1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * add a branch ++ */ ++ ++static int test_overlap(struct super_block *sb, struct dentry *h_d1, ++ struct dentry *h_d2) ++{ ++ if (unlikely(h_d1 == h_d2)) ++ return 1; ++ return !!au_test_subdir(h_d1, h_d2) ++ || !!au_test_subdir(h_d2, h_d1) ++ || au_test_loopback_overlap(sb, h_d1, h_d2) ++ || au_test_loopback_overlap(sb, h_d2, h_d1); ++} ++ ++/* ++ * returns a newly allocated branch. @new_nbranch is a number of branches ++ * after adding a branch. ++ */ ++static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch, ++ int perm) ++{ ++ struct au_branch *add_branch; ++ struct dentry *root; ++ ++ root = sb->s_root; ++ add_branch = kmalloc(sizeof(*add_branch), GFP_NOFS); ++ if (unlikely(!add_branch)) ++ goto out; ++ ++ add_branch->br_wbr = NULL; ++ if (au_br_writable(perm)) { ++ /* may be freed separately at changing the branch permission */ ++ add_branch->br_wbr = kmalloc(sizeof(*add_branch->br_wbr), ++ GFP_NOFS); ++ if (unlikely(!add_branch->br_wbr)) ++ goto out_br; ++ } ++ ++ if (unlikely(au_sbr_realloc(au_sbi(sb), new_nbranch) ++ || au_di_realloc(au_di(root), new_nbranch) ++ || au_ii_realloc(au_ii(root->d_inode), new_nbranch))) ++ goto out_wbr; ++ return add_branch; /* success */ ++ ++ out_wbr: ++ kfree(add_branch->br_wbr); ++ out_br: ++ kfree(add_branch); ++ out: ++ return ERR_PTR(-ENOMEM); ++} ++ ++/* ++ * test if the branch permission is legal or not. ++ */ ++static int test_br(struct inode *inode, int brperm, char *path) ++{ ++ int err; ++ ++ err = 0; ++ if (unlikely(au_br_writable(brperm) && IS_RDONLY(inode))) { ++ AuErr("write permission for readonly mount or inode, %s\n", ++ path); ++ err = -EINVAL; ++ } ++ ++ return err; ++} ++ ++/* ++ * returns: ++ * 0: success, the caller will add it ++ * plus: success, it is already unified, the caller should ignore it ++ * minus: error ++ */ ++static int test_add(struct super_block *sb, struct au_opt_add *add, int remount) ++{ ++ int err; ++ aufs_bindex_t bend, bindex; ++ struct dentry *root; ++ struct inode *inode, *h_inode; ++ ++ root = sb->s_root; ++ bend = au_sbend(sb); ++ if (unlikely(bend >= 0 ++ && au_find_dbindex(root, add->path.dentry) >= 0)) { ++ err = 1; ++ if (!remount) { ++ err = -EINVAL; ++ AuErr("%s duplicated\n", add->pathname); ++ } ++ goto out; ++ } ++ ++ err = -ENOSPC; /* -E2BIG; */ ++ if (unlikely(AUFS_BRANCH_MAX <= add->bindex ++ || AUFS_BRANCH_MAX - 1 <= bend)) { ++ AuErr("number of branches exceeded %s\n", add->pathname); ++ goto out; ++ } ++ ++ err = -EDOM; ++ if (unlikely(add->bindex < 0 || bend + 1 < add->bindex)) { ++ AuErr("bad index %d\n", add->bindex); ++ goto out; ++ } ++ ++ inode = add->path.dentry->d_inode; ++ err = -ENOENT; ++ if (unlikely(!inode->i_nlink)) { ++ AuErr("no existence %s\n", add->pathname); ++ goto out; ++ } ++ ++ err = -EINVAL; ++ if (unlikely(inode->i_sb == sb)) { ++ AuErr("%s must be outside\n", add->pathname); ++ goto out; ++ } ++ ++ if (unlikely(au_test_fs_unsuppoted(inode->i_sb))) { ++ AuErr("unsupported filesystem, %s (%s)\n", ++ add->pathname, au_sbtype(inode->i_sb)); ++ goto out; ++ } ++ ++ err = test_br(add->path.dentry->d_inode, add->perm, add->pathname); ++ if (unlikely(err)) ++ goto out; ++ ++ if (bend < 0) ++ return 0; /* success */ ++ ++ err = -EINVAL; ++ for (bindex = 0; bindex <= bend; bindex++) ++ if (unlikely(test_overlap(sb, add->path.dentry, ++ au_h_dptr(root, bindex)))) { ++ AuErr("%s is overlapped\n", add->pathname); ++ goto out; ++ } ++ ++ err = 0; ++ if (au_opt_test(au_mntflags(sb), WARN_PERM)) { ++ h_inode = au_h_dptr(root, 0)->d_inode; ++ if ((h_inode->i_mode & S_IALLUGO) != (inode->i_mode & S_IALLUGO) ++ || h_inode->i_uid != inode->i_uid ++ || h_inode->i_gid != inode->i_gid) ++ AuWarn("uid/gid/perm %s %u/%u/0%o, %u/%u/0%o\n", ++ add->pathname, ++ inode->i_uid, inode->i_gid, ++ (inode->i_mode & S_IALLUGO), ++ h_inode->i_uid, h_inode->i_gid, ++ (h_inode->i_mode & S_IALLUGO)); ++ } ++ ++ out: ++ return err; ++} ++ ++/* ++ * initialize or clean the whiteouts for an adding branch ++ */ ++static int au_br_init_wh(struct super_block *sb, struct au_branch *br, ++ int new_perm, struct dentry *h_root) ++{ ++ int err, old_perm; ++ aufs_bindex_t bindex; ++ struct mutex *h_mtx; ++ struct au_wbr *wbr; ++ struct au_hinode *hdir; ++ ++ wbr = br->br_wbr; ++ old_perm = br->br_perm; ++ br->br_perm = new_perm; ++ hdir = NULL; ++ h_mtx = NULL; ++ bindex = au_br_index(sb, br->br_id); ++ if (0 <= bindex) { ++ hdir = au_hi(sb->s_root->d_inode, bindex); ++ au_hin_imtx_lock_nested(hdir, AuLsc_I_PARENT); ++ } else { ++ h_mtx = &h_root->d_inode->i_mutex; ++ mutex_lock_nested(h_mtx, AuLsc_I_PARENT); ++ } ++ if (!wbr) ++ err = au_wh_init(h_root, br, sb); ++ else { ++ wbr_wh_write_lock(wbr); ++ err = au_wh_init(h_root, br, sb); ++ wbr_wh_write_unlock(wbr); ++ } ++ if (hdir) ++ au_hin_imtx_unlock(hdir); ++ else ++ mutex_unlock(h_mtx); ++ br->br_perm = old_perm; ++ ++ if (!err && wbr && !au_br_writable(new_perm)) { ++ kfree(wbr); ++ br->br_wbr = NULL; ++ } ++ ++ return err; ++} ++ ++static int au_wbr_init(struct au_branch *br, struct super_block *sb, ++ int perm, struct path *path) ++{ ++ int err; ++ struct au_wbr *wbr; ++ ++ wbr = br->br_wbr; ++ init_rwsem(&wbr->wbr_wh_rwsem); ++ memset(wbr->wbr_wh, 0, sizeof(wbr->wbr_wh)); ++ atomic_set(&wbr->wbr_wh_running, 0); ++ wbr->wbr_bytes = 0; ++ ++ err = au_br_init_wh(sb, br, perm, path->dentry); ++ ++ return err; ++} ++ ++/* intialize a new branch */ ++static int au_br_init(struct au_branch *br, struct super_block *sb, ++ struct au_opt_add *add) ++{ ++ int err; ++ ++ err = 0; ++ memset(&br->br_xino, 0, sizeof(br->br_xino)); ++ mutex_init(&br->br_xino.xi_nondir_mtx); ++ br->br_perm = add->perm; ++ br->br_mnt = add->path.mnt; /* set first, mntget() later */ ++ atomic_set(&br->br_count, 0); ++ br->br_xino_upper = AUFS_XINO_TRUNC_INIT; ++ atomic_set(&br->br_xino_running, 0); ++ br->br_id = au_new_br_id(sb); ++ ++ if (au_br_writable(add->perm)) { ++ err = au_wbr_init(br, sb, add->perm, &add->path); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ if (au_opt_test(au_mntflags(sb), XINO)) { ++ err = au_xino_br(sb, br, add->path.dentry->d_inode->i_ino, ++ au_sbr(sb, 0)->br_xino.xi_file, /*do_test*/1); ++ if (unlikely(err)) { ++ AuDebugOn(br->br_xino.xi_file); ++ goto out; ++ } ++ } ++ ++ sysaufs_br_init(br); ++ mntget(add->path.mnt); ++ ++ out: ++ return err; ++} ++ ++static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex, ++ struct au_branch *br, aufs_bindex_t bend, ++ aufs_bindex_t amount) ++{ ++ struct au_branch **brp; ++ ++ brp = sbinfo->si_branch + bindex; ++ memmove(brp + 1, brp, sizeof(*brp) * amount); ++ *brp = br; ++ sbinfo->si_bend++; ++ if (unlikely(bend < 0)) ++ sbinfo->si_bend = 0; ++} ++ ++static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex, ++ aufs_bindex_t bend, aufs_bindex_t amount) ++{ ++ struct au_hdentry *hdp; ++ ++ hdp = dinfo->di_hdentry + bindex; ++ memmove(hdp + 1, hdp, sizeof(*hdp) * amount); ++ au_h_dentry_init(hdp); ++ dinfo->di_bend++; ++ if (unlikely(bend < 0)) ++ dinfo->di_bstart = 0; ++} ++ ++static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex, ++ aufs_bindex_t bend, aufs_bindex_t amount) ++{ ++ struct au_hinode *hip; ++ ++ hip = iinfo->ii_hinode + bindex; ++ memmove(hip + 1, hip, sizeof(*hip) * amount); ++ hip->hi_inode = NULL; ++ au_hin_init(hip, NULL); ++ iinfo->ii_bend++; ++ if (unlikely(bend < 0)) ++ iinfo->ii_bstart = 0; ++} ++ ++static void au_br_do_add(struct super_block *sb, struct dentry *h_dentry, ++ struct au_branch *br, aufs_bindex_t bindex) ++{ ++ struct dentry *root; ++ struct inode *root_inode; ++ aufs_bindex_t bend, amount; ++ ++ root = sb->s_root; ++ root_inode = root->d_inode; ++ au_plink_block_maintain(sb); ++ bend = au_sbend(sb); ++ amount = bend + 1 - bindex; ++ au_br_do_add_brp(au_sbi(sb), bindex, br, bend, amount); ++ au_br_do_add_hdp(au_di(root), bindex, bend, amount); ++ au_br_do_add_hip(au_ii(root_inode), bindex, bend, amount); ++ au_set_h_dptr(root, bindex, dget(h_dentry)); ++ au_set_h_iptr(root_inode, bindex, au_igrab(h_dentry->d_inode), ++ /*flags*/0); ++} ++ ++int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount) ++{ ++ int err; ++ unsigned long long maxb; ++ aufs_bindex_t bend, add_bindex; ++ struct dentry *root, *h_dentry; ++ struct inode *root_inode; ++ struct au_branch *add_branch; ++ ++ root = sb->s_root; ++ root_inode = root->d_inode; ++ IMustLock(root_inode); ++ err = test_add(sb, add, remount); ++ if (unlikely(err < 0)) ++ goto out; ++ if (err) { ++ err = 0; ++ goto out; /* success */ ++ } ++ ++ bend = au_sbend(sb); ++ add_branch = au_br_alloc(sb, bend + 2, add->perm); ++ err = PTR_ERR(add_branch); ++ if (IS_ERR(add_branch)) ++ goto out; ++ ++ err = au_br_init(add_branch, sb, add); ++ if (unlikely(err)) { ++ au_br_do_free(add_branch); ++ goto out; ++ } ++ ++ add_bindex = add->bindex; ++ h_dentry = add->path.dentry; ++ if (!remount) ++ au_br_do_add(sb, h_dentry, add_branch, add_bindex); ++ else { ++ sysaufs_brs_del(sb, add_bindex); ++ au_br_do_add(sb, h_dentry, add_branch, add_bindex); ++ sysaufs_brs_add(sb, add_bindex); ++ } ++ ++ if (!add_bindex) ++ au_cpup_attr_all(root_inode, /*force*/1); ++ else ++ au_add_nlink(root_inode, h_dentry->d_inode); ++ maxb = h_dentry->d_sb->s_maxbytes; ++ if (sb->s_maxbytes < maxb) ++ sb->s_maxbytes = maxb; ++ ++ /* ++ * this test/set prevents aufs from handling unnecesary inotify events ++ * of xino files, in a case of re-adding a writable branch which was ++ * once detached from aufs. ++ */ ++ if (au_xino_brid(sb) < 0 ++ && au_br_writable(add_branch->br_perm) ++ && !au_test_fs_bad_xino(h_dentry->d_sb) ++ && add_branch->br_xino.xi_file ++ && add_branch->br_xino.xi_file->f_dentry->d_parent == h_dentry) ++ au_xino_brid_set(sb, add_branch->br_id); ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * delete a branch ++ */ ++ ++/* to show the line number, do not make it inlined function */ ++#define AuVerbose(do_info, fmt, args...) do { \ ++ if (do_info) \ ++ AuInfo(fmt, ##args); \ ++} while (0) ++ ++/* ++ * test if the branch is deletable or not. ++ */ ++static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex, ++ unsigned int sigen) ++{ ++ int err, i, j, ndentry; ++ aufs_bindex_t bstart, bend; ++ unsigned char verbose; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry *d; ++ struct inode *inode; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, root, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ verbose = !!au_opt_test(au_mntflags(root->d_sb), VERBOSE); ++ for (i = 0; !err && i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ ndentry = dpage->ndentry; ++ for (j = 0; !err && j < ndentry; j++) { ++ d = dpage->dentries[j]; ++ AuDebugOn(!atomic_read(&d->d_count)); ++ inode = d->d_inode; ++ if (au_digen(d) == sigen && au_iigen(inode) == sigen) ++ di_read_lock_child(d, AuLock_IR); ++ else { ++ di_write_lock_child(d); ++ err = au_reval_dpath(d, sigen); ++ if (!err) ++ di_downgrade_lock(d, AuLock_IR); ++ else { ++ di_write_unlock(d); ++ break; ++ } ++ } ++ ++ bstart = au_dbstart(d); ++ bend = au_dbend(d); ++ if (bstart <= bindex ++ && bindex <= bend ++ && au_h_dptr(d, bindex) ++ && (!S_ISDIR(inode->i_mode) || bstart == bend)) { ++ err = -EBUSY; ++ AuVerbose(verbose, "busy %.*s\n", AuDLNPair(d)); ++ } ++ di_read_unlock(d, AuLock_IR); ++ } ++ } ++ ++ out_dpages: ++ au_dpages_free(&dpages); ++ out: ++ return err; ++} ++ ++static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex, ++ unsigned int sigen) ++{ ++ int err; ++ struct inode *i; ++ aufs_bindex_t bstart, bend; ++ unsigned char verbose; ++ ++ err = 0; ++ verbose = !!au_opt_test(au_mntflags(sb), VERBOSE); ++ list_for_each_entry(i, &sb->s_inodes, i_sb_list) { ++ AuDebugOn(!atomic_read(&i->i_count)); ++ if (!list_empty(&i->i_dentry)) ++ continue; ++ ++ if (au_iigen(i) == sigen) ++ ii_read_lock_child(i); ++ else { ++ ii_write_lock_child(i); ++ err = au_refresh_hinode_self(i, /*do_attr*/1); ++ if (!err) ++ ii_downgrade_lock(i); ++ else { ++ ii_write_unlock(i); ++ break; ++ } ++ } ++ ++ bstart = au_ibstart(i); ++ bend = au_ibend(i); ++ if (bstart <= bindex ++ && bindex <= bend ++ && au_h_iptr(i, bindex) ++ && (!S_ISDIR(i->i_mode) || bstart == bend)) { ++ err = -EBUSY; ++ AuVerbose(verbose, "busy i%lu\n", i->i_ino); ++ ii_read_unlock(i); ++ break; ++ } ++ ii_read_unlock(i); ++ } ++ ++ return err; ++} ++ ++static int test_children_busy(struct dentry *root, aufs_bindex_t bindex) ++{ ++ int err; ++ unsigned int sigen; ++ ++ sigen = au_sigen(root->d_sb); ++ DiMustNoWaiters(root); ++ IiMustNoWaiters(root->d_inode); ++ di_write_unlock(root); ++ err = test_dentry_busy(root, bindex, sigen); ++ if (!err) ++ err = test_inode_busy(root->d_sb, bindex, sigen); ++ di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */ ++ ++ return err; ++} ++ ++static void au_br_do_del_brp(struct au_sbinfo *sbinfo, ++ const aufs_bindex_t bindex, ++ const aufs_bindex_t bend) ++{ ++ struct au_branch **brp, **p; ++ ++ brp = sbinfo->si_branch + bindex; ++ if (bindex < bend) ++ memmove(brp, brp + 1, sizeof(*brp) * (bend - bindex)); ++ sbinfo->si_branch[0 + bend] = NULL; ++ sbinfo->si_bend--; ++ ++ p = krealloc(sbinfo->si_branch, sizeof(*p) * bend, GFP_NOFS); ++ if (p) ++ sbinfo->si_branch = p; ++} ++ ++static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex, ++ const aufs_bindex_t bend) ++{ ++ struct au_hdentry *hdp, *p; ++ ++ hdp = dinfo->di_hdentry + bindex; ++ if (bindex < bend) ++ memmove(hdp, hdp + 1, sizeof(*hdp) * (bend - bindex)); ++ dinfo->di_hdentry[0 + bend].hd_dentry = NULL; ++ dinfo->di_bend--; ++ ++ p = krealloc(dinfo->di_hdentry, sizeof(*p) * bend, GFP_NOFS); ++ if (p) ++ dinfo->di_hdentry = p; ++} ++ ++static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex, ++ const aufs_bindex_t bend) ++{ ++ struct au_hinode *hip, *p; ++ ++ hip = iinfo->ii_hinode + bindex; ++ if (bindex < bend) ++ memmove(hip, hip + 1, sizeof(*hip) * (bend - bindex)); ++ iinfo->ii_hinode[0 + bend].hi_inode = NULL; ++ au_hin_init(iinfo->ii_hinode + bend, NULL); ++ iinfo->ii_bend--; ++ ++ p = krealloc(iinfo->ii_hinode, sizeof(*p) * bend, GFP_NOFS); ++ if (p) ++ iinfo->ii_hinode = p; ++} ++ ++static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_branch *br) ++{ ++ aufs_bindex_t bend; ++ struct au_sbinfo *sbinfo; ++ struct dentry *root; ++ struct inode *inode; ++ ++ root = sb->s_root; ++ inode = root->d_inode; ++ au_plink_block_maintain(sb); ++ sbinfo = au_sbi(sb); ++ bend = sbinfo->si_bend; ++ ++ dput(au_h_dptr(root, bindex)); ++ au_hiput(au_hi(inode, bindex)); ++ au_br_do_free(br); ++ ++ au_br_do_del_brp(sbinfo, bindex, bend); ++ au_br_do_del_hdp(au_di(root), bindex, bend); ++ au_br_do_del_hip(au_ii(inode), bindex, bend); ++} ++ ++int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount) ++{ ++ int err, rerr, i; ++ unsigned int mnt_flags; ++ aufs_bindex_t bindex, bend, br_id; ++ unsigned char do_wh, verbose; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ ++ err = 0; ++ bindex = au_find_dbindex(sb->s_root, del->h_path.dentry); ++ if (bindex < 0) { ++ if (remount) ++ goto out; /* success */ ++ err = -ENOENT; ++ AuErr("%s no such branch\n", del->pathname); ++ goto out; ++ } ++ AuDbg("bindex b%d\n", bindex); ++ ++ err = -EBUSY; ++ mnt_flags = au_mntflags(sb); ++ verbose = !!au_opt_test(mnt_flags, VERBOSE); ++ bend = au_sbend(sb); ++ if (unlikely(!bend)) { ++ AuVerbose(verbose, "no more branches left\n"); ++ goto out; ++ } ++ br = au_sbr(sb, bindex); ++ i = atomic_read(&br->br_count); ++ if (unlikely(i)) { ++ AuVerbose(verbose, "%d file(s) opened\n", i); ++ goto out; ++ } ++ ++ wbr = br->br_wbr; ++ do_wh = wbr && (wbr->wbr_whbase || wbr->wbr_plink || wbr->wbr_orph); ++ if (do_wh) { ++ for (i = 0; i < AuBrWh_Last; i++) { ++ dput(wbr->wbr_wh[i]); ++ wbr->wbr_wh[i] = NULL; ++ } ++ } ++ ++ err = test_children_busy(sb->s_root, bindex); ++ if (unlikely(err)) { ++ if (do_wh) ++ goto out_wh; ++ goto out; ++ } ++ ++ err = 0; ++ br_id = br->br_id; ++ if (!remount) ++ au_br_do_del(sb, bindex, br); ++ else { ++ sysaufs_brs_del(sb, bindex); ++ au_br_do_del(sb, bindex, br); ++ sysaufs_brs_add(sb, bindex); ++ } ++ ++ if (!bindex) ++ au_cpup_attr_all(sb->s_root->d_inode, /*force*/1); ++ else ++ au_sub_nlink(sb->s_root->d_inode, del->h_path.dentry->d_inode); ++ if (au_opt_test(mnt_flags, PLINK)) ++ au_plink_half_refresh(sb, br_id); ++ ++ if (sb->s_maxbytes == del->h_path.dentry->d_sb->s_maxbytes) { ++ bend--; ++ sb->s_maxbytes = 0; ++ for (bindex = 0; bindex <= bend; bindex++) { ++ unsigned long long maxb; ++ ++ maxb = au_sbr_sb(sb, bindex)->s_maxbytes; ++ if (sb->s_maxbytes < maxb) ++ sb->s_maxbytes = maxb; ++ } ++ } ++ ++ if (au_xino_brid(sb) == br->br_id) ++ au_xino_brid_set(sb, -1); ++ goto out; /* success */ ++ ++ out_wh: ++ /* revert */ ++ rerr = au_br_init_wh(sb, br, br->br_perm, del->h_path.dentry); ++ if (rerr) ++ AuWarn("failed re-creating base whiteout, %s. (%d)\n", ++ del->pathname, rerr); ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * change a branch permission ++ */ ++ ++static int do_need_sigen_inc(int a, int b) ++{ ++ return au_br_whable(a) && !au_br_whable(b); ++} ++ ++static int need_sigen_inc(int old, int new) ++{ ++ return do_need_sigen_inc(old, new) ++ || do_need_sigen_inc(new, old); ++} ++ ++static int au_br_mod_files_ro(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ int err; ++ unsigned long n, ul, bytes, files; ++ aufs_bindex_t bstart; ++ struct file *file, *hf, **a; ++ const int step_bytes = 1024, /* memory allocation unit */ ++ step_files = step_bytes / sizeof(*a); ++ ++ err = -ENOMEM; ++ n = 0; ++ bytes = step_bytes; ++ files = step_files; ++ a = kmalloc(bytes, GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ /* no need file_list_lock() since sbinfo is locked? defered? */ ++ list_for_each_entry(file, &sb->s_files, f_u.fu_list) { ++ if (special_file(file->f_dentry->d_inode->i_mode)) ++ continue; ++ ++ AuDbg("%.*s\n", AuDLNPair(file->f_dentry)); ++ fi_read_lock(file); ++ if (unlikely(au_test_mmapped(file))) { ++ err = -EBUSY; ++ FiMustNoWaiters(file); ++ fi_read_unlock(file); ++ goto out_free; ++ } ++ ++ bstart = au_fbstart(file); ++ if (!S_ISREG(file->f_dentry->d_inode->i_mode) ++ || !(file->f_mode & FMODE_WRITE) ++ || bstart != bindex) { ++ FiMustNoWaiters(file); ++ fi_read_unlock(file); ++ continue; ++ } ++ ++ hf = au_h_fptr(file, bstart); ++ FiMustNoWaiters(file); ++ fi_read_unlock(file); ++ ++ if (n < files) ++ a[n++] = hf; ++ else { ++ void *p; ++ ++ err = -ENOMEM; ++ bytes += step_bytes; ++ files += step_files; ++ p = krealloc(a, bytes, GFP_NOFS); ++ if (p) { ++ a = p; ++ a[n++] = hf; ++ } else ++ goto out_free; ++ } ++ } ++ ++ err = 0; ++ for (ul = 0; ul < n; ul++) { ++ /* todo: already flushed? */ ++ /* cf. fs/super.c:mark_files_ro() */ ++ hf = a[ul]; ++ hf->f_mode &= ~FMODE_WRITE; ++ if (!file_check_writeable(hf)) { ++ file_release_write(hf); ++ mnt_drop_write(hf->f_vfsmnt); ++ } ++ } ++ ++ out_free: ++ kfree(a); ++ out: ++ return err; ++} ++ ++int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount, ++ int *do_update) ++{ ++ int err, rerr; ++ aufs_bindex_t bindex; ++ struct dentry *root; ++ struct au_branch *br; ++ ++ root = sb->s_root; ++ au_plink_block_maintain(sb); ++ bindex = au_find_dbindex(root, mod->h_root); ++ if (bindex < 0) { ++ if (remount) ++ return 0; /* success */ ++ err = -ENOENT; ++ AuErr("%s no such branch\n", mod->path); ++ goto out; ++ } ++ AuDbg("bindex b%d\n", bindex); ++ ++ err = test_br(mod->h_root->d_inode, mod->perm, mod->path); ++ if (unlikely(err)) ++ goto out; ++ ++ br = au_sbr(sb, bindex); ++ if (br->br_perm == mod->perm) ++ return 0; /* success */ ++ ++ if (au_br_writable(br->br_perm)) { ++ /* remove whiteout base */ ++ err = au_br_init_wh(sb, br, mod->perm, mod->h_root); ++ if (unlikely(err)) ++ goto out; ++ ++ if (!au_br_writable(mod->perm)) { ++ /* rw --> ro, file might be mmapped */ ++ DiMustNoWaiters(root); ++ IiMustNoWaiters(root->d_inode); ++ di_write_unlock(root); ++ err = au_br_mod_files_ro(sb, bindex); ++ /* aufs_write_lock() calls ..._child() */ ++ di_write_lock_child(root); ++ ++ if (unlikely(err)) { ++ rerr = -ENOMEM; ++ br->br_wbr = kmalloc(sizeof(*br->br_wbr), ++ GFP_NOFS); ++ if (br->br_wbr) ++ rerr = au_br_init_wh ++ (sb, br, br->br_perm, ++ mod->h_root); ++ if (unlikely(rerr)) { ++ AuIOErr("nested error %d (%d)\n", ++ rerr, err); ++ br->br_perm = mod->perm; ++ } ++ } ++ } ++ } else if (au_br_writable(mod->perm)) { ++ /* ro --> rw */ ++ err = -ENOMEM; ++ br->br_wbr = kmalloc(sizeof(*br->br_wbr), GFP_NOFS); ++ if (br->br_wbr) { ++ struct path path = { ++ .mnt = br->br_mnt, ++ .dentry = mod->h_root ++ }; ++ ++ err = au_wbr_init(br, sb, mod->perm, &path); ++ if (unlikely(err)) { ++ kfree(br->br_wbr); ++ br->br_wbr = NULL; ++ } ++ } ++ } ++ ++ if (!err) { ++ *do_update |= need_sigen_inc(br->br_perm, mod->perm); ++ br->br_perm = mod->perm; ++ } ++ ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/branch.h b/fs/aufs/branch.h +--- a/fs/aufs/branch.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/branch.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,215 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * branch filesystems and xino for them ++ */ ++ ++#ifndef __AUFS_BRANCH_H__ ++#define __AUFS_BRANCH_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/mount.h> ++#include <linux/aufs_type.h> ++#include "rwsem.h" ++#include "super.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* a xino file */ ++struct au_xino_file { ++ struct file *xi_file; ++ struct mutex xi_nondir_mtx; ++ ++ /* todo: make xino files an array to support huge inode number */ ++ ++#ifdef CONFIG_DEBUG_FS ++ struct dentry *xi_dbgaufs; ++#endif ++}; ++ ++/* members for writable branch only */ ++enum {AuBrWh_BASE, AuBrWh_PLINK, AuBrWh_ORPH, AuBrWh_Last}; ++struct au_wbr { ++ struct rw_semaphore wbr_wh_rwsem; ++ struct dentry *wbr_wh[AuBrWh_Last]; ++ atomic_t wbr_wh_running; ++#define wbr_whbase wbr_wh[AuBrWh_BASE] /* whiteout base */ ++#define wbr_plink wbr_wh[AuBrWh_PLINK] /* pseudo-link dir */ ++#define wbr_orph wbr_wh[AuBrWh_ORPH] /* dir for orphans */ ++ ++ /* mfs mode */ ++ unsigned long long wbr_bytes; ++}; ++ ++/* protected by superblock rwsem */ ++struct au_branch { ++ struct au_xino_file br_xino; ++ ++ aufs_bindex_t br_id; ++ ++ int br_perm; ++ struct vfsmount *br_mnt; ++ atomic_t br_count; ++ ++ struct au_wbr *br_wbr; ++ ++ /* xino truncation */ ++ blkcnt_t br_xino_upper; /* watermark in blocks */ ++ atomic_t br_xino_running; ++ ++#ifdef CONFIG_SYSFS ++ /* an entry under sysfs per mount-point */ ++ char br_name[8]; ++ struct attribute br_attr; ++#endif ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* branch permission and attribute */ ++enum { ++ AuBrPerm_RW, /* writable, linkable wh */ ++ AuBrPerm_RO, /* readonly, no wh */ ++ AuBrPerm_RR, /* natively readonly, no wh */ ++ ++ AuBrPerm_RWNoLinkWH, /* un-linkable whiteouts */ ++ ++ AuBrPerm_ROWH, /* whiteout-able */ ++ AuBrPerm_RRWH, /* whiteout-able */ ++ ++ AuBrPerm_Last ++}; ++ ++static inline int au_br_writable(int brperm) ++{ ++ return brperm == AuBrPerm_RW || brperm == AuBrPerm_RWNoLinkWH; ++} ++ ++static inline int au_br_whable(int brperm) ++{ ++ return brperm == AuBrPerm_RW ++ || brperm == AuBrPerm_ROWH ++ || brperm == AuBrPerm_RRWH; ++} ++ ++static inline int au_br_rdonly(struct au_branch *br) ++{ ++ return ((br->br_mnt->mnt_sb->s_flags & MS_RDONLY) ++ || !au_br_writable(br->br_perm)) ++ ? -EROFS : 0; ++} ++ ++static inline int au_br_hinotifyable(int brperm __maybe_unused) ++{ ++#ifdef CONFIG_AUFS_HINOTIFY ++ return brperm != AuBrPerm_RR && brperm != AuBrPerm_RRWH; ++#else ++ return 0; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* branch.c */ ++struct au_sbinfo; ++void au_br_free(struct au_sbinfo *sinfo); ++int au_br_index(struct super_block *sb, aufs_bindex_t br_id); ++struct au_opt_add; ++int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount); ++struct au_opt_del; ++int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount); ++struct au_opt_mod; ++int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount, ++ int *do_update); ++ ++/* xino.c */ ++static const loff_t au_loff_max = LLONG_MAX; ++ ++int au_xib_trunc(struct super_block *sb); ++ssize_t xino_fread(au_readf_t func, struct file *file, void *buf, size_t size, ++ loff_t *pos); ++ssize_t xino_fwrite(au_writef_t func, struct file *file, void *buf, size_t size, ++ loff_t *pos); ++struct file *au_xino_create2(struct file *base_file, struct file *copy_src); ++struct file *au_xino_create(struct super_block *sb, char *fname, int silent); ++ino_t au_xino_new_ino(struct super_block *sb); ++int au_xino_write0(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino); ++int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino); ++int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t *ino); ++int au_xino_br(struct super_block *sb, struct au_branch *br, ino_t hino, ++ struct file *base_file, int do_test); ++int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex); ++ ++struct au_opt_xino; ++int au_xino_set(struct super_block *sb, struct au_opt_xino *xino, int remount); ++void au_xino_clr(struct super_block *sb); ++struct file *au_xino_def(struct super_block *sb); ++int au_xino_path(struct seq_file *seq, struct file *file); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Superblock to branch */ ++static inline ++aufs_bindex_t au_sbr_id(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr(sb, bindex)->br_id; ++} ++ ++static inline ++struct vfsmount *au_sbr_mnt(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr(sb, bindex)->br_mnt; ++} ++ ++static inline ++struct super_block *au_sbr_sb(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr_mnt(sb, bindex)->mnt_sb; ++} ++ ++static inline void au_sbr_put(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ atomic_dec(&au_sbr(sb, bindex)->br_count); ++} ++ ++static inline int au_sbr_perm(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_sbr(sb, bindex)->br_perm; ++} ++ ++static inline int au_sbr_whable(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ return au_br_whable(au_sbr_perm(sb, bindex)); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * wbr_wh_read_lock, wbr_wh_write_lock ++ * wbr_wh_read_unlock, wbr_wh_write_unlock, wbr_wh_downgrade_lock ++ */ ++AuSimpleRwsemFuncs(wbr_wh, struct au_wbr *wbr, &wbr->wbr_wh_rwsem); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_BRANCH_H__ */ +diff -Naur a/fs/aufs/cpup.c b/fs/aufs/cpup.c +--- a/fs/aufs/cpup.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/cpup.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,1039 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * copy-up functions, see wbr_policy.c for copy-down ++ */ ++ ++#include <linux/file.h> ++#include <linux/fs_stack.h> ++#include <linux/mm.h> ++#include <linux/uaccess.h> ++#include "aufs.h" ++ ++void au_cpup_attr_flags(struct inode *dst, struct inode *src) ++{ ++ const unsigned int mask = S_DEAD | S_SWAPFILE | S_PRIVATE ++ | S_NOATIME | S_NOCMTIME; ++ ++ dst->i_flags |= src->i_flags & ~mask; ++ if (au_test_fs_notime(dst->i_sb)) ++ dst->i_flags |= S_NOATIME | S_NOCMTIME; ++} ++ ++void au_cpup_attr_timesizes(struct inode *inode) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibstart(inode)); ++ fsstack_copy_attr_times(inode, h_inode); ++ vfsub_copy_inode_size(inode, h_inode); ++} ++ ++void au_cpup_attr_nlink(struct inode *inode, int force) ++{ ++ struct inode *h_inode; ++ struct super_block *sb; ++ aufs_bindex_t bindex, bend; ++ ++ sb = inode->i_sb; ++ bindex = au_ibstart(inode); ++ h_inode = au_h_iptr(inode, bindex); ++ if (!force ++ && !S_ISDIR(h_inode->i_mode) ++ && au_opt_test(au_mntflags(sb), PLINK) ++ && au_plink_test(inode)) ++ return; ++ ++ inode->i_nlink = h_inode->i_nlink; ++ ++ /* ++ * fewer nlink makes find(1) noisy, but larger nlink doesn't. ++ * it may includes whplink directory. ++ */ ++ if (S_ISDIR(h_inode->i_mode)) { ++ bend = au_ibend(inode); ++ for (bindex++; bindex <= bend; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (h_inode) ++ au_add_nlink(inode, h_inode); ++ } ++ } ++} ++ ++void au_cpup_attr_changeable(struct inode *inode) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibstart(inode)); ++ inode->i_mode = h_inode->i_mode; ++ inode->i_uid = h_inode->i_uid; ++ inode->i_gid = h_inode->i_gid; ++ au_cpup_attr_timesizes(inode); ++ au_cpup_attr_flags(inode, h_inode); ++} ++ ++void au_cpup_igen(struct inode *inode, struct inode *h_inode) ++{ ++ struct au_iinfo *iinfo = au_ii(inode); ++ ++ iinfo->ii_higen = h_inode->i_generation; ++ iinfo->ii_hsb1 = h_inode->i_sb; ++} ++ ++void au_cpup_attr_all(struct inode *inode, int force) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, au_ibstart(inode)); ++ au_cpup_attr_changeable(inode); ++ if (inode->i_nlink > 0) ++ au_cpup_attr_nlink(inode, force); ++ inode->i_rdev = h_inode->i_rdev; ++ inode->i_blkbits = h_inode->i_blkbits; ++ au_cpup_igen(inode, h_inode); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Note: dt_dentry and dt_h_dentry are not dget/dput-ed */ ++ ++/* keep the timestamps of the parent dir when cpup */ ++void au_dtime_store(struct au_dtime *dt, struct dentry *dentry, ++ struct path *h_path) ++{ ++ struct inode *h_inode; ++ ++ dt->dt_dentry = dentry; ++ dt->dt_h_path = *h_path; ++ h_inode = h_path->dentry->d_inode; ++ dt->dt_atime = h_inode->i_atime; ++ dt->dt_mtime = h_inode->i_mtime; ++ /* smp_mb(); */ ++} ++ ++void au_dtime_revert(struct au_dtime *dt) ++{ ++ struct iattr attr; ++ int err; ++ ++ attr.ia_atime = dt->dt_atime; ++ attr.ia_mtime = dt->dt_mtime; ++ attr.ia_valid = ATTR_FORCE | ATTR_MTIME | ATTR_MTIME_SET ++ | ATTR_ATIME | ATTR_ATIME_SET; ++ ++ err = vfsub_notify_change(&dt->dt_h_path, &attr); ++ if (unlikely(err)) ++ AuWarn("restoring timestamps failed(%d). ignored\n", err); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static noinline_for_stack ++int cpup_iattr(struct dentry *dst, aufs_bindex_t bindex, struct dentry *h_src) ++{ ++ int err, sbits; ++ struct iattr ia; ++ struct path h_path; ++ struct inode *h_isrc; ++ ++ h_path.dentry = au_h_dptr(dst, bindex); ++ h_path.mnt = au_sbr_mnt(dst->d_sb, bindex); ++ h_isrc = h_src->d_inode; ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE | ATTR_UID | ATTR_GID ++ | ATTR_ATIME | ATTR_MTIME ++ | ATTR_ATIME_SET | ATTR_MTIME_SET; ++ ia.ia_mode = h_isrc->i_mode; ++ ia.ia_uid = h_isrc->i_uid; ++ ia.ia_gid = h_isrc->i_gid; ++ ia.ia_atime = h_isrc->i_atime; ++ ia.ia_mtime = h_isrc->i_mtime; ++ sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID)); ++ au_cpup_attr_flags(h_path.dentry->d_inode, h_isrc); ++ err = vfsub_notify_change(&h_path, &ia); ++ ++ /* is this nfs only? */ ++ if (!err && sbits && au_test_nfs(h_path.dentry->d_sb)) { ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE; ++ ia.ia_mode = h_isrc->i_mode; ++ err = vfsub_notify_change(&h_path, &ia); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_copy_file(struct file *dst, struct file *src, loff_t len, ++ char *buf, unsigned long blksize) ++{ ++ int err; ++ size_t sz, rbytes, wbytes; ++ unsigned char all_zero; ++ char *p, *zp; ++ struct mutex *h_mtx; ++ /* reduce stack usage */ ++ struct iattr *ia; ++ ++ zp = page_address(ZERO_PAGE(0)); ++ if (unlikely(!zp)) ++ return -ENOMEM; /* possible? */ ++ ++ err = 0; ++ all_zero = 0; ++ while (len) { ++ AuDbg("len %lld\n", len); ++ sz = blksize; ++ if (len < blksize) ++ sz = len; ++ ++ rbytes = 0; ++ /* todo: signal_pending? */ ++ while (!rbytes || err == -EAGAIN || err == -EINTR) { ++ rbytes = vfsub_read_k(src, buf, sz, &src->f_pos); ++ err = rbytes; ++ } ++ if (unlikely(err < 0)) ++ break; ++ ++ all_zero = 0; ++ if (len >= rbytes && rbytes == blksize) ++ all_zero = !memcmp(buf, zp, rbytes); ++ if (!all_zero) { ++ wbytes = rbytes; ++ p = buf; ++ while (wbytes) { ++ size_t b; ++ ++ b = vfsub_write_k(dst, p, wbytes, &dst->f_pos); ++ err = b; ++ /* todo: signal_pending? */ ++ if (unlikely(err == -EAGAIN || err == -EINTR)) ++ continue; ++ if (unlikely(err < 0)) ++ break; ++ wbytes -= b; ++ p += b; ++ } ++ } else { ++ loff_t res; ++ ++ AuLabel(hole); ++ res = vfsub_llseek(dst, rbytes, SEEK_CUR); ++ err = res; ++ if (unlikely(res < 0)) ++ break; ++ } ++ len -= rbytes; ++ err = 0; ++ } ++ ++ /* the last block may be a hole */ ++ if (!err && all_zero) { ++ AuLabel(last hole); ++ ++ err = 1; ++ if (au_test_nfs(dst->f_dentry->d_sb)) { ++ /* nfs requires this step to make last hole */ ++ /* is this only nfs? */ ++ do { ++ /* todo: signal_pending? */ ++ err = vfsub_write_k(dst, "\0", 1, &dst->f_pos); ++ } while (err == -EAGAIN || err == -EINTR); ++ if (err == 1) ++ dst->f_pos--; ++ } ++ ++ if (err == 1) { ++ ia = (void *)buf; ++ ia->ia_size = dst->f_pos; ++ ia->ia_valid = ATTR_SIZE | ATTR_FILE; ++ ia->ia_file = dst; ++ h_mtx = &dst->f_dentry->d_inode->i_mutex; ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD2); ++ err = vfsub_notify_change(&dst->f_path, ia); ++ mutex_unlock(h_mtx); ++ } ++ } ++ ++ return err; ++} ++ ++int au_copy_file(struct file *dst, struct file *src, loff_t len) ++{ ++ int err; ++ unsigned long blksize; ++ unsigned char do_kfree; ++ char *buf; ++ ++ err = -ENOMEM; ++ blksize = dst->f_dentry->d_sb->s_blocksize; ++ if (!blksize || PAGE_SIZE < blksize) ++ blksize = PAGE_SIZE; ++ AuDbg("blksize %lu\n", blksize); ++ do_kfree = (blksize != PAGE_SIZE && blksize >= sizeof(struct iattr *)); ++ if (do_kfree) ++ buf = kmalloc(blksize, GFP_NOFS); ++ else ++ buf = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!buf)) ++ goto out; ++ ++ if (len > (1 << 22)) ++ AuDbg("copying a large file %lld\n", (long long)len); ++ ++ src->f_pos = 0; ++ dst->f_pos = 0; ++ err = au_do_copy_file(dst, src, len, buf, blksize); ++ if (do_kfree) ++ kfree(buf); ++ else ++ free_page((unsigned long)buf); ++ ++ out: ++ return err; ++} ++ ++/* ++ * to support a sparse file which is opened with O_APPEND, ++ * we need to close the file. ++ */ ++static int au_cp_regular(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len) ++{ ++ int err, i; ++ enum { SRC, DST }; ++ struct { ++ aufs_bindex_t bindex; ++ unsigned int flags; ++ struct dentry *dentry; ++ struct file *file; ++ void *label, *label_file; ++ } *f, file[] = { ++ { ++ .bindex = bsrc, ++ .flags = O_RDONLY | O_NOATIME | O_LARGEFILE, ++ .file = NULL, ++ .label = &&out, ++ .label_file = &&out_src ++ }, ++ { ++ .bindex = bdst, ++ .flags = O_WRONLY | O_NOATIME | O_LARGEFILE, ++ .file = NULL, ++ .label = &&out_src, ++ .label_file = &&out_dst ++ } ++ }; ++ struct super_block *sb; ++ ++ /* bsrc branch can be ro/rw. */ ++ sb = dentry->d_sb; ++ f = file; ++ for (i = 0; i < 2; i++, f++) { ++ f->dentry = au_h_dptr(dentry, f->bindex); ++ f->file = au_h_open(dentry, f->bindex, f->flags, /*file*/NULL); ++ err = PTR_ERR(f->file); ++ if (IS_ERR(f->file)) ++ goto *f->label; ++ err = -EINVAL; ++ if (unlikely(!f->file->f_op)) ++ goto *f->label_file; ++ } ++ ++ /* try stopping to update while we copyup */ ++ IMustLock(file[SRC].dentry->d_inode); ++ err = au_copy_file(file[DST].file, file[SRC].file, len); ++ ++ out_dst: ++ fput(file[DST].file); ++ au_sbr_put(sb, file[DST].bindex); ++ out_src: ++ fput(file[SRC].file); ++ au_sbr_put(sb, file[SRC].bindex); ++ out: ++ return err; ++} ++ ++static int au_do_cpup_regular(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len, ++ struct inode *h_dir, struct path *h_path) ++{ ++ int err, rerr; ++ loff_t l; ++ ++ err = 0; ++ l = i_size_read(au_h_iptr(dentry->d_inode, bsrc)); ++ if (len == -1 || l < len) ++ len = l; ++ if (len) ++ err = au_cp_regular(dentry, bdst, bsrc, len); ++ if (!err) ++ goto out; /* success */ ++ ++ rerr = vfsub_unlink(h_dir, h_path, /*force*/0); ++ if (rerr) { ++ AuIOErr("failed unlinking cpup-ed %.*s(%d, %d)\n", ++ AuDLNPair(h_path->dentry), err, rerr); ++ err = -EIO; ++ } ++ ++ out: ++ return err; ++} ++ ++static int au_do_cpup_symlink(struct path *h_path, struct dentry *h_src, ++ struct inode *h_dir) ++{ ++ int err, symlen; ++ mm_segment_t old_fs; ++ char *sym; ++ ++ err = -ENOSYS; ++ if (unlikely(!h_src->d_inode->i_op->readlink)) ++ goto out; ++ ++ err = -ENOMEM; ++ sym = __getname(); ++ if (unlikely(!sym)) ++ goto out; ++ ++ old_fs = get_fs(); ++ set_fs(KERNEL_DS); ++ symlen = h_src->d_inode->i_op->readlink(h_src, (char __user *)sym, ++ PATH_MAX); ++ err = symlen; ++ set_fs(old_fs); ++ ++ if (symlen > 0) { ++ sym[symlen] = 0; ++ err = vfsub_symlink(h_dir, h_path, sym); ++ } ++ __putname(sym); ++ ++ out: ++ return err; ++} ++ ++/* return with the lower dst inode is locked */ ++static noinline_for_stack ++int cpup_entry(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len, unsigned int flags, ++ struct dentry *dst_parent) ++{ ++ int err; ++ umode_t mode; ++ unsigned int mnt_flags; ++ unsigned char isdir; ++ const unsigned char do_dt = !!au_ftest_cpup(flags, DTIME); ++ struct au_dtime dt; ++ struct path h_path; ++ struct dentry *h_src, *h_dst, *h_parent; ++ struct inode *h_inode, *h_dir; ++ struct super_block *sb; ++ ++ /* bsrc branch can be ro/rw. */ ++ h_src = au_h_dptr(dentry, bsrc); ++ h_inode = h_src->d_inode; ++ AuDebugOn(h_inode != au_h_iptr(dentry->d_inode, bsrc)); ++ ++ /* try stopping to be referenced while we are creating */ ++ h_dst = au_h_dptr(dentry, bdst); ++ h_parent = h_dst->d_parent; /* dir inode is locked */ ++ h_dir = h_parent->d_inode; ++ IMustLock(h_dir); ++ AuDebugOn(h_parent != h_dst->d_parent); ++ ++ sb = dentry->d_sb; ++ h_path.mnt = au_sbr_mnt(sb, bdst); ++ if (do_dt) { ++ h_path.dentry = h_parent; ++ au_dtime_store(&dt, dst_parent, &h_path); ++ } ++ h_path.dentry = h_dst; ++ ++ isdir = 0; ++ mode = h_inode->i_mode; ++ switch (mode & S_IFMT) { ++ case S_IFREG: ++ /* try stopping to update while we are referencing */ ++ IMustLock(h_inode); ++ err = vfsub_create(h_dir, &h_path, mode | S_IWUSR); ++ if (!err) ++ err = au_do_cpup_regular ++ (dentry, bdst, bsrc, len, ++ au_h_iptr(dst_parent->d_inode, bdst), &h_path); ++ break; ++ case S_IFDIR: ++ isdir = 1; ++ err = vfsub_mkdir(h_dir, &h_path, mode); ++ if (!err) { ++ /* ++ * strange behaviour from the users view, ++ * particularry setattr case ++ */ ++ if (au_ibstart(dst_parent->d_inode) == bdst) ++ au_cpup_attr_nlink(dst_parent->d_inode, ++ /*force*/1); ++ au_cpup_attr_nlink(dentry->d_inode, /*force*/1); ++ } ++ break; ++ case S_IFLNK: ++ err = au_do_cpup_symlink(&h_path, h_src, h_dir); ++ break; ++ case S_IFCHR: ++ case S_IFBLK: ++ AuDebugOn(!capable(CAP_MKNOD)); ++ /*FALLTHROUGH*/ ++ case S_IFIFO: ++ case S_IFSOCK: ++ err = vfsub_mknod(h_dir, &h_path, mode, h_inode->i_rdev); ++ break; ++ default: ++ AuIOErr("Unknown inode type 0%o\n", mode); ++ err = -EIO; ++ } ++ ++ mnt_flags = au_mntflags(sb); ++ if (!au_opt_test(mnt_flags, UDBA_NONE) ++ && !isdir ++ && au_opt_test(mnt_flags, XINO) ++ && h_inode->i_nlink == 1 ++ /* todo: unnecessary? */ ++ /* && dentry->d_inode->i_nlink == 1 */ ++ && bdst < bsrc ++ && !au_ftest_cpup(flags, KEEPLINO)) ++ au_xino_write0(sb, bsrc, h_inode->i_ino, /*ino*/0); ++ /* ignore this error */ ++ ++ if (do_dt) ++ au_dtime_revert(&dt); ++ return err; ++} ++ ++/* ++ * copyup the @dentry from @bsrc to @bdst. ++ * the caller must set the both of lower dentries. ++ * @len is for truncating when it is -1 copyup the entire file. ++ * in link/rename cases, @dst_parent may be different from the real one. ++ */ ++static int au_cpup_single(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len, unsigned int flags, ++ struct dentry *dst_parent) ++{ ++ int err, rerr; ++ aufs_bindex_t old_ibstart; ++ unsigned char isdir, plink; ++ struct au_dtime dt; ++ struct path h_path; ++ struct dentry *h_src, *h_dst, *h_parent; ++ struct inode *dst_inode, *h_dir, *inode; ++ struct super_block *sb; ++ ++ AuDebugOn(bsrc <= bdst); ++ ++ sb = dentry->d_sb; ++ h_path.mnt = au_sbr_mnt(sb, bdst); ++ h_dst = au_h_dptr(dentry, bdst); ++ h_parent = h_dst->d_parent; /* dir inode is locked */ ++ h_dir = h_parent->d_inode; ++ IMustLock(h_dir); ++ ++ h_src = au_h_dptr(dentry, bsrc); ++ inode = dentry->d_inode; ++ ++ if (!dst_parent) ++ dst_parent = dget_parent(dentry); ++ else ++ dget(dst_parent); ++ ++ plink = !!au_opt_test(au_mntflags(sb), PLINK); ++ dst_inode = au_h_iptr(inode, bdst); ++ if (dst_inode) { ++ if (unlikely(!plink)) { ++ err = -EIO; ++ AuIOErr("i%lu exists on a upper branch " ++ "but plink is disabled\n", inode->i_ino); ++ goto out; ++ } ++ ++ if (dst_inode->i_nlink) { ++ const int do_dt = au_ftest_cpup(flags, DTIME); ++ ++ h_src = au_plink_lkup(inode, bdst); ++ err = PTR_ERR(h_src); ++ if (IS_ERR(h_src)) ++ goto out; ++ if (unlikely(!h_src->d_inode)) { ++ err = -EIO; ++ AuIOErr("i%lu exists on a upper branch " ++ "but plink is broken\n", inode->i_ino); ++ dput(h_src); ++ goto out; ++ } ++ ++ if (do_dt) { ++ h_path.dentry = h_parent; ++ au_dtime_store(&dt, dst_parent, &h_path); ++ } ++ h_path.dentry = h_dst; ++ err = vfsub_link(h_src, h_dir, &h_path); ++ if (do_dt) ++ au_dtime_revert(&dt); ++ dput(h_src); ++ goto out; ++ } else ++ /* todo: cpup_wh_file? */ ++ /* udba work */ ++ au_update_brange(inode, 1); ++ } ++ ++ old_ibstart = au_ibstart(inode); ++ err = cpup_entry(dentry, bdst, bsrc, len, flags, dst_parent); ++ if (unlikely(err)) ++ goto out; ++ dst_inode = h_dst->d_inode; ++ mutex_lock_nested(&dst_inode->i_mutex, AuLsc_I_CHILD2); ++ ++ err = cpup_iattr(dentry, bdst, h_src); ++ isdir = S_ISDIR(dst_inode->i_mode); ++ if (!err) { ++ if (bdst < old_ibstart) ++ au_set_ibstart(inode, bdst); ++ au_set_h_iptr(inode, bdst, au_igrab(dst_inode), ++ au_hi_flags(inode, isdir)); ++ mutex_unlock(&dst_inode->i_mutex); ++ if (!isdir ++ && h_src->d_inode->i_nlink > 1 ++ && plink) ++ au_plink_append(inode, bdst, h_dst); ++ goto out; /* success */ ++ } ++ ++ /* revert */ ++ h_path.dentry = h_parent; ++ mutex_unlock(&dst_inode->i_mutex); ++ au_dtime_store(&dt, dst_parent, &h_path); ++ h_path.dentry = h_dst; ++ if (!isdir) ++ rerr = vfsub_unlink(h_dir, &h_path, /*force*/0); ++ else ++ rerr = vfsub_rmdir(h_dir, &h_path); ++ au_dtime_revert(&dt); ++ if (rerr) { ++ AuIOErr("failed removing broken entry(%d, %d)\n", err, rerr); ++ err = -EIO; ++ } ++ ++ out: ++ dput(dst_parent); ++ return err; ++} ++ ++struct au_cpup_single_args { ++ int *errp; ++ struct dentry *dentry; ++ aufs_bindex_t bdst, bsrc; ++ loff_t len; ++ unsigned int flags; ++ struct dentry *dst_parent; ++}; ++ ++static void au_call_cpup_single(void *args) ++{ ++ struct au_cpup_single_args *a = args; ++ *a->errp = au_cpup_single(a->dentry, a->bdst, a->bsrc, a->len, ++ a->flags, a->dst_parent); ++} ++ ++int au_sio_cpup_single(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len, unsigned int flags, ++ struct dentry *dst_parent) ++{ ++ int err, wkq_err; ++ umode_t mode; ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bsrc); ++ mode = h_dentry->d_inode->i_mode & S_IFMT; ++ if ((mode != S_IFCHR && mode != S_IFBLK) ++ || capable(CAP_MKNOD)) ++ err = au_cpup_single(dentry, bdst, bsrc, len, flags, ++ dst_parent); ++ else { ++ struct au_cpup_single_args args = { ++ .errp = &err, ++ .dentry = dentry, ++ .bdst = bdst, ++ .bsrc = bsrc, ++ .len = len, ++ .flags = flags, ++ .dst_parent = dst_parent ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_single, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++ ++/* ++ * copyup the @dentry from the first active lower branch to @bdst, ++ * using au_cpup_single(). ++ */ ++static int au_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ unsigned int flags) ++{ ++ int err; ++ aufs_bindex_t bsrc, bend; ++ ++ bend = au_dbend(dentry); ++ for (bsrc = bdst + 1; bsrc <= bend; bsrc++) ++ if (au_h_dptr(dentry, bsrc)) ++ break; ++ ++ err = au_lkup_neg(dentry, bdst); ++ if (!err) { ++ err = au_cpup_single(dentry, bdst, bsrc, len, flags, NULL); ++ if (!err) ++ return 0; /* success */ ++ ++ /* revert */ ++ au_set_h_dptr(dentry, bdst, NULL); ++ au_set_dbstart(dentry, bsrc); ++ } ++ ++ return err; ++} ++ ++struct au_cpup_simple_args { ++ int *errp; ++ struct dentry *dentry; ++ aufs_bindex_t bdst; ++ loff_t len; ++ unsigned int flags; ++}; ++ ++static void au_call_cpup_simple(void *args) ++{ ++ struct au_cpup_simple_args *a = args; ++ *a->errp = au_cpup_simple(a->dentry, a->bdst, a->len, a->flags); ++} ++ ++int au_sio_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ unsigned int flags) ++{ ++ int err, wkq_err; ++ unsigned char do_sio; ++ struct dentry *parent; ++ struct inode *h_dir; ++ ++ parent = dget_parent(dentry); ++ h_dir = au_h_iptr(parent->d_inode, bdst); ++ do_sio = !!au_test_h_perm_sio(h_dir, MAY_EXEC | MAY_WRITE); ++ if (!do_sio) { ++ /* ++ * testing CAP_MKNOD is for generic fs, ++ * but CAP_FSETID is for xfs only, currently. ++ */ ++ umode_t mode = dentry->d_inode->i_mode; ++ do_sio = (((mode & (S_IFCHR | S_IFBLK)) ++ && !capable(CAP_MKNOD)) ++ || ((mode & (S_ISUID | S_ISGID)) ++ && !capable(CAP_FSETID))); ++ } ++ if (!do_sio) ++ err = au_cpup_simple(dentry, bdst, len, flags); ++ else { ++ struct au_cpup_simple_args args = { ++ .errp = &err, ++ .dentry = dentry, ++ .bdst = bdst, ++ .len = len, ++ .flags = flags ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_simple, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * copyup the deleted file for writing. ++ */ ++static int au_do_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, ++ struct dentry *wh_dentry, struct file *file, ++ loff_t len) ++{ ++ int err; ++ aufs_bindex_t bstart; ++ struct au_dinfo *dinfo; ++ struct dentry *h_d_dst, *h_d_start; ++ ++ dinfo = au_di(dentry); ++ bstart = dinfo->di_bstart; ++ h_d_dst = dinfo->di_hdentry[0 + bdst].hd_dentry; ++ dinfo->di_bstart = bdst; ++ dinfo->di_hdentry[0 + bdst].hd_dentry = wh_dentry; ++ h_d_start = dinfo->di_hdentry[0 + bstart].hd_dentry; ++ if (file) ++ dinfo->di_hdentry[0 + bstart].hd_dentry ++ = au_h_fptr(file, au_fbstart(file))->f_dentry; ++ err = au_cpup_single(dentry, bdst, bstart, len, !AuCpup_DTIME, ++ /*h_parent*/NULL); ++ if (!err && file) { ++ err = au_reopen_nondir(file); ++ dinfo->di_hdentry[0 + bstart].hd_dentry = h_d_start; ++ } ++ dinfo->di_hdentry[0 + bdst].hd_dentry = h_d_dst; ++ dinfo->di_bstart = bstart; ++ ++ return err; ++} ++ ++static int au_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ struct file *file) ++{ ++ int err; ++ struct au_dtime dt; ++ struct dentry *parent, *h_parent, *wh_dentry; ++ struct au_branch *br; ++ struct path h_path; ++ ++ br = au_sbr(dentry->d_sb, bdst); ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bdst); ++ wh_dentry = au_whtmp_lkup(h_parent, br, &dentry->d_name); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ h_path.dentry = h_parent; ++ h_path.mnt = br->br_mnt; ++ au_dtime_store(&dt, parent, &h_path); ++ err = au_do_cpup_wh(dentry, bdst, wh_dentry, file, len); ++ if (unlikely(err)) ++ goto out_wh; ++ ++ dget(wh_dentry); ++ h_path.dentry = wh_dentry; ++ err = vfsub_unlink(h_parent->d_inode, &h_path, /*force*/0); ++ if (unlikely(err)) { ++ AuIOErr("failed remove copied-up tmp file %.*s(%d)\n", ++ AuDLNPair(wh_dentry), err); ++ err = -EIO; ++ } ++ au_dtime_revert(&dt); ++ au_set_hi_wh(dentry->d_inode, bdst, wh_dentry); ++ ++ out_wh: ++ dput(wh_dentry); ++ out: ++ dput(parent); ++ return err; ++} ++ ++struct au_cpup_wh_args { ++ int *errp; ++ struct dentry *dentry; ++ aufs_bindex_t bdst; ++ loff_t len; ++ struct file *file; ++}; ++ ++static void au_call_cpup_wh(void *args) ++{ ++ struct au_cpup_wh_args *a = args; ++ *a->errp = au_cpup_wh(a->dentry, a->bdst, a->len, a->file); ++} ++ ++int au_sio_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ struct file *file) ++{ ++ int err, wkq_err; ++ struct dentry *parent, *h_orph, *h_parent, *h_dentry; ++ struct inode *dir, *h_dir, *h_tmpdir, *h_inode; ++ struct au_wbr *wbr; ++ ++ parent = dget_parent(dentry); ++ dir = parent->d_inode; ++ h_orph = NULL; ++ h_parent = NULL; ++ h_dir = au_igrab(au_h_iptr(dir, bdst)); ++ h_tmpdir = h_dir; ++ if (!h_dir->i_nlink) { ++ wbr = au_sbr(dentry->d_sb, bdst)->br_wbr; ++ h_orph = wbr->wbr_orph; ++ ++ h_parent = dget(au_h_dptr(parent, bdst)); ++ au_set_h_dptr(parent, bdst, NULL); ++ au_set_h_dptr(parent, bdst, dget(h_orph)); ++ h_tmpdir = h_orph->d_inode; ++ au_set_h_iptr(dir, bdst, NULL, 0); ++ au_set_h_iptr(dir, bdst, au_igrab(h_tmpdir), /*flags*/0); ++ ++ /* this temporary unlock is safe */ ++ if (file) ++ h_dentry = au_h_fptr(file, au_fbstart(file))->f_dentry; ++ else ++ h_dentry = au_h_dptr(dentry, au_dbstart(dentry)); ++ h_inode = h_dentry->d_inode; ++ IMustLock(h_inode); ++ mutex_unlock(&h_inode->i_mutex); ++ mutex_lock_nested(&h_tmpdir->i_mutex, AuLsc_I_PARENT2); ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ } ++ ++ if (!au_test_h_perm_sio(h_tmpdir, MAY_EXEC | MAY_WRITE)) ++ err = au_cpup_wh(dentry, bdst, len, file); ++ else { ++ struct au_cpup_wh_args args = { ++ .errp = &err, ++ .dentry = dentry, ++ .bdst = bdst, ++ .len = len, ++ .file = file ++ }; ++ wkq_err = au_wkq_wait(au_call_cpup_wh, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ if (h_orph) { ++ mutex_unlock(&h_tmpdir->i_mutex); ++ au_set_h_iptr(dir, bdst, NULL, 0); ++ au_set_h_iptr(dir, bdst, au_igrab(h_dir), /*flags*/0); ++ au_set_h_dptr(parent, bdst, NULL); ++ au_set_h_dptr(parent, bdst, h_parent); ++ } ++ iput(h_dir); ++ dput(parent); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * generic routine for both of copy-up and copy-down. ++ */ ++/* cf. revalidate function in file.c */ ++int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst, ++ int (*cp)(struct dentry *dentry, aufs_bindex_t bdst, ++ struct dentry *h_parent, void *arg), ++ void *arg) ++{ ++ int err; ++ struct au_pin pin; ++ struct dentry *d, *parent, *h_parent, *real_parent; ++ ++ err = 0; ++ parent = dget_parent(dentry); ++ if (IS_ROOT(parent)) ++ goto out; ++ ++ au_pin_init(&pin, dentry, bdst, AuLsc_DI_PARENT2, AuLsc_I_PARENT2, ++ au_opt_udba(dentry->d_sb), AuPin_MNT_WRITE); ++ ++ /* do not use au_dpage */ ++ real_parent = parent; ++ while (1) { ++ dput(parent); ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bdst); ++ if (h_parent) ++ goto out; /* success */ ++ ++ /* find top dir which is necessary to cpup */ ++ do { ++ d = parent; ++ dput(parent); ++ parent = dget_parent(d); ++ di_read_lock_parent3(parent, !AuLock_IR); ++ h_parent = au_h_dptr(parent, bdst); ++ di_read_unlock(parent, !AuLock_IR); ++ } while (!h_parent); ++ ++ if (d != real_parent) ++ di_write_lock_child3(d); ++ ++ /* somebody else might create while we were sleeping */ ++ if (!au_h_dptr(d, bdst) || !au_h_dptr(d, bdst)->d_inode) { ++ if (au_h_dptr(d, bdst)) ++ au_update_dbstart(d); ++ ++ au_pin_set_dentry(&pin, d); ++ err = au_do_pin(&pin); ++ if (!err) { ++ err = cp(d, bdst, h_parent, arg); ++ au_unpin(&pin); ++ } ++ } ++ ++ if (d != real_parent) ++ di_write_unlock(d); ++ if (unlikely(err)) ++ break; ++ } ++ ++ out: ++ dput(parent); ++ return err; ++} ++ ++static int au_cpup_dir(struct dentry *dentry, aufs_bindex_t bdst, ++ struct dentry *h_parent __maybe_unused , ++ void *arg __maybe_unused) ++{ ++ return au_sio_cpup_simple(dentry, bdst, -1, AuCpup_DTIME); ++} ++ ++int au_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ return au_cp_dirs(dentry, bdst, au_cpup_dir, NULL); ++} ++ ++int au_test_and_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ int err; ++ struct dentry *parent; ++ struct inode *dir; ++ ++ parent = dget_parent(dentry); ++ dir = parent->d_inode; ++ err = 0; ++ if (au_h_iptr(dir, bdst)) ++ goto out; ++ ++ di_read_unlock(parent, AuLock_IR); ++ di_write_lock_parent(parent); ++ /* someone else might change our inode while we were sleeping */ ++ if (!au_h_iptr(dir, bdst)) ++ err = au_cpup_dirs(dentry, bdst); ++ di_downgrade_lock(parent, AuLock_IR); ++ ++ out: ++ dput(parent); ++ return err; ++} +diff -Naur a/fs/aufs/cpup.h b/fs/aufs/cpup.h +--- a/fs/aufs/cpup.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/cpup.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,81 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * copy-up/down functions ++ */ ++ ++#ifndef __AUFS_CPUP_H__ ++#define __AUFS_CPUP_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/path.h> ++#include <linux/time.h> ++#include <linux/aufs_type.h> ++ ++struct inode; ++struct file; ++ ++void au_cpup_attr_flags(struct inode *dst, struct inode *src); ++void au_cpup_attr_timesizes(struct inode *inode); ++void au_cpup_attr_nlink(struct inode *inode, int force); ++void au_cpup_attr_changeable(struct inode *inode); ++void au_cpup_igen(struct inode *inode, struct inode *h_inode); ++void au_cpup_attr_all(struct inode *inode, int force); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* cpup flags */ ++#define AuCpup_DTIME 1 /* do dtime_store/revert */ ++#define AuCpup_KEEPLINO (1 << 1) /* do not clear the lower xino, ++ for link(2) */ ++#define au_ftest_cpup(flags, name) ((flags) & AuCpup_##name) ++#define au_fset_cpup(flags, name) { (flags) |= AuCpup_##name; } ++#define au_fclr_cpup(flags, name) { (flags) &= ~AuCpup_##name; } ++ ++int au_copy_file(struct file *dst, struct file *src, loff_t len); ++int au_sio_cpup_single(struct dentry *dentry, aufs_bindex_t bdst, ++ aufs_bindex_t bsrc, loff_t len, unsigned int flags, ++ struct dentry *dst_parent); ++int au_sio_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ unsigned int flags); ++int au_sio_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, loff_t len, ++ struct file *file); ++ ++int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst, ++ int (*cp)(struct dentry *dentry, aufs_bindex_t bdst, ++ struct dentry *h_parent, void *arg), ++ void *arg); ++int au_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++int au_test_and_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* keep timestamps when copyup */ ++struct au_dtime { ++ struct dentry *dt_dentry; ++ struct path dt_h_path; ++ struct timespec dt_atime, dt_mtime; ++}; ++void au_dtime_store(struct au_dtime *dt, struct dentry *dentry, ++ struct path *h_path); ++void au_dtime_revert(struct au_dtime *dt); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_CPUP_H__ */ +diff -Naur a/fs/aufs/dbgaufs.c b/fs/aufs/dbgaufs.c +--- a/fs/aufs/dbgaufs.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dbgaufs.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,313 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * debugfs interface ++ */ ++ ++#include <linux/debugfs.h> ++#include "aufs.h" ++ ++#ifndef CONFIG_SYSFS ++#error DEBUG_FS depends upon SYSFS ++#endif ++ ++static struct dentry *dbgaufs; ++static const mode_t dbgaufs_mode = S_IRUSR | S_IRGRP | S_IROTH; ++ ++/* 20 is max digits length of ulong 64 */ ++struct dbgaufs_arg { ++ int n; ++ char a[20 * 4]; ++}; ++ ++/* ++ * common function for all XINO files ++ */ ++static int dbgaufs_xi_release(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ kfree(file->private_data); ++ return 0; ++} ++ ++static int dbgaufs_xi_open(struct file *xf, struct file *file, int do_fcnt) ++{ ++ int err; ++ struct kstat st; ++ struct dbgaufs_arg *p; ++ ++ err = -ENOMEM; ++ p = kmalloc(sizeof(*p), GFP_NOFS); ++ if (unlikely(!p)) ++ goto out; ++ ++ err = 0; ++ p->n = 0; ++ file->private_data = p; ++ if (!xf) ++ goto out; ++ ++ err = vfs_getattr(xf->f_vfsmnt, xf->f_dentry, &st); ++ if (!err) { ++ if (do_fcnt) ++ p->n = snprintf ++ (p->a, sizeof(p->a), "%ld, %llux%lu %lld\n", ++ (long)file_count(xf), st.blocks, st.blksize, ++ (long long)st.size); ++ else ++ p->n = snprintf(p->a, sizeof(p->a), "%llux%lu %lld\n", ++ st.blocks, st.blksize, ++ (long long)st.size); ++ AuDebugOn(p->n >= sizeof(p->a)); ++ } else { ++ p->n = snprintf(p->a, sizeof(p->a), "err %d\n", err); ++ err = 0; ++ } ++ ++ out: ++ return err; ++ ++} ++ ++static ssize_t dbgaufs_xi_read(struct file *file, char __user *buf, ++ size_t count, loff_t *ppos) ++{ ++ struct dbgaufs_arg *p; ++ ++ p = file->private_data; ++ return simple_read_from_buffer(buf, count, ppos, p->a, p->n); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int dbgaufs_xib_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ err = dbgaufs_xi_open(sbinfo->si_xib, file, /*do_fcnt*/0); ++ si_read_unlock(sb); ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xib_fop = { ++ .open = dbgaufs_xib_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define DbgaufsXi_PREFIX "xi" ++ ++static int dbgaufs_xino_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ long l; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ struct file *xf; ++ struct qstr *name; ++ ++ err = -ENOENT; ++ xf = NULL; ++ name = &file->f_dentry->d_name; ++ if (unlikely(name->len < sizeof(DbgaufsXi_PREFIX) ++ || memcmp(name->name, DbgaufsXi_PREFIX, ++ sizeof(DbgaufsXi_PREFIX) - 1))) ++ goto out; ++ err = strict_strtol(name->name + sizeof(DbgaufsXi_PREFIX) - 1, 10, &l); ++ if (unlikely(err)) ++ goto out; ++ ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ if (l <= au_sbend(sb)) { ++ xf = au_sbr(sb, (aufs_bindex_t)l)->br_xino.xi_file; ++ err = dbgaufs_xi_open(xf, file, /*do_fcnt*/1); ++ } else ++ err = -ENOENT; ++ si_read_unlock(sb); ++ ++ out: ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xino_fop = { ++ .open = dbgaufs_xino_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ aufs_bindex_t bend; ++ struct au_branch *br; ++ struct au_xino_file *xi; ++ ++ if (!au_sbi(sb)->si_dbgaufs) ++ return; ++ ++ bend = au_sbend(sb); ++ for (; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ xi = &br->br_xino; ++ if (xi->xi_dbgaufs) { ++ debugfs_remove(xi->xi_dbgaufs); ++ xi->xi_dbgaufs = NULL; ++ } ++ } ++} ++ ++void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ struct au_sbinfo *sbinfo; ++ struct dentry *parent; ++ struct au_branch *br; ++ struct au_xino_file *xi; ++ aufs_bindex_t bend; ++ char name[sizeof(DbgaufsXi_PREFIX) + 5]; /* "xi" bindex NULL */ ++ ++ sbinfo = au_sbi(sb); ++ parent = sbinfo->si_dbgaufs; ++ if (!parent) ++ return; ++ ++ bend = au_sbend(sb); ++ for (; bindex <= bend; bindex++) { ++ snprintf(name, sizeof(name), DbgaufsXi_PREFIX "%d", bindex); ++ br = au_sbr(sb, bindex); ++ xi = &br->br_xino; ++ AuDebugOn(xi->xi_dbgaufs); ++ xi->xi_dbgaufs = debugfs_create_file(name, dbgaufs_mode, parent, ++ sbinfo, &dbgaufs_xino_fop); ++ /* ignore an error */ ++ if (unlikely(!xi->xi_dbgaufs)) ++ AuWarn1("failed %s under debugfs\n", name); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++static int dbgaufs_xigen_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ ++ sbinfo = inode->i_private; ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ err = dbgaufs_xi_open(sbinfo->si_xigen, file, /*do_fcnt*/0); ++ si_read_unlock(sb); ++ return err; ++} ++ ++static const struct file_operations dbgaufs_xigen_fop = { ++ .open = dbgaufs_xigen_open, ++ .release = dbgaufs_xi_release, ++ .read = dbgaufs_xi_read ++}; ++ ++static int dbgaufs_xigen_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ ++ err = -EIO; ++ sbinfo->si_dbgaufs_xigen = debugfs_create_file ++ ("xigen", dbgaufs_mode, sbinfo->si_dbgaufs, sbinfo, ++ &dbgaufs_xigen_fop); ++ if (sbinfo->si_dbgaufs_xigen) ++ err = 0; ++ ++ return err; ++} ++#else ++static int dbgaufs_xigen_init(struct au_sbinfo *sbinfo) ++{ ++ return 0; ++} ++#endif /* CONFIG_AUFS_EXPORT */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++void dbgaufs_si_fin(struct au_sbinfo *sbinfo) ++{ ++ debugfs_remove_recursive(sbinfo->si_dbgaufs); ++ sbinfo->si_dbgaufs = NULL; ++ kobject_put(&sbinfo->si_kobj); ++} ++ ++int dbgaufs_si_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ char name[SysaufsSiNameLen]; ++ ++ err = -ENOENT; ++ if (!dbgaufs) { ++ AuErr1("/debug/aufs is uninitialized\n"); ++ goto out; ++ } ++ ++ err = -EIO; ++ sysaufs_name(sbinfo, name); ++ sbinfo->si_dbgaufs = debugfs_create_dir(name, dbgaufs); ++ if (unlikely(!sbinfo->si_dbgaufs)) ++ goto out; ++ kobject_get(&sbinfo->si_kobj); ++ ++ sbinfo->si_dbgaufs_xib = debugfs_create_file ++ ("xib", dbgaufs_mode, sbinfo->si_dbgaufs, sbinfo, ++ &dbgaufs_xib_fop); ++ if (unlikely(!sbinfo->si_dbgaufs_xib)) ++ goto out_dir; ++ ++ err = dbgaufs_xigen_init(sbinfo); ++ if (!err) ++ goto out; /* success */ ++ ++ out_dir: ++ dbgaufs_si_fin(sbinfo); ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void dbgaufs_fin(void) ++{ ++ debugfs_remove(dbgaufs); ++} ++ ++int __init dbgaufs_init(void) ++{ ++ int err; ++ ++ err = -EIO; ++ dbgaufs = debugfs_create_dir(AUFS_NAME, NULL); ++ if (dbgaufs) ++ err = 0; ++ return err; ++} +diff -Naur a/fs/aufs/dbgaufs.h b/fs/aufs/dbgaufs.h +--- a/fs/aufs/dbgaufs.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dbgaufs.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,79 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * debugfs interface ++ */ ++ ++#ifndef __DBGAUFS_H__ ++#define __DBGAUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/init.h> ++#include <linux/aufs_type.h> ++ ++struct super_block; ++struct au_sbinfo; ++ ++#ifdef CONFIG_DEBUG_FS ++/* dbgaufs.c */ ++void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex); ++void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex); ++void dbgaufs_si_fin(struct au_sbinfo *sbinfo); ++int dbgaufs_si_init(struct au_sbinfo *sbinfo); ++void dbgaufs_fin(void); ++int __init dbgaufs_init(void); ++ ++#else ++ ++static inline ++void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ /* empty */ ++} ++ ++static inline ++void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ /* empty */ ++} ++ ++static inline ++void dbgaufs_si_fin(struct au_sbinfo *sbinfo) ++{ ++ /* empty */ ++} ++ ++static inline ++int dbgaufs_si_init(struct au_sbinfo *sbinfo) ++{ ++ return 0; ++} ++ ++#define dbgaufs_fin() do {} while (0) ++ ++static inline ++int __init dbgaufs_init(void) ++{ ++ return 0; ++} ++#endif /* CONFIG_DEBUG_FS */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __DBGAUFS_H__ */ +diff -Naur a/fs/aufs/dcsub.c b/fs/aufs/dcsub.c +--- a/fs/aufs/dcsub.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dcsub.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,223 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sub-routines for dentry cache ++ */ ++ ++#include "aufs.h" ++ ++static void au_dpage_free(struct au_dpage *dpage) ++{ ++ int i; ++ struct dentry **p; ++ ++ p = dpage->dentries; ++ for (i = 0; i < dpage->ndentry; i++) ++ dput(*p++); ++ free_page((unsigned long)dpage->dentries); ++} ++ ++int au_dpages_init(struct au_dcsub_pages *dpages, gfp_t gfp) ++{ ++ int err; ++ void *p; ++ ++ err = -ENOMEM; ++ dpages->dpages = kmalloc(sizeof(*dpages->dpages), gfp); ++ if (unlikely(!dpages->dpages)) ++ goto out; ++ ++ p = (void *)__get_free_page(gfp); ++ if (unlikely(!p)) ++ goto out_dpages; ++ ++ dpages->dpages[0].ndentry = 0; ++ dpages->dpages[0].dentries = p; ++ dpages->ndpage = 1; ++ return 0; /* success */ ++ ++ out_dpages: ++ kfree(dpages->dpages); ++ out: ++ return err; ++} ++ ++void au_dpages_free(struct au_dcsub_pages *dpages) ++{ ++ int i; ++ struct au_dpage *p; ++ ++ p = dpages->dpages; ++ for (i = 0; i < dpages->ndpage; i++) ++ au_dpage_free(p++); ++ kfree(dpages->dpages); ++} ++ ++static int au_dpages_append(struct au_dcsub_pages *dpages, ++ struct dentry *dentry, gfp_t gfp) ++{ ++ int err, sz; ++ struct au_dpage *dpage; ++ void *p; ++ ++ dpage = dpages->dpages + dpages->ndpage - 1; ++ sz = PAGE_SIZE / sizeof(dentry); ++ if (unlikely(dpage->ndentry >= sz)) { ++ AuLabel(new dpage); ++ err = -ENOMEM; ++ sz = dpages->ndpage * sizeof(*dpages->dpages); ++ p = au_kzrealloc(dpages->dpages, sz, ++ sz + sizeof(*dpages->dpages), gfp); ++ if (unlikely(!p)) ++ goto out; ++ ++ dpages->dpages = p; ++ dpage = dpages->dpages + dpages->ndpage; ++ p = (void *)__get_free_page(gfp); ++ if (unlikely(!p)) ++ goto out; ++ ++ dpage->ndentry = 0; ++ dpage->dentries = p; ++ dpages->ndpage++; ++ } ++ ++ dpage->dentries[dpage->ndentry++] = dget(dentry); ++ return 0; /* success */ ++ ++ out: ++ return err; ++} ++ ++int au_dcsub_pages(struct au_dcsub_pages *dpages, struct dentry *root, ++ au_dpages_test test, void *arg) ++{ ++ int err; ++ struct dentry *this_parent = root; ++ struct list_head *next; ++ struct super_block *sb = root->d_sb; ++ ++ err = 0; ++ spin_lock(&dcache_lock); ++ repeat: ++ next = this_parent->d_subdirs.next; ++ resume: ++ if (this_parent->d_sb == sb ++ && !IS_ROOT(this_parent) ++ && atomic_read(&this_parent->d_count) ++ && this_parent->d_inode ++ && (!test || test(this_parent, arg))) { ++ err = au_dpages_append(dpages, this_parent, GFP_ATOMIC); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ while (next != &this_parent->d_subdirs) { ++ struct list_head *tmp = next; ++ struct dentry *dentry = list_entry(tmp, struct dentry, ++ d_u.d_child); ++ next = tmp->next; ++ if (/*d_unhashed(dentry) || */!dentry->d_inode) ++ continue; ++ if (!list_empty(&dentry->d_subdirs)) { ++ this_parent = dentry; ++ goto repeat; ++ } ++ if (dentry->d_sb == sb ++ && atomic_read(&dentry->d_count) ++ && (!test || test(dentry, arg))) { ++ err = au_dpages_append(dpages, dentry, GFP_ATOMIC); ++ if (unlikely(err)) ++ goto out; ++ } ++ } ++ ++ if (this_parent != root) { ++ next = this_parent->d_u.d_child.next; ++ this_parent = this_parent->d_parent; /* dcache_lock is locked */ ++ goto resume; ++ } ++ out: ++ spin_unlock(&dcache_lock); ++ return err; ++} ++ ++int au_dcsub_pages_rev(struct au_dcsub_pages *dpages, struct dentry *dentry, ++ int do_include, au_dpages_test test, void *arg) ++{ ++ int err; ++ ++ err = 0; ++ spin_lock(&dcache_lock); ++ if (do_include && (!test || test(dentry, arg))) { ++ err = au_dpages_append(dpages, dentry, GFP_ATOMIC); ++ if (unlikely(err)) ++ goto out; ++ } ++ while (!IS_ROOT(dentry)) { ++ dentry = dentry->d_parent; /* dcache_lock is locked */ ++ if (!test || test(dentry, arg)) { ++ err = au_dpages_append(dpages, dentry, GFP_ATOMIC); ++ if (unlikely(err)) ++ break; ++ } ++ } ++ ++ out: ++ spin_unlock(&dcache_lock); ++ ++ return err; ++} ++ ++struct dentry *au_test_subdir(struct dentry *d1, struct dentry *d2) ++{ ++ struct dentry *trap, **dentries; ++ int err, i, j; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ ++ trap = ERR_PTR(-ENOMEM); ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages_rev(&dpages, d1, /*do_include*/1, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ trap = d1; ++ for (i = 0; !err && i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ for (j = 0; !err && j < dpage->ndentry; j++) { ++ struct dentry *d; ++ ++ d = dentries[j]; ++ err = (d == d2); ++ if (!err) ++ trap = d; ++ } ++ } ++ if (!err) ++ trap = NULL; ++ ++ out_dpages: ++ au_dpages_free(&dpages); ++ out: ++ return trap; ++} +diff -Naur a/fs/aufs/dcsub.h b/fs/aufs/dcsub.h +--- a/fs/aufs/dcsub.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dcsub.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,54 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sub-routines for dentry cache ++ */ ++ ++#ifndef __AUFS_DCSUB_H__ ++#define __AUFS_DCSUB_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/types.h> ++ ++struct dentry; ++ ++struct au_dpage { ++ int ndentry; ++ struct dentry **dentries; ++}; ++ ++struct au_dcsub_pages { ++ int ndpage; ++ struct au_dpage *dpages; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_dpages_init(struct au_dcsub_pages *dpages, gfp_t gfp); ++void au_dpages_free(struct au_dcsub_pages *dpages); ++typedef int (*au_dpages_test)(struct dentry *dentry, void *arg); ++int au_dcsub_pages(struct au_dcsub_pages *dpages, struct dentry *root, ++ au_dpages_test test, void *arg); ++int au_dcsub_pages_rev(struct au_dcsub_pages *dpages, struct dentry *dentry, ++ int do_include, au_dpages_test test, void *arg); ++struct dentry *au_test_subdir(struct dentry *d1, struct dentry *d2); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DCSUB_H__ */ +diff -Naur a/fs/aufs/debug.c b/fs/aufs/debug.c +--- a/fs/aufs/debug.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/debug.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,427 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * debug print functions ++ */ ++ ++#include <linux/module.h> ++#include <linux/vt_kern.h> ++#include "aufs.h" ++ ++int aufs_debug; ++MODULE_PARM_DESC(debug, "debug print"); ++module_param_named(debug, aufs_debug, int, S_IRUGO | S_IWUSR | S_IWGRP); ++ ++char *au_plevel = KERN_DEBUG; ++#define dpri(fmt, arg...) do { \ ++ if (au_debug_test()) \ ++ printk("%s" fmt, au_plevel, ##arg); \ ++} while (0) ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_dpri_whlist(struct au_nhash *whlist) ++{ ++ unsigned long ul, n; ++ struct hlist_head *head; ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos; ++ ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (ul = 0; ul < n; ul++) { ++ hlist_for_each_entry(tpos, pos, head, wh_hash) ++ dpri("b%d, %.*s, %d\n", ++ tpos->wh_bindex, ++ tpos->wh_str.len, tpos->wh_str.name, ++ tpos->wh_str.len); ++ head++; ++ } ++} ++ ++void au_dpri_vdir(struct au_vdir *vdir) ++{ ++ unsigned long ul; ++ union au_vdir_deblk_p p; ++ unsigned char *o; ++ ++ if (!vdir || IS_ERR(vdir)) { ++ dpri("err %ld\n", PTR_ERR(vdir)); ++ return; ++ } ++ ++ dpri("deblk %u, nblk %lu, deblk %p, last{%lu, %p}, ver %lu\n", ++ vdir->vd_deblk_sz, vdir->vd_nblk, vdir->vd_deblk, ++ vdir->vd_last.ul, vdir->vd_last.p.deblk, vdir->vd_version); ++ for (ul = 0; ul < vdir->vd_nblk; ul++) { ++ p.deblk = vdir->vd_deblk[ul]; ++ o = p.deblk; ++ dpri("[%lu]: %p\n", ul, o); ++ } ++} ++ ++static int do_pri_inode(aufs_bindex_t bindex, struct inode *inode, ++ struct dentry *wh) ++{ ++ char *n = NULL; ++ int l = 0; ++ ++ if (!inode || IS_ERR(inode)) { ++ dpri("i%d: err %ld\n", bindex, PTR_ERR(inode)); ++ return -1; ++ } ++ ++ /* the type of i_blocks depends upon CONFIG_LSF */ ++ BUILD_BUG_ON(sizeof(inode->i_blocks) != sizeof(unsigned long) ++ && sizeof(inode->i_blocks) != sizeof(u64)); ++ if (wh) { ++ n = (void *)wh->d_name.name; ++ l = wh->d_name.len; ++ } ++ ++ dpri("i%d: i%lu, %s, cnt %d, nl %u, 0%o, sz %llu, blk %llu," ++ " ct %lld, np %lu, st 0x%lx, f 0x%x, g %x%s%.*s\n", ++ bindex, ++ inode->i_ino, inode->i_sb ? au_sbtype(inode->i_sb) : "??", ++ atomic_read(&inode->i_count), inode->i_nlink, inode->i_mode, ++ i_size_read(inode), (unsigned long long)inode->i_blocks, ++ (long long)timespec_to_ns(&inode->i_ctime) & 0x0ffff, ++ inode->i_mapping ? inode->i_mapping->nrpages : 0, ++ inode->i_state, inode->i_flags, inode->i_generation, ++ l ? ", wh " : "", l, n); ++ return 0; ++} ++ ++void au_dpri_inode(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ aufs_bindex_t bindex; ++ int err; ++ ++ err = do_pri_inode(-1, inode, NULL); ++ if (err || !au_test_aufs(inode->i_sb)) ++ return; ++ ++ iinfo = au_ii(inode); ++ if (!iinfo) ++ return; ++ dpri("i-1: bstart %d, bend %d, gen %d\n", ++ iinfo->ii_bstart, iinfo->ii_bend, au_iigen(inode)); ++ if (iinfo->ii_bstart < 0) ++ return; ++ for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend; bindex++) ++ do_pri_inode(bindex, iinfo->ii_hinode[0 + bindex].hi_inode, ++ iinfo->ii_hinode[0 + bindex].hi_whdentry); ++} ++ ++static int do_pri_dentry(aufs_bindex_t bindex, struct dentry *dentry) ++{ ++ struct dentry *wh = NULL; ++ ++ if (!dentry || IS_ERR(dentry)) { ++ dpri("d%d: err %ld\n", bindex, PTR_ERR(dentry)); ++ return -1; ++ } ++ /* do not call dget_parent() here */ ++ dpri("d%d: %.*s?/%.*s, %s, cnt %d, flags 0x%x\n", ++ bindex, ++ AuDLNPair(dentry->d_parent), AuDLNPair(dentry), ++ dentry->d_sb ? au_sbtype(dentry->d_sb) : "??", ++ atomic_read(&dentry->d_count), dentry->d_flags); ++ if (bindex >= 0 && dentry->d_inode && au_test_aufs(dentry->d_sb)) { ++ struct au_iinfo *iinfo = au_ii(dentry->d_inode); ++ if (iinfo) ++ wh = iinfo->ii_hinode[0 + bindex].hi_whdentry; ++ } ++ do_pri_inode(bindex, dentry->d_inode, wh); ++ return 0; ++} ++ ++void au_dpri_dentry(struct dentry *dentry) ++{ ++ struct au_dinfo *dinfo; ++ aufs_bindex_t bindex; ++ int err; ++ ++ err = do_pri_dentry(-1, dentry); ++ if (err || !au_test_aufs(dentry->d_sb)) ++ return; ++ ++ dinfo = au_di(dentry); ++ if (!dinfo) ++ return; ++ dpri("d-1: bstart %d, bend %d, bwh %d, bdiropq %d, gen %d\n", ++ dinfo->di_bstart, dinfo->di_bend, ++ dinfo->di_bwh, dinfo->di_bdiropq, au_digen(dentry)); ++ if (dinfo->di_bstart < 0) ++ return; ++ for (bindex = dinfo->di_bstart; bindex <= dinfo->di_bend; bindex++) ++ do_pri_dentry(bindex, dinfo->di_hdentry[0 + bindex].hd_dentry); ++} ++ ++static int do_pri_file(aufs_bindex_t bindex, struct file *file) ++{ ++ char a[32]; ++ ++ if (!file || IS_ERR(file)) { ++ dpri("f%d: err %ld\n", bindex, PTR_ERR(file)); ++ return -1; ++ } ++ a[0] = 0; ++ if (bindex < 0 ++ && file->f_dentry ++ && au_test_aufs(file->f_dentry->d_sb) ++ && au_fi(file)) ++ snprintf(a, sizeof(a), ", mmapped %d", au_test_mmapped(file)); ++ dpri("f%d: mode 0x%x, flags 0%o, cnt %ld, pos %llu%s\n", ++ bindex, file->f_mode, file->f_flags, (long)file_count(file), ++ file->f_pos, a); ++ if (file->f_dentry) ++ do_pri_dentry(bindex, file->f_dentry); ++ return 0; ++} ++ ++void au_dpri_file(struct file *file) ++{ ++ struct au_finfo *finfo; ++ aufs_bindex_t bindex; ++ int err; ++ ++ err = do_pri_file(-1, file); ++ if (err || !file->f_dentry || !au_test_aufs(file->f_dentry->d_sb)) ++ return; ++ ++ finfo = au_fi(file); ++ if (!finfo) ++ return; ++ if (finfo->fi_bstart < 0) ++ return; ++ for (bindex = finfo->fi_bstart; bindex <= finfo->fi_bend; bindex++) { ++ struct au_hfile *hf; ++ ++ hf = finfo->fi_hfile + bindex; ++ do_pri_file(bindex, hf ? hf->hf_file : NULL); ++ } ++} ++ ++static int do_pri_br(aufs_bindex_t bindex, struct au_branch *br) ++{ ++ struct vfsmount *mnt; ++ struct super_block *sb; ++ ++ if (!br || IS_ERR(br)) ++ goto out; ++ mnt = br->br_mnt; ++ if (!mnt || IS_ERR(mnt)) ++ goto out; ++ sb = mnt->mnt_sb; ++ if (!sb || IS_ERR(sb)) ++ goto out; ++ ++ dpri("s%d: {perm 0x%x, cnt %d, wbr %p}, " ++ "%s, dev 0x%02x%02x, flags 0x%lx, cnt(BIAS) %d, active %d, " ++ "xino %d\n", ++ bindex, br->br_perm, atomic_read(&br->br_count), br->br_wbr, ++ au_sbtype(sb), MAJOR(sb->s_dev), MINOR(sb->s_dev), ++ sb->s_flags, sb->s_count - S_BIAS, ++ atomic_read(&sb->s_active), !!br->br_xino.xi_file); ++ return 0; ++ ++ out: ++ dpri("s%d: err %ld\n", bindex, PTR_ERR(br)); ++ return -1; ++} ++ ++void au_dpri_sb(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ aufs_bindex_t bindex; ++ int err; ++ /* to reuduce stack size */ ++ struct { ++ struct vfsmount mnt; ++ struct au_branch fake; ++ } *a; ++ ++ /* this function can be called from magic sysrq */ ++ a = kzalloc(sizeof(*a), GFP_ATOMIC); ++ if (unlikely(!a)) { ++ dpri("no memory\n"); ++ return; ++ } ++ ++ a->mnt.mnt_sb = sb; ++ a->fake.br_perm = 0; ++ a->fake.br_mnt = &a->mnt; ++ a->fake.br_xino.xi_file = NULL; ++ atomic_set(&a->fake.br_count, 0); ++ smp_mb(); /* atomic_set */ ++ err = do_pri_br(-1, &a->fake); ++ kfree(a); ++ dpri("dev 0x%x\n", sb->s_dev); ++ if (err || !au_test_aufs(sb)) ++ return; ++ ++ sbinfo = au_sbi(sb); ++ if (!sbinfo) ++ return; ++ dpri("nw %d, gen %u, kobj %d\n", ++ atomic_read(&sbinfo->si_nowait.nw_len), sbinfo->si_generation, ++ atomic_read(&sbinfo->si_kobj.kref.refcount)); ++ for (bindex = 0; bindex <= sbinfo->si_bend; bindex++) ++ do_pri_br(bindex, sbinfo->si_branch[0 + bindex]); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_dbg_sleep_jiffy(int jiffy) ++{ ++ while (jiffy) ++ jiffy = schedule_timeout_uninterruptible(jiffy); ++} ++ ++void au_dbg_iattr(struct iattr *ia) ++{ ++#define AuBit(name) if (ia->ia_valid & ATTR_ ## name) \ ++ dpri(#name "\n") ++ AuBit(MODE); ++ AuBit(UID); ++ AuBit(GID); ++ AuBit(SIZE); ++ AuBit(ATIME); ++ AuBit(MTIME); ++ AuBit(CTIME); ++ AuBit(ATIME_SET); ++ AuBit(MTIME_SET); ++ AuBit(FORCE); ++ AuBit(ATTR_FLAG); ++ AuBit(KILL_SUID); ++ AuBit(KILL_SGID); ++ AuBit(FILE); ++ AuBit(KILL_PRIV); ++ AuBit(OPEN); ++ AuBit(TIMES_SET); ++#undef AuBit ++ dpri("ia_file %p\n", ia->ia_file); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_dbg_verify_dir_parent(struct dentry *dentry, unsigned int sigen) ++{ ++ struct dentry *parent; ++ ++ parent = dget_parent(dentry); ++ AuDebugOn(!S_ISDIR(dentry->d_inode->i_mode) ++ || IS_ROOT(dentry) ++ || au_digen(parent) != sigen); ++ dput(parent); ++} ++ ++void au_dbg_verify_nondir_parent(struct dentry *dentry, unsigned int sigen) ++{ ++ struct dentry *parent; ++ ++ parent = dget_parent(dentry); ++ AuDebugOn(S_ISDIR(dentry->d_inode->i_mode) ++ || au_digen(parent) != sigen); ++ dput(parent); ++} ++ ++void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen) ++{ ++ int err, i, j; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ AuDebugOn(err); ++ err = au_dcsub_pages_rev(&dpages, parent, /*do_include*/1, NULL, NULL); ++ AuDebugOn(err); ++ for (i = dpages.ndpage - 1; !err && i >= 0; i--) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ for (j = dpage->ndentry - 1; !err && j >= 0; j--) ++ AuDebugOn(au_digen(dentries[j]) != sigen); ++ } ++ au_dpages_free(&dpages); ++} ++ ++void au_dbg_verify_hf(struct au_finfo *finfo) ++{ ++ struct au_hfile *hf; ++ aufs_bindex_t bend, bindex; ++ ++ if (finfo->fi_bstart >= 0) { ++ bend = finfo->fi_bend; ++ for (bindex = finfo->fi_bstart; bindex <= bend; bindex++) { ++ hf = finfo->fi_hfile + bindex; ++ AuDebugOn(hf->hf_file || hf->hf_br); ++ } ++ } ++} ++ ++void au_dbg_verify_kthread(void) ++{ ++ if (au_test_wkq(current)) { ++ au_dbg_blocked(); ++ BUG(); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_debug_sbinfo_init(struct au_sbinfo *sbinfo __maybe_unused) ++{ ++#ifdef AuForceNoPlink ++ au_opt_clr(sbinfo->si_mntflags, PLINK); ++#endif ++#ifdef AuForceNoXino ++ au_opt_clr(sbinfo->si_mntflags, XINO); ++#endif ++#ifdef AuForceNoRefrof ++ au_opt_clr(sbinfo->si_mntflags, REFROF); ++#endif ++#ifdef AuForceHinotify ++ au_opt_set_udba(sbinfo->si_mntflags, UDBA_HINOTIFY); ++#endif ++} ++ ++int __init au_debug_init(void) ++{ ++ aufs_bindex_t bindex; ++ struct au_vdir_destr destr; ++ ++ bindex = -1; ++ AuDebugOn(bindex >= 0); ++ ++ destr.len = -1; ++ AuDebugOn(destr.len < NAME_MAX); ++ ++#ifdef CONFIG_4KSTACKS ++ AuWarn("CONFIG_4KSTACKS is defined.\n"); ++#endif ++ ++#ifdef AuForceNoBrs ++ sysaufs_brs = 0; ++#endif ++ ++ return 0; ++} +diff -Naur a/fs/aufs/debug.h b/fs/aufs/debug.h +--- a/fs/aufs/debug.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/debug.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,260 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * debug print functions ++ */ ++ ++#ifndef __AUFS_DEBUG_H__ ++#define __AUFS_DEBUG_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/bug.h> ++/* #include <linux/err.h> */ ++/* #include <linux/init.h> */ ++/* #include <linux/kernel.h> */ ++#include <linux/delay.h> ++/* #include <linux/kd.h> */ ++/* #include <linux/vt_kern.h> */ ++#include <linux/sysrq.h> ++#include <linux/aufs_type.h> ++ ++#ifdef CONFIG_AUFS_DEBUG ++#define AuDebugOn(a) BUG_ON(a) ++ ++/* module parameter */ ++extern int aufs_debug; ++static inline void au_debug(int n) ++{ ++ aufs_debug = n; ++ smp_mb(); ++} ++ ++static inline int au_debug_test(void) ++{ ++ return aufs_debug; ++} ++#else ++#define AuDebugOn(a) do {} while (0) ++#define au_debug() do {} while (0) ++static inline int au_debug_test(void) ++{ ++ return 0; ++} ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* debug print */ ++ ++#define AuDpri(lvl, fmt, arg...) \ ++ printk(lvl AUFS_NAME " %s:%d:%s[%d]: " fmt, \ ++ __func__, __LINE__, current->comm, current->pid, ##arg) ++#define AuDbg(fmt, arg...) do { \ ++ if (au_debug_test()) \ ++ AuDpri(KERN_DEBUG, fmt, ##arg); \ ++} while (0) ++#define AuLabel(l) AuDbg(#l "\n") ++#define AuInfo(fmt, arg...) AuDpri(KERN_INFO, fmt, ##arg) ++#define AuWarn(fmt, arg...) AuDpri(KERN_WARNING, fmt, ##arg) ++#define AuErr(fmt, arg...) AuDpri(KERN_ERR, fmt, ##arg) ++#define AuIOErr(fmt, arg...) AuErr("I/O Error, " fmt, ##arg) ++#define AuWarn1(fmt, arg...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ AuWarn(fmt, ##arg); \ ++} while (0) ++ ++#define AuErr1(fmt, arg...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ AuErr(fmt, ##arg); \ ++} while (0) ++ ++#define AuIOErr1(fmt, arg...) do { \ ++ static unsigned char _c; \ ++ if (!_c++) \ ++ AuIOErr(fmt, ##arg); \ ++} while (0) ++ ++#define AuUnsupportMsg "This operation is not supported." \ ++ " Please report this application to aufs-users ML." ++#define AuUnsupport(fmt, args...) do { \ ++ AuErr(AuUnsupportMsg "\n" fmt, ##args); \ ++ dump_stack(); \ ++} while (0) ++ ++#define AuTraceErr(e) do { \ ++ if (unlikely((e) < 0)) \ ++ AuDbg("err %d\n", (int)(e)); \ ++} while (0) ++ ++#define AuTraceErrPtr(p) do { \ ++ if (IS_ERR(p)) \ ++ AuDbg("err %ld\n", PTR_ERR(p)); \ ++} while (0) ++ ++/* dirty macros for debug print, use with "%.*s" and caution */ ++#define AuLNPair(qstr) (qstr)->len, (qstr)->name ++#define AuDLNPair(d) AuLNPair(&(d)->d_name) ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_sbinfo; ++struct au_finfo; ++struct dentry; ++#ifdef CONFIG_AUFS_DEBUG ++extern char *au_plevel; ++struct au_nhash; ++void au_dpri_whlist(struct au_nhash *whlist); ++struct au_vdir; ++void au_dpri_vdir(struct au_vdir *vdir); ++struct inode; ++void au_dpri_inode(struct inode *inode); ++void au_dpri_dentry(struct dentry *dentry); ++struct file; ++void au_dpri_file(struct file *filp); ++struct super_block; ++void au_dpri_sb(struct super_block *sb); ++ ++void au_dbg_sleep_jiffy(int jiffy); ++struct iattr; ++void au_dbg_iattr(struct iattr *ia); ++ ++void au_dbg_verify_dir_parent(struct dentry *dentry, unsigned int sigen); ++void au_dbg_verify_nondir_parent(struct dentry *dentry, unsigned int sigen); ++void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen); ++void au_dbg_verify_hf(struct au_finfo *finfo); ++void au_dbg_verify_kthread(void); ++ ++int __init au_debug_init(void); ++void au_debug_sbinfo_init(struct au_sbinfo *sbinfo); ++#define AuDbgWhlist(w) do { \ ++ AuDbg(#w "\n"); \ ++ au_dpri_whlist(w); \ ++} while (0) ++ ++#define AuDbgVdir(v) do { \ ++ AuDbg(#v "\n"); \ ++ au_dpri_vdir(v); \ ++} while (0) ++ ++#define AuDbgInode(i) do { \ ++ AuDbg(#i "\n"); \ ++ au_dpri_inode(i); \ ++} while (0) ++ ++#define AuDbgDentry(d) do { \ ++ AuDbg(#d "\n"); \ ++ au_dpri_dentry(d); \ ++} while (0) ++ ++#define AuDbgFile(f) do { \ ++ AuDbg(#f "\n"); \ ++ au_dpri_file(f); \ ++} while (0) ++ ++#define AuDbgSb(sb) do { \ ++ AuDbg(#sb "\n"); \ ++ au_dpri_sb(sb); \ ++} while (0) ++ ++#define AuDbgSleep(sec) do { \ ++ AuDbg("sleep %d sec\n", sec); \ ++ ssleep(sec); \ ++} while (0) ++ ++#define AuDbgSleepJiffy(jiffy) do { \ ++ AuDbg("sleep %d jiffies\n", jiffy); \ ++ au_dbg_sleep_jiffy(jiffy); \ ++} while (0) ++ ++#define AuDbgIAttr(ia) do { \ ++ AuDbg("ia_valid 0x%x\n", (ia)->ia_valid); \ ++ au_dbg_iattr(ia); \ ++} while (0) ++#else ++static inline void au_dbg_verify_dir_parent(struct dentry *dentry, ++ unsigned int sigen) ++{ ++ /* empty */ ++} ++static inline void au_dbg_verify_nondir_parent(struct dentry *dentry, ++ unsigned int sigen) ++{ ++ /* empty */ ++} ++static inline void au_dbg_verify_gen(struct dentry *parent, unsigned int sigen) ++{ ++ /* empty */ ++} ++static inline void au_dbg_verify_hf(struct au_finfo *finfo) ++{ ++ /* empty */ ++} ++static inline void au_dbg_verify_kthread(void) ++{ ++ /* empty */ ++} ++ ++static inline int au_debug_init(void) ++{ ++ return 0; ++} ++static inline void au_debug_sbinfo_init(struct au_sbinfo *sbinfo) ++{ ++ /* empty */ ++} ++#define AuDbgWhlist(w) do {} while (0) ++#define AuDbgVdir(v) do {} while (0) ++#define AuDbgInode(i) do {} while (0) ++#define AuDbgDentry(d) do {} while (0) ++#define AuDbgFile(f) do {} while (0) ++#define AuDbgSb(sb) do {} while (0) ++#define AuDbgSleep(sec) do {} while (0) ++#define AuDbgSleepJiffy(jiffy) do {} while (0) ++#define AuDbgIAttr(ia) do {} while (0) ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_MAGIC_SYSRQ ++int __init au_sysrq_init(void); ++void au_sysrq_fin(void); ++ ++#ifdef CONFIG_HW_CONSOLE ++#define au_dbg_blocked() do { \ ++ WARN_ON(1); \ ++ handle_sysrq('w', vc_cons[fg_console].d->vc_tty); \ ++} while (0) ++#else ++#define au_dbg_blocked() do {} while (0) ++#endif ++ ++#else ++static inline int au_sysrq_init(void) ++{ ++ return 0; ++} ++#define au_sysrq_fin() do {} while (0) ++#define au_dbg_blocked() do {} while (0) ++#endif /* CONFIG_AUFS_MAGIC_SYSRQ */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DEBUG_H__ */ +diff -Naur a/fs/aufs/dentry.c b/fs/aufs/dentry.c +--- a/fs/aufs/dentry.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dentry.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,876 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * lookup and dentry operations ++ */ ++ ++#include <linux/namei.h> ++#include "aufs.h" ++ ++static void au_h_nd(struct nameidata *h_nd, struct nameidata *nd) ++{ ++ if (nd) { ++ *h_nd = *nd; ++ ++ /* ++ * gave up supporting LOOKUP_CREATE/OPEN for lower fs, ++ * due to whiteout and branch permission. ++ */ ++ h_nd->flags &= ~(/*LOOKUP_PARENT |*/ LOOKUP_OPEN | LOOKUP_CREATE ++ | LOOKUP_FOLLOW); ++ /* unnecessary? */ ++ h_nd->intent.open.file = NULL; ++ } else ++ memset(h_nd, 0, sizeof(*h_nd)); ++} ++ ++struct au_lkup_one_args { ++ struct dentry **errp; ++ struct qstr *name; ++ struct dentry *h_parent; ++ struct au_branch *br; ++ struct nameidata *nd; ++}; ++ ++struct dentry *au_lkup_one(struct qstr *name, struct dentry *h_parent, ++ struct au_branch *br, struct nameidata *nd) ++{ ++ struct dentry *h_dentry; ++ int err; ++ struct nameidata h_nd; ++ ++ if (au_test_fs_null_nd(h_parent->d_sb)) ++ return vfsub_lookup_one_len(name->name, h_parent, name->len); ++ ++ au_h_nd(&h_nd, nd); ++ h_nd.path.dentry = h_parent; ++ h_nd.path.mnt = br->br_mnt; ++ ++ err = __lookup_one_len(name->name, &h_nd.last, NULL, name->len); ++ h_dentry = ERR_PTR(err); ++ if (!err) { ++ path_get(&h_nd.path); ++ h_dentry = vfsub_lookup_hash(&h_nd); ++ path_put(&h_nd.path); ++ } ++ ++ return h_dentry; ++} ++ ++static void au_call_lkup_one(void *args) ++{ ++ struct au_lkup_one_args *a = args; ++ *a->errp = au_lkup_one(a->name, a->h_parent, a->br, a->nd); ++} ++ ++#define AuLkup_ALLOW_NEG 1 ++#define au_ftest_lkup(flags, name) ((flags) & AuLkup_##name) ++#define au_fset_lkup(flags, name) { (flags) |= AuLkup_##name; } ++#define au_fclr_lkup(flags, name) { (flags) &= ~AuLkup_##name; } ++ ++struct au_do_lookup_args { ++ unsigned int flags; ++ mode_t type; ++ struct nameidata *nd; ++}; ++ ++/* ++ * returns positive/negative dentry, NULL or an error. ++ * NULL means whiteout-ed or not-found. ++ */ ++static struct dentry* ++au_do_lookup(struct dentry *h_parent, struct dentry *dentry, ++ aufs_bindex_t bindex, struct qstr *wh_name, ++ struct au_do_lookup_args *args) ++{ ++ struct dentry *h_dentry; ++ struct inode *h_inode, *inode; ++ struct qstr *name; ++ struct au_branch *br; ++ int wh_found, opq; ++ unsigned char wh_able; ++ const unsigned char allow_neg = !!au_ftest_lkup(args->flags, ALLOW_NEG); ++ ++ name = &dentry->d_name; ++ wh_found = 0; ++ br = au_sbr(dentry->d_sb, bindex); ++ wh_able = !!au_br_whable(br->br_perm); ++ if (wh_able) ++ wh_found = au_wh_test(h_parent, wh_name, br, /*try_sio*/0); ++ h_dentry = ERR_PTR(wh_found); ++ if (!wh_found) ++ goto real_lookup; ++ if (unlikely(wh_found < 0)) ++ goto out; ++ ++ /* We found a whiteout */ ++ /* au_set_dbend(dentry, bindex); */ ++ au_set_dbwh(dentry, bindex); ++ if (!allow_neg) ++ return NULL; /* success */ ++ ++ real_lookup: ++ h_dentry = au_lkup_one(name, h_parent, br, args->nd); ++ if (IS_ERR(h_dentry)) ++ goto out; ++ ++ h_inode = h_dentry->d_inode; ++ if (!h_inode) { ++ if (!allow_neg) ++ goto out_neg; ++ } else if (wh_found ++ || (args->type && args->type != (h_inode->i_mode & S_IFMT))) ++ goto out_neg; ++ ++ if (au_dbend(dentry) <= bindex) ++ au_set_dbend(dentry, bindex); ++ if (au_dbstart(dentry) < 0 || bindex < au_dbstart(dentry)) ++ au_set_dbstart(dentry, bindex); ++ au_set_h_dptr(dentry, bindex, h_dentry); ++ ++ inode = dentry->d_inode; ++ if (!h_inode || !S_ISDIR(h_inode->i_mode) || !wh_able ++ || (inode && !S_ISDIR(inode->i_mode))) ++ goto out; /* success */ ++ ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ opq = au_diropq_test(h_dentry, br); ++ mutex_unlock(&h_inode->i_mutex); ++ if (opq > 0) ++ au_set_dbdiropq(dentry, bindex); ++ else if (unlikely(opq < 0)) { ++ au_set_h_dptr(dentry, bindex, NULL); ++ h_dentry = ERR_PTR(opq); ++ } ++ goto out; ++ ++ out_neg: ++ dput(h_dentry); ++ h_dentry = NULL; ++ out: ++ return h_dentry; ++} ++ ++static int au_test_shwh(struct super_block *sb, const struct qstr *name) ++{ ++ if (unlikely(!au_opt_test(au_mntflags(sb), SHWH) ++ && !strncmp(name->name, AUFS_WH_PFX, AUFS_WH_PFX_LEN))) ++ return -EPERM; ++ return 0; ++} ++ ++/* ++ * returns the number of lower positive dentries, ++ * otherwise an error. ++ * can be called at unlinking with @type is zero. ++ */ ++int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type, ++ struct nameidata *nd) ++{ ++ int npositive, err; ++ aufs_bindex_t bindex, btail, bdiropq; ++ unsigned char isdir; ++ struct qstr whname; ++ struct au_do_lookup_args args = { ++ .flags = 0, ++ .type = type, ++ .nd = nd ++ }; ++ const struct qstr *name = &dentry->d_name; ++ struct dentry *parent; ++ struct inode *inode; ++ ++ parent = dget_parent(dentry); ++ err = au_test_shwh(dentry->d_sb, name); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_wh_name_alloc(&whname, name); ++ if (unlikely(err)) ++ goto out; ++ ++ inode = dentry->d_inode; ++ isdir = !!(inode && S_ISDIR(inode->i_mode)); ++ if (!type) ++ au_fset_lkup(args.flags, ALLOW_NEG); ++ ++ npositive = 0; ++ btail = au_dbtaildir(parent); ++ for (bindex = bstart; bindex <= btail; bindex++) { ++ struct dentry *h_parent, *h_dentry; ++ struct inode *h_inode, *h_dir; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry) { ++ if (h_dentry->d_inode) ++ npositive++; ++ if (type != S_IFDIR) ++ break; ++ continue; ++ } ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent) ++ continue; ++ h_dir = h_parent->d_inode; ++ if (!h_dir || !S_ISDIR(h_dir->i_mode)) ++ continue; ++ ++ mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_PARENT); ++ h_dentry = au_do_lookup(h_parent, dentry, bindex, &whname, ++ &args); ++ mutex_unlock(&h_dir->i_mutex); ++ err = PTR_ERR(h_dentry); ++ if (IS_ERR(h_dentry)) ++ goto out_wh; ++ au_fclr_lkup(args.flags, ALLOW_NEG); ++ ++ if (au_dbwh(dentry) >= 0) ++ break; ++ if (!h_dentry) ++ continue; ++ h_inode = h_dentry->d_inode; ++ if (!h_inode) ++ continue; ++ npositive++; ++ if (!args.type) ++ args.type = h_inode->i_mode & S_IFMT; ++ if (args.type != S_IFDIR) ++ break; ++ else if (isdir) { ++ /* the type of lower may be different */ ++ bdiropq = au_dbdiropq(dentry); ++ if (bdiropq >= 0 && bdiropq <= bindex) ++ break; ++ } ++ } ++ ++ if (npositive) { ++ AuLabel(positive); ++ au_update_dbstart(dentry); ++ } ++ err = npositive; ++ if (unlikely(!au_opt_test(au_mntflags(dentry->d_sb), UDBA_NONE) ++ && au_dbstart(dentry) < 0)) ++ /* both of real entry and whiteout found */ ++ err = -EIO; ++ ++ out_wh: ++ kfree(whname.name); ++ out: ++ dput(parent); ++ return err; ++} ++ ++struct dentry *au_sio_lkup_one(struct qstr *name, struct dentry *parent, ++ struct au_branch *br) ++{ ++ struct dentry *dentry; ++ int wkq_err; ++ ++ if (!au_test_h_perm_sio(parent->d_inode, MAY_EXEC)) ++ dentry = au_lkup_one(name, parent, br, /*nd*/NULL); ++ else { ++ struct au_lkup_one_args args = { ++ .errp = &dentry, ++ .name = name, ++ .h_parent = parent, ++ .br = br, ++ .nd = NULL ++ }; ++ ++ wkq_err = au_wkq_wait(au_call_lkup_one, &args); ++ if (unlikely(wkq_err)) ++ dentry = ERR_PTR(wkq_err); ++ } ++ ++ return dentry; ++} ++ ++/* ++ * lookup @dentry on @bindex which should be negative. ++ */ ++int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ int err; ++ struct dentry *parent, *h_parent, *h_dentry; ++ struct qstr *name; ++ ++ name = &dentry->d_name; ++ parent = dget_parent(dentry); ++ h_parent = au_h_dptr(parent, bindex); ++ h_dentry = au_sio_lkup_one(name, h_parent, ++ au_sbr(dentry->d_sb, bindex)); ++ err = PTR_ERR(h_dentry); ++ if (IS_ERR(h_dentry)) ++ goto out; ++ if (unlikely(h_dentry->d_inode)) { ++ err = -EIO; ++ AuIOErr("b%d %.*s should be negative.\n", ++ bindex, AuDLNPair(h_dentry)); ++ dput(h_dentry); ++ goto out; ++ } ++ ++ if (bindex < au_dbstart(dentry)) ++ au_set_dbstart(dentry, bindex); ++ if (au_dbend(dentry) < bindex) ++ au_set_dbend(dentry, bindex); ++ au_set_h_dptr(dentry, bindex, h_dentry); ++ err = 0; ++ ++ out: ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* subset of struct inode */ ++struct au_iattr { ++ unsigned long i_ino; ++ /* unsigned int i_nlink; */ ++ uid_t i_uid; ++ gid_t i_gid; ++ u64 i_version; ++/* ++ loff_t i_size; ++ blkcnt_t i_blocks; ++*/ ++ umode_t i_mode; ++}; ++ ++static void au_iattr_save(struct au_iattr *ia, struct inode *h_inode) ++{ ++ ia->i_ino = h_inode->i_ino; ++ /* ia->i_nlink = h_inode->i_nlink; */ ++ ia->i_uid = h_inode->i_uid; ++ ia->i_gid = h_inode->i_gid; ++ ia->i_version = h_inode->i_version; ++/* ++ ia->i_size = h_inode->i_size; ++ ia->i_blocks = h_inode->i_blocks; ++*/ ++ ia->i_mode = (h_inode->i_mode & S_IFMT); ++} ++ ++static int au_iattr_test(struct au_iattr *ia, struct inode *h_inode) ++{ ++ return ia->i_ino != h_inode->i_ino ++ /* || ia->i_nlink != h_inode->i_nlink */ ++ || ia->i_uid != h_inode->i_uid ++ || ia->i_gid != h_inode->i_gid ++ || ia->i_version != h_inode->i_version ++/* ++ || ia->i_size != h_inode->i_size ++ || ia->i_blocks != h_inode->i_blocks ++*/ ++ || ia->i_mode != (h_inode->i_mode & S_IFMT); ++} ++ ++static int au_h_verify_dentry(struct dentry *h_dentry, struct dentry *h_parent, ++ struct au_branch *br) ++{ ++ int err; ++ struct au_iattr ia; ++ struct inode *h_inode; ++ struct dentry *h_d; ++ struct super_block *h_sb; ++ ++ err = 0; ++ memset(&ia, -1, sizeof(ia)); ++ h_sb = h_dentry->d_sb; ++ h_inode = h_dentry->d_inode; ++ if (h_inode) ++ au_iattr_save(&ia, h_inode); ++ else if (au_test_nfs(h_sb) || au_test_fuse(h_sb)) ++ /* nfs d_revalidate may return 0 for negative dentry */ ++ /* fuse d_revalidate always return 0 for negative dentry */ ++ goto out; ++ ++ /* main purpose is namei.c:cached_lookup() and d_revalidate */ ++ h_d = au_lkup_one(&h_dentry->d_name, h_parent, br, /*nd*/NULL); ++ err = PTR_ERR(h_d); ++ if (IS_ERR(h_d)) ++ goto out; ++ ++ err = 0; ++ if (unlikely(h_d != h_dentry ++ || h_d->d_inode != h_inode ++ || (h_inode && au_iattr_test(&ia, h_inode)))) ++ err = au_busy_or_stale(); ++ dput(h_d); ++ ++ out: ++ AuTraceErr(err); ++ return err; ++} ++ ++int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir, ++ struct dentry *h_parent, struct au_branch *br) ++{ ++ int err; ++ ++ err = 0; ++ if (udba == AuOpt_UDBA_REVAL) { ++ IMustLock(h_dir); ++ err = (h_dentry->d_parent->d_inode != h_dir); ++ } else if (udba == AuOpt_UDBA_HINOTIFY) ++ err = au_h_verify_dentry(h_dentry, h_parent, br); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_do_refresh_hdentry(struct au_hdentry *p, struct au_dinfo *dinfo, ++ struct dentry *parent) ++{ ++ struct dentry *h_d, *h_dp; ++ struct au_hdentry tmp, *q; ++ struct super_block *sb; ++ aufs_bindex_t new_bindex, bindex, bend, bwh, bdiropq; ++ ++ bend = dinfo->di_bend; ++ bwh = dinfo->di_bwh; ++ bdiropq = dinfo->di_bdiropq; ++ for (bindex = dinfo->di_bstart; bindex <= bend; bindex++, p++) { ++ h_d = p->hd_dentry; ++ if (!h_d) ++ continue; ++ ++ h_dp = dget_parent(h_d); ++ if (h_dp == au_h_dptr(parent, bindex)) { ++ dput(h_dp); ++ continue; ++ } ++ ++ new_bindex = au_find_dbindex(parent, h_dp); ++ dput(h_dp); ++ if (dinfo->di_bwh == bindex) ++ bwh = new_bindex; ++ if (dinfo->di_bdiropq == bindex) ++ bdiropq = new_bindex; ++ if (new_bindex < 0) { ++ au_hdput(p); ++ p->hd_dentry = NULL; ++ continue; ++ } ++ ++ /* swap two lower dentries, and loop again */ ++ q = dinfo->di_hdentry + new_bindex; ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hd_dentry) { ++ bindex--; ++ p--; ++ } ++ } ++ ++ sb = parent->d_sb; ++ dinfo->di_bwh = -1; ++ if (bwh >= 0 && bwh <= au_sbend(sb) && au_sbr_whable(sb, bwh)) ++ dinfo->di_bwh = bwh; ++ ++ dinfo->di_bdiropq = -1; ++ if (bdiropq >= 0 ++ && bdiropq <= au_sbend(sb) ++ && au_sbr_whable(sb, bdiropq)) ++ dinfo->di_bdiropq = bdiropq; ++ ++ bend = au_dbend(parent); ++ p = dinfo->di_hdentry; ++ for (bindex = 0; bindex <= bend; bindex++, p++) ++ if (p->hd_dentry) { ++ dinfo->di_bstart = bindex; ++ break; ++ } ++ ++ p = dinfo->di_hdentry + bend; ++ for (bindex = bend; bindex >= 0; bindex--, p--) ++ if (p->hd_dentry) { ++ dinfo->di_bend = bindex; ++ break; ++ } ++} ++ ++/* ++ * returns the number of found lower positive dentries, ++ * otherwise an error. ++ */ ++int au_refresh_hdentry(struct dentry *dentry, mode_t type) ++{ ++ int npositive, err; ++ unsigned int sigen; ++ aufs_bindex_t bstart; ++ struct au_dinfo *dinfo; ++ struct super_block *sb; ++ struct dentry *parent; ++ ++ sb = dentry->d_sb; ++ AuDebugOn(IS_ROOT(dentry)); ++ sigen = au_sigen(sb); ++ parent = dget_parent(dentry); ++ AuDebugOn(au_digen(parent) != sigen ++ || au_iigen(parent->d_inode) != sigen); ++ ++ dinfo = au_di(dentry); ++ err = au_di_realloc(dinfo, au_sbend(sb) + 1); ++ npositive = err; ++ if (unlikely(err)) ++ goto out; ++ au_do_refresh_hdentry(dinfo->di_hdentry + dinfo->di_bstart, dinfo, ++ parent); ++ ++ npositive = 0; ++ bstart = au_dbstart(parent); ++ if (type != S_IFDIR && dinfo->di_bstart == bstart) ++ goto out_dgen; /* success */ ++ ++ npositive = au_lkup_dentry(dentry, bstart, type, /*nd*/NULL); ++ if (npositive < 0) ++ goto out; ++ if (dinfo->di_bwh >= 0 && dinfo->di_bwh <= dinfo->di_bstart) ++ d_drop(dentry); ++ ++ out_dgen: ++ au_update_digen(dentry); ++ out: ++ dput(parent); ++ AuTraceErr(npositive); ++ return npositive; ++} ++ ++static noinline_for_stack ++int au_do_h_d_reval(struct dentry *h_dentry, struct nameidata *nd, ++ struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ int err, valid; ++ int (*reval)(struct dentry *, struct nameidata *); ++ ++ err = 0; ++ reval = NULL; ++ if (h_dentry->d_op) ++ reval = h_dentry->d_op->d_revalidate; ++ if (!reval) ++ goto out; ++ ++ AuDbg("b%d\n", bindex); ++ if (au_test_fs_null_nd(h_dentry->d_sb)) ++ /* it may return tri-state */ ++ valid = reval(h_dentry, NULL); ++ else { ++ struct nameidata h_nd; ++ int locked; ++ struct dentry *parent; ++ ++ au_h_nd(&h_nd, nd); ++ parent = nd->path.dentry; ++ locked = (nd && nd->path.dentry != dentry); ++ if (locked) ++ di_read_lock_parent(parent, AuLock_IR); ++ BUG_ON(bindex > au_dbend(parent)); ++ h_nd.path.dentry = au_h_dptr(parent, bindex); ++ BUG_ON(!h_nd.path.dentry); ++ h_nd.path.mnt = au_sbr(parent->d_sb, bindex)->br_mnt; ++ path_get(&h_nd.path); ++ valid = reval(h_dentry, &h_nd); ++ path_put(&h_nd.path); ++ if (locked) ++ di_read_unlock(parent, AuLock_IR); ++ } ++ ++ if (unlikely(valid < 0)) ++ err = valid; ++ else if (!valid) ++ err = -EINVAL; ++ ++ out: ++ AuTraceErr(err); ++ return err; ++} ++ ++/* todo: remove this */ ++static int h_d_revalidate(struct dentry *dentry, struct inode *inode, ++ struct nameidata *nd, int do_udba) ++{ ++ int err; ++ umode_t mode, h_mode; ++ aufs_bindex_t bindex, btail, bstart, ibs, ibe; ++ unsigned char plus, unhashed, is_root, h_plus; ++ struct inode *first, *h_inode, *h_cached_inode; ++ struct dentry *h_dentry; ++ struct qstr *name, *h_name; ++ ++ err = 0; ++ plus = 0; ++ mode = 0; ++ first = NULL; ++ ibs = -1; ++ ibe = -1; ++ unhashed = !!d_unhashed(dentry); ++ is_root = !!IS_ROOT(dentry); ++ name = &dentry->d_name; ++ ++ /* ++ * Theoretically, REVAL test should be unnecessary in case of INOTIFY. ++ * But inotify doesn't fire some necessary events, ++ * IN_ATTRIB for atime/nlink/pageio ++ * IN_DELETE for NFS dentry ++ * Let's do REVAL test too. ++ */ ++ if (do_udba && inode) { ++ mode = (inode->i_mode & S_IFMT); ++ plus = (inode->i_nlink > 0); ++ first = au_h_iptr(inode, au_ibstart(inode)); ++ ibs = au_ibstart(inode); ++ ibe = au_ibend(inode); ++ } ++ ++ bstart = au_dbstart(dentry); ++ btail = bstart; ++ if (inode && S_ISDIR(inode->i_mode)) ++ btail = au_dbtaildir(dentry); ++ for (bindex = bstart; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ ++ AuDbg("b%d, %.*s\n", bindex, AuDLNPair(h_dentry)); ++ h_name = &h_dentry->d_name; ++ if (unlikely(do_udba ++ && !is_root ++ && (unhashed != !!d_unhashed(h_dentry) ++ || name->len != h_name->len ++ || memcmp(name->name, h_name->name, name->len)) ++ )) { ++ AuDbg("unhash 0x%x 0x%x, %.*s %.*s\n", ++ unhashed, d_unhashed(h_dentry), ++ AuDLNPair(dentry), AuDLNPair(h_dentry)); ++ goto err; ++ } ++ ++ err = au_do_h_d_reval(h_dentry, nd, dentry, bindex); ++ if (unlikely(err)) ++ /* do not goto err, to keep the errno */ ++ break; ++ ++ /* todo: plink too? */ ++ if (!do_udba) ++ continue; ++ ++ /* UDBA tests */ ++ h_inode = h_dentry->d_inode; ++ if (unlikely(!!inode != !!h_inode)) ++ goto err; ++ ++ h_plus = plus; ++ h_mode = mode; ++ h_cached_inode = h_inode; ++ if (h_inode) { ++ h_mode = (h_inode->i_mode & S_IFMT); ++ h_plus = (h_inode->i_nlink > 0); ++ } ++ if (inode && ibs <= bindex && bindex <= ibe) ++ h_cached_inode = au_h_iptr(inode, bindex); ++ ++ if (unlikely(plus != h_plus ++ || mode != h_mode ++ || h_cached_inode != h_inode)) ++ goto err; ++ continue; ++ ++ err: ++ err = -EINVAL; ++ break; ++ } ++ ++ return err; ++} ++ ++static int simple_reval_dpath(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct dentry *parent; ++ struct inode *inode; ++ ++ inode = dentry->d_inode; ++ if (au_digen(dentry) == sigen && au_iigen(inode) == sigen) ++ return 0; ++ ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ AuDebugOn(au_digen(parent) != sigen ++ || au_iigen(parent->d_inode) != sigen); ++ au_dbg_verify_gen(parent, sigen); ++ ++ /* returns a number of positive dentries */ ++ err = au_refresh_hdentry(dentry, inode->i_mode & S_IFMT); ++ if (err >= 0) ++ err = au_refresh_hinode(inode, dentry); ++ ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++ return err; ++} ++ ++int au_reval_dpath(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct dentry *d, *parent; ++ struct inode *inode; ++ ++ if (!au_ftest_si(au_sbi(dentry->d_sb), FAILED_REFRESH_DIRS)) ++ return simple_reval_dpath(dentry, sigen); ++ ++ /* slow loop, keep it simple and stupid */ ++ /* cf: au_cpup_dirs() */ ++ err = 0; ++ parent = NULL; ++ while (au_digen(dentry) != sigen ++ || au_iigen(dentry->d_inode) != sigen) { ++ d = dentry; ++ while (1) { ++ dput(parent); ++ parent = dget_parent(d); ++ if (au_digen(parent) == sigen ++ && au_iigen(parent->d_inode) == sigen) ++ break; ++ d = parent; ++ } ++ ++ inode = d->d_inode; ++ if (d != dentry) ++ di_write_lock_child(d); ++ ++ /* someone might update our dentry while we were sleeping */ ++ if (au_digen(d) != sigen || au_iigen(d->d_inode) != sigen) { ++ di_read_lock_parent(parent, AuLock_IR); ++ /* returns a number of positive dentries */ ++ err = au_refresh_hdentry(d, inode->i_mode & S_IFMT); ++ if (err >= 0) ++ err = au_refresh_hinode(inode, d); ++ di_read_unlock(parent, AuLock_IR); ++ } ++ ++ if (d != dentry) ++ di_write_unlock(d); ++ dput(parent); ++ if (unlikely(err)) ++ break; ++ } ++ ++ return err; ++} ++ ++/* ++ * if valid returns 1, otherwise 0. ++ */ ++static int aufs_d_revalidate(struct dentry *dentry, struct nameidata *nd) ++{ ++ int valid, err; ++ unsigned int sigen; ++ unsigned char do_udba; ++ struct super_block *sb; ++ struct inode *inode; ++ ++ err = -EINVAL; ++ sb = dentry->d_sb; ++ inode = dentry->d_inode; ++ aufs_read_lock(dentry, AuLock_FLUSH | AuLock_DW); ++ sigen = au_sigen(sb); ++ if (au_digen(dentry) != sigen) { ++ AuDebugOn(IS_ROOT(dentry)); ++ if (inode) ++ err = au_reval_dpath(dentry, sigen); ++ if (unlikely(err)) ++ goto out_dgrade; ++ AuDebugOn(au_digen(dentry) != sigen); ++ } ++ if (inode && au_iigen(inode) != sigen) { ++ AuDebugOn(IS_ROOT(dentry)); ++ err = au_refresh_hinode(inode, dentry); ++ if (unlikely(err)) ++ goto out_dgrade; ++ AuDebugOn(au_iigen(inode) != sigen); ++ } ++ di_downgrade_lock(dentry, AuLock_IR); ++ ++ AuDebugOn(au_digen(dentry) != sigen); ++ AuDebugOn(inode && au_iigen(inode) != sigen); ++ err = -EINVAL; ++ do_udba = !au_opt_test(au_mntflags(sb), UDBA_NONE); ++ if (do_udba && inode) { ++ aufs_bindex_t bstart = au_ibstart(inode); ++ ++ if (bstart >= 0 ++ && au_test_higen(inode, au_h_iptr(inode, bstart))) ++ goto out; ++ } ++ ++ err = h_d_revalidate(dentry, inode, nd, do_udba); ++ if (unlikely(!err && do_udba && au_dbstart(dentry) < 0)) ++ /* both of real entry and whiteout found */ ++ err = -EIO; ++ goto out; ++ ++ out_dgrade: ++ di_downgrade_lock(dentry, AuLock_IR); ++ out: ++ au_store_oflag(nd, inode); ++ aufs_read_unlock(dentry, AuLock_IR); ++ AuTraceErr(err); ++ valid = !err; ++ if (!valid) ++ AuDbg("%.*s invalid\n", AuDLNPair(dentry)); ++ return valid; ++} ++ ++static void aufs_d_release(struct dentry *dentry) ++{ ++ struct au_dinfo *dinfo; ++ aufs_bindex_t bend, bindex; ++ ++ dinfo = dentry->d_fsdata; ++ if (!dinfo) ++ return; ++ ++ /* dentry may not be revalidated */ ++ bindex = dinfo->di_bstart; ++ if (bindex >= 0) { ++ struct au_hdentry *p; ++ ++ bend = dinfo->di_bend; ++ p = dinfo->di_hdentry + bindex; ++ while (bindex++ <= bend) { ++ if (p->hd_dentry) ++ au_hdput(p); ++ p++; ++ } ++ } ++ kfree(dinfo->di_hdentry); ++ au_rwsem_destroy(&dinfo->di_rwsem); ++ au_cache_free_dinfo(dinfo); ++ au_hin_di_reinit(dentry); ++} ++ ++struct dentry_operations aufs_dop = { ++ .d_revalidate = aufs_d_revalidate, ++ .d_release = aufs_d_release ++}; +diff -Naur a/fs/aufs/dentry.h b/fs/aufs/dentry.h +--- a/fs/aufs/dentry.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dentry.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,221 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * lookup and dentry operations ++ */ ++ ++#ifndef __AUFS_DENTRY_H__ ++#define __AUFS_DENTRY_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/dcache.h> ++#include <linux/aufs_type.h> ++#include "rwsem.h" ++ ++/* make a single member structure for future use */ ++/* todo: remove this structure */ ++struct au_hdentry { ++ struct dentry *hd_dentry; ++}; ++ ++struct au_dinfo { ++ atomic_t di_generation; ++ ++ struct rw_semaphore di_rwsem; ++ aufs_bindex_t di_bstart, di_bend, di_bwh, di_bdiropq; ++ struct au_hdentry *di_hdentry; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dentry.c */ ++extern struct dentry_operations aufs_dop; ++struct au_branch; ++struct dentry *au_lkup_one(struct qstr *name, struct dentry *h_parent, ++ struct au_branch *br, struct nameidata *nd); ++struct dentry *au_sio_lkup_one(struct qstr *name, struct dentry *parent, ++ struct au_branch *br); ++int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir, ++ struct dentry *h_parent, struct au_branch *br); ++ ++int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type, ++ struct nameidata *nd); ++int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex); ++int au_refresh_hdentry(struct dentry *dentry, mode_t type); ++int au_reval_dpath(struct dentry *dentry, unsigned int sigen); ++ ++/* dinfo.c */ ++int au_alloc_dinfo(struct dentry *dentry); ++int au_di_realloc(struct au_dinfo *dinfo, int nbr); ++ ++void di_read_lock(struct dentry *d, int flags, unsigned int lsc); ++void di_read_unlock(struct dentry *d, int flags); ++void di_downgrade_lock(struct dentry *d, int flags); ++void di_write_lock(struct dentry *d, unsigned int lsc); ++void di_write_unlock(struct dentry *d); ++void di_write_lock2_child(struct dentry *d1, struct dentry *d2, int isdir); ++void di_write_lock2_parent(struct dentry *d1, struct dentry *d2, int isdir); ++void di_write_unlock2(struct dentry *d1, struct dentry *d2); ++ ++struct dentry *au_h_dptr(struct dentry *dentry, aufs_bindex_t bindex); ++aufs_bindex_t au_dbtail(struct dentry *dentry); ++aufs_bindex_t au_dbtaildir(struct dentry *dentry); ++ ++void au_set_h_dptr(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_dentry); ++void au_update_digen(struct dentry *dentry); ++void au_update_dbrange(struct dentry *dentry, int do_put_zero); ++void au_update_dbstart(struct dentry *dentry); ++void au_update_dbend(struct dentry *dentry); ++int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_dinfo *au_di(struct dentry *dentry) ++{ ++ return dentry->d_fsdata; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for dinfo */ ++enum { ++ AuLsc_DI_CHILD, /* child first */ ++ AuLsc_DI_CHILD2, /* rename(2), link(2), and cpup at hinotify */ ++ AuLsc_DI_CHILD3, /* copyup dirs */ ++ AuLsc_DI_PARENT, ++ AuLsc_DI_PARENT2, ++ AuLsc_DI_PARENT3 ++}; ++ ++/* ++ * di_read_lock_child, di_write_lock_child, ++ * di_read_lock_child2, di_write_lock_child2, ++ * di_read_lock_child3, di_write_lock_child3, ++ * di_read_lock_parent, di_write_lock_parent, ++ * di_read_lock_parent2, di_write_lock_parent2, ++ * di_read_lock_parent3, di_write_lock_parent3, ++ */ ++#define AuReadLockFunc(name, lsc) \ ++static inline void di_read_lock_##name(struct dentry *d, int flags) \ ++{ di_read_lock(d, flags, AuLsc_DI_##lsc); } ++ ++#define AuWriteLockFunc(name, lsc) \ ++static inline void di_write_lock_##name(struct dentry *d) \ ++{ di_write_lock(d, AuLsc_DI_##lsc); } ++ ++#define AuRWLockFuncs(name, lsc) \ ++ AuReadLockFunc(name, lsc) \ ++ AuWriteLockFunc(name, lsc) ++ ++AuRWLockFuncs(child, CHILD); ++AuRWLockFuncs(child2, CHILD2); ++AuRWLockFuncs(child3, CHILD3); ++AuRWLockFuncs(parent, PARENT); ++AuRWLockFuncs(parent2, PARENT2); ++AuRWLockFuncs(parent3, PARENT3); ++ ++#undef AuReadLockFunc ++#undef AuWriteLockFunc ++#undef AuRWLockFuncs ++ ++#define DiMustNoWaiters(d) AuRwMustNoWaiters(&au_di(d)->di_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: memory barrier? */ ++static inline unsigned int au_digen(struct dentry *d) ++{ ++ return atomic_read(&au_di(d)->di_generation); ++} ++ ++static inline void au_h_dentry_init(struct au_hdentry *hdentry) ++{ ++ hdentry->hd_dentry = NULL; ++} ++ ++static inline void au_hdput(struct au_hdentry *hd) ++{ ++ dput(hd->hd_dentry); ++} ++ ++static inline aufs_bindex_t au_dbstart(struct dentry *dentry) ++{ ++ return au_di(dentry)->di_bstart; ++} ++ ++static inline aufs_bindex_t au_dbend(struct dentry *dentry) ++{ ++ return au_di(dentry)->di_bend; ++} ++ ++static inline aufs_bindex_t au_dbwh(struct dentry *dentry) ++{ ++ return au_di(dentry)->di_bwh; ++} ++ ++static inline aufs_bindex_t au_dbdiropq(struct dentry *dentry) ++{ ++ return au_di(dentry)->di_bdiropq; ++} ++ ++/* todo: hard/soft set? */ ++static inline void au_set_dbstart(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ au_di(dentry)->di_bstart = bindex; ++} ++ ++static inline void au_set_dbend(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ au_di(dentry)->di_bend = bindex; ++} ++ ++static inline void au_set_dbwh(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ /* dbwh can be outside of bstart - bend range */ ++ au_di(dentry)->di_bwh = bindex; ++} ++ ++static inline void au_set_dbdiropq(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ au_di(dentry)->di_bdiropq = bindex; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_HINOTIFY ++static inline void au_digen_dec(struct dentry *d) ++{ ++ atomic_dec(&au_di(d)->di_generation); ++} ++ ++static inline void au_hin_di_reinit(struct dentry *dentry) ++{ ++ dentry->d_fsdata = NULL; ++} ++#else ++static inline void au_hin_di_reinit(struct dentry *dentry __maybe_unused) ++{ ++ /* empty */ ++} ++#endif /* CONFIG_AUFS_HINOTIFY */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DENTRY_H__ */ +diff -Naur a/fs/aufs/dinfo.c b/fs/aufs/dinfo.c +--- a/fs/aufs/dinfo.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dinfo.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,360 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * dentry private data ++ */ ++ ++#include "aufs.h" ++ ++int au_alloc_dinfo(struct dentry *dentry) ++{ ++ struct au_dinfo *dinfo; ++ struct super_block *sb; ++ int nbr; ++ ++ dinfo = au_cache_alloc_dinfo(); ++ if (unlikely(!dinfo)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ nbr = au_sbend(sb) + 1; ++ if (nbr <= 0) ++ nbr = 1; ++ dinfo->di_hdentry = kcalloc(nbr, sizeof(*dinfo->di_hdentry), GFP_NOFS); ++ if (unlikely(!dinfo->di_hdentry)) ++ goto out_dinfo; ++ ++ atomic_set(&dinfo->di_generation, au_sigen(sb)); ++ /* smp_mb(); */ /* atomic_set */ ++ init_rwsem(&dinfo->di_rwsem); ++ down_write_nested(&dinfo->di_rwsem, AuLsc_DI_CHILD); ++ dinfo->di_bstart = -1; ++ dinfo->di_bend = -1; ++ dinfo->di_bwh = -1; ++ dinfo->di_bdiropq = -1; ++ ++ dentry->d_fsdata = dinfo; ++ dentry->d_op = &aufs_dop; ++ return 0; /* success */ ++ ++ out_dinfo: ++ au_cache_free_dinfo(dinfo); ++ out: ++ return -ENOMEM; ++} ++ ++int au_di_realloc(struct au_dinfo *dinfo, int nbr) ++{ ++ int err, sz; ++ struct au_hdentry *hdp; ++ ++ err = -ENOMEM; ++ sz = sizeof(*hdp) * (dinfo->di_bend + 1); ++ if (!sz) ++ sz = sizeof(*hdp); ++ hdp = au_kzrealloc(dinfo->di_hdentry, sz, sizeof(*hdp) * nbr, GFP_NOFS); ++ if (hdp) { ++ dinfo->di_hdentry = hdp; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void do_ii_write_lock(struct inode *inode, unsigned int lsc) ++{ ++ switch (lsc) { ++ case AuLsc_DI_CHILD: ++ ii_write_lock_child(inode); ++ break; ++ case AuLsc_DI_CHILD2: ++ ii_write_lock_child2(inode); ++ break; ++ case AuLsc_DI_CHILD3: ++ ii_write_lock_child3(inode); ++ break; ++ case AuLsc_DI_PARENT: ++ ii_write_lock_parent(inode); ++ break; ++ case AuLsc_DI_PARENT2: ++ ii_write_lock_parent2(inode); ++ break; ++ case AuLsc_DI_PARENT3: ++ ii_write_lock_parent3(inode); ++ break; ++ default: ++ BUG(); ++ } ++} ++ ++static void do_ii_read_lock(struct inode *inode, unsigned int lsc) ++{ ++ switch (lsc) { ++ case AuLsc_DI_CHILD: ++ ii_read_lock_child(inode); ++ break; ++ case AuLsc_DI_CHILD2: ++ ii_read_lock_child2(inode); ++ break; ++ case AuLsc_DI_CHILD3: ++ ii_read_lock_child3(inode); ++ break; ++ case AuLsc_DI_PARENT: ++ ii_read_lock_parent(inode); ++ break; ++ case AuLsc_DI_PARENT2: ++ ii_read_lock_parent2(inode); ++ break; ++ case AuLsc_DI_PARENT3: ++ ii_read_lock_parent3(inode); ++ break; ++ default: ++ BUG(); ++ } ++} ++ ++void di_read_lock(struct dentry *d, int flags, unsigned int lsc) ++{ ++ down_read_nested(&au_di(d)->di_rwsem, lsc); ++ if (d->d_inode) { ++ if (au_ftest_lock(flags, IW)) ++ do_ii_write_lock(d->d_inode, lsc); ++ else if (au_ftest_lock(flags, IR)) ++ do_ii_read_lock(d->d_inode, lsc); ++ } ++} ++ ++void di_read_unlock(struct dentry *d, int flags) ++{ ++ if (d->d_inode) { ++ if (au_ftest_lock(flags, IW)) ++ ii_write_unlock(d->d_inode); ++ else if (au_ftest_lock(flags, IR)) ++ ii_read_unlock(d->d_inode); ++ } ++ up_read(&au_di(d)->di_rwsem); ++} ++ ++void di_downgrade_lock(struct dentry *d, int flags) ++{ ++ downgrade_write(&au_di(d)->di_rwsem); ++ if (d->d_inode && au_ftest_lock(flags, IR)) ++ ii_downgrade_lock(d->d_inode); ++} ++ ++void di_write_lock(struct dentry *d, unsigned int lsc) ++{ ++ down_write_nested(&au_di(d)->di_rwsem, lsc); ++ if (d->d_inode) ++ do_ii_write_lock(d->d_inode, lsc); ++} ++ ++void di_write_unlock(struct dentry *d) ++{ ++ if (d->d_inode) ++ ii_write_unlock(d->d_inode); ++ up_write(&au_di(d)->di_rwsem); ++} ++ ++void di_write_lock2_child(struct dentry *d1, struct dentry *d2, int isdir) ++{ ++ AuDebugOn(d1 == d2 ++ || d1->d_inode == d2->d_inode ++ || d1->d_sb != d2->d_sb); ++ ++ if (isdir && au_test_subdir(d1, d2)) { ++ di_write_lock_child(d1); ++ di_write_lock_child2(d2); ++ } else { ++ /* there should be no races */ ++ di_write_lock_child(d2); ++ di_write_lock_child2(d1); ++ } ++} ++ ++void di_write_lock2_parent(struct dentry *d1, struct dentry *d2, int isdir) ++{ ++ AuDebugOn(d1 == d2 ++ || d1->d_inode == d2->d_inode ++ || d1->d_sb != d2->d_sb); ++ ++ if (isdir && au_test_subdir(d1, d2)) { ++ di_write_lock_parent(d1); ++ di_write_lock_parent2(d2); ++ } else { ++ /* there should be no races */ ++ di_write_lock_parent(d2); ++ di_write_lock_parent2(d1); ++ } ++} ++ ++void di_write_unlock2(struct dentry *d1, struct dentry *d2) ++{ ++ di_write_unlock(d1); ++ if (d1->d_inode == d2->d_inode) ++ up_write(&au_di(d2)->di_rwsem); ++ else ++ di_write_unlock(d2); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry *au_h_dptr(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ struct dentry *d; ++ ++ if (au_dbstart(dentry) < 0 || bindex < au_dbstart(dentry)) ++ return NULL; ++ AuDebugOn(bindex < 0); ++ d = au_di(dentry)->di_hdentry[0 + bindex].hd_dentry; ++ AuDebugOn(d && (atomic_read(&d->d_count) <= 0)); ++ return d; ++} ++ ++aufs_bindex_t au_dbtail(struct dentry *dentry) ++{ ++ aufs_bindex_t bend, bwh; ++ ++ bend = au_dbend(dentry); ++ if (0 <= bend) { ++ bwh = au_dbwh(dentry); ++ if (!bwh) ++ return bwh; ++ if (0 < bwh && bwh < bend) ++ return bwh - 1; ++ } ++ return bend; ++} ++ ++aufs_bindex_t au_dbtaildir(struct dentry *dentry) ++{ ++ aufs_bindex_t bend, bopq; ++ ++ bend = au_dbtail(dentry); ++ if (0 <= bend) { ++ bopq = au_dbdiropq(dentry); ++ if (0 <= bopq && bopq < bend) ++ bend = bopq; ++ } ++ return bend; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_set_h_dptr(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_dentry) ++{ ++ struct au_hdentry *hd = au_di(dentry)->di_hdentry + bindex; ++ ++ if (hd->hd_dentry) ++ au_hdput(hd); ++ hd->hd_dentry = h_dentry; ++} ++ ++void au_update_digen(struct dentry *dentry) ++{ ++ atomic_set(&au_di(dentry)->di_generation, au_sigen(dentry->d_sb)); ++ /* smp_mb(); */ /* atomic_set */ ++} ++ ++void au_update_dbrange(struct dentry *dentry, int do_put_zero) ++{ ++ struct au_dinfo *dinfo; ++ struct dentry *h_d; ++ ++ dinfo = au_di(dentry); ++ if (!dinfo || dinfo->di_bstart < 0) ++ return; ++ ++ if (do_put_zero) { ++ aufs_bindex_t bindex, bend; ++ ++ bend = dinfo->di_bend; ++ for (bindex = dinfo->di_bstart; bindex <= bend; bindex++) { ++ h_d = dinfo->di_hdentry[0 + bindex].hd_dentry; ++ if (h_d && !h_d->d_inode) ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++ } ++ ++ dinfo->di_bstart = -1; ++ while (++dinfo->di_bstart <= dinfo->di_bend) ++ if (dinfo->di_hdentry[0 + dinfo->di_bstart].hd_dentry) ++ break; ++ if (dinfo->di_bstart > dinfo->di_bend) { ++ dinfo->di_bstart = -1; ++ dinfo->di_bend = -1; ++ return; ++ } ++ ++ dinfo->di_bend++; ++ while (0 <= --dinfo->di_bend) ++ if (dinfo->di_hdentry[0 + dinfo->di_bend].hd_dentry) ++ break; ++ AuDebugOn(dinfo->di_bstart > dinfo->di_bend || dinfo->di_bend < 0); ++} ++ ++void au_update_dbstart(struct dentry *dentry) ++{ ++ aufs_bindex_t bindex, bend; ++ struct dentry *h_dentry; ++ ++ bend = au_dbend(dentry); ++ for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ if (h_dentry->d_inode) { ++ au_set_dbstart(dentry, bindex); ++ return; ++ } ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++} ++ ++void au_update_dbend(struct dentry *dentry) ++{ ++ aufs_bindex_t bindex, bstart; ++ struct dentry *h_dentry; ++ ++ bstart = au_dbstart(dentry); ++ for (bindex = au_dbend(dentry); bindex <= bstart; bindex--) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ if (h_dentry->d_inode) { ++ au_set_dbend(dentry, bindex); ++ return; ++ } ++ au_set_h_dptr(dentry, bindex, NULL); ++ } ++} ++ ++int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry) ++{ ++ aufs_bindex_t bindex, bend; ++ ++ bend = au_dbend(dentry); ++ for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) ++ if (au_h_dptr(dentry, bindex) == h_dentry) ++ return bindex; ++ return -1; ++} +diff -Naur a/fs/aufs/dir.c b/fs/aufs/dir.c +--- a/fs/aufs/dir.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dir.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,532 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * directory operations ++ */ ++ ++#include <linux/file.h> ++#include <linux/fs_stack.h> ++#include "aufs.h" ++ ++void au_add_nlink(struct inode *dir, struct inode *h_dir) ++{ ++ AuDebugOn(!S_ISDIR(dir->i_mode) || !S_ISDIR(h_dir->i_mode)); ++ ++ dir->i_nlink += h_dir->i_nlink - 2; ++ if (h_dir->i_nlink < 2) ++ dir->i_nlink += 2; ++} ++ ++void au_sub_nlink(struct inode *dir, struct inode *h_dir) ++{ ++ AuDebugOn(!S_ISDIR(dir->i_mode) || !S_ISDIR(h_dir->i_mode)); ++ ++ dir->i_nlink -= h_dir->i_nlink - 2; ++ if (h_dir->i_nlink < 2) ++ dir->i_nlink -= 2; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int reopen_dir(struct file *file) ++{ ++ int err; ++ unsigned int flags; ++ aufs_bindex_t bindex, btail, bstart; ++ struct dentry *dentry, *h_dentry; ++ struct file *h_file; ++ ++ /* open all lower dirs */ ++ dentry = file->f_dentry; ++ bstart = au_dbstart(dentry); ++ for (bindex = au_fbstart(file); bindex < bstart; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbstart(file, bstart); ++ ++ btail = au_dbtaildir(dentry); ++ for (bindex = au_fbend(file); btail < bindex; bindex--) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbend(file, btail); ++ ++ flags = file->f_flags; ++ for (bindex = bstart; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ h_file = au_h_fptr(file, bindex); ++ if (h_file) ++ continue; ++ ++ h_file = au_h_open(dentry, bindex, flags, file); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; /* close all? */ ++ au_set_h_fptr(file, bindex, h_file); ++ } ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ err = 0; ++ ++ out: ++ return err; ++} ++ ++static int do_open_dir(struct file *file, int flags) ++{ ++ int err; ++ aufs_bindex_t bindex, btail; ++ struct dentry *dentry, *h_dentry; ++ struct file *h_file; ++ ++ err = 0; ++ dentry = file->f_dentry; ++ au_set_fvdir_cache(file, NULL); ++ au_fi(file)->fi_maintain_plink = 0; ++ file->f_version = dentry->d_inode->i_version; ++ bindex = au_dbstart(dentry); ++ au_set_fbstart(file, bindex); ++ btail = au_dbtaildir(dentry); ++ au_set_fbend(file, btail); ++ for (; !err && bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!h_dentry) ++ continue; ++ ++ h_file = au_h_open(dentry, bindex, flags, file); ++ if (IS_ERR(h_file)) { ++ err = PTR_ERR(h_file); ++ break; ++ } ++ au_set_h_fptr(file, bindex, h_file); ++ } ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ if (!err) ++ return 0; /* success */ ++ ++ /* close all */ ++ for (bindex = au_fbstart(file); bindex <= btail; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbstart(file, -1); ++ au_set_fbend(file, -1); ++ return err; ++} ++ ++static int aufs_open_dir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ return au_do_open(file, do_open_dir); ++} ++ ++static int aufs_release_dir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ struct au_vdir *vdir_cache; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ sb = file->f_dentry->d_sb; ++ si_noflush_read_lock(sb); ++ fi_write_lock(file); ++ vdir_cache = au_fvdir_cache(file); ++ if (vdir_cache) ++ au_vdir_free(vdir_cache); ++ if (au_fi(file)->fi_maintain_plink) { ++ sbinfo = au_sbi(sb); ++ au_fclr_si(sbinfo, MAINTAIN_PLINK); ++ wake_up_all(&sbinfo->si_plink_wq); ++ } ++ fi_write_unlock(file); ++ au_finfo_fin(file); ++ si_read_unlock(sb); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_do_fsync_dir_no_file(struct dentry *dentry, int datasync) ++{ ++ int err; ++ aufs_bindex_t bend, bindex; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ inode = dentry->d_inode; ++ IMustLock(inode); ++ bend = au_dbend(dentry); ++ for (bindex = au_dbstart(dentry); !err && bindex <= bend; bindex++) { ++ struct path h_path; ++ struct inode *h_inode; ++ ++ if (au_test_ro(sb, bindex, inode)) ++ continue; ++ h_path.dentry = au_h_dptr(dentry, bindex); ++ if (!h_path.dentry) ++ continue; ++ h_inode = h_path.dentry->d_inode; ++ if (!h_inode) ++ continue; ++ ++ /* no mnt_want_write() */ ++ /* cf. fs/nsfd/vfs.c and fs/nfsd/nfs4recover.c */ ++ /* todo: inotiry fired? */ ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ mutex_lock(&h_inode->i_mutex); ++ err = filemap_fdatawrite(h_inode->i_mapping); ++ AuDebugOn(!h_inode->i_fop); ++ if (!err && h_inode->i_fop->fsync) ++ err = h_inode->i_fop->fsync(NULL, h_path.dentry, ++ datasync); ++ if (!err) ++ err = filemap_fdatawrite(h_inode->i_mapping); ++ if (!err) ++ vfsub_update_h_iattr(&h_path, /*did*/NULL); /*ignore*/ ++ mutex_unlock(&h_inode->i_mutex); ++ } ++ ++ return err; ++} ++ ++static int au_do_fsync_dir(struct file *file, int datasync) ++{ ++ int err; ++ aufs_bindex_t bend, bindex; ++ struct file *h_file; ++ struct super_block *sb; ++ struct inode *inode; ++ struct mutex *h_mtx; ++ ++ err = au_reval_and_lock_fdi(file, reopen_dir, /*wlock*/1); ++ if (unlikely(err)) ++ goto out; ++ ++ sb = file->f_dentry->d_sb; ++ inode = file->f_dentry->d_inode; ++ bend = au_fbend(file); ++ for (bindex = au_fbstart(file); !err && bindex <= bend; bindex++) { ++ h_file = au_h_fptr(file, bindex); ++ if (!h_file || au_test_ro(sb, bindex, inode)) ++ continue; ++ ++ err = vfs_fsync(h_file, h_file->f_dentry, datasync); ++ if (!err) { ++ h_mtx = &h_file->f_dentry->d_inode->i_mutex; ++ mutex_lock(h_mtx); ++ vfsub_update_h_iattr(&h_file->f_path, /*did*/NULL); ++ /*ignore*/ ++ mutex_unlock(h_mtx); ++ } ++ } ++ ++ out: ++ return err; ++} ++ ++/* ++ * @file may be NULL ++ */ ++static int aufs_fsync_dir(struct file *file, struct dentry *dentry, ++ int datasync) ++{ ++ int err; ++ struct super_block *sb; ++ ++ IMustLock(dentry->d_inode); ++ ++ err = 0; ++ sb = dentry->d_sb; ++ si_noflush_read_lock(sb); ++ if (file) ++ err = au_do_fsync_dir(file, datasync); ++ else { ++ di_write_lock_child(dentry); ++ err = au_do_fsync_dir_no_file(dentry, datasync); ++ } ++ au_cpup_attr_timesizes(dentry->d_inode); ++ di_write_unlock(dentry); ++ if (file) ++ fi_write_unlock(file); ++ ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_readdir(struct file *file, void *dirent, filldir_t filldir) ++{ ++ int err; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ inode = dentry->d_inode; ++ IMustLock(inode); ++ ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, reopen_dir, /*wlock*/1); ++ if (unlikely(err)) ++ goto out; ++ err = au_vdir_init(file); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ if (!au_test_nfsd(current)) { ++ err = au_vdir_fill_de(file, dirent, filldir); ++ fsstack_copy_attr_atime(inode, ++ au_h_iptr(inode, au_ibstart(inode))); ++ } else { ++ /* ++ * nfsd filldir may call lookup_one_len(), vfs_getattr(), ++ * encode_fh() and others. ++ */ ++ struct inode *h_inode = au_h_iptr(inode, au_ibstart(inode)); ++ ++ di_read_unlock(dentry, AuLock_IR); ++ si_read_unlock(sb); ++ lockdep_off(); ++ err = au_vdir_fill_de(file, dirent, filldir); ++ lockdep_on(); ++ fsstack_copy_attr_atime(inode, h_inode); ++ fi_write_unlock(file); ++ ++ AuTraceErr(err); ++ return err; ++ } ++ ++ out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ fi_write_unlock(file); ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AuTestEmpty_WHONLY 1 ++#define AuTestEmpty_CALLED (1 << 1) ++#define AuTestEmpty_SHWH (1 << 2) ++#define au_ftest_testempty(flags, name) ((flags) & AuTestEmpty_##name) ++#define au_fset_testempty(flags, name) { (flags) |= AuTestEmpty_##name; } ++#define au_fclr_testempty(flags, name) { (flags) &= ~AuTestEmpty_##name; } ++ ++#ifndef CONFIG_AUFS_SHWH ++#undef AuTestEmpty_SHWH ++#define AuTestEmpty_SHWH 0 ++#endif ++ ++struct test_empty_arg { ++ struct au_nhash whlist; ++ unsigned int flags; ++ int err; ++ aufs_bindex_t bindex; ++}; ++ ++static int test_empty_cb(void *__arg, const char *__name, int namelen, ++ loff_t offset __maybe_unused, u64 ino, ++ unsigned int d_type) ++{ ++ struct test_empty_arg *arg = __arg; ++ char *name = (void *)__name; ++ ++ arg->err = 0; ++ au_fset_testempty(arg->flags, CALLED); ++ /* smp_mb(); */ ++ if (name[0] == '.' ++ && (namelen == 1 || (name[1] == '.' && namelen == 2))) ++ goto out; /* success */ ++ ++ if (namelen <= AUFS_WH_PFX_LEN ++ || memcmp(name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ if (au_ftest_testempty(arg->flags, WHONLY) ++ && !au_nhash_test_known_wh(&arg->whlist, name, namelen)) ++ arg->err = -ENOTEMPTY; ++ goto out; ++ } ++ ++ name += AUFS_WH_PFX_LEN; ++ namelen -= AUFS_WH_PFX_LEN; ++ if (!au_nhash_test_known_wh(&arg->whlist, name, namelen)) ++ arg->err = au_nhash_append_wh ++ (&arg->whlist, name, namelen, ino, d_type, arg->bindex, ++ au_ftest_testempty(arg->flags, SHWH)); ++ ++ out: ++ /* smp_mb(); */ ++ AuTraceErr(arg->err); ++ return arg->err; ++} ++ ++static int do_test_empty(struct dentry *dentry, struct test_empty_arg *arg) ++{ ++ int err; ++ struct file *h_file; ++ ++ h_file = au_h_open(dentry, arg->bindex, ++ O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_LARGEFILE, ++ /*file*/NULL); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; ++ ++ err = 0; ++ if (!au_opt_test(au_mntflags(dentry->d_sb), UDBA_NONE) ++ && !h_file->f_dentry->d_inode->i_nlink) ++ goto out_put; ++ ++ do { ++ arg->err = 0; ++ au_fclr_testempty(arg->flags, CALLED); ++ /* smp_mb(); */ ++ err = vfsub_readdir(h_file, test_empty_cb, arg); ++ if (err >= 0) ++ err = arg->err; ++ } while (!err && au_ftest_testempty(arg->flags, CALLED)); ++ ++ out_put: ++ fput(h_file); ++ au_sbr_put(dentry->d_sb, arg->bindex); ++ out: ++ return err; ++} ++ ++struct do_test_empty_args { ++ int *errp; ++ struct dentry *dentry; ++ struct test_empty_arg *arg; ++}; ++ ++static void call_do_test_empty(void *args) ++{ ++ struct do_test_empty_args *a = args; ++ *a->errp = do_test_empty(a->dentry, a->arg); ++} ++ ++static int sio_test_empty(struct dentry *dentry, struct test_empty_arg *arg) ++{ ++ int err, wkq_err; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ h_dentry = au_h_dptr(dentry, arg->bindex); ++ h_inode = h_dentry->d_inode; ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ err = au_test_h_perm_sio(h_inode, MAY_EXEC | MAY_READ); ++ mutex_unlock(&h_inode->i_mutex); ++ if (!err) ++ err = do_test_empty(dentry, arg); ++ else { ++ struct do_test_empty_args args = { ++ .errp = &err, ++ .dentry = dentry, ++ .arg = arg ++ }; ++ unsigned int flags = arg->flags; ++ ++ wkq_err = au_wkq_wait(call_do_test_empty, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ arg->flags = flags; ++ } ++ ++ return err; ++} ++ ++int au_test_empty_lower(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bindex, bstart, btail; ++ struct test_empty_arg arg; ++ ++ err = au_nhash_alloc(&arg.whlist, au_sbi(dentry->d_sb)->si_rdhash, ++ GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ ++ bstart = au_dbstart(dentry); ++ arg.flags = 0; ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH)) ++ au_fset_testempty(arg.flags, SHWH); ++ arg.bindex = bstart; ++ err = do_test_empty(dentry, &arg); ++ if (unlikely(err)) ++ goto out_whlist; ++ ++ au_fset_testempty(arg.flags, WHONLY); ++ btail = au_dbtaildir(dentry); ++ for (bindex = bstart + 1; !err && bindex <= btail; bindex++) { ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && h_dentry->d_inode) { ++ arg.bindex = bindex; ++ err = do_test_empty(dentry, &arg); ++ } ++ } ++ ++ out_whlist: ++ au_nhash_wh_free(&arg.whlist); ++ out: ++ return err; ++} ++ ++int au_test_empty(struct dentry *dentry, struct au_nhash *whlist) ++{ ++ int err; ++ struct test_empty_arg arg; ++ aufs_bindex_t bindex, btail; ++ ++ err = 0; ++ arg.whlist = *whlist; ++ arg.flags = AuTestEmpty_WHONLY; ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH)) ++ au_fset_testempty(arg.flags, SHWH); ++ btail = au_dbtaildir(dentry); ++ for (bindex = au_dbstart(dentry); !err && bindex <= btail; bindex++) { ++ struct dentry *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry && h_dentry->d_inode) { ++ arg.bindex = bindex; ++ err = sio_test_empty(dentry, &arg); ++ } ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++const struct file_operations aufs_dir_fop = { ++ .read = generic_read_dir, ++ .readdir = aufs_readdir, ++ .unlocked_ioctl = aufs_ioctl_dir, ++ .open = aufs_open_dir, ++ .release = aufs_release_dir, ++ .flush = aufs_flush, ++ .fsync = aufs_fsync_dir ++}; +diff -Naur a/fs/aufs/dir.h b/fs/aufs/dir.h +--- a/fs/aufs/dir.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/dir.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,114 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * directory operations ++ */ ++ ++#ifndef __AUFS_DIR_H__ ++#define __AUFS_DIR_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/aufs_type.h> ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* need to be faster and smaller */ ++ ++struct au_nhash { ++ unsigned int nh_num; ++ struct hlist_head *nh_head; ++}; ++ ++struct au_vdir_destr { ++ unsigned char len; ++ unsigned char name[0]; ++} __packed; ++ ++struct au_vdir_dehstr { ++ struct hlist_node hash; ++ struct au_vdir_destr *str; ++}; ++ ++struct au_vdir_de { ++ ino_t de_ino; ++ unsigned char de_type; ++ /* caution: packed */ ++ struct au_vdir_destr de_str; ++} __packed; ++ ++struct au_vdir_wh { ++ struct hlist_node wh_hash; ++#ifdef CONFIG_AUFS_SHWH ++ ino_t wh_ino; ++ aufs_bindex_t wh_bindex; ++ unsigned char wh_type; ++#else ++ aufs_bindex_t wh_bindex; ++#endif ++ /* caution: packed */ ++ struct au_vdir_destr wh_str; ++} __packed; ++ ++union au_vdir_deblk_p { ++ unsigned char *deblk; ++ struct au_vdir_de *de; ++}; ++ ++struct au_vdir { ++ unsigned char **vd_deblk; ++ unsigned long vd_nblk; ++ struct { ++ unsigned long ul; ++ union au_vdir_deblk_p p; ++ } vd_last; ++ ++ unsigned long vd_version; ++ unsigned int vd_deblk_sz; ++ unsigned long vd_jiffy; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dir.c */ ++extern const struct file_operations aufs_dir_fop; ++void au_add_nlink(struct inode *dir, struct inode *h_dir); ++void au_sub_nlink(struct inode *dir, struct inode *h_dir); ++int au_test_empty_lower(struct dentry *dentry); ++int au_test_empty(struct dentry *dentry, struct au_nhash *whlist); ++ ++/* vdir.c */ ++int au_nhash_alloc(struct au_nhash *nhash, unsigned int num_hash, gfp_t gfp); ++void au_nhash_wh_free(struct au_nhash *whlist); ++int au_nhash_test_longer_wh(struct au_nhash *whlist, aufs_bindex_t btgt, ++ int limit); ++int au_nhash_test_known_wh(struct au_nhash *whlist, char *name, int nlen); ++int au_nhash_append_wh(struct au_nhash *whlist, char *name, int nlen, ino_t ino, ++ unsigned int d_type, aufs_bindex_t bindex, ++ unsigned char shwh); ++void au_vdir_free(struct au_vdir *vdir); ++int au_vdir_init(struct file *file); ++int au_vdir_fill_de(struct file *file, void *dirent, filldir_t filldir); ++ ++/* ioctl.c */ ++long aufs_ioctl_dir(struct file *file, unsigned int cmd, unsigned long arg); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_DIR_H__ */ +diff -Naur a/fs/aufs/export.c b/fs/aufs/export.c +--- a/fs/aufs/export.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/export.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,736 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * export via nfs ++ */ ++ ++#include <linux/exportfs.h> ++#include <linux/file.h> ++#include <linux/mnt_namespace.h> ++#include <linux/namei.h> ++#include <linux/random.h> ++#include "aufs.h" ++ ++union conv { ++#ifdef CONFIG_AUFS_INO_T_64 ++ __u32 a[2]; ++#else ++ __u32 a[1]; ++#endif ++ ino_t ino; ++}; ++ ++static ino_t decode_ino(__u32 *a) ++{ ++ union conv u; ++ ++ BUILD_BUG_ON(sizeof(u.ino) != sizeof(u.a)); ++ u.a[0] = a[0]; ++#ifdef CONFIG_AUFS_INO_T_64 ++ u.a[1] = a[1]; ++#endif ++ return u.ino; ++} ++ ++static void encode_ino(__u32 *a, ino_t ino) ++{ ++ union conv u; ++ ++ u.ino = ino; ++ a[0] = u.a[0]; ++#ifdef CONFIG_AUFS_INO_T_64 ++ a[1] = u.a[1]; ++#endif ++} ++ ++/* NFS file handle */ ++enum { ++ Fh_br_id, ++ Fh_sigen, ++#ifdef CONFIG_AUFS_INO_T_64 ++ /* support 64bit inode number */ ++ Fh_ino1, ++ Fh_ino2, ++ Fh_dir_ino1, ++ Fh_dir_ino2, ++#else ++ Fh_ino1, ++ Fh_dir_ino1, ++#endif ++ Fh_igen, ++ Fh_h_type, ++ Fh_tail, ++ ++ Fh_ino = Fh_ino1, ++ Fh_dir_ino = Fh_dir_ino1 ++}; ++ ++static int au_test_anon(struct dentry *dentry) ++{ ++ return !!(dentry->d_flags & DCACHE_DISCONNECTED); ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* inode generation external table */ ++ ++int au_xigen_inc(struct inode *inode) ++{ ++ int err; ++ loff_t pos; ++ ssize_t sz; ++ __u32 igen; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ sb = inode->i_sb; ++ if (unlikely(!au_opt_test(au_mntflags(sb), XINO))) ++ goto out; ++ ++ pos = inode->i_ino; ++ pos *= sizeof(igen); ++ igen = inode->i_generation + 1; ++ sbinfo = au_sbi(sb); ++ sz = xino_fwrite(sbinfo->si_xwrite, sbinfo->si_xigen, &igen, ++ sizeof(igen), &pos); ++ if (sz == sizeof(igen)) ++ goto out; /* success */ ++ ++ err = sz; ++ if (unlikely(sz >= 0)) { ++ err = -EIO; ++ AuIOErr("xigen error (%zd)\n", sz); ++ } ++ ++ out: ++ return err; ++} ++ ++int au_xigen_new(struct inode *inode) ++{ ++ int err; ++ loff_t pos; ++ ssize_t sz; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ err = 0; ++ /* todo: dirty, at mount time */ ++ if (inode->i_ino == AUFS_ROOT_INO) ++ goto out; ++ sb = inode->i_sb; ++ if (unlikely(!au_opt_test(au_mntflags(sb), XINO))) ++ goto out; ++ ++ err = -EFBIG; ++ pos = inode->i_ino; ++ if (unlikely(au_loff_max / sizeof(inode->i_generation) - 1 < pos)) { ++ AuIOErr1("too large i%lld\n", pos); ++ goto out; ++ } ++ pos *= sizeof(inode->i_generation); ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ file = sbinfo->si_xigen; ++ BUG_ON(!file); ++ ++ if (i_size_read(file->f_dentry->d_inode) ++ < pos + sizeof(inode->i_generation)) { ++ inode->i_generation = atomic_inc_return(&sbinfo->si_xigen_next); ++ sz = xino_fwrite(sbinfo->si_xwrite, file, &inode->i_generation, ++ sizeof(inode->i_generation), &pos); ++ } else ++ sz = xino_fread(sbinfo->si_xread, file, &inode->i_generation, ++ sizeof(inode->i_generation), &pos); ++ if (sz == sizeof(inode->i_generation)) ++ goto out; /* success */ ++ ++ err = sz; ++ if (unlikely(sz >= 0)) { ++ err = -EIO; ++ AuIOErr("xigen error (%zd)\n", sz); ++ } ++ ++ out: ++ return err; ++} ++ ++int au_xigen_set(struct super_block *sb, struct file *base) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ sbinfo = au_sbi(sb); ++ file = au_xino_create2(base, sbinfo->si_xigen); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ err = 0; ++ if (sbinfo->si_xigen) ++ fput(sbinfo->si_xigen); ++ sbinfo->si_xigen = file; ++ ++ out: ++ return err; ++} ++ ++void au_xigen_clr(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ if (sbinfo->si_xigen) { ++ fput(sbinfo->si_xigen); ++ sbinfo->si_xigen = NULL; ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *decode_by_ino(struct super_block *sb, ino_t ino, ++ ino_t dir_ino) ++{ ++ struct dentry *dentry, *d; ++ struct inode *inode; ++ unsigned int sigen; ++ ++ dentry = NULL; ++ inode = ilookup(sb, ino); ++ if (!inode) ++ goto out; ++ ++ dentry = ERR_PTR(-ESTALE); ++ sigen = au_sigen(sb); ++ if (unlikely(is_bad_inode(inode) ++ || IS_DEADDIR(inode) ++ || sigen != au_iigen(inode))) ++ goto out_iput; ++ ++ dentry = NULL; ++ if (!dir_ino || S_ISDIR(inode->i_mode)) ++ dentry = d_find_alias(inode); ++ else { ++ spin_lock(&dcache_lock); ++ list_for_each_entry(d, &inode->i_dentry, d_alias) ++ if (!au_test_anon(d) ++ && d->d_parent->d_inode->i_ino == dir_ino) { ++ dentry = dget_locked(d); ++ break; ++ } ++ spin_unlock(&dcache_lock); ++ } ++ if (unlikely(dentry && sigen != au_digen(dentry))) { ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ } ++ ++ out_iput: ++ iput(inode); ++ out: ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: dirty? */ ++/* if exportfs_decode_fh() passed vfsmount*, we could be happy */ ++static struct vfsmount *au_mnt_get(struct super_block *sb) ++{ ++ struct mnt_namespace *ns; ++ struct vfsmount *pos, *mnt; ++ ++ spin_lock(&vfsmount_lock); ++ /* no get/put ?? */ ++ AuDebugOn(!current->nsproxy); ++ ns = current->nsproxy->mnt_ns; ++ AuDebugOn(!ns); ++ mnt = NULL; ++ /* the order (reverse) will not be a problem */ ++ list_for_each_entry(pos, &ns->list, mnt_list) ++ if (pos->mnt_sb == sb) { ++ mnt = mntget(pos); ++ break; ++ } ++ spin_unlock(&vfsmount_lock); ++ AuDebugOn(!mnt); ++ ++ return mnt; ++} ++ ++struct au_nfsd_si_lock { ++ const unsigned int sigen; ++ const aufs_bindex_t br_id; ++ unsigned char force_lock; ++}; ++ ++static aufs_bindex_t si_nfsd_read_lock(struct super_block *sb, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ aufs_bindex_t bindex; ++ ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ /* branch id may be wrapped around */ ++ bindex = au_br_index(sb, nsi_lock->br_id); ++ if (bindex >= 0 && nsi_lock->sigen + AUFS_BRANCH_MAX > au_sigen(sb)) ++ goto out; /* success */ ++ ++ if (!nsi_lock->force_lock) ++ si_read_unlock(sb); ++ bindex = -1; ++ ++ out: ++ return bindex; ++} ++ ++struct find_name_by_ino { ++ int called, found; ++ ino_t ino; ++ char *name; ++ int namelen; ++}; ++ ++static int ++find_name_by_ino(void *arg, const char *name, int namelen, loff_t offset, ++ u64 ino, unsigned int d_type) ++{ ++ struct find_name_by_ino *a = arg; ++ ++ a->called++; ++ if (a->ino != ino) ++ return 0; ++ ++ memcpy(a->name, name, namelen); ++ a->namelen = namelen; ++ a->found = 1; ++ return 1; ++} ++ ++static struct dentry *au_lkup_by_ino(struct path *path, ino_t ino, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry, *parent; ++ struct file *file; ++ struct inode *dir; ++ struct find_name_by_ino arg; ++ int err; ++ ++ parent = path->dentry; ++ if (nsi_lock) ++ si_read_unlock(parent->d_sb); ++ path_get(path); ++ file = dentry_open(parent, path->mnt, au_dir_roflags, current_cred()); ++ dentry = (void *)file; ++ if (IS_ERR(file)) ++ goto out; ++ ++ dentry = ERR_PTR(-ENOMEM); ++ arg.name = __getname(); ++ if (unlikely(!arg.name)) ++ goto out_file; ++ arg.ino = ino; ++ arg.found = 0; ++ do { ++ arg.called = 0; ++ /* smp_mb(); */ ++ err = vfsub_readdir(file, find_name_by_ino, &arg); ++ } while (!err && !arg.found && arg.called); ++ dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_name; ++ dentry = ERR_PTR(-ENOENT); ++ if (!arg.found) ++ goto out_name; ++ ++ /* do not call au_lkup_one() */ ++ dir = parent->d_inode; ++ mutex_lock(&dir->i_mutex); ++ dentry = vfsub_lookup_one_len(arg.name, parent, arg.namelen); ++ mutex_unlock(&dir->i_mutex); ++ AuTraceErrPtr(dentry); ++ if (IS_ERR(dentry)) ++ goto out_name; ++ AuDebugOn(au_test_anon(dentry)); ++ if (unlikely(!dentry->d_inode)) { ++ dput(dentry); ++ dentry = ERR_PTR(-ENOENT); ++ } ++ ++ out_name: ++ __putname(arg.name); ++ out_file: ++ fput(file); ++ out: ++ if (unlikely(nsi_lock ++ && si_nfsd_read_lock(parent->d_sb, nsi_lock) < 0)) ++ if (!IS_ERR(dentry)) { ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ } ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++static struct dentry *decode_by_dir_ino(struct super_block *sb, ino_t ino, ++ ino_t dir_ino, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry; ++ struct path path; ++ ++ if (dir_ino != AUFS_ROOT_INO) { ++ path.dentry = decode_by_ino(sb, dir_ino, 0); ++ dentry = path.dentry; ++ if (!path.dentry || IS_ERR(path.dentry)) ++ goto out; ++ AuDebugOn(au_test_anon(path.dentry)); ++ } else ++ path.dentry = dget(sb->s_root); ++ ++ path.mnt = au_mnt_get(sb); ++ dentry = au_lkup_by_ino(&path, ino, nsi_lock); ++ path_put(&path); ++ ++ out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int h_acceptable(void *expv, struct dentry *dentry) ++{ ++ return 1; ++} ++ ++static char *au_build_path(struct dentry *h_parent, struct path *h_rootpath, ++ char *buf, int len, struct super_block *sb) ++{ ++ char *p; ++ int n; ++ struct path path; ++ ++ p = d_path(h_rootpath, buf, len); ++ if (IS_ERR(p)) ++ goto out; ++ n = strlen(p); ++ ++ path.mnt = h_rootpath->mnt; ++ path.dentry = h_parent; ++ p = d_path(&path, buf, len); ++ if (IS_ERR(p)) ++ goto out; ++ if (n != 1) ++ p += n; ++ ++ path.mnt = au_mnt_get(sb); ++ path.dentry = sb->s_root; ++ p = d_path(&path, buf, len - strlen(p)); ++ mntput(path.mnt); ++ if (IS_ERR(p)) ++ goto out; ++ if (n != 1) ++ p[strlen(p)] = '/'; ++ ++ out: ++ AuTraceErrPtr(p); ++ return p; ++} ++ ++static ++struct dentry *decode_by_path(struct super_block *sb, aufs_bindex_t bindex, ++ ino_t ino, __u32 *fh, int fh_len, ++ struct au_nfsd_si_lock *nsi_lock) ++{ ++ struct dentry *dentry, *h_parent, *root; ++ struct super_block *h_sb; ++ char *pathname, *p; ++ struct vfsmount *h_mnt; ++ struct au_branch *br; ++ int err; ++ struct path path; ++ ++ br = au_sbr(sb, bindex); ++ /* au_br_get(br); */ ++ h_mnt = br->br_mnt; ++ h_sb = h_mnt->mnt_sb; ++ /* todo: call lower fh_to_dentry()? fh_to_parent()? */ ++ h_parent = exportfs_decode_fh(h_mnt, (void *)(fh + Fh_tail), ++ fh_len - Fh_tail, fh[Fh_h_type], ++ h_acceptable, /*context*/NULL); ++ dentry = h_parent; ++ if (unlikely(!h_parent || IS_ERR(h_parent))) { ++ AuWarn1("%s decode_fh failed, %ld\n", ++ au_sbtype(h_sb), PTR_ERR(h_parent)); ++ goto out; ++ } ++ dentry = NULL; ++ if (unlikely(au_test_anon(h_parent))) { ++ AuWarn1("%s decode_fh returned a disconnected dentry\n", ++ au_sbtype(h_sb)); ++ goto out_h_parent; ++ } ++ ++ dentry = ERR_PTR(-ENOMEM); ++ pathname = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!pathname)) ++ goto out_h_parent; ++ ++ root = sb->s_root; ++ path.mnt = h_mnt; ++ di_read_lock_parent(root, !AuLock_IR); ++ path.dentry = au_h_dptr(root, bindex); ++ di_read_unlock(root, !AuLock_IR); ++ p = au_build_path(h_parent, &path, pathname, PAGE_SIZE, sb); ++ dentry = (void *)p; ++ if (IS_ERR(p)) ++ goto out_pathname; ++ ++ si_read_unlock(sb); ++ err = vfsub_kern_path(p, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path); ++ dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_relock; ++ ++ dentry = ERR_PTR(-ENOENT); ++ AuDebugOn(au_test_anon(path.dentry)); ++ if (unlikely(!path.dentry->d_inode)) ++ goto out_path; ++ ++ if (ino != path.dentry->d_inode->i_ino) ++ dentry = au_lkup_by_ino(&path, ino, /*nsi_lock*/NULL); ++ else ++ dentry = dget(path.dentry); ++ ++ out_path: ++ path_put(&path); ++ out_relock: ++ if (unlikely(si_nfsd_read_lock(sb, nsi_lock) < 0)) ++ if (!IS_ERR(dentry)) { ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ } ++ out_pathname: ++ free_page((unsigned long)pathname); ++ out_h_parent: ++ dput(h_parent); ++ out: ++ /* au_br_put(br); */ ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry * ++aufs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, ++ int fh_type) ++{ ++ struct dentry *dentry; ++ __u32 *fh = fid->raw; ++ ino_t ino, dir_ino; ++ aufs_bindex_t bindex; ++ struct au_nfsd_si_lock nsi_lock = { ++ .sigen = fh[Fh_sigen], ++ .br_id = fh[Fh_br_id], ++ .force_lock = 0 ++ }; ++ ++ AuDebugOn(fh_len < Fh_tail); ++ ++ dentry = ERR_PTR(-ESTALE); ++ /* branch id may be wrapped around */ ++ bindex = si_nfsd_read_lock(sb, &nsi_lock); ++ if (unlikely(bindex < 0)) ++ goto out; ++ nsi_lock.force_lock = 1; ++ ++ /* is this inode still cached? */ ++ ino = decode_ino(fh + Fh_ino); ++ AuDebugOn(ino == AUFS_ROOT_INO); ++ dir_ino = decode_ino(fh + Fh_dir_ino); ++ dentry = decode_by_ino(sb, ino, dir_ino); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (dentry) ++ goto accept; ++ ++ /* is the parent dir cached? */ ++ dentry = decode_by_dir_ino(sb, ino, dir_ino, &nsi_lock); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (dentry) ++ goto accept; ++ ++ /* lookup path */ ++ dentry = decode_by_path(sb, bindex, ino, fh, fh_len, &nsi_lock); ++ if (IS_ERR(dentry)) ++ goto out_unlock; ++ if (unlikely(!dentry)) ++ /* todo?: make it ESTALE */ ++ goto out_unlock; ++ ++ accept: ++ if (dentry->d_inode->i_generation == fh[Fh_igen]) ++ goto out_unlock; /* success */ ++ ++ dput(dentry); ++ dentry = ERR_PTR(-ESTALE); ++ out_unlock: ++ si_read_unlock(sb); ++ out: ++ AuTraceErrPtr(dentry); ++ return dentry; ++} ++ ++#if 0 /* reserved for future use */ ++/* support subtreecheck option */ ++static struct dentry *aufs_fh_to_parent(struct super_block *sb, struct fid *fid, ++ int fh_len, int fh_type) ++{ ++ struct dentry *parent; ++ __u32 *fh = fid->raw; ++ ino_t dir_ino; ++ ++ dir_ino = decode_ino(fh + Fh_dir_ino); ++ parent = decode_by_ino(sb, dir_ino, 0); ++ if (IS_ERR(parent)) ++ goto out; ++ if (!parent) ++ parent = decode_by_path(sb, au_br_index(sb, fh[Fh_br_id]), ++ dir_ino, fh, fh_len); ++ ++ out: ++ AuTraceErrPtr(parent); ++ return parent; ++} ++#endif ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_encode_fh(struct dentry *dentry, __u32 *fh, int *max_len, ++ int connectable) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ struct super_block *sb, *h_sb; ++ struct inode *inode; ++ struct dentry *parent, *h_parent; ++ struct au_branch *br; ++ ++ AuDebugOn(au_test_anon(dentry)); ++ ++ parent = NULL; ++ err = -ENOSPC; ++ if (unlikely(*max_len <= Fh_tail)) { ++ AuWarn1("NFSv2 client (max_len %d)?\n", *max_len); ++ goto out; ++ } ++ ++ err = FILEID_ROOT; ++ if (IS_ROOT(dentry)) { ++ AuDebugOn(dentry->d_inode->i_ino != AUFS_ROOT_INO); ++ goto out; ++ } ++ ++ err = -EIO; ++ h_parent = NULL; ++ sb = dentry->d_sb; ++ aufs_read_lock(dentry, AuLock_FLUSH | AuLock_IR); ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, !AuLock_IR); ++ inode = dentry->d_inode; ++ AuDebugOn(!inode); ++#ifdef CONFIG_AUFS_DEBUG ++ if (unlikely(!au_opt_test(au_mntflags(sb), XINO))) ++ AuWarn1("NFS-exporting requires xino\n"); ++#endif ++ ++ bend = au_dbtaildir(parent); ++ for (bindex = au_dbstart(parent); bindex <= bend; bindex++) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (h_parent) { ++ dget(h_parent); ++ break; ++ } ++ } ++ if (unlikely(!h_parent)) ++ goto out_unlock; ++ ++ err = -EPERM; ++ br = au_sbr(sb, bindex); ++ h_sb = br->br_mnt->mnt_sb; ++ if (unlikely(!h_sb->s_export_op)) { ++ AuErr1("%s branch is not exportable\n", au_sbtype(h_sb)); ++ goto out_dput; ++ } ++ ++ fh[Fh_br_id] = br->br_id; ++ fh[Fh_sigen] = au_sigen(sb); ++ encode_ino(fh + Fh_ino, inode->i_ino); ++ encode_ino(fh + Fh_dir_ino, parent->d_inode->i_ino); ++ fh[Fh_igen] = inode->i_generation; ++ ++ *max_len -= Fh_tail; ++ fh[Fh_h_type] = exportfs_encode_fh(h_parent, (void *)(fh + Fh_tail), ++ max_len, ++ /*connectable or subtreecheck*/0); ++ err = fh[Fh_h_type]; ++ *max_len += Fh_tail; ++ /* todo: macros? */ ++ if (err != 255) ++ err = 99; ++ else ++ AuWarn1("%s encode_fh failed\n", au_sbtype(h_sb)); ++ ++ out_dput: ++ dput(h_parent); ++ out_unlock: ++ di_read_unlock(parent, !AuLock_IR); ++ dput(parent); ++ aufs_read_unlock(dentry, AuLock_IR); ++ out: ++ if (unlikely(err < 0)) ++ err = 255; ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct export_operations aufs_export_op = { ++ .fh_to_dentry = aufs_fh_to_dentry, ++ /* .fh_to_parent = aufs_fh_to_parent, */ ++ .encode_fh = aufs_encode_fh ++}; ++ ++void au_export_init(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ __u32 u; ++ ++ sb->s_export_op = &aufs_export_op; ++ sbinfo = au_sbi(sb); ++ sbinfo->si_xigen = NULL; ++ get_random_bytes(&u, sizeof(u)); ++ BUILD_BUG_ON(sizeof(u) != sizeof(int)); ++ atomic_set(&sbinfo->si_xigen_next, u); ++} +diff -Naur a/fs/aufs/file.c b/fs/aufs/file.c +--- a/fs/aufs/file.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/file.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,568 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * handling file/dir, and address_space operation ++ */ ++ ++#include <linux/file.h> ++#include <linux/fsnotify.h> ++#include <linux/namei.h> ++#include <linux/pagemap.h> ++#include "aufs.h" ++ ++/* ++ * a dirty trick for handling deny_write_access(). ++ * because FMODE_EXEC flag is not passed to f_op->open(), ++ * set it to file->private_data temporary. ++ */ ++void au_store_oflag(struct nameidata *nd, struct inode *inode) ++{ ++ if (nd ++ /* && !(nd->flags & LOOKUP_CONTINUE) */ ++ && (nd->flags & LOOKUP_OPEN) ++ && (nd->intent.open.flags & vfsub_fmode_to_uint(FMODE_EXEC)) ++ && inode ++ && S_ISREG(inode->i_mode)) { ++ /* suppress a warning in lp64 */ ++ unsigned long flags = nd->intent.open.flags; ++ nd->intent.open.file->private_data = (void *)flags; ++ /* smp_mb(); */ ++ } ++} ++ ++/* drop flags for writing */ ++unsigned int au_file_roflags(unsigned int flags) ++{ ++ flags &= ~(O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC); ++ flags |= O_RDONLY | O_NOATIME; ++ return flags; ++} ++ ++/* common functions to regular file and dir */ ++struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags, ++ struct file *file) ++{ ++ struct file *h_file; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct super_block *sb; ++ struct au_branch *br; ++ int err; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ h_inode = h_dentry->d_inode; ++ /* a race condition can happen between open and unlink/rmdir */ ++ h_file = ERR_PTR(-ENOENT); ++ if (unlikely((!d_unhashed(dentry) && d_unhashed(h_dentry)) ++ || !h_inode)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, bindex); ++ h_file = ERR_PTR(-EACCES); ++ if (file && (file->f_mode & FMODE_EXEC) ++ && (br->br_mnt->mnt_flags & MNT_NOEXEC)) ++ goto out; ++ ++ /* drop flags for writing */ ++ if (au_test_ro(sb, bindex, dentry->d_inode)) ++ flags = au_file_roflags(flags); ++ flags &= ~O_CREAT; ++ atomic_inc(&br->br_count); ++ h_file = dentry_open(dget(h_dentry), mntget(br->br_mnt), flags, ++ current_cred()); ++ if (IS_ERR(h_file)) ++ goto out_br; ++ ++ if (file && (file->f_mode & FMODE_EXEC)) { ++ h_file->f_mode |= FMODE_EXEC; ++ err = deny_write_access(h_file); ++ if (unlikely(err)) { ++ fput(h_file); ++ h_file = ERR_PTR(err); ++ goto out_br; ++ } ++ } ++ fsnotify_open(h_dentry); ++ goto out; /* success */ ++ ++ out_br: ++ atomic_dec(&br->br_count); ++ out: ++ return h_file; ++} ++ ++int au_do_open(struct file *file, int (*open)(struct file *file, int flags)) ++{ ++ int err; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_finfo_init(file); ++ if (unlikely(err)) ++ goto out; ++ ++ di_read_lock_child(dentry, AuLock_IR); ++ err = open(file, file->f_flags); ++ di_read_unlock(dentry, AuLock_IR); ++ ++ fi_write_unlock(file); ++ if (unlikely(err)) ++ au_finfo_fin(file); ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++int au_reopen_nondir(struct file *file) ++{ ++ int err; ++ aufs_bindex_t bstart, bindex, bend; ++ struct dentry *dentry; ++ struct file *h_file, *h_file_tmp; ++ ++ dentry = file->f_dentry; ++ bstart = au_dbstart(dentry); ++ h_file_tmp = NULL; ++ if (au_fbstart(file) == bstart) { ++ h_file = au_h_fptr(file, bstart); ++ if (file->f_mode == h_file->f_mode) ++ return 0; /* success */ ++ h_file_tmp = h_file; ++ get_file(h_file_tmp); ++ au_set_h_fptr(file, bstart, NULL); ++ } ++ AuDebugOn(au_fbstart(file) < bstart ++ || au_fi(file)->fi_hfile[0 + bstart].hf_file); ++ ++ h_file = au_h_open(dentry, bstart, file->f_flags & ~O_TRUNC, file); ++ err = PTR_ERR(h_file); ++ if (IS_ERR(h_file)) ++ goto out; /* todo: close all? */ ++ ++ err = 0; ++ au_set_fbstart(file, bstart); ++ au_set_h_fptr(file, bstart, h_file); ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ ++ /* close lower files */ ++ bend = au_fbend(file); ++ for (bindex = bstart + 1; bindex <= bend; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ au_set_fbend(file, bstart); ++ ++ out: ++ if (h_file_tmp) ++ fput(h_file_tmp); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_reopen_wh(struct file *file, aufs_bindex_t btgt, ++ struct dentry *hi_wh) ++{ ++ int err; ++ aufs_bindex_t bstart; ++ struct au_dinfo *dinfo; ++ struct dentry *h_dentry; ++ ++ dinfo = au_di(file->f_dentry); ++ bstart = dinfo->di_bstart; ++ dinfo->di_bstart = btgt; ++ h_dentry = dinfo->di_hdentry[0 + btgt].hd_dentry; ++ dinfo->di_hdentry[0 + btgt].hd_dentry = hi_wh; ++ err = au_reopen_nondir(file); ++ dinfo->di_hdentry[0 + btgt].hd_dentry = h_dentry; ++ dinfo->di_bstart = bstart; ++ ++ return err; ++} ++ ++static int au_ready_to_write_wh(struct file *file, loff_t len, ++ aufs_bindex_t bcpup) ++{ ++ int err; ++ struct inode *inode; ++ struct dentry *dentry, *hi_wh; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ inode = dentry->d_inode; ++ hi_wh = au_hi_wh(inode, bcpup); ++ if (!hi_wh) ++ err = au_sio_cpup_wh(dentry, bcpup, len, file); ++ else ++ /* already copied-up after unlink */ ++ err = au_reopen_wh(file, bcpup, hi_wh); ++ ++ sb = dentry->d_sb; ++ if (!err && inode->i_nlink > 1 && au_opt_test(au_mntflags(sb), PLINK)) ++ au_plink_append(inode, bcpup, au_h_dptr(dentry, bcpup)); ++ ++ return err; ++} ++ ++/* ++ * prepare the @file for writing. ++ */ ++int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin) ++{ ++ int err; ++ aufs_bindex_t bstart, bcpup; ++ struct dentry *dentry, *parent, *h_dentry; ++ struct inode *h_inode, *inode; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ bstart = au_fbstart(file); ++ inode = dentry->d_inode; ++ err = au_test_ro(sb, bstart, inode); ++ if (!err && (au_h_fptr(file, bstart)->f_mode & FMODE_WRITE)) { ++ err = au_pin(pin, dentry, bstart, AuOpt_UDBA_NONE, /*flags*/0); ++ goto out; ++ } ++ ++ /* need to cpup */ ++ parent = dget_parent(dentry); ++ di_write_lock_parent(parent); ++ err = AuWbrCopyup(au_sbi(sb), dentry); ++ bcpup = err; ++ if (unlikely(err < 0)) ++ goto out_dgrade; ++ err = 0; ++ ++ if (!au_h_dptr(parent, bcpup)) { ++ err = au_cpup_dirs(dentry, bcpup); ++ if (unlikely(err)) ++ goto out_dgrade; ++ } ++ ++ err = au_pin(pin, dentry, bcpup, AuOpt_UDBA_NONE, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_dgrade; ++ ++ h_dentry = au_h_fptr(file, bstart)->f_dentry; ++ h_inode = h_dentry->d_inode; ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ if (d_unhashed(dentry) /* || d_unhashed(h_dentry) */ ++ /* || !h_inode->i_nlink */) { ++ err = au_ready_to_write_wh(file, len, bcpup); ++ di_downgrade_lock(parent, AuLock_IR); ++ } else { ++ di_downgrade_lock(parent, AuLock_IR); ++ if (!au_h_dptr(dentry, bcpup)) ++ err = au_sio_cpup_simple(dentry, bcpup, len, ++ AuCpup_DTIME); ++ if (!err) ++ err = au_reopen_nondir(file); ++ } ++ mutex_unlock(&h_inode->i_mutex); ++ ++ if (!err) { ++ au_pin_set_parent_lflag(pin, /*lflag*/0); ++ goto out_dput; /* success */ ++ } ++ au_unpin(pin); ++ goto out_unlock; ++ ++ out_dgrade: ++ di_downgrade_lock(parent, AuLock_IR); ++ out_unlock: ++ di_read_unlock(parent, AuLock_IR); ++ out_dput: ++ dput(parent); ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_file_refresh_by_inode(struct file *file, int *need_reopen) ++{ ++ int err; ++ aufs_bindex_t bstart; ++ struct au_pin pin; ++ struct au_finfo *finfo; ++ struct dentry *dentry, *parent, *hi_wh; ++ struct inode *inode; ++ struct super_block *sb; ++ ++ err = 0; ++ finfo = au_fi(file); ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ inode = dentry->d_inode; ++ bstart = au_ibstart(inode); ++ if (bstart == finfo->fi_bstart) ++ goto out; ++ ++ parent = dget_parent(dentry); ++ if (au_test_ro(sb, bstart, inode)) { ++ di_read_lock_parent(parent, !AuLock_IR); ++ err = AuWbrCopyup(au_sbi(sb), dentry); ++ bstart = err; ++ di_read_unlock(parent, !AuLock_IR); ++ if (unlikely(err < 0)) ++ goto out_parent; ++ err = 0; ++ } ++ ++ di_read_lock_parent(parent, AuLock_IR); ++ hi_wh = au_hi_wh(inode, bstart); ++ if (au_opt_test(au_mntflags(sb), PLINK) ++ && au_plink_test(inode) ++ && !d_unhashed(dentry)) { ++ err = au_test_and_cpup_dirs(dentry, bstart); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ /* always superio. */ ++ err = au_pin(&pin, dentry, bstart, AuOpt_UDBA_NONE, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (!err) ++ err = au_sio_cpup_simple(dentry, bstart, -1, ++ AuCpup_DTIME); ++ au_unpin(&pin); ++ } else if (hi_wh) { ++ /* already copied-up after unlink */ ++ err = au_reopen_wh(file, bstart, hi_wh); ++ *need_reopen = 0; ++ } ++ ++ out_unlock: ++ di_read_unlock(parent, AuLock_IR); ++ out_parent: ++ dput(parent); ++ out: ++ return err; ++} ++ ++static void au_do_refresh_file(struct file *file) ++{ ++ aufs_bindex_t bindex, bend, new_bindex, brid; ++ struct au_hfile *p, tmp, *q; ++ struct au_finfo *finfo; ++ struct super_block *sb; ++ ++ sb = file->f_dentry->d_sb; ++ finfo = au_fi(file); ++ p = finfo->fi_hfile + finfo->fi_bstart; ++ brid = p->hf_br->br_id; ++ bend = finfo->fi_bend; ++ for (bindex = finfo->fi_bstart; bindex <= bend; bindex++, p++) { ++ if (!p->hf_file) ++ continue; ++ ++ new_bindex = au_br_index(sb, p->hf_br->br_id); ++ if (new_bindex == bindex) ++ continue; ++ if (new_bindex < 0) { ++ au_set_h_fptr(file, bindex, NULL); ++ continue; ++ } ++ ++ /* swap two lower inode, and loop again */ ++ q = finfo->fi_hfile + new_bindex; ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hf_file) { ++ bindex--; ++ p--; ++ } ++ } ++ ++ p = finfo->fi_hfile; ++ if (!au_test_mmapped(file) && !d_unhashed(file->f_dentry)) { ++ bend = au_sbend(sb); ++ for (finfo->fi_bstart = 0; finfo->fi_bstart <= bend; ++ finfo->fi_bstart++, p++) ++ if (p->hf_file) { ++ if (p->hf_file->f_dentry ++ && p->hf_file->f_dentry->d_inode) ++ break; ++ else ++ au_hfput(p, file); ++ } ++ } else { ++ bend = au_br_index(sb, brid); ++ for (finfo->fi_bstart = 0; finfo->fi_bstart < bend; ++ finfo->fi_bstart++, p++) ++ if (p->hf_file) ++ au_hfput(p, file); ++ bend = au_sbend(sb); ++ } ++ ++ p = finfo->fi_hfile + bend; ++ for (finfo->fi_bend = bend; finfo->fi_bend >= finfo->fi_bstart; ++ finfo->fi_bend--, p--) ++ if (p->hf_file) { ++ if (p->hf_file->f_dentry ++ && p->hf_file->f_dentry->d_inode) ++ break; ++ else ++ au_hfput(p, file); ++ } ++ AuDebugOn(finfo->fi_bend < finfo->fi_bstart); ++} ++ ++/* ++ * after branch manipulating, refresh the file. ++ */ ++static int refresh_file(struct file *file, int (*reopen)(struct file *file)) ++{ ++ int err, need_reopen; ++ struct dentry *dentry; ++ aufs_bindex_t bend, bindex; ++ ++ dentry = file->f_dentry; ++ err = au_fi_realloc(au_fi(file), au_sbend(dentry->d_sb) + 1); ++ if (unlikely(err)) ++ goto out; ++ au_do_refresh_file(file); ++ ++ err = 0; ++ need_reopen = 1; ++ if (!au_test_mmapped(file)) ++ err = au_file_refresh_by_inode(file, &need_reopen); ++ if (!err && need_reopen && !d_unhashed(dentry)) ++ err = reopen(file); ++ if (!err) { ++ au_update_figen(file); ++ return 0; /* success */ ++ } ++ ++ /* error, close all lower files */ ++ bend = au_fbend(file); ++ for (bindex = au_fbstart(file); bindex <= bend; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ ++ out: ++ return err; ++} ++ ++/* common function to regular file and dir */ ++int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file), ++ int wlock) ++{ ++ int err; ++ unsigned int sigen, figen; ++ aufs_bindex_t bstart; ++ unsigned char pseudo_link; ++ struct dentry *dentry; ++ ++ err = 0; ++ dentry = file->f_dentry; ++ sigen = au_sigen(dentry->d_sb); ++ fi_write_lock(file); ++ figen = au_figen(file); ++ di_write_lock_child(dentry); ++ bstart = au_dbstart(dentry); ++ pseudo_link = (bstart != au_ibstart(dentry->d_inode)); ++ if (sigen == figen && !pseudo_link && au_fbstart(file) == bstart) { ++ if (!wlock) { ++ di_downgrade_lock(dentry, AuLock_IR); ++ fi_downgrade_lock(file); ++ } ++ goto out; /* success */ ++ } ++ ++ AuDbg("sigen %d, figen %d\n", sigen, figen); ++ if (sigen != au_digen(dentry) ++ || sigen != au_iigen(dentry->d_inode)) { ++ err = au_reval_dpath(dentry, sigen); ++ if (unlikely(err < 0)) ++ goto out; ++ AuDebugOn(au_digen(dentry) != sigen ++ || au_iigen(dentry->d_inode) != sigen); ++ } ++ ++ err = refresh_file(file, reopen); ++ if (!err) { ++ if (!wlock) { ++ di_downgrade_lock(dentry, AuLock_IR); ++ fi_downgrade_lock(file); ++ } ++ } else { ++ di_write_unlock(dentry); ++ fi_write_unlock(file); ++ } ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* cf. aufs_nopage() */ ++/* for madvise(2) */ ++static int aufs_readpage(struct file *file __maybe_unused, struct page *page) ++{ ++ unlock_page(page); ++ return 0; ++} ++ ++/* they will never be called. */ ++#ifdef CONFIG_AUFS_DEBUG ++static int aufs_write_begin(struct file *file, struct address_space *mapping, ++ loff_t pos, unsigned len, unsigned flags, ++ struct page **pagep, void **fsdata) ++{ AuUnsupport(); return 0; } ++static int aufs_write_end(struct file *file, struct address_space *mapping, ++ loff_t pos, unsigned len, unsigned copied, ++ struct page *page, void *fsdata) ++{ AuUnsupport(); return 0; } ++static int aufs_writepage(struct page *page, struct writeback_control *wbc) ++{ AuUnsupport(); return 0; } ++static void aufs_sync_page(struct page *page) ++{ AuUnsupport(); } ++ ++static int aufs_set_page_dirty(struct page *page) ++{ AuUnsupport(); return 0; } ++static void aufs_invalidatepage(struct page *page, unsigned long offset) ++{ AuUnsupport(); } ++static int aufs_releasepage(struct page *page, gfp_t gfp) ++{ AuUnsupport(); return 0; } ++static ssize_t aufs_direct_IO(int rw, struct kiocb *iocb, ++ const struct iovec *iov, loff_t offset, ++ unsigned long nr_segs) ++{ AuUnsupport(); return 0; } ++#endif /* CONFIG_AUFS_DEBUG */ ++ ++struct address_space_operations aufs_aop = { ++ .readpage = aufs_readpage, ++#ifdef CONFIG_AUFS_DEBUG ++ .writepage = aufs_writepage, ++ .sync_page = aufs_sync_page, ++ .set_page_dirty = aufs_set_page_dirty, ++ .write_begin = aufs_write_begin, ++ .write_end = aufs_write_end, ++ .invalidatepage = aufs_invalidatepage, ++ .releasepage = aufs_releasepage, ++ .direct_IO = aufs_direct_IO, ++#endif /* CONFIG_AUFS_DEBUG */ ++}; +diff -Naur a/fs/aufs/file.h b/fs/aufs/file.h +--- a/fs/aufs/file.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/file.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,159 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * file operations ++ */ ++ ++#ifndef __AUFS_FILE_H__ ++#define __AUFS_FILE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/aufs_type.h> ++#include "rwsem.h" ++ ++struct au_branch; ++struct au_hfile { ++ struct file *hf_file; ++ struct au_branch *hf_br; ++}; ++ ++struct au_vdir; ++struct au_finfo { ++ atomic_t fi_generation; ++ ++ struct rw_semaphore fi_rwsem; ++ struct au_hfile *fi_hfile; ++ aufs_bindex_t fi_bstart, fi_bend; ++ ++ union { ++ /* non-dir only */ ++ struct { ++ struct vm_operations_struct *fi_h_vm_ops; ++ struct vm_operations_struct *fi_vm_ops; ++ }; ++ ++ /* dir only */ ++ struct { ++ struct au_vdir *fi_vdir_cache; ++ int fi_maintain_plink; ++ }; ++ }; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* file.c */ ++extern struct address_space_operations aufs_aop; ++void au_store_oflag(struct nameidata *nd, struct inode *inode); ++unsigned int au_file_roflags(unsigned int flags); ++struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags, ++ struct file *file); ++int au_do_open(struct file *file, int (*open)(struct file *file, int flags)); ++int au_reopen_nondir(struct file *file); ++struct au_pin; ++int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin); ++int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file), ++ int wlock); ++ ++/* f_op.c */ ++extern const struct file_operations aufs_file_fop; ++int aufs_flush(struct file *file, fl_owner_t id); ++ ++/* finfo.c */ ++void au_hfput(struct au_hfile *hf, struct file *file); ++void au_set_h_fptr(struct file *file, aufs_bindex_t bindex, ++ struct file *h_file); ++ ++void au_update_figen(struct file *file); ++ ++void au_finfo_fin(struct file *file); ++int au_finfo_init(struct file *file); ++int au_fi_realloc(struct au_finfo *finfo, int nbr); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_finfo *au_fi(struct file *file) ++{ ++ return file->private_data; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * fi_read_lock, fi_write_lock, ++ * fi_read_unlock, fi_write_unlock, fi_downgrade_lock ++ */ ++AuSimpleRwsemFuncs(fi, struct file *f, &au_fi(f)->fi_rwsem); ++ ++#define FiMustNoWaiters(f) AuRwMustNoWaiters(&au_fi(f)->fi_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* todo: hard/soft set? */ ++static inline aufs_bindex_t au_fbstart(struct file *file) ++{ ++ return au_fi(file)->fi_bstart; ++} ++ ++static inline aufs_bindex_t au_fbend(struct file *file) ++{ ++ return au_fi(file)->fi_bend; ++} ++ ++static inline struct au_vdir *au_fvdir_cache(struct file *file) ++{ ++ return au_fi(file)->fi_vdir_cache; ++} ++ ++static inline void au_set_fbstart(struct file *file, aufs_bindex_t bindex) ++{ ++ au_fi(file)->fi_bstart = bindex; ++} ++ ++static inline void au_set_fbend(struct file *file, aufs_bindex_t bindex) ++{ ++ au_fi(file)->fi_bend = bindex; ++} ++ ++static inline void au_set_fvdir_cache(struct file *file, ++ struct au_vdir *vdir_cache) ++{ ++ au_fi(file)->fi_vdir_cache = vdir_cache; ++} ++ ++static inline struct file *au_h_fptr(struct file *file, aufs_bindex_t bindex) ++{ ++ return au_fi(file)->fi_hfile[0 + bindex].hf_file; ++} ++ ++/* todo: memory barrier? */ ++static inline unsigned int au_figen(struct file *f) ++{ ++ return atomic_read(&au_fi(f)->fi_generation); ++} ++ ++static inline int au_test_mmapped(struct file *f) ++{ ++ return !!(au_fi(f)->fi_h_vm_ops); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_FILE_H__ */ +diff -Naur a/fs/aufs/finfo.c b/fs/aufs/finfo.c +--- a/fs/aufs/finfo.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/finfo.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,134 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * file private data ++ */ ++ ++#include <linux/file.h> ++#include "aufs.h" ++ ++void au_hfput(struct au_hfile *hf, struct file *file) ++{ ++ if (file->f_mode & FMODE_EXEC) ++ allow_write_access(hf->hf_file); ++ fput(hf->hf_file); ++ hf->hf_file = NULL; ++ atomic_dec(&hf->hf_br->br_count); ++ hf->hf_br = NULL; ++} ++ ++void au_set_h_fptr(struct file *file, aufs_bindex_t bindex, struct file *val) ++{ ++ struct au_finfo *finfo = au_fi(file); ++ struct au_hfile *hf; ++ ++ hf = finfo->fi_hfile + bindex; ++ if (hf->hf_file) ++ au_hfput(hf, file); ++ if (val) { ++ hf->hf_file = val; ++ hf->hf_br = au_sbr(file->f_dentry->d_sb, bindex); ++ } ++} ++ ++void au_update_figen(struct file *file) ++{ ++ atomic_set(&au_fi(file)->fi_generation, au_digen(file->f_dentry)); ++ /* smp_mb(); */ /* atomic_set */ ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_finfo_fin(struct file *file) ++{ ++ struct au_finfo *finfo; ++ aufs_bindex_t bindex, bend; ++ ++ fi_write_lock(file); ++ bend = au_fbend(file); ++ bindex = au_fbstart(file); ++ if (bindex >= 0) ++ /* ++ * calls fput() instead of filp_close(), ++ * since no dnotify or lock for the lower file. ++ */ ++ for (; bindex <= bend; bindex++) ++ au_set_h_fptr(file, bindex, NULL); ++ ++ finfo = au_fi(file); ++ au_dbg_verify_hf(finfo); ++ kfree(finfo->fi_hfile); ++ fi_write_unlock(file); ++ au_rwsem_destroy(&finfo->fi_rwsem); ++ au_cache_free_finfo(finfo); ++} ++ ++int au_finfo_init(struct file *file) ++{ ++ struct au_finfo *finfo; ++ struct dentry *dentry; ++ unsigned long ul; ++ ++ dentry = file->f_dentry; ++ finfo = au_cache_alloc_finfo(); ++ if (unlikely(!finfo)) ++ goto out; ++ ++ finfo->fi_hfile = kcalloc(au_sbend(dentry->d_sb) + 1, ++ sizeof(*finfo->fi_hfile), GFP_NOFS); ++ if (unlikely(!finfo->fi_hfile)) ++ goto out_finfo; ++ ++ init_rwsem(&finfo->fi_rwsem); ++ down_write(&finfo->fi_rwsem); ++ finfo->fi_bstart = -1; ++ finfo->fi_bend = -1; ++ atomic_set(&finfo->fi_generation, au_digen(dentry)); ++ /* smp_mb(); */ /* atomic_set */ ++ ++ /* cf. au_store_oflag() */ ++ /* suppress a warning in lp64 */ ++ ul = (unsigned long)file->private_data; ++ file->f_mode |= (vfsub_uint_to_fmode(ul) & FMODE_EXEC); ++ file->private_data = finfo; ++ return 0; /* success */ ++ ++ out_finfo: ++ au_cache_free_finfo(finfo); ++ out: ++ return -ENOMEM; ++} ++ ++int au_fi_realloc(struct au_finfo *finfo, int nbr) ++{ ++ int err, sz; ++ struct au_hfile *hfp; ++ ++ err = -ENOMEM; ++ sz = sizeof(*hfp) * (finfo->fi_bend + 1); ++ if (!sz) ++ sz = sizeof(*hfp); ++ hfp = au_kzrealloc(finfo->fi_hfile, sz, sizeof(*hfp) * nbr, GFP_NOFS); ++ if (hfp) { ++ finfo->fi_hfile = hfp; ++ err = 0; ++ } ++ ++ return err; ++} +diff -Naur a/fs/aufs/f_op.c b/fs/aufs/f_op.c +--- a/fs/aufs/f_op.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/f_op.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,648 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * file and vm operations ++ */ ++ ++#include <linux/fs_stack.h> ++#include <linux/mm.h> ++#include <linux/poll.h> ++#include "aufs.h" ++ ++/* common function to regular file and dir */ ++int aufs_flush(struct file *file, fl_owner_t id) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ struct dentry *dentry; ++ struct file *h_file; ++ ++ dentry = file->f_dentry; ++ si_noflush_read_lock(dentry->d_sb); ++ fi_read_lock(file); ++ di_read_lock_child(dentry, AuLock_IW); ++ ++ err = 0; ++ bend = au_fbend(file); ++ for (bindex = au_fbstart(file); !err && bindex <= bend; bindex++) { ++ h_file = au_h_fptr(file, bindex); ++ if (!h_file || !h_file->f_op || !h_file->f_op->flush) ++ continue; ++ ++ err = h_file->f_op->flush(h_file, id); ++ if (!err) ++ vfsub_update_h_iattr(&h_file->f_path, /*did*/NULL); ++ /*ignore*/ ++ } ++ au_cpup_attr_timesizes(dentry->d_inode); ++ ++ di_read_unlock(dentry, AuLock_IW); ++ fi_read_unlock(file); ++ si_read_unlock(dentry->d_sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int do_open_nondir(struct file *file, int flags) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct file *h_file; ++ struct dentry *dentry; ++ struct au_finfo *finfo; ++ ++ err = 0; ++ dentry = file->f_dentry; ++ finfo = au_fi(file); ++ finfo->fi_h_vm_ops = NULL; ++ finfo->fi_vm_ops = NULL; ++ bindex = au_dbstart(dentry); ++ /* O_TRUNC is processed already */ ++ BUG_ON(au_test_ro(dentry->d_sb, bindex, dentry->d_inode) ++ && (flags & O_TRUNC)); ++ ++ h_file = au_h_open(dentry, bindex, flags, file); ++ if (IS_ERR(h_file)) ++ err = PTR_ERR(h_file); ++ else { ++ au_set_fbstart(file, bindex); ++ au_set_fbend(file, bindex); ++ au_set_h_fptr(file, bindex, h_file); ++ au_update_figen(file); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ } ++ return err; ++} ++ ++static int aufs_open_nondir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ return au_do_open(file, do_open_nondir); ++} ++ ++static int aufs_release_nondir(struct inode *inode __maybe_unused, ++ struct file *file) ++{ ++ struct super_block *sb = file->f_dentry->d_sb; ++ ++ si_noflush_read_lock(sb); ++ kfree(au_fi(file)->fi_vm_ops); ++ au_finfo_fin(file); ++ si_read_unlock(sb); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static ssize_t aufs_read(struct file *file, char __user *buf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ struct dentry *dentry; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ err = vfsub_read_u(h_file, buf, count, ppos); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ fsstack_copy_attr_atime(dentry->d_inode, h_file->f_dentry->d_inode); ++ ++ di_read_unlock(dentry, AuLock_IR); ++ fi_read_unlock(file); ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++static ssize_t aufs_write(struct file *file, const char __user *ubuf, ++ size_t count, loff_t *ppos) ++{ ++ ssize_t err; ++ aufs_bindex_t bstart; ++ struct au_pin pin; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ struct file *h_file; ++ char __user *buf = (char __user *)ubuf; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ inode = dentry->d_inode; ++ mutex_lock(&inode->i_mutex); ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_ready_to_write(file, -1, &pin); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ bstart = au_fbstart(file); ++ h_file = au_h_fptr(file, bstart); ++ au_unpin(&pin); ++ err = vfsub_write_u(h_file, buf, count, ppos); ++ au_cpup_attr_timesizes(inode); ++ inode->i_mode = h_file->f_dentry->d_inode->i_mode; ++ ++ out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ fi_write_unlock(file); ++ out: ++ si_read_unlock(sb); ++ mutex_unlock(&inode->i_mutex); ++ return err; ++} ++ ++static ssize_t aufs_splice_read(struct file *file, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) ++{ ++ ssize_t err; ++ struct file *h_file; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ err = -EINVAL; ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ if (au_test_loopback_kthread()) { ++ file->f_mapping = h_file->f_mapping; ++ smp_mb(); /* unnecessary? */ ++ } ++ err = vfsub_splice_to(h_file, ppos, pipe, len, flags); ++ /* todo: necessasry? */ ++ /* file->f_ra = h_file->f_ra; */ ++ fsstack_copy_attr_atime(dentry->d_inode, h_file->f_dentry->d_inode); ++ ++ di_read_unlock(dentry, AuLock_IR); ++ fi_read_unlock(file); ++ ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++static ssize_t ++aufs_splice_write(struct pipe_inode_info *pipe, struct file *file, loff_t *ppos, ++ size_t len, unsigned int flags) ++{ ++ ssize_t err; ++ struct au_pin pin; ++ struct dentry *dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ struct file *h_file; ++ ++ dentry = file->f_dentry; ++ inode = dentry->d_inode; ++ mutex_lock(&inode->i_mutex); ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_ready_to_write(file, -1, &pin); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ au_unpin(&pin); ++ err = vfsub_splice_from(pipe, h_file, ppos, len, flags); ++ au_cpup_attr_timesizes(inode); ++ inode->i_mode = h_file->f_dentry->d_inode->i_mode; ++ ++ out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ fi_write_unlock(file); ++ out: ++ si_read_unlock(sb); ++ mutex_unlock(&inode->i_mutex); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct file *au_safe_file(struct vm_area_struct *vma) ++{ ++ struct file *file; ++ ++ file = vma->vm_file; ++ if (file->private_data && au_test_aufs(file->f_dentry->d_sb)) ++ return file; ++ return NULL; ++} ++ ++static void au_reset_file(struct vm_area_struct *vma, struct file *file) ++{ ++ vma->vm_file = file; ++ /* smp_mb(); */ /* flush vm_file */ ++} ++ ++static int aufs_fault(struct vm_area_struct *vma, struct vm_fault *vmf) ++{ ++ int err; ++ static DECLARE_WAIT_QUEUE_HEAD(wq); ++ struct file *file, *h_file; ++ struct au_finfo *finfo; ++ ++ /* todo: non-robr mode, user vm_file as it is? */ ++ wait_event(wq, (file = au_safe_file(vma))); ++ ++ /* do not revalidate, no si lock */ ++ finfo = au_fi(file); ++ h_file = finfo->fi_hfile[0 + finfo->fi_bstart].hf_file; ++ AuDebugOn(!h_file || !au_test_mmapped(file)); ++ ++ fi_write_lock(file); ++ vma->vm_file = h_file; ++ err = finfo->fi_h_vm_ops->fault(vma, vmf); ++ /* todo: necessary? */ ++ /* file->f_ra = h_file->f_ra; */ ++ au_reset_file(vma, file); ++ fi_write_unlock(file); ++#if 0 /* def CONFIG_SMP */ ++ /* wake_up_nr(&wq, online_cpu - 1); */ ++ wake_up_all(&wq); ++#else ++ wake_up(&wq); ++#endif ++ ++ return err; ++} ++ ++static int aufs_page_mkwrite(struct vm_area_struct *vma, struct page *page) ++{ ++ int err; ++ static DECLARE_WAIT_QUEUE_HEAD(wq); ++ struct file *file, *h_file; ++ struct au_finfo *finfo; ++ ++ wait_event(wq, (file = au_safe_file(vma))); ++ ++ finfo = au_fi(file); ++ h_file = finfo->fi_hfile[0 + finfo->fi_bstart].hf_file; ++ AuDebugOn(!h_file || !au_test_mmapped(file)); ++ ++ fi_write_lock(file); ++ vma->vm_file = h_file; ++ err = finfo->fi_h_vm_ops->page_mkwrite(vma, page); ++ au_reset_file(vma, file); ++ fi_write_unlock(file); ++ wake_up(&wq); ++ ++ return err; ++} ++ ++static void aufs_vm_close(struct vm_area_struct *vma) ++{ ++ static DECLARE_WAIT_QUEUE_HEAD(wq); ++ struct file *file, *h_file; ++ struct au_finfo *finfo; ++ ++ wait_event(wq, (file = au_safe_file(vma))); ++ ++ finfo = au_fi(file); ++ h_file = finfo->fi_hfile[0 + finfo->fi_bstart].hf_file; ++ AuDebugOn(!h_file || !au_test_mmapped(file)); ++ ++ fi_write_lock(file); ++ vma->vm_file = h_file; ++ finfo->fi_h_vm_ops->close(vma); ++ au_reset_file(vma, file); ++ fi_write_unlock(file); ++ wake_up(&wq); ++} ++ ++static struct vm_operations_struct aufs_vm_ops = { ++ /* .close and .page_mkwrite are not set by default */ ++ .fault = aufs_fault, ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct vm_operations_struct *au_vm_ops(struct file *h_file, ++ struct vm_area_struct *vma) ++{ ++ struct vm_operations_struct *vm_ops; ++ int err; ++ ++ vm_ops = ERR_PTR(-ENODEV); ++ if (!h_file->f_op || !h_file->f_op->mmap) ++ goto out; ++ ++ err = h_file->f_op->mmap(h_file, vma); ++ vm_ops = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ vm_ops = vma->vm_ops; ++ err = do_munmap(current->mm, vma->vm_start, ++ vma->vm_end - vma->vm_start); ++ if (unlikely(err)) { ++ AuIOErr("failed internal unmapping %.*s, %d\n", ++ AuDLNPair(h_file->f_dentry), err); ++ vm_ops = ERR_PTR(-EIO); ++ } ++ ++ out: ++ return vm_ops; ++} ++ ++static int au_custom_vm_ops(struct au_finfo *finfo, struct vm_area_struct *vma) ++{ ++ int err; ++ struct vm_operations_struct *h_ops; ++ ++ err = 0; ++ h_ops = finfo->fi_h_vm_ops; ++ AuDebugOn(!h_ops); ++ if ((!h_ops->page_mkwrite && !h_ops->close) ++ || finfo->fi_vm_ops) ++ goto out; ++ ++ err = -ENOMEM; ++ finfo->fi_vm_ops = kmemdup(&aufs_vm_ops, sizeof(aufs_vm_ops), GFP_NOFS); ++ if (unlikely(!finfo->fi_vm_ops)) ++ goto out; ++ ++ err = 0; ++ if (h_ops->page_mkwrite) ++ finfo->fi_vm_ops->page_mkwrite = aufs_page_mkwrite; ++ if (h_ops->close) ++ finfo->fi_vm_ops->close = aufs_vm_close; ++ ++ vma->vm_ops = finfo->fi_vm_ops; ++ ++ out: ++ return err; ++} ++ ++static int aufs_mmap(struct file *file, struct vm_area_struct *vma) ++{ ++ int err; ++ unsigned char wlock, mmapped; ++ struct dentry *dentry; ++ struct super_block *sb; ++ struct file *h_file; ++ struct vm_operations_struct *vm_ops; ++ ++ dentry = file->f_dentry; ++ mmapped = !!au_test_mmapped(file); /* can be harmless race condition */ ++ wlock = !!(file->f_mode & FMODE_WRITE) && (vma->vm_flags & VM_SHARED); ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, wlock | !mmapped); ++ if (unlikely(err)) ++ goto out; ++ ++ if (wlock) { ++ struct au_pin pin; ++ ++ err = au_ready_to_write(file, -1, &pin); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ au_unpin(&pin); ++ } else if (!mmapped) ++ di_downgrade_lock(dentry, AuLock_IR); ++ ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ if (au_test_fs_bad_mapping(h_file->f_dentry->d_sb)) { ++ /* ++ * by this assignment, f_mapping will differs from aufs inode ++ * i_mapping. ++ * if someone else mixes the use of f_dentry->d_inode and ++ * f_mapping->host, then a problem may arise. ++ */ ++ file->f_mapping = h_file->f_mapping; ++ } ++ ++ vm_ops = NULL; ++ if (!mmapped) { ++ vm_ops = au_vm_ops(h_file, vma); ++ err = PTR_ERR(vm_ops); ++ if (IS_ERR(vm_ops)) ++ goto out_unlock; ++ } ++ ++ /* ++ * unnecessary to handle MAP_DENYWRITE and deny_write_access()? ++ * currently MAP_DENYWRITE from userspace is ignored, but elf loader ++ * sets it. when FMODE_EXEC is set (by open_exec() or sys_uselib()), ++ * both of the aufs file and the lower file is deny_write_access()-ed. ++ * finally I hope we can skip handlling MAP_DENYWRITE here. ++ */ ++ err = generic_file_mmap(file, vma); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ vma->vm_ops = &aufs_vm_ops; ++ /* test again */ ++ if (!au_test_mmapped(file)) ++ au_fi(file)->fi_h_vm_ops = vm_ops; ++ ++ err = au_custom_vm_ops(au_fi(file), vma); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ vfsub_file_accessed(h_file); ++ fsstack_copy_attr_atime(dentry->d_inode, h_file->f_dentry->d_inode); ++ ++ out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ if (!wlock && mmapped) ++ fi_read_unlock(file); ++ else ++ fi_write_unlock(file); ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static unsigned int aufs_poll(struct file *file, poll_table *wait) ++{ ++ unsigned int mask; ++ int err; ++ struct file *h_file; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ /* We should pretend an error happened. */ ++ mask = POLLERR /* | POLLIN | POLLOUT */; ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ /* it is not an error if h_file has no operation */ ++ mask = DEFAULT_POLLMASK; ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ if (h_file->f_op && h_file->f_op->poll) ++ mask = h_file->f_op->poll(h_file, wait); ++ ++ di_read_unlock(dentry, AuLock_IR); ++ fi_read_unlock(file); ++ ++ out: ++ si_read_unlock(sb); ++ AuTraceErr((int)mask); ++ return mask; ++} ++ ++static int aufs_fsync_nondir(struct file *file, struct dentry *dentry, ++ int datasync) ++{ ++ int err; ++ struct au_pin pin; ++ struct inode *inode; ++ struct file *h_file; ++ struct super_block *sb; ++ ++ inode = dentry->d_inode; ++ IMustLock(file->f_mapping->host); ++ if (inode != file->f_mapping->host) { ++ mutex_unlock(&file->f_mapping->host->i_mutex); ++ mutex_lock(&inode->i_mutex); ++ } ++ IMustLock(inode); ++ ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ err = 0; /* -EBADF; */ /* posix? */ ++ if (unlikely(!(file->f_mode & FMODE_WRITE))) ++ goto out; ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/1); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_ready_to_write(file, -1, &pin); ++ di_downgrade_lock(dentry, AuLock_IR); ++ if (unlikely(err)) ++ goto out_unlock; ++ au_unpin(&pin); ++ ++ err = -EINVAL; ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ if (h_file->f_op && h_file->f_op->fsync) { ++ struct dentry *h_d; ++ struct mutex *h_mtx; ++ ++ /* ++ * no filemap_fdatawrite() since aufs file has no its own ++ * mapping, but dir. ++ */ ++ h_d = h_file->f_dentry; ++ h_mtx = &h_d->d_inode->i_mutex; ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ err = h_file->f_op->fsync(h_file, h_d, datasync); ++ if (!err) ++ vfsub_update_h_iattr(&h_file->f_path, /*did*/NULL); ++ /*ignore*/ ++ au_cpup_attr_timesizes(inode); ++ mutex_unlock(h_mtx); ++ } ++ ++ out_unlock: ++ di_read_unlock(dentry, AuLock_IR); ++ fi_write_unlock(file); ++ out: ++ si_read_unlock(sb); ++ if (inode != file->f_mapping->host) { ++ mutex_unlock(&inode->i_mutex); ++ mutex_lock(&file->f_mapping->host->i_mutex); ++ } ++ return err; ++} ++ ++static int aufs_fasync(int fd, struct file *file, int flag) ++{ ++ int err; ++ struct file *h_file; ++ struct dentry *dentry; ++ struct super_block *sb; ++ ++ dentry = file->f_dentry; ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_reval_and_lock_fdi(file, au_reopen_nondir, /*wlock*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ h_file = au_h_fptr(file, au_fbstart(file)); ++ if (h_file->f_op && h_file->f_op->fasync) ++ err = h_file->f_op->fasync(fd, h_file, flag); ++ ++ di_read_unlock(dentry, AuLock_IR); ++ fi_read_unlock(file); ++ ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++const struct file_operations aufs_file_fop = { ++ /* ++ * while generic_file_llseek/_unlocked() don't use BKL, ++ * don't use it since it operates file->f_mapping->host. ++ * in aufs, it may be a real file and may confuse users by UDBA. ++ */ ++ /* .llseek = generic_file_llseek, */ ++ ++ .read = aufs_read, ++ .write = aufs_write, ++ .poll = aufs_poll, ++ .mmap = aufs_mmap, ++ .open = aufs_open_nondir, ++ .flush = aufs_flush, ++ .release = aufs_release_nondir, ++ .fsync = aufs_fsync_nondir, ++ .fasync = aufs_fasync, ++ .splice_write = aufs_splice_write, ++ .splice_read = aufs_splice_read ++}; +diff -Naur a/fs/aufs/fstype.h b/fs/aufs/fstype.h +--- a/fs/aufs/fstype.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/fstype.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,474 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * judging filesystem type ++ */ ++ ++#ifndef __AUFS_FSTYPE_H__ ++#define __AUFS_FSTYPE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/cramfs_fs.h> ++#include <linux/fs.h> ++#include <linux/magic.h> ++#include <linux/romfs_fs.h> ++#include <linux/aufs_type.h> ++ ++static inline int au_test_aufs(struct super_block *sb) ++{ ++ return sb->s_magic == AUFS_SUPER_MAGIC; ++} ++ ++static inline const char *au_sbtype(struct super_block *sb) ++{ ++ return sb->s_type->name; ++} ++ ++static inline int au_test_iso9660(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_ROMFS_FS) || defined(CONFIG_ROMFS_FS_MODULE) ++ return sb->s_magic == ROMFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_romfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_ISO9660_FS) || defined(CONFIG_ISO9660_FS_MODULE) ++ return sb->s_magic == ISOFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_cramfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_CRAMFS) || defined(CONFIG_CRAMFS_MODULE) ++ return sb->s_magic == CRAMFS_MAGIC; ++#endif ++ return 0; ++} ++ ++static inline int au_test_nfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_NFS_FS) || defined(CONFIG_NFS_FS_MODULE) ++ return sb->s_magic == NFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_fuse(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_FUSE_FS) || defined(CONFIG_FUSE_FS_MODULE) ++ return sb->s_magic == FUSE_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_xfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_XFS_FS) || defined(CONFIG_XFS_FS_MODULE) ++ return sb->s_magic == XFS_SB_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_tmpfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_TMPFS ++ return sb->s_magic == TMPFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ecryptfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_ECRYPT_FS) || defined(CONFIG_ECRYPT_FS_MODULE) ++ return !strcmp(au_sbtype(sb), "ecryptfs"); ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_smbfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_SMB_FS) || defined(CONFIG_SMB_FS_MODULE) ++ return sb->s_magic == SMB_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ocfs2(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_OCFS2_FS) || defined(CONFIG_OCFS2_FS_MODULE) ++ return sb->s_magic == OCFS2_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ocfs2_dlmfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_OCFS2_FS_O2CB) || defined(CONFIG_OCFS2_FS_O2CB_MODULE) ++ return sb->s_magic == DLMFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_coda(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_CODA_FS) || defined(CONFIG_CODA_FS_MODULE) ++ return sb->s_magic == CODA_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_v9fs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_9P_FS) || defined(CONFIG_9P_FS_MODULE) ++ return sb->s_magic == V9FS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ext4(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_EXT4DEV_FS) || defined(CONFIG_EXT4DEV_FS_MODULE) ++ return sb->s_magic == EXT4_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_sysv(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_SYSV_FS) || defined(CONFIG_SYSV_FS_MODULE) ++ return !strcmp(au_sbtype(sb), "sysv"); ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_ramfs(struct super_block *sb) ++{ ++ return sb->s_magic == RAMFS_MAGIC; ++} ++ ++static inline int au_test_ubifs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_UBIFS_FS) || defined(CONFIG_UBIFS_FS_MODULE) ++ return sb->s_magic == UBIFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_procfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_PROC_FS ++ return sb->s_magic == PROC_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_sysfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_SYSFS ++ return sb->s_magic == SYSFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_configfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_CONFIGFS_FS) || defined(CONFIG_CONFIGFS_FS_MODULE) ++ return sb->s_magic == CONFIGFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_minix(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_MINIX_FS) || defined(CONFIG_MINIX_FS_MODULE) ++ return sb->s_magic == MINIX3_SUPER_MAGIC ++ || sb->s_magic == MINIX2_SUPER_MAGIC ++ || sb->s_magic == MINIX2_SUPER_MAGIC2 ++ || sb->s_magic == MINIX_SUPER_MAGIC ++ || sb->s_magic == MINIX_SUPER_MAGIC2; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_cifs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_CIFS_FS) || defined(CONFIGCIFS_FS_MODULE) ++ return sb->s_magic == CIFS_MAGIC_NUMBER; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_fat(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_FAT_FS) || defined(CONFIG_FAT_FS_MODULE) ++ return sb->s_magic == MSDOS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_msdos(struct super_block *sb) ++{ ++ return au_test_fat(sb); ++} ++ ++static inline int au_test_vfat(struct super_block *sb) ++{ ++ return au_test_fat(sb); ++} ++ ++static inline int au_test_securityfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_SECURITYFS ++ return sb->s_magic == SECURITYFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_squashfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_SQUASHFS) || defined(CONFIG_SQUASHFS_MODULE) ++ return sb->s_magic == SQUASHFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_btrfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_BTRFS_FS) || defined(CONFIG_BTRFS_FS_MODULE) ++ return sb->s_magic == BTRFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_xenfs(struct super_block *sb __maybe_unused) ++{ ++#if defined(CONFIG_XENFS) || defined(CONFIG_XENFS_MODULE) ++ return sb->s_magic == XENFS_SUPER_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++static inline int au_test_debugfs(struct super_block *sb __maybe_unused) ++{ ++#ifdef CONFIG_DEBUG_FS ++ return sb->s_magic == DEBUGFS_MAGIC; ++#else ++ return 0; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * they can't be an aufs branch. ++ */ ++static inline int au_test_fs_unsuppoted(struct super_block *sb) ++{ ++ return ++#ifndef CONFIG_AUFS_BR_RAMFS ++ au_test_ramfs(sb) || ++#endif ++ au_test_procfs(sb) ++ || au_test_sysfs(sb) ++ || au_test_configfs(sb) ++ || au_test_debugfs(sb) ++ || au_test_securityfs(sb) ++ || au_test_xenfs(sb) ++ /* || !strcmp(au_sbtype(sb), "unionfs") */ ++ || au_test_aufs(sb); /* will be supported in next version */ ++} ++ ++/* ++ * If the filesystem supports NFS-export, then it has to support NULL as ++ * a nameidata parameter for ->create(), ->lookup() and ->d_revalidate(). ++ * We can apply this principle when we handle a lower filesystem. ++ */ ++static inline int au_test_fs_null_nd(struct super_block *sb) ++{ ++ return !!sb->s_export_op; ++} ++ ++static inline int au_test_fs_remote(struct super_block *sb) ++{ ++ return !au_test_tmpfs(sb) ++#ifdef CONFIG_AUFS_BR_RAMFS ++ && !au_test_ramfs(sb) ++#endif ++ && !(sb->s_type->fs_flags & FS_REQUIRES_DEV); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * Note: these functions (below) are created after reading ->getattr() in all ++ * filesystems under linux/fs. it means we have to do so in every update... ++ */ ++ ++/* ++ * some filesystems require getattr to refresh the inode attributes before ++ * referencing. ++ * in most cases, we can rely on the inode attribute in NFS (or every remote fs) ++ * and leave the work for d_revalidate() ++ */ ++static inline int au_test_fs_refresh_iattr(struct super_block *sb) ++{ ++ return au_test_nfs(sb) ++ || au_test_fuse(sb) ++ /* || au_test_smbfs(sb) */ /* untested */ ++ /* || au_test_ocfs2(sb) */ /* untested */ ++ /* || au_test_btrfs(sb) */ /* untested */ ++ /* || au_test_coda(sb) */ /* untested */ ++ /* || au_test_v9fs(sb) */ /* untested */ ++ ; ++} ++ ++/* ++ * filesystems which don't maintain i_size or i_blocks. ++ */ ++static inline int au_test_fs_bad_iattr_size(struct super_block *sb) ++{ ++ return au_test_xfs(sb) ++ /* || au_test_ext4(sb) */ /* untested */ ++ /* || au_test_ocfs2(sb) */ /* untested */ ++ /* || au_test_ocfs2_dlmfs(sb) */ /* untested */ ++ /* || au_test_sysv(sb) */ /* untested */ ++ /* || au_test_ubifs(sb) */ /* untested */ ++ /* || au_test_minix(sb) */ /* untested */ ++ ; ++} ++ ++/* ++ * filesystems which don't store the correct value in some of their inode ++ * attributes. ++ */ ++static inline int au_test_fs_bad_iattr(struct super_block *sb) ++{ ++ return au_test_fs_bad_iattr_size(sb) ++ /* || au_test_cifs(sb) */ /* untested */ ++ || au_test_fat(sb) ++ || au_test_msdos(sb) ++ || au_test_vfat(sb); ++} ++ ++/* they don't check i_nlink in link(2) */ ++static inline int au_test_fs_no_limit_nlink(struct super_block *sb) ++{ ++ return au_test_tmpfs(sb) ++#ifdef CONFIG_AUFS_BR_RAMFS ++ || au_test_ramfs(sb) ++#endif ++ || au_test_ubifs(sb); ++} ++ ++/* ++ * filesystems which sets S_NOATIME and S_NOCMTIME. ++ */ ++static inline int au_test_fs_notime(struct super_block *sb) ++{ ++ return au_test_nfs(sb) ++ || au_test_fuse(sb) ++ || au_test_ubifs(sb) ++ /* || au_test_cifs(sb) */ /* untested */ ++ ; ++} ++ ++/* ++ * filesystems which requires replacing i_mapping. ++ */ ++static inline int au_test_fs_bad_mapping(struct super_block *sb) ++{ ++ return au_test_fuse(sb) ++ || au_test_ubifs(sb); ++} ++ ++/* temporary support for i#1 in cramfs */ ++static inline int au_test_fs_unique_ino(struct inode *inode) ++{ ++ if (au_test_cramfs(inode->i_sb)) ++ return inode->i_ino != 1; ++ return 1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * the filesystem where the xino files placed must support i/o after unlink and ++ * maintain i_size and i_blocks. ++ */ ++static inline int au_test_fs_bad_xino(struct super_block *sb) ++{ ++ return au_test_fs_remote(sb) ++ || au_test_fs_bad_iattr_size(sb) ++#ifdef CONFIG_AUFS_BR_RAMFS ++ || !(au_test_ramfs(sb) || au_test_fs_null_nd(sb)) ++#else ++ || !au_test_fs_null_nd(sb) /* to keep xino code simple */ ++#endif ++ /* don't want unnecessary work for xino */ ++ || au_test_aufs(sb) ++ || au_test_ecryptfs(sb); ++} ++ ++static inline int au_test_fs_trunc_xino(struct super_block *sb) ++{ ++ return au_test_tmpfs(sb) ++ || au_test_ramfs(sb); ++} ++ ++/* ++ * test if the @sb is real-readonly. ++ */ ++static inline int au_test_fs_rr(struct super_block *sb) ++{ ++ return au_test_squashfs(sb) ++ || au_test_iso9660(sb) ++ || au_test_cramfs(sb) ++ || au_test_romfs(sb); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_FSTYPE_H__ */ +diff -Naur a/fs/aufs/hinotify.c b/fs/aufs/hinotify.c +--- a/fs/aufs/hinotify.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/hinotify.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,755 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inotify for the lower directories ++ */ ++ ++#include "aufs.h" ++ ++static const __u32 AuHinMask = (IN_MOVE | IN_DELETE | IN_CREATE); ++static struct inotify_handle *au_hin_handle; ++ ++AuCacheFuncs(hinotify, HINOTIFY); ++ ++int au_hin_alloc(struct au_hinode *hinode, struct inode *inode, ++ struct inode *h_inode) ++{ ++ int err; ++ struct au_hinotify *hin; ++ s32 wd; ++ ++ err = -ENOMEM; ++ hin = au_cache_alloc_hinotify(); ++ if (hin) { ++ AuDebugOn(hinode->hi_notify); ++ hinode->hi_notify = hin; ++ hin->hin_aufs_inode = inode; ++ ++ inotify_init_watch(&hin->hin_watch); ++ wd = inotify_add_watch(au_hin_handle, &hin->hin_watch, h_inode, ++ AuHinMask); ++ if (wd >= 0) ++ return 0; /* success */ ++ ++ err = wd; ++ put_inotify_watch(&hin->hin_watch); ++ au_cache_free_hinotify(hin); ++ hinode->hi_notify = NULL; ++ } ++ ++ return err; ++} ++ ++void au_hin_free(struct au_hinode *hinode) ++{ ++ int err; ++ struct au_hinotify *hin; ++ ++ hin = hinode->hi_notify; ++ if (hin) { ++ err = 0; ++ if (atomic_read(&hin->hin_watch.count)) ++ err = inotify_rm_watch(au_hin_handle, &hin->hin_watch); ++ if (unlikely(err)) ++ /* it means the watch is already removed */ ++ AuWarn("failed inotify_rm_watch() %d\n", err); ++ au_cache_free_hinotify(hin); ++ hinode->hi_notify = NULL; ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_hin_ctl(struct au_hinode *hinode, int do_set) ++{ ++ struct inode *h_inode; ++ struct inotify_watch *watch; ++ ++ if (!hinode->hi_notify) ++ return; ++ ++ h_inode = hinode->hi_inode; ++ IMustLock(h_inode); ++ ++ /* todo: try inotify_find_update_watch()? */ ++ watch = &hinode->hi_notify->hin_watch; ++ mutex_lock(&h_inode->inotify_mutex); ++ /* mutex_lock(&watch->ih->mutex); */ ++ if (do_set) { ++ AuDebugOn(watch->mask & AuHinMask); ++ watch->mask |= AuHinMask; ++ } else { ++ AuDebugOn(!(watch->mask & AuHinMask)); ++ watch->mask &= ~AuHinMask; ++ } ++ /* mutex_unlock(&watch->ih->mutex); */ ++ mutex_unlock(&h_inode->inotify_mutex); ++} ++ ++void au_reset_hinotify(struct inode *inode, unsigned int flags) ++{ ++ aufs_bindex_t bindex, bend; ++ struct inode *hi; ++ struct dentry *iwhdentry; ++ ++ bend = au_ibend(inode); ++ for (bindex = au_ibstart(inode); bindex <= bend; bindex++) { ++ hi = au_h_iptr(inode, bindex); ++ if (!hi) ++ continue; ++ ++ /* mutex_lock_nested(&hi->i_mutex, AuLsc_I_CHILD); */ ++ iwhdentry = au_hi_wh(inode, bindex); ++ if (iwhdentry) ++ dget(iwhdentry); ++ au_igrab(hi); ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ au_set_h_iptr(inode, bindex, au_igrab(hi), ++ flags & ~AuHi_XINO); ++ iput(hi); ++ dput(iwhdentry); ++ /* mutex_unlock(&hi->i_mutex); */ ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int hin_xino(struct inode *inode, struct inode *h_inode) ++{ ++ int err; ++ aufs_bindex_t bindex, bend, bfound, bstart; ++ struct inode *h_i; ++ ++ err = 0; ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ AuWarn("branch root dir was changed\n"); ++ goto out; ++ } ++ ++ bfound = -1; ++ bend = au_ibend(inode); ++ bstart = au_ibstart(inode); ++#if 0 /* reserved for future use */ ++ if (bindex == bend) { ++ /* keep this ino in rename case */ ++ goto out; ++ } ++#endif ++ for (bindex = bstart; bindex <= bend; bindex++) { ++ if (au_h_iptr(inode, bindex) == h_inode) { ++ bfound = bindex; ++ break; ++ } ++ } ++ if (bfound < 0) ++ goto out; ++ ++ for (bindex = bstart; bindex <= bend; bindex++) { ++ h_i = au_h_iptr(inode, bindex); ++ if (!h_i) ++ continue; ++ ++ err = au_xino_write0(inode->i_sb, bindex, h_i->i_ino, 0); ++ /* ignore this error */ ++ /* bad action? */ ++ } ++ ++ /* children inode number will be broken */ ++ ++ out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int hin_gen_tree(struct dentry *dentry) ++{ ++ int err, i, j, ndentry; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ ++ err = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_dcsub_pages(&dpages, dentry, NULL, NULL); ++ if (unlikely(err)) ++ goto out_dpages; ++ ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) { ++ struct dentry *d; ++ ++ d = dentries[j]; ++ if (IS_ROOT(d)) ++ continue; ++ ++ d_drop(d); ++ au_digen_dec(d); ++ if (d->d_inode) ++ /* todo: reset children xino? ++ cached children only? */ ++ au_iigen_dec(d->d_inode); ++ } ++ } ++ ++ out_dpages: ++ au_dpages_free(&dpages); ++ ++ /* discard children */ ++ dentry_unhash(dentry); ++ dput(dentry); ++ out: ++ return err; ++} ++ ++/* ++ * return 0 if processed. ++ */ ++static int hin_gen_by_inode(char *name, unsigned int nlen, struct inode *inode, ++ const unsigned int isdir) ++{ ++ int err; ++ struct dentry *d; ++ struct qstr *dname; ++ ++ err = 1; ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ AuWarn("branch root dir was changed\n"); ++ err = 0; ++ goto out; ++ } ++ ++ if (!isdir) { ++ AuDebugOn(!name); ++ au_iigen_dec(inode); ++ spin_lock(&dcache_lock); ++ list_for_each_entry(d, &inode->i_dentry, d_alias) { ++ dname = &d->d_name; ++ if (dname->len != nlen ++ && memcmp(dname->name, name, nlen)) ++ continue; ++ err = 0; ++ spin_lock(&d->d_lock); ++ __d_drop(d); ++ au_digen_dec(d); ++ spin_unlock(&d->d_lock); ++ break; ++ } ++ spin_unlock(&dcache_lock); ++ } else { ++ au_fset_si(au_sbi(inode->i_sb), FAILED_REFRESH_DIRS); ++ d = d_find_alias(inode); ++ if (!d) { ++ au_iigen_dec(inode); ++ goto out; ++ } ++ ++ dname = &d->d_name; ++ if (dname->len == nlen && !memcmp(dname->name, name, nlen)) ++ err = hin_gen_tree(d); ++ dput(d); ++ } ++ ++ out: ++ AuTraceErr(err); ++ return err; ++} ++ ++static int hin_gen_by_name(struct dentry *dentry, const unsigned int isdir) ++{ ++ int err; ++ struct inode *inode; ++ ++ inode = dentry->d_inode; ++ if (IS_ROOT(dentry) ++ /* || (inode && inode->i_ino == AUFS_ROOT_INO) */ ++ ) { ++ AuWarn("branch root dir was changed\n"); ++ return 0; ++ } ++ ++ err = 0; ++ if (!isdir) { ++ d_drop(dentry); ++ au_digen_dec(dentry); ++ if (inode) ++ au_iigen_dec(inode); ++ } else { ++ au_fset_si(au_sbi(dentry->d_sb), FAILED_REFRESH_DIRS); ++ if (inode) ++ err = hin_gen_tree(dentry); ++ } ++ ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* hinotify job flags */ ++#define AuHinJob_XINO0 1 ++#define AuHinJob_GEN (1 << 1) ++#define AuHinJob_DIRENT (1 << 2) ++#define AuHinJob_ISDIR (1 << 3) ++#define AuHinJob_TRYXINO0 (1 << 4) ++#define AuHinJob_MNTPNT (1 << 5) ++#define au_ftest_hinjob(flags, name) ((flags) & AuHinJob_##name) ++#define au_fset_hinjob(flags, name) { (flags) |= AuHinJob_##name; } ++#define au_fclr_hinjob(flags, name) { (flags) &= ~AuHinJob_##name; } ++ ++struct hin_job_args { ++ unsigned int flags; ++ struct inode *inode, *h_inode, *dir, *h_dir; ++ struct dentry *dentry; ++ char *h_name; ++ int h_nlen; ++}; ++ ++static int hin_job(struct hin_job_args *a) ++{ ++ const unsigned int isdir = au_ftest_hinjob(a->flags, ISDIR); ++ ++ /* reset xino */ ++ if (au_ftest_hinjob(a->flags, XINO0) && a->inode) ++ hin_xino(a->inode, a->h_inode); /* ignore this error */ ++ ++ if (au_ftest_hinjob(a->flags, TRYXINO0) ++ && a->inode ++ && a->h_inode) { ++ mutex_lock_nested(&a->h_inode->i_mutex, AuLsc_I_CHILD); ++ if (!a->h_inode->i_nlink) ++ hin_xino(a->inode, a->h_inode); /* ignore this error */ ++ mutex_unlock(&a->h_inode->i_mutex); ++ } ++ ++ /* make the generation obsolete */ ++ if (au_ftest_hinjob(a->flags, GEN)) { ++ int err = -1; ++ if (a->inode) ++ err = hin_gen_by_inode(a->h_name, a->h_nlen, a->inode, ++ isdir); ++ if (err && a->dentry) ++ hin_gen_by_name(a->dentry, isdir); ++ /* ignore this error */ ++ } ++ ++ /* make dir entries obsolete */ ++ if (au_ftest_hinjob(a->flags, DIRENT) && a->inode) { ++ struct au_vdir *vdir; ++ ++ vdir = au_ivdir(a->inode); ++ if (vdir) ++ vdir->vd_jiffy = 0; ++ /* IMustLock(a->inode); */ ++ /* a->inode->i_version++; */ ++ } ++ ++ /* can do nothing but warn */ ++ if (au_ftest_hinjob(a->flags, MNTPNT) ++ && a->dentry ++ && d_mountpoint(a->dentry)) ++ AuWarn("mount-point %.*s is removed or renamed\n", ++ AuDLNPair(a->dentry)); ++ ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static char *in_name(u32 mask) ++{ ++#ifdef CONFIG_AUFS_DEBUG ++#define test_ret(flag) if (mask & flag) \ ++ return #flag; ++ test_ret(IN_ACCESS); ++ test_ret(IN_MODIFY); ++ test_ret(IN_ATTRIB); ++ test_ret(IN_CLOSE_WRITE); ++ test_ret(IN_CLOSE_NOWRITE); ++ test_ret(IN_OPEN); ++ test_ret(IN_MOVED_FROM); ++ test_ret(IN_MOVED_TO); ++ test_ret(IN_CREATE); ++ test_ret(IN_DELETE); ++ test_ret(IN_DELETE_SELF); ++ test_ret(IN_MOVE_SELF); ++ test_ret(IN_UNMOUNT); ++ test_ret(IN_Q_OVERFLOW); ++ test_ret(IN_IGNORED); ++ return ""; ++#undef test_ret ++#else ++ return "??"; ++#endif ++} ++ ++static struct dentry *lookup_wlock_by_name(char *name, unsigned int nlen, ++ struct inode *dir) ++{ ++ struct dentry *dentry, *d, *parent; ++ struct qstr *dname; ++ ++ parent = d_find_alias(dir); ++ if (!parent) ++ return NULL; ++ ++ dentry = NULL; ++ spin_lock(&dcache_lock); ++ list_for_each_entry(d, &parent->d_subdirs, d_u.d_child) { ++ /* AuDbg("%.*s\n", AuDLNPair(d)); */ ++ dname = &d->d_name; ++ if (dname->len != nlen || memcmp(dname->name, name, nlen)) ++ continue; ++ if (!atomic_read(&d->d_count) || !d->d_fsdata) { ++ spin_lock(&d->d_lock); ++ __d_drop(d); ++ spin_unlock(&d->d_lock); ++ continue; ++ } ++ ++ dentry = dget(d); ++ break; ++ } ++ spin_unlock(&dcache_lock); ++ dput(parent); ++ ++ if (dentry) ++ di_write_lock_child(dentry); ++ ++ return dentry; ++} ++ ++static struct inode *lookup_wlock_by_ino(struct super_block *sb, ++ aufs_bindex_t bindex, ino_t h_ino) ++{ ++ struct inode *inode; ++ ino_t ino; ++ int err; ++ ++ inode = NULL; ++ err = au_xino_read(sb, bindex, h_ino, &ino); ++ if (!err && ino) ++ inode = ilookup(sb, ino); ++ if (!inode) ++ goto out; ++ ++ if (unlikely(inode->i_ino == AUFS_ROOT_INO)) { ++ AuWarn("wrong root branch\n"); ++ iput(inode); ++ inode = NULL; ++ goto out; ++ } ++ ++ ii_write_lock_child(inode); ++ ++ out: ++ return inode; ++} ++ ++enum { CHILD, PARENT }; ++struct postproc_args { ++ struct inode *h_dir, *dir, *h_child_inode; ++ u32 mask; ++ unsigned int flags[2]; ++ unsigned int h_child_nlen; ++ char h_child_name[]; ++}; ++ ++static void postproc(void *_args) ++{ ++ struct postproc_args *a = _args; ++ struct super_block *sb; ++ aufs_bindex_t bindex, bend, bfound; ++ unsigned char xino, try_iput; ++ int err; ++ struct inode *inode; ++ ino_t h_ino; ++ struct hin_job_args args; ++ struct dentry *dentry; ++ struct au_sbinfo *sbinfo; ++ ++ AuDebugOn(!_args); ++ AuDebugOn(!a->h_dir); ++ AuDebugOn(!a->dir); ++ AuDebugOn(!a->mask); ++ AuDbg("mask 0x%x %s, i%lu, hi%lu, hci%lu\n", ++ a->mask, in_name(a->mask), a->dir->i_ino, a->h_dir->i_ino, ++ a->h_child_inode ? a->h_child_inode->i_ino : 0); ++ ++ inode = NULL; ++ dentry = NULL; ++ /* ++ * do not lock a->dir->i_mutex here ++ * because of d_revalidate() may cause a deadlock. ++ */ ++ sb = a->dir->i_sb; ++ AuDebugOn(!sb); ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!sbinfo); ++ /* big aufs lock */ ++ si_noflush_write_lock(sb); ++ ++ ii_read_lock_parent(a->dir); ++ bfound = -1; ++ bend = au_ibend(a->dir); ++ for (bindex = au_ibstart(a->dir); bindex <= bend; bindex++) ++ if (au_h_iptr(a->dir, bindex) == a->h_dir) { ++ bfound = bindex; ++ break; ++ } ++ ii_read_unlock(a->dir); ++ if (unlikely(bfound < 0)) ++ goto out; ++ ++ xino = !!au_opt_test(au_mntflags(sb), XINO); ++ h_ino = 0; ++ if (a->h_child_inode) ++ h_ino = a->h_child_inode->i_ino; ++ ++ if (a->h_child_nlen ++ && (au_ftest_hinjob(a->flags[CHILD], GEN) ++ || au_ftest_hinjob(a->flags[CHILD], MNTPNT))) ++ dentry = lookup_wlock_by_name(a->h_child_name, a->h_child_nlen, ++ a->dir); ++ try_iput = 0; ++ if (dentry) ++ inode = dentry->d_inode; ++ if (xino && !inode && h_ino ++ && (au_ftest_hinjob(a->flags[CHILD], XINO0) ++ || au_ftest_hinjob(a->flags[CHILD], TRYXINO0) ++ || au_ftest_hinjob(a->flags[CHILD], GEN))) { ++ inode = lookup_wlock_by_ino(sb, bfound, h_ino); ++ try_iput = 1; ++ } ++ ++ args.flags = a->flags[CHILD]; ++ args.dentry = dentry; ++ args.inode = inode; ++ args.h_inode = a->h_child_inode; ++ args.dir = a->dir; ++ args.h_dir = a->h_dir; ++ args.h_name = a->h_child_name; ++ args.h_nlen = a->h_child_nlen; ++ err = hin_job(&args); ++ if (dentry) { ++ if (dentry->d_fsdata) ++ di_write_unlock(dentry); ++ dput(dentry); ++ } ++ if (inode && try_iput) { ++ ii_write_unlock(inode); ++ iput(inode); ++ } ++ ++ ii_write_lock_parent(a->dir); ++ args.flags = a->flags[PARENT]; ++ args.dentry = NULL; ++ args.inode = a->dir; ++ args.h_inode = a->h_dir; ++ args.dir = NULL; ++ args.h_dir = NULL; ++ args.h_name = NULL; ++ args.h_nlen = 0; ++ err = hin_job(&args); ++ ii_write_unlock(a->dir); ++ ++ out: ++ au_nwt_done(&sbinfo->si_nowait); ++ si_write_unlock(sb); ++ ++ iput(a->h_child_inode); ++ iput(a->h_dir); ++ iput(a->dir); ++ kfree(a); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void aufs_inotify(struct inotify_watch *watch, u32 wd __maybe_unused, ++ u32 mask, u32 cookie __maybe_unused, ++ const char *h_child_name, struct inode *h_child_inode) ++{ ++ struct au_hinotify *hinotify; ++ struct postproc_args *args; ++ int len, wkq_err; ++ unsigned char isdir, isroot, wh; ++ char *p; ++ struct inode *dir; ++ unsigned int flags[2]; ++ ++ /* if IN_UNMOUNT happens, there must be another bug */ ++ AuDebugOn(mask & IN_UNMOUNT); ++ if (mask & (IN_IGNORED | IN_UNMOUNT)) { ++ put_inotify_watch(watch); ++ return; ++ } ++#ifdef AuDbgHinotify ++ au_debug(1); ++ if (1 || !h_child_name || strcmp(h_child_name, AUFS_XINO_FNAME)) { ++ AuDbg("i%lu, wd %d, mask 0x%x %s, cookie 0x%x, hcname %s," ++ " hi%lu\n", ++ watch->inode->i_ino, wd, mask, in_name(mask), cookie, ++ h_child_name ? h_child_name : "", ++ h_child_inode ? h_child_inode->i_ino : 0); ++ WARN_ON(1); ++ } ++ au_debug(0); ++#endif ++ ++ hinotify = container_of(watch, struct au_hinotify, hin_watch); ++ AuDebugOn(!hinotify || !hinotify->hin_aufs_inode); ++ dir = igrab(hinotify->hin_aufs_inode); ++ if (!dir) ++ return; ++ ++ isroot = (dir->i_ino == AUFS_ROOT_INO); ++ len = 0; ++ wh = 0; ++ if (h_child_name) { ++ len = strlen(h_child_name); ++ if (!memcmp(h_child_name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ h_child_name += AUFS_WH_PFX_LEN; ++ len -= AUFS_WH_PFX_LEN; ++ wh = 1; ++ } ++ } ++ ++ isdir = 0; ++ if (h_child_inode) ++ isdir = !!S_ISDIR(h_child_inode->i_mode); ++ flags[PARENT] = AuHinJob_ISDIR; ++ flags[CHILD] = 0; ++ if (isdir) ++ flags[CHILD] = AuHinJob_ISDIR; ++ switch (mask & IN_ALL_EVENTS) { ++ case IN_MOVED_FROM: ++ case IN_MOVED_TO: ++ AuDebugOn(!h_child_name || !h_child_inode); ++ au_fset_hinjob(flags[CHILD], GEN); ++ au_fset_hinjob(flags[CHILD], XINO0); ++ au_fset_hinjob(flags[CHILD], MNTPNT); ++ au_fset_hinjob(flags[PARENT], DIRENT); ++ break; ++ ++ case IN_CREATE: ++ AuDebugOn(!h_child_name || !h_child_inode); ++ au_fset_hinjob(flags[PARENT], DIRENT); ++ au_fset_hinjob(flags[CHILD], GEN); ++ break; ++ ++ case IN_DELETE: ++ /* ++ * aufs never be able to get this child inode. ++ * revalidation should be in d_revalidate() ++ * by checking i_nlink, i_generation or d_unhashed(). ++ */ ++ AuDebugOn(!h_child_name); ++ au_fset_hinjob(flags[PARENT], DIRENT); ++ au_fset_hinjob(flags[CHILD], GEN); ++ au_fset_hinjob(flags[CHILD], TRYXINO0); ++ au_fset_hinjob(flags[CHILD], MNTPNT); ++ break; ++ ++ default: ++ AuDebugOn(1); ++ } ++ ++ if (wh) ++ h_child_inode = NULL; ++ ++ /* iput() and kfree() will be called in postproc() */ ++ /* ++ * inotify_mutex is already acquired and kmalloc/prune_icache may lock ++ * iprune_mutex. strange. ++ */ ++ lockdep_off(); ++ args = kmalloc(sizeof(*args) + len + 1, GFP_NOFS); ++ lockdep_on(); ++ if (unlikely(!args)) { ++ AuErr1("no memory\n"); ++ iput(dir); ++ return; ++ } ++ args->flags[PARENT] = flags[PARENT]; ++ args->flags[CHILD] = flags[CHILD]; ++ args->mask = mask; ++ args->dir = dir; ++ args->h_dir = igrab(watch->inode); ++ if (h_child_inode) ++ h_child_inode = igrab(h_child_inode); /* can be NULL */ ++ args->h_child_inode = h_child_inode; ++ args->h_child_nlen = len; ++ if (len) { ++ p = (void *)args; ++ p += sizeof(*args); ++ memcpy(p, h_child_name, len + 1); ++ } ++ ++ lockdep_off(); ++ wkq_err = au_wkq_nowait(postproc, args, dir->i_sb); ++ lockdep_on(); ++ if (unlikely(wkq_err)) ++ AuErr("wkq %d\n", wkq_err); ++} ++ ++static void aufs_inotify_destroy(struct inotify_watch *watch __maybe_unused) ++{ ++ return; ++} ++ ++static struct inotify_operations aufs_inotify_ops = { ++ .handle_event = aufs_inotify, ++ .destroy_watch = aufs_inotify_destroy ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_hin_destroy_cache(void) ++{ ++ kmem_cache_destroy(au_cachep[AuCache_HINOTIFY]); ++ au_cachep[AuCache_HINOTIFY] = NULL; ++} ++ ++int __init au_hinotify_init(void) ++{ ++ int err; ++ ++ err = -ENOMEM; ++ au_cachep[AuCache_HINOTIFY] = AuCache(au_hinotify); ++ if (au_cachep[AuCache_HINOTIFY]) { ++ err = 0; ++ au_hin_handle = inotify_init(&aufs_inotify_ops); ++ if (IS_ERR(au_hin_handle)) { ++ err = PTR_ERR(au_hin_handle); ++ au_hin_destroy_cache(); ++ } ++ } ++ AuTraceErr(err); ++ return err; ++} ++ ++void au_hinotify_fin(void) ++{ ++ inotify_destroy(au_hin_handle); ++ if (au_cachep[AuCache_HINOTIFY]) ++ au_hin_destroy_cache(); ++} +diff -Naur a/fs/aufs/iinfo.c b/fs/aufs/iinfo.c +--- a/fs/aufs/iinfo.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/iinfo.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,271 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode private data ++ */ ++ ++#include "aufs.h" ++ ++struct inode *au_h_iptr(struct inode *inode, aufs_bindex_t bindex) ++{ ++ struct inode *h_inode; ++ ++ h_inode = au_ii(inode)->ii_hinode[0 + bindex].hi_inode; ++ AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0); ++ return h_inode; ++} ++ ++/* todo: hard/soft set? */ ++void au_set_ibstart(struct inode *inode, aufs_bindex_t bindex) ++{ ++ struct au_iinfo *iinfo = au_ii(inode); ++ struct inode *h_inode; ++ ++ iinfo->ii_bstart = bindex; ++ h_inode = iinfo->ii_hinode[bindex + 0].hi_inode; ++ if (h_inode) ++ au_cpup_igen(inode, h_inode); ++} ++ ++void au_hiput(struct au_hinode *hinode) ++{ ++ au_hin_free(hinode); ++ dput(hinode->hi_whdentry); ++ iput(hinode->hi_inode); ++} ++ ++unsigned int au_hi_flags(struct inode *inode, int isdir) ++{ ++ unsigned int flags; ++ const unsigned int mnt_flags = au_mntflags(inode->i_sb); ++ ++ flags = 0; ++ if (au_opt_test(mnt_flags, XINO)) ++ au_fset_hi(flags, XINO); ++ if (isdir && au_opt_test(mnt_flags, UDBA_HINOTIFY)) ++ au_fset_hi(flags, HINOTIFY); ++ return flags; ++} ++ ++void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode, unsigned int flags) ++{ ++ struct au_hinode *hinode; ++ struct inode *hi; ++ struct au_iinfo *iinfo = au_ii(inode); ++ ++ hinode = iinfo->ii_hinode + bindex; ++ hi = hinode->hi_inode; ++ AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0); ++ AuDebugOn(h_inode && hi); ++ ++ if (hi) ++ au_hiput(hinode); ++ hinode->hi_inode = h_inode; ++ if (h_inode) { ++ int err; ++ struct super_block *sb = inode->i_sb; ++ struct au_branch *br; ++ ++ if (bindex == iinfo->ii_bstart) ++ au_cpup_igen(inode, h_inode); ++ br = au_sbr(sb, bindex); ++ hinode->hi_id = br->br_id; ++ if (au_ftest_hi(flags, XINO)) { ++ err = au_xino_write(sb, bindex, h_inode->i_ino, ++ inode->i_ino); ++ if (unlikely(err)) ++ AuIOErr1("failed au_xino_write() %d\n", err); ++ } ++ ++ if (au_ftest_hi(flags, HINOTIFY) ++ && au_br_hinotifyable(br->br_perm)) { ++ err = au_hin_alloc(hinode, inode, h_inode); ++ if (unlikely(err)) ++ AuIOErr1("au_hin_alloc() %d\n", err); ++ } ++ } ++} ++ ++void au_set_hi_wh(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_wh) ++{ ++ struct au_hinode *hinode; ++ ++ hinode = au_ii(inode)->ii_hinode + bindex; ++ AuDebugOn(hinode->hi_whdentry); ++ hinode->hi_whdentry = h_wh; ++} ++ ++void au_update_iigen(struct inode *inode) ++{ ++ atomic_set(&au_ii(inode)->ii_generation, au_sigen(inode->i_sb)); ++ /* smp_mb(); */ /* atomic_set */ ++} ++ ++/* it may be called at remount time, too */ ++void au_update_brange(struct inode *inode, int do_put_zero) ++{ ++ struct au_iinfo *iinfo; ++ ++ iinfo = au_ii(inode); ++ if (!iinfo || iinfo->ii_bstart < 0) ++ return; ++ ++ if (do_put_zero) { ++ aufs_bindex_t bindex; ++ ++ for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend; ++ bindex++) { ++ struct inode *h_i; ++ ++ h_i = iinfo->ii_hinode[0 + bindex].hi_inode; ++ if (h_i && !h_i->i_nlink) ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ } ++ } ++ ++ iinfo->ii_bstart = -1; ++ while (++iinfo->ii_bstart <= iinfo->ii_bend) ++ if (iinfo->ii_hinode[0 + iinfo->ii_bstart].hi_inode) ++ break; ++ if (iinfo->ii_bstart > iinfo->ii_bend) { ++ iinfo->ii_bstart = -1; ++ iinfo->ii_bend = -1; ++ return; ++ } ++ ++ iinfo->ii_bend++; ++ while (0 <= --iinfo->ii_bend) ++ if (iinfo->ii_hinode[0 + iinfo->ii_bend].hi_inode) ++ break; ++ AuDebugOn(iinfo->ii_bstart > iinfo->ii_bend || iinfo->ii_bend < 0); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_iinfo_init(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ struct super_block *sb; ++ int nbr, i; ++ ++ sb = inode->i_sb; ++ iinfo = &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo); ++ nbr = au_sbend(sb) + 1; ++ if (unlikely(nbr <= 0)) ++ nbr = 1; ++ iinfo->ii_hinode = kcalloc(nbr, sizeof(*iinfo->ii_hinode), GFP_NOFS); ++ if (iinfo->ii_hinode) { ++ for (i = 0; i < nbr; i++) ++ iinfo->ii_hinode[i].hi_id = -1; ++ ++ atomic_set(&iinfo->ii_generation, au_sigen(sb)); ++ /* smp_mb(); */ /* atomic_set */ ++ init_rwsem(&iinfo->ii_rwsem); ++ iinfo->ii_bstart = -1; ++ iinfo->ii_bend = -1; ++ iinfo->ii_vdir = NULL; ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++int au_ii_realloc(struct au_iinfo *iinfo, int nbr) ++{ ++ int err, sz; ++ struct au_hinode *hip; ++ ++ err = -ENOMEM; ++ sz = sizeof(*hip) * (iinfo->ii_bend + 1); ++ if (!sz) ++ sz = sizeof(*hip); ++ hip = au_kzrealloc(iinfo->ii_hinode, sz, sizeof(*hip) * nbr, GFP_NOFS); ++ if (hip) { ++ iinfo->ii_hinode = hip; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++static int au_iinfo_write0(struct super_block *sb, struct au_hinode *hinode, ++ ino_t ino) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ unsigned char locked; ++ ++ err = 0; ++ locked = !!si_noflush_read_trylock(sb); ++ bindex = au_br_index(sb, hinode->hi_id); ++ if (bindex >= 0) ++ err = au_xino_write0(sb, bindex, hinode->hi_inode->i_ino, ino); ++ /* error action? */ ++ if (locked) ++ si_read_unlock(sb); ++ return err; ++} ++ ++void au_iinfo_fin(struct inode *inode) ++{ ++ ino_t ino; ++ aufs_bindex_t bend; ++ unsigned char unlinked = !inode->i_nlink; ++ struct au_iinfo *iinfo; ++ struct au_hinode *hi; ++ struct super_block *sb; ++ ++ if (unlinked) { ++ int err = au_xigen_inc(inode); ++ if (unlikely(err)) ++ AuWarn1("failed resetting i_generation, %d\n", err); ++ } ++ ++ iinfo = au_ii(inode); ++ /* bad_inode case */ ++ if (!iinfo) ++ return; ++ ++ if (iinfo->ii_vdir) ++ au_vdir_free(iinfo->ii_vdir); ++ ++ if (iinfo->ii_bstart >= 0) { ++ sb = inode->i_sb; ++ ino = 0; ++ if (unlinked) ++ ino = inode->i_ino; ++ hi = iinfo->ii_hinode + iinfo->ii_bstart; ++ bend = iinfo->ii_bend; ++ while (iinfo->ii_bstart++ <= bend) { ++ if (hi->hi_inode) { ++ if (unlinked || !hi->hi_inode->i_nlink) { ++ au_iinfo_write0(sb, hi, ino); ++ /* ignore this error */ ++ ino = 0; ++ } ++ au_hiput(hi); ++ } ++ hi++; ++ } ++ } ++ ++ kfree(iinfo->ii_hinode); ++ au_rwsem_destroy(&iinfo->ii_rwsem); ++} +diff -Naur a/fs/aufs/inode.c b/fs/aufs/inode.c +--- a/fs/aufs/inode.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/inode.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,376 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode functions ++ */ ++ ++#include "aufs.h" ++ ++struct inode *au_igrab(struct inode *inode) ++{ ++ if (inode) { ++ AuDebugOn(!atomic_read(&inode->i_count)); ++ atomic_inc(&inode->i_count); ++ } ++ return inode; ++} ++ ++static void au_refresh_hinode_attr(struct inode *inode, int do_version) ++{ ++ au_cpup_attr_all(inode, /*force*/0); ++ au_update_iigen(inode); ++ if (do_version) ++ inode->i_version++; ++} ++ ++int au_refresh_hinode_self(struct inode *inode, int do_attr) ++{ ++ int err; ++ aufs_bindex_t bindex, new_bindex; ++ unsigned char update; ++ struct inode *first; ++ struct au_hinode *p, *q, tmp; ++ struct super_block *sb; ++ struct au_iinfo *iinfo; ++ ++ update = 0; ++ sb = inode->i_sb; ++ iinfo = au_ii(inode); ++ err = au_ii_realloc(iinfo, au_sbend(sb) + 1); ++ if (unlikely(err)) ++ goto out; ++ ++ p = iinfo->ii_hinode + iinfo->ii_bstart; ++ first = p->hi_inode; ++ err = 0; ++ for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend; ++ bindex++, p++) { ++ if (!p->hi_inode) ++ continue; ++ ++ new_bindex = au_br_index(sb, p->hi_id); ++ if (new_bindex == bindex) ++ continue; ++ ++ if (new_bindex < 0) { ++ update++; ++ au_hiput(p); ++ p->hi_inode = NULL; ++ continue; ++ } ++ ++ if (new_bindex < iinfo->ii_bstart) ++ iinfo->ii_bstart = new_bindex; ++ if (iinfo->ii_bend < new_bindex) ++ iinfo->ii_bend = new_bindex; ++ /* swap two lower inode, and loop again */ ++ q = iinfo->ii_hinode + new_bindex; ++ tmp = *q; ++ *q = *p; ++ *p = tmp; ++ if (tmp.hi_inode) { ++ bindex--; ++ p--; ++ } ++ } ++ au_update_brange(inode, /*do_put_zero*/0); ++ if (do_attr) ++ au_refresh_hinode_attr(inode, update && S_ISDIR(inode->i_mode)); ++ ++ out: ++ return err; ++} ++ ++int au_refresh_hinode(struct inode *inode, struct dentry *dentry) ++{ ++ int err, update; ++ unsigned int flags; ++ aufs_bindex_t bindex, bend; ++ unsigned char isdir; ++ struct inode *first; ++ struct au_hinode *p; ++ struct au_iinfo *iinfo; ++ ++ err = au_refresh_hinode_self(inode, /*do_attr*/0); ++ if (unlikely(err)) ++ goto out; ++ ++ update = 0; ++ iinfo = au_ii(inode); ++ p = iinfo->ii_hinode + iinfo->ii_bstart; ++ first = p->hi_inode; ++ isdir = S_ISDIR(inode->i_mode); ++ flags = au_hi_flags(inode, isdir); ++ bend = au_dbend(dentry); ++ for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) { ++ struct inode *h_i; ++ struct dentry *h_d; ++ ++ h_d = au_h_dptr(dentry, bindex); ++ if (!h_d || !h_d->d_inode) ++ continue; ++ ++ if (iinfo->ii_bstart <= bindex && bindex <= iinfo->ii_bend) { ++ h_i = au_h_iptr(inode, bindex); ++ if (h_i) { ++ if (h_i == h_d->d_inode) ++ continue; ++ err = -EIO; ++ break; ++ } ++ } ++ if (bindex < iinfo->ii_bstart) ++ iinfo->ii_bstart = bindex; ++ if (iinfo->ii_bend < bindex) ++ iinfo->ii_bend = bindex; ++ au_set_h_iptr(inode, bindex, au_igrab(h_d->d_inode), flags); ++ update = 1; ++ } ++ au_update_brange(inode, /*do_put_zero*/0); ++ ++ if (unlikely(err)) ++ goto out; ++ ++ au_refresh_hinode_attr(inode, update && isdir); ++ ++ out: ++ return err; ++} ++ ++static int set_inode(struct inode *inode, struct dentry *dentry) ++{ ++ int err; ++ unsigned int flags; ++ umode_t mode; ++ aufs_bindex_t bindex, bstart, btail; ++ unsigned char isdir; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ struct au_iinfo *iinfo; ++ ++ err = 0; ++ isdir = 0; ++ bstart = au_dbstart(dentry); ++ h_inode = au_h_dptr(dentry, bstart)->d_inode; ++ mode = h_inode->i_mode; ++ switch (mode & S_IFMT) { ++ case S_IFREG: ++ btail = au_dbtail(dentry); ++ inode->i_op = &aufs_iop; ++ inode->i_fop = &aufs_file_fop; ++ inode->i_mapping->a_ops = &aufs_aop; ++ break; ++ case S_IFDIR: ++ isdir = 1; ++ btail = au_dbtaildir(dentry); ++ inode->i_op = &aufs_dir_iop; ++ inode->i_fop = &aufs_dir_fop; ++ break; ++ case S_IFLNK: ++ btail = au_dbtail(dentry); ++ inode->i_op = &aufs_symlink_iop; ++ break; ++ case S_IFBLK: ++ case S_IFCHR: ++ case S_IFIFO: ++ case S_IFSOCK: ++ btail = au_dbtail(dentry); ++ inode->i_op = &aufs_iop; ++ init_special_inode(inode, mode, h_inode->i_rdev); ++ break; ++ default: ++ AuIOErr("Unknown file type 0%o\n", mode); ++ err = -EIO; ++ goto out; ++ } ++ ++ /* do not set inotify for whiteouted dirs (SHWH mode) */ ++ flags = au_hi_flags(inode, isdir); ++ if (au_opt_test(au_mntflags(dentry->d_sb), SHWH) ++ && au_ftest_hi(flags, HINOTIFY) ++ && dentry->d_name.len > AUFS_WH_PFX_LEN ++ && !memcmp(dentry->d_name.name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) ++ au_fclr_hi(flags, HINOTIFY); ++ iinfo = au_ii(inode); ++ iinfo->ii_bstart = bstart; ++ iinfo->ii_bend = btail; ++ for (bindex = bstart; bindex <= btail; bindex++) { ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (h_dentry) ++ au_set_h_iptr(inode, bindex, ++ au_igrab(h_dentry->d_inode), flags); ++ } ++ au_cpup_attr_all(inode, /*force*/1); ++ ++ out: ++ return err; ++} ++ ++/* successful returns with iinfo write_locked */ ++static int reval_inode(struct inode *inode, struct dentry *dentry, int *matched) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ struct inode *h_inode, *h_dinode; ++ ++ *matched = 0; ++ ++ /* ++ * before this function, if aufs got any iinfo lock, it must be only ++ * one, the parent dir. ++ * it can happen by UDBA and the obsoleted inode number. ++ */ ++ err = -EIO; ++ if (unlikely(inode->i_ino == parent_ino(dentry))) ++ goto out; ++ ++ err = 0; ++ ii_write_lock_new_child(inode); ++ h_dinode = au_h_dptr(dentry, au_dbstart(dentry))->d_inode; ++ bend = au_ibend(inode); ++ for (bindex = au_ibstart(inode); bindex <= bend; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (h_inode && h_inode == h_dinode) { ++ *matched = 1; ++ err = 0; ++ if (au_iigen(inode) != au_digen(dentry)) ++ err = au_refresh_hinode(inode, dentry); ++ break; ++ } ++ } ++ ++ if (unlikely(err)) ++ ii_write_unlock(inode); ++ out: ++ return err; ++} ++ ++/* successful returns with iinfo write_locked */ ++/* todo: return with unlocked? */ ++struct inode *au_new_inode(struct dentry *dentry, int must_new) ++{ ++ struct inode *inode; ++ struct dentry *h_dentry; ++ struct super_block *sb; ++ ino_t h_ino, ino; ++ int err, match; ++ aufs_bindex_t bstart; ++ ++ sb = dentry->d_sb; ++ bstart = au_dbstart(dentry); ++ h_dentry = au_h_dptr(dentry, bstart); ++ h_ino = h_dentry->d_inode->i_ino; ++ err = au_xino_read(sb, bstart, h_ino, &ino); ++ inode = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ new_ino: ++ if (!ino) { ++ ino = au_xino_new_ino(sb); ++ if (unlikely(!ino)) { ++ inode = ERR_PTR(-EIO); ++ goto out; ++ } ++ } ++ ++ AuDbg("i%lu\n", (unsigned long)ino); ++ inode = au_iget_locked(sb, ino); ++ err = PTR_ERR(inode); ++ if (IS_ERR(inode)) ++ goto out; ++ ++ AuDbg("%lx, new %d\n", inode->i_state, !!(inode->i_state & I_NEW)); ++ if (inode->i_state & I_NEW) { ++ ii_write_lock_new_child(inode); ++ err = set_inode(inode, dentry); ++ unlock_new_inode(inode); ++ if (!err) ++ goto out; /* success */ ++ ++ iget_failed(inode); ++ ii_write_unlock(inode); ++ goto out_iput; ++ } else if (!must_new) { ++ err = reval_inode(inode, dentry, &match); ++ if (!err) ++ goto out; /* success */ ++ else if (match) ++ goto out_iput; ++ } ++ ++ if (unlikely(au_test_fs_unique_ino(h_dentry->d_inode))) ++ AuWarn1("Un-notified UDBA or repeatedly renamed dir," ++ " b%d, %s, %.*s, hi%lu, i%lu.\n", ++ bstart, au_sbtype(h_dentry->d_sb), AuDLNPair(dentry), ++ (unsigned long)h_ino, (unsigned long)ino); ++ ino = 0; ++ err = au_xino_write0(sb, bstart, h_ino, 0); ++ if (!err) { ++ iput(inode); ++ goto new_ino; ++ } ++ ++ out_iput: ++ iput(inode); ++ inode = ERR_PTR(err); ++ out: ++ return inode; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_test_ro(struct super_block *sb, aufs_bindex_t bindex, ++ struct inode *inode) ++{ ++ int err; ++ ++ err = au_br_rdonly(au_sbr(sb, bindex)); ++ ++ /* pseudo-link after flushed may happen out of bounds */ ++ if (!err ++ && inode ++ && au_ibstart(inode) <= bindex ++ && bindex <= au_ibend(inode)) { ++ /* ++ * permission check is unnecessary since vfsub routine ++ * will be called later ++ */ ++ struct inode *hi = au_h_iptr(inode, bindex); ++ if (hi) ++ err = IS_IMMUTABLE(hi) ? -EROFS : 0; ++ } ++ ++ return err; ++} ++ ++int au_test_h_perm(struct inode *h_inode, int mask) ++{ ++ if (!current_fsuid()) ++ return 0; ++ return inode_permission(h_inode, mask); ++} ++ ++int au_test_h_perm_sio(struct inode *h_inode, int mask) ++{ ++ if (au_test_nfs(h_inode->i_sb) ++ && (mask & MAY_WRITE) ++ && S_ISDIR(h_inode->i_mode)) ++ mask |= MAY_READ; /* force permission check */ ++ return au_test_h_perm(h_inode, mask); ++} +diff -Naur a/fs/aufs/inode.h b/fs/aufs/inode.h +--- a/fs/aufs/inode.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/inode.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,473 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode operations ++ */ ++ ++#ifndef __AUFS_INODE_H__ ++#define __AUFS_INODE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/inotify.h> ++#include <linux/aufs_type.h> ++#include "rwsem.h" ++ ++struct vfsmount; ++ ++struct au_hinotify { ++#ifdef CONFIG_AUFS_HINOTIFY ++ struct inotify_watch hin_watch; ++ struct inode *hin_aufs_inode; /* no get/put */ ++#endif ++}; ++ ++struct au_hinode { ++ struct inode *hi_inode; ++ aufs_bindex_t hi_id; ++#ifdef CONFIG_AUFS_HINOTIFY ++ struct au_hinotify *hi_notify; ++#endif ++ ++ /* reference to the copied-up whiteout with get/put */ ++ struct dentry *hi_whdentry; ++}; ++ ++struct au_vdir; ++struct au_iinfo { ++ atomic_t ii_generation; ++ struct super_block *ii_hsb1; /* no get/put */ ++ ++ struct rw_semaphore ii_rwsem; ++ aufs_bindex_t ii_bstart, ii_bend; ++ __u32 ii_higen; ++ struct au_hinode *ii_hinode; ++ struct au_vdir *ii_vdir; ++}; ++ ++struct au_icntnr { ++ struct au_iinfo iinfo; ++ struct inode vfs_inode; ++}; ++ ++/* au_pin flags */ ++#define AuPin_DI_LOCKED 1 ++#define AuPin_MNT_WRITE (1 << 1) ++#define au_ftest_pin(flags, name) ((flags) & AuPin_##name) ++#define au_fset_pin(flags, name) { (flags) |= AuPin_##name; } ++#define au_fclr_pin(flags, name) { (flags) &= ~AuPin_##name; } ++ ++struct au_pin { ++ /* input */ ++ struct dentry *dentry; ++ unsigned int udba; ++ unsigned char lsc_di, lsc_hi, flags; ++ aufs_bindex_t bindex; ++ ++ /* output */ ++ struct dentry *parent; ++ struct au_hinode *hdir; ++ struct vfsmount *h_mnt; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_iinfo *au_ii(struct inode *inode) ++{ ++ struct au_iinfo *iinfo; ++ ++ iinfo = &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo); ++ if (iinfo->ii_hinode) ++ return iinfo; ++ return NULL; /* debugging bad_inode case */ ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* inode.c */ ++struct inode *au_igrab(struct inode *inode); ++int au_refresh_hinode_self(struct inode *inode, int do_attr); ++int au_refresh_hinode(struct inode *inode, struct dentry *dentry); ++struct inode *au_new_inode(struct dentry *dentry, int must_new); ++int au_test_ro(struct super_block *sb, aufs_bindex_t bindex, ++ struct inode *inode); ++int au_test_h_perm(struct inode *h_inode, int mask); ++int au_test_h_perm_sio(struct inode *h_inode, int mask); ++ ++/* i_op.c */ ++extern struct inode_operations aufs_iop, aufs_symlink_iop, aufs_dir_iop; ++ ++/* au_wr_dir flags */ ++#define AuWrDir_ADD_ENTRY 1 ++#define AuWrDir_ISDIR (1 << 1) ++#define au_ftest_wrdir(flags, name) ((flags) & AuWrDir_##name) ++#define au_fset_wrdir(flags, name) { (flags) |= AuWrDir_##name; } ++#define au_fclr_wrdir(flags, name) { (flags) &= ~AuWrDir_##name; } ++ ++struct au_wr_dir_args { ++ aufs_bindex_t force_btgt; ++ unsigned char flags; ++}; ++int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry, ++ struct au_wr_dir_args *args); ++ ++struct dentry *au_pinned_h_parent(struct au_pin *pin); ++void au_pin_init(struct au_pin *pin, struct dentry *dentry, ++ aufs_bindex_t bindex, int lsc_di, int lsc_hi, ++ unsigned int udba, unsigned char flags); ++int au_pin(struct au_pin *pin, struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int udba, unsigned char flags) __must_check; ++int au_do_pin(struct au_pin *pin) __must_check; ++void au_unpin(struct au_pin *pin); ++ ++/* i_op_add.c */ ++int au_may_add(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir); ++int aufs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev); ++int aufs_symlink(struct inode *dir, struct dentry *dentry, const char *symname); ++int aufs_create(struct inode *dir, struct dentry *dentry, int mode, ++ struct nameidata *nd); ++int aufs_link(struct dentry *src_dentry, struct inode *dir, ++ struct dentry *dentry); ++int aufs_mkdir(struct inode *dir, struct dentry *dentry, int mode); ++ ++/* i_op_del.c */ ++int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup); ++int au_may_del(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir); ++int aufs_unlink(struct inode *dir, struct dentry *dentry); ++int aufs_rmdir(struct inode *dir, struct dentry *dentry); ++ ++/* i_op_ren.c */ ++int au_wbr(struct dentry *dentry, aufs_bindex_t btgt); ++int aufs_rename(struct inode *src_dir, struct dentry *src_dentry, ++ struct inode *dir, struct dentry *dentry); ++ ++/* iinfo.c */ ++struct inode *au_h_iptr(struct inode *inode, aufs_bindex_t bindex); ++void au_hiput(struct au_hinode *hinode); ++void au_set_ibstart(struct inode *inode, aufs_bindex_t bindex); ++void au_set_hi_wh(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_wh); ++unsigned int au_hi_flags(struct inode *inode, int isdir); ++ ++/* hinode flags */ ++#define AuHi_XINO 1 ++#define AuHi_HINOTIFY (1 << 1) ++#define au_ftest_hi(flags, name) ((flags) & AuHi_##name) ++#define au_fset_hi(flags, name) { (flags) |= AuHi_##name; } ++#define au_fclr_hi(flags, name) { (flags) &= ~AuHi_##name; } ++ ++#ifndef CONFIG_AUFS_HINOTIFY ++#undef AuHi_HINOTIFY ++#define AuHi_HINOTIFY 0 ++#endif ++ ++void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex, ++ struct inode *h_inode, unsigned int flags); ++ ++void au_update_iigen(struct inode *inode); ++void au_update_brange(struct inode *inode, int do_put_zero); ++ ++int au_iinfo_init(struct inode *inode); ++void au_iinfo_fin(struct inode *inode); ++int au_ii_realloc(struct au_iinfo *iinfo, int nbr); ++ ++/* plink.c */ ++void au_plink_block_maintain(struct super_block *sb); ++#ifdef CONFIG_AUFS_DEBUG ++void au_plink_list(struct super_block *sb); ++#else ++static inline void au_plink_list(struct super_block *sb) ++{ ++ /* nothing */ ++} ++#endif ++int au_plink_test(struct inode *inode); ++struct dentry *au_plink_lkup(struct inode *inode, aufs_bindex_t bindex); ++void au_plink_append(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_dentry); ++void au_plink_put(struct super_block *sb); ++void au_plink_half_refresh(struct super_block *sb, aufs_bindex_t br_id); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for iinfo */ ++enum { ++ AuLsc_II_CHILD, /* child first */ ++ AuLsc_II_CHILD2, /* rename(2), link(2), and cpup at hinotify */ ++ AuLsc_II_CHILD3, /* copyup dirs */ ++ AuLsc_II_PARENT, /* see AuLsc_I_PARENT in vfsub.h */ ++ AuLsc_II_PARENT2, ++ AuLsc_II_PARENT3, /* copyup dirs */ ++ AuLsc_II_NEW_CHILD ++}; ++ ++/* ++ * ii_read_lock_child, ii_write_lock_child, ++ * ii_read_lock_child2, ii_write_lock_child2, ++ * ii_read_lock_child3, ii_write_lock_child3, ++ * ii_read_lock_parent, ii_write_lock_parent, ++ * ii_read_lock_parent2, ii_write_lock_parent2, ++ * ii_read_lock_parent3, ii_write_lock_parent3, ++ * ii_read_lock_new_child, ii_write_lock_new_child, ++ */ ++#define AuReadLockFunc(name, lsc) \ ++static inline void ii_read_lock_##name(struct inode *i) \ ++{ \ ++ down_read_nested(&au_ii(i)->ii_rwsem, AuLsc_II_##lsc); \ ++} ++ ++#define AuWriteLockFunc(name, lsc) \ ++static inline void ii_write_lock_##name(struct inode *i) \ ++{ \ ++ down_write_nested(&au_ii(i)->ii_rwsem, AuLsc_II_##lsc); \ ++} ++ ++#define AuRWLockFuncs(name, lsc) \ ++ AuReadLockFunc(name, lsc) \ ++ AuWriteLockFunc(name, lsc) ++ ++AuRWLockFuncs(child, CHILD); ++AuRWLockFuncs(child2, CHILD2); ++AuRWLockFuncs(child3, CHILD3); ++AuRWLockFuncs(parent, PARENT); ++AuRWLockFuncs(parent2, PARENT2); ++AuRWLockFuncs(parent3, PARENT3); ++AuRWLockFuncs(new_child, NEW_CHILD); ++ ++#undef AuReadLockFunc ++#undef AuWriteLockFunc ++#undef AuRWLockFuncs ++ ++/* ++ * ii_read_unlock, ii_write_unlock, ii_downgrade_lock ++ */ ++AuSimpleUnlockRwsemFuncs(ii, struct inode *i, &au_ii(i)->ii_rwsem); ++ ++#define IiMustNoWaiters(i) AuRwMustNoWaiters(&au_ii(i)->ii_rwsem) ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline unsigned int au_iigen(struct inode *inode) ++{ ++ return atomic_read(&au_ii(inode)->ii_generation); ++} ++ ++/* tiny test for inode number */ ++/* tmpfs generation is too rough */ ++static inline int au_test_higen(struct inode *inode, struct inode *h_inode) ++{ ++ struct au_iinfo *iinfo; ++ ++ iinfo = au_ii(inode); ++ return !(iinfo->ii_hsb1 == h_inode->i_sb ++ && iinfo->ii_higen == h_inode->i_generation); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline aufs_bindex_t au_ii_br_id(struct inode *inode, ++ aufs_bindex_t bindex) ++{ ++ return au_ii(inode)->ii_hinode[0 + bindex].hi_id; ++} ++ ++static inline aufs_bindex_t au_ibstart(struct inode *inode) ++{ ++ return au_ii(inode)->ii_bstart; ++} ++ ++static inline aufs_bindex_t au_ibend(struct inode *inode) ++{ ++ return au_ii(inode)->ii_bend; ++} ++ ++static inline struct au_vdir *au_ivdir(struct inode *inode) ++{ ++ return au_ii(inode)->ii_vdir; ++} ++ ++static inline struct dentry *au_hi_wh(struct inode *inode, aufs_bindex_t bindex) ++{ ++ return au_ii(inode)->ii_hinode[0 + bindex].hi_whdentry; ++} ++ ++static inline void au_set_ibend(struct inode *inode, aufs_bindex_t bindex) ++{ ++ au_ii(inode)->ii_bend = bindex; ++} ++ ++static inline void au_set_ivdir(struct inode *inode, struct au_vdir *vdir) ++{ ++ au_ii(inode)->ii_vdir = vdir; ++} ++ ++static inline struct au_hinode *au_hi(struct inode *inode, aufs_bindex_t bindex) ++{ ++ return au_ii(inode)->ii_hinode + bindex; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct dentry *au_pinned_parent(struct au_pin *pin) ++{ ++ if (pin) ++ return pin->parent; ++ return NULL; ++} ++ ++static inline struct inode *au_pinned_h_dir(struct au_pin *pin) ++{ ++ if (pin && pin->hdir) ++ return pin->hdir->hi_inode; ++ return NULL; ++} ++ ++static inline struct au_hinode *au_pinned_hdir(struct au_pin *pin) ++{ ++ if (pin) ++ return pin->hdir; ++ return NULL; ++} ++ ++static inline void au_pin_set_dentry(struct au_pin *pin, struct dentry *dentry) ++{ ++ if (pin) ++ pin->dentry = dentry; ++} ++ ++static inline void au_pin_set_parent_lflag(struct au_pin *pin, ++ unsigned char lflag) ++{ ++ if (pin) { ++ /* dirty macros require brackets */ ++ if (lflag) { ++ au_fset_pin(pin->flags, DI_LOCKED); ++ } else { ++ au_fclr_pin(pin->flags, DI_LOCKED); ++ } ++ } ++} ++ ++static inline void au_pin_set_parent(struct au_pin *pin, struct dentry *parent) ++{ ++ if (pin) { ++ dput(pin->parent); ++ pin->parent = dget(parent); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_HINOTIFY ++/* hinotify.c */ ++int au_hin_alloc(struct au_hinode *hinode, struct inode *inode, ++ struct inode *h_inode); ++void au_hin_free(struct au_hinode *hinode); ++void au_hin_ctl(struct au_hinode *hinode, int do_set); ++void au_reset_hinotify(struct inode *inode, unsigned int flags); ++ ++int __init au_hinotify_init(void); ++void au_hinotify_fin(void); ++ ++static inline ++void au_hin_init(struct au_hinode *hinode, struct au_hinotify *val) ++{ ++ hinode->hi_notify = val; ++} ++ ++static inline void au_iigen_dec(struct inode *inode) ++{ ++ atomic_dec(&au_ii(inode)->ii_generation); ++} ++ ++#else ++static inline ++int au_hin_alloc(struct au_hinode *hinode __maybe_unused, ++ struct inode *inode __maybe_unused, ++ struct inode *h_inode __maybe_unused) ++{ ++ return -EOPNOTSUPP; ++} ++ ++static inline void au_hin_free(struct au_hinode *hinode __maybe_unused) ++{ ++ /* nothing */ ++} ++ ++static inline void au_hin_ctl(struct au_hinode *hinode __maybe_unused, ++ int do_set __maybe_unused) ++{ ++ /* nothing */ ++} ++ ++static inline void au_reset_hinotify(struct inode *inode __maybe_unused, ++ unsigned int flags __maybe_unused) ++{ ++ /* nothing */ ++} ++ ++static inline int au_hinotify_init(void) ++{ ++ return 0; ++} ++ ++#define au_hinotify_fin() do {} while (0) ++ ++static inline ++void au_hin_init(struct au_hinode *hinode __maybe_unused, ++ struct au_hinotify *val __maybe_unused) ++{ ++ /* empty */ ++} ++#endif /* CONFIG_AUFS_HINOTIFY */ ++ ++static inline void au_hin_suspend(struct au_hinode *hdir) ++{ ++ au_hin_ctl(hdir, /*do_set*/0); ++} ++ ++static inline void au_hin_resume(struct au_hinode *hdir) ++{ ++ au_hin_ctl(hdir, /*do_set*/1); ++} ++ ++static inline void au_hin_imtx_lock(struct au_hinode *hdir) ++{ ++ mutex_lock(&hdir->hi_inode->i_mutex); ++ au_hin_suspend(hdir); ++} ++ ++static inline void au_hin_imtx_lock_nested(struct au_hinode *hdir, ++ unsigned int sc __maybe_unused) ++{ ++ mutex_lock_nested(&hdir->hi_inode->i_mutex, sc); ++ au_hin_suspend(hdir); ++} ++ ++static inline void au_hin_imtx_unlock(struct au_hinode *hdir) ++{ ++ au_hin_resume(hdir); ++ mutex_unlock(&hdir->hi_inode->i_mutex); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_INODE_H__ */ +diff -Naur a/fs/aufs/ioctl.c b/fs/aufs/ioctl.c +--- a/fs/aufs/ioctl.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/ioctl.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,68 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * ioctl ++ * currently plink-management only. ++ */ ++ ++#include <linux/uaccess.h> ++#include "aufs.h" ++ ++long aufs_ioctl_dir(struct file *file, unsigned int cmd, ++ unsigned long arg __maybe_unused) ++{ ++ long err; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++ err = -EACCES; ++ if (!capable(CAP_SYS_ADMIN)) ++ goto out; ++ ++ err = 0; ++ sb = file->f_dentry->d_sb; ++ sbinfo = au_sbi(sb); ++ switch (cmd) { ++ case AUFS_CTL_PLINK_MAINT: ++ /* ++ * pseudo-link maintenance mode, ++ * cleared by aufs_release_dir() ++ */ ++ si_write_lock(sb); ++ if (!au_ftest_si(sbinfo, MAINTAIN_PLINK)) { ++ au_fset_si(sbinfo, MAINTAIN_PLINK); ++ au_fi(file)->fi_maintain_plink = 1; ++ } else ++ err = -EBUSY; ++ si_write_unlock(sb); ++ break; ++ case AUFS_CTL_PLINK_CLEAN: ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) { ++ aufs_write_lock(sb->s_root); ++ au_plink_put(sb); ++ aufs_write_unlock(sb->s_root); ++ } ++ break; ++ default: ++ err = -EINVAL; ++ } ++ ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/i_op_add.c b/fs/aufs/i_op_add.c +--- a/fs/aufs/i_op_add.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/i_op_add.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,638 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode operations (add entry) ++ */ ++ ++#include "aufs.h" ++ ++/* ++ * final procedure of adding a new entry, except link(2). ++ * remove whiteout, instantiate, copyup the parent dir's times and size ++ * and update version. ++ * if it failed, re-create the removed whiteout. ++ */ ++static int epilog(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct dentry *dentry) ++{ ++ int err, rerr; ++ aufs_bindex_t bwh; ++ struct path h_path; ++ struct inode *inode, *h_dir; ++ struct dentry *wh; ++ ++ bwh = -1; ++ if (wh_dentry) { ++ h_dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */ ++ IMustLock(h_dir); ++ AuDebugOn(au_h_iptr(dir, bindex) != h_dir); ++ bwh = au_dbwh(dentry); ++ h_path.dentry = wh_dentry; ++ h_path.mnt = au_sbr_mnt(dir->i_sb, bindex); ++ err = au_wh_unlink_dentry(au_h_iptr(dir, bindex), &h_path, ++ dentry); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ inode = au_new_inode(dentry, /*must_new*/1); ++ if (!IS_ERR(inode)) { ++ d_instantiate(dentry, inode); ++ dir = dentry->d_parent->d_inode; /* dir inode is locked */ ++ IMustLock(dir); ++ if (au_ibstart(dir) == au_dbstart(dentry)) ++ au_cpup_attr_timesizes(dir); ++ dir->i_version++; ++ return 0; /* success */ ++ } ++ ++ err = PTR_ERR(inode); ++ if (!wh_dentry) ++ goto out; ++ ++ /* revert */ ++ /* dir inode is locked */ ++ wh = au_wh_create(dentry, bwh, wh_dentry->d_parent); ++ rerr = PTR_ERR(wh); ++ if (IS_ERR(wh)) { ++ AuIOErr("%.*s reverting whiteout failed(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ err = -EIO; ++ } else ++ dput(wh); ++ ++ out: ++ return err; ++} ++ ++/* ++ * simple tests for the adding inode operations. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++int au_may_add(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir) ++{ ++ int err; ++ umode_t h_mode; ++ struct dentry *h_dentry; ++ struct inode *h_inode; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ h_inode = h_dentry->d_inode; ++ if (!dentry->d_inode) { ++ err = -EEXIST; ++ if (unlikely(h_inode)) ++ goto out; ++ } else { ++ /* rename(2) case */ ++ err = -EIO; ++ if (unlikely(!h_inode || !h_inode->i_nlink)) ++ goto out; ++ ++ h_mode = h_inode->i_mode; ++ if (!isdir) { ++ err = -EISDIR; ++ if (unlikely(S_ISDIR(h_mode))) ++ goto out; ++ } else if (unlikely(!S_ISDIR(h_mode))) { ++ err = -ENOTDIR; ++ goto out; ++ } ++ } ++ ++ err = -EIO; ++ /* expected parent dir is locked */ ++ if (unlikely(h_parent != h_dentry->d_parent)) ++ goto out; ++ err = 0; ++ ++ out: ++ return err; ++} ++ ++/* ++ * initial procedure of adding a new entry. ++ * prepare writable branch and the parent dir, lock it, ++ * and lookup whiteout for the new entry. ++ */ ++static struct dentry* ++lock_hdir_lkup_wh(struct dentry *dentry, struct au_dtime *dt, ++ struct dentry *src_dentry, struct au_pin *pin, ++ struct au_wr_dir_args *wr_dir_args) ++{ ++ struct dentry *wh_dentry, *h_parent; ++ struct super_block *sb; ++ struct au_branch *br; ++ int err; ++ unsigned int udba; ++ aufs_bindex_t bcpup; ++ ++ err = au_wr_dir(dentry, src_dentry, wr_dir_args); ++ bcpup = err; ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err < 0)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ udba = au_opt_udba(sb); ++ err = au_pin(pin, dentry, bcpup, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ h_parent = au_pinned_h_parent(pin); ++ if (udba != AuOpt_UDBA_NONE ++ && au_dbstart(dentry) == bcpup) { ++ err = au_may_add(dentry, bcpup, h_parent, ++ au_ftest_wrdir(wr_dir_args->flags, ISDIR)); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_unpin; ++ } ++ ++ br = au_sbr(sb, bcpup); ++ if (dt) { ++ struct path tmp = { ++ .dentry = h_parent, ++ .mnt = br->br_mnt ++ }; ++ au_dtime_store(dt, au_pinned_parent(pin), &tmp); ++ } ++ ++ wh_dentry = NULL; ++ if (bcpup != au_dbwh(dentry)) ++ goto out; /* success */ ++ ++ wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, br); ++ ++ out_unpin: ++ if (IS_ERR(wh_dentry)) ++ au_unpin(pin); ++ out: ++ return wh_dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++enum { Mknod, Symlink, Creat }; ++struct simple_arg { ++ int type; ++ union { ++ struct { ++ int mode; ++ struct nameidata *nd; ++ } c; ++ struct { ++ const char *symname; ++ } s; ++ struct { ++ int mode; ++ dev_t dev; ++ } m; ++ } u; ++}; ++ ++static int add_simple(struct inode *dir, struct dentry *dentry, ++ struct simple_arg *arg) ++{ ++ int err; ++ aufs_bindex_t bstart; ++ unsigned char created; ++ struct au_dtime dt; ++ struct au_pin pin; ++ struct path h_path; ++ struct dentry *wh_dentry, *parent; ++ struct inode *h_dir; ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = AuWrDir_ADD_ENTRY ++ }; ++ ++ IMustLock(dir); ++ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ aufs_read_lock(dentry, AuLock_DW); ++ di_write_lock_parent(parent); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &dt, /*src_dentry*/NULL, &pin, ++ &wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ bstart = au_dbstart(dentry); ++ h_path.dentry = au_h_dptr(dentry, bstart); ++ h_path.mnt = au_sbr_mnt(dentry->d_sb, bstart); ++ h_dir = au_pinned_h_dir(&pin); ++ switch (arg->type) { ++ case Creat: ++ err = vfsub_create(h_dir, &h_path, arg->u.c.mode); ++ break; ++ case Symlink: ++ err = vfsub_symlink(h_dir, &h_path, arg->u.s.symname); ++ break; ++ case Mknod: ++ err = vfsub_mknod(h_dir, &h_path, arg->u.m.mode, arg->u.m.dev); ++ break; ++ default: ++ BUG(); ++ } ++ created = !err; ++ if (!err) ++ err = epilog(dir, bstart, wh_dentry, dentry); ++ ++ /* revert */ ++ if (unlikely(created && err && h_path.dentry->d_inode)) { ++ int rerr; ++ rerr = vfsub_unlink(h_dir, &h_path, /*force*/0); ++ if (rerr) { ++ AuIOErr("%.*s revert failure(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ err = -EIO; ++ } ++ au_dtime_revert(&dt); ++ d_drop(dentry); ++ } ++ ++ au_unpin(&pin); ++ dput(wh_dentry); ++ ++ out: ++ if (unlikely(err)) { ++ au_update_dbstart(dentry); ++ d_drop(dentry); ++ } ++ di_write_unlock(parent); ++ aufs_read_unlock(dentry, AuLock_DW); ++ return err; ++} ++ ++int aufs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) ++{ ++ struct simple_arg arg = { ++ .type = Mknod, ++ .u.m = { ++ .mode = mode, ++ .dev = dev ++ } ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int aufs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) ++{ ++ struct simple_arg arg = { ++ .type = Symlink, ++ .u.s.symname = symname ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++int aufs_create(struct inode *dir, struct dentry *dentry, int mode, ++ struct nameidata *nd) ++{ ++ struct simple_arg arg = { ++ .type = Creat, ++ .u.c = { ++ .mode = mode, ++ .nd = nd ++ } ++ }; ++ return add_simple(dir, dentry, &arg); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_link_args { ++ aufs_bindex_t bdst, bsrc; ++ struct au_pin pin; ++ struct path h_path; ++ struct dentry *src_parent, *parent; ++}; ++ ++static int au_cpup_before_link(struct dentry *src_dentry, ++ struct au_link_args *a) ++{ ++ int err; ++ struct dentry *h_src_dentry; ++ struct mutex *h_mtx; ++ ++ di_read_lock_parent(a->src_parent, AuLock_IR); ++ err = au_test_and_cpup_dirs(src_dentry, a->bdst); ++ if (unlikely(err)) ++ goto out; ++ ++ h_src_dentry = au_h_dptr(src_dentry, a->bsrc); ++ h_mtx = &h_src_dentry->d_inode->i_mutex; ++ err = au_pin(&a->pin, src_dentry, a->bdst, ++ au_opt_udba(src_dentry->d_sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out; ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ err = au_sio_cpup_simple(src_dentry, a->bdst, -1, ++ AuCpup_DTIME /* | AuCpup_KEEPLINO */); ++ mutex_unlock(h_mtx); ++ au_unpin(&a->pin); ++ ++ out: ++ di_read_unlock(a->src_parent, AuLock_IR); ++ return err; ++} ++ ++static int au_cpup_or_link(struct dentry *src_dentry, struct au_link_args *a) ++{ ++ int err; ++ unsigned char plink; ++ struct inode *h_inode, *inode; ++ struct dentry *h_src_dentry; ++ struct super_block *sb; ++ ++ plink = 0; ++ h_inode = NULL; ++ sb = src_dentry->d_sb; ++ inode = src_dentry->d_inode; ++ if (au_ibstart(inode) <= a->bdst) ++ h_inode = au_h_iptr(inode, a->bdst); ++ if (!h_inode || !h_inode->i_nlink) { ++ /* copyup src_dentry as the name of dentry. */ ++ au_set_dbstart(src_dentry, a->bdst); ++ au_set_h_dptr(src_dentry, a->bdst, dget(a->h_path.dentry)); ++ h_inode = au_h_dptr(src_dentry, a->bsrc)->d_inode; ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ err = au_sio_cpup_single(src_dentry, a->bdst, a->bsrc, -1, ++ AuCpup_KEEPLINO, a->parent); ++ mutex_unlock(&h_inode->i_mutex); ++ au_set_h_dptr(src_dentry, a->bdst, NULL); ++ au_set_dbstart(src_dentry, a->bsrc); ++ } else { ++ /* the inode of src_dentry already exists on a.bdst branch */ ++ h_src_dentry = d_find_alias(h_inode); ++ if (!h_src_dentry && au_plink_test(inode)) { ++ plink = 1; ++ h_src_dentry = au_plink_lkup(inode, a->bdst); ++ err = PTR_ERR(h_src_dentry); ++ if (IS_ERR(h_src_dentry)) ++ goto out; ++ ++ if (unlikely(!h_src_dentry->d_inode)) { ++ dput(h_src_dentry); ++ h_src_dentry = NULL; ++ } ++ ++ } ++ if (h_src_dentry) { ++ err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin), ++ &a->h_path); ++ dput(h_src_dentry); ++ } else { ++ AuIOErr("no dentry found for hi%lu on b%d\n", ++ h_inode->i_ino, a->bdst); ++ err = -EIO; ++ } ++ } ++ ++ if (!err && !plink) ++ au_plink_append(inode, a->bdst, a->h_path.dentry); ++ ++out: ++ return err; ++} ++ ++int aufs_link(struct dentry *src_dentry, struct inode *dir, ++ struct dentry *dentry) ++{ ++ int err, rerr; ++ struct au_dtime dt; ++ struct au_link_args *a; ++ struct dentry *wh_dentry, *h_src_dentry; ++ struct inode *inode; ++ struct super_block *sb; ++ struct au_wr_dir_args wr_dir_args = { ++ /* .force_btgt = -1, */ ++ .flags = AuWrDir_ADD_ENTRY ++ }; ++ ++ IMustLock(dir); ++ inode = src_dentry->d_inode; ++ IMustLock(inode); ++ ++ err = -ENOENT; ++ if (unlikely(!inode->i_nlink)) ++ goto out; ++ ++ err = -ENOMEM; ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ a->parent = dentry->d_parent; /* dir inode is locked */ ++ aufs_read_and_write_lock2(dentry, src_dentry, /*AuLock_FLUSH*/0); ++ a->src_parent = dget_parent(src_dentry); ++ wr_dir_args.force_btgt = au_dbstart(src_dentry); ++ ++ di_write_lock_parent(a->parent); ++ wr_dir_args.force_btgt = au_wbr(dentry, wr_dir_args.force_btgt); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &dt, src_dentry, &a->pin, ++ &wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_unlock; ++ ++ err = 0; ++ sb = dentry->d_sb; ++ a->bdst = au_dbstart(dentry); ++ a->h_path.dentry = au_h_dptr(dentry, a->bdst); ++ a->h_path.mnt = au_sbr_mnt(sb, a->bdst); ++ a->bsrc = au_dbstart(src_dentry); ++ if (au_opt_test(au_mntflags(sb), PLINK)) { ++ if (a->bdst < a->bsrc ++ /* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */) ++ err = au_cpup_or_link(src_dentry, a); ++ else { ++ h_src_dentry = au_h_dptr(src_dentry, a->bdst); ++ err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin), ++ &a->h_path); ++ } ++ } else { ++ /* ++ * copyup src_dentry to the branch we process, ++ * and then link(2) to it. ++ */ ++ if (a->bdst < a->bsrc ++ /* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */) { ++ au_unpin(&a->pin); ++ di_write_unlock(a->parent); ++ err = au_cpup_before_link(src_dentry, a); ++ if (!err) { ++ di_write_lock_parent(a->parent); ++ err = au_pin(&a->pin, dentry, a->bdst, ++ au_opt_udba(sb), ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ if (unlikely(err)) ++ goto out_wh; ++ } ++ } ++ if (!err) { ++ h_src_dentry = au_h_dptr(src_dentry, a->bdst); ++ err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin), ++ &a->h_path); ++ } ++ } ++ if (unlikely(err)) ++ goto out_unpin; ++ ++ if (wh_dentry) { ++ a->h_path.dentry = wh_dentry; ++ err = au_wh_unlink_dentry(au_pinned_h_dir(&a->pin), &a->h_path, ++ dentry); ++ if (unlikely(err)) ++ goto out_revert; ++ } ++ ++ dir->i_version++; ++ if (au_ibstart(dir) == au_dbstart(dentry)) ++ au_cpup_attr_timesizes(dir); ++ inc_nlink(inode); ++ inode->i_ctime = dir->i_ctime; ++ if (!d_unhashed(a->h_path.dentry)) ++ d_instantiate(dentry, au_igrab(inode)); ++ else ++ /* some filesystem calls d_drop() */ ++ d_drop(dentry); ++ goto out_unpin; /* success */ ++ ++ out_revert: ++ rerr = vfsub_unlink(au_pinned_h_dir(&a->pin), &a->h_path, /*force*/0); ++ if (!rerr) ++ goto out_dt; ++ AuIOErr("%.*s reverting failed(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ err = -EIO; ++ out_dt: ++ d_drop(dentry); ++ au_dtime_revert(&dt); ++ out_unpin: ++ au_unpin(&a->pin); ++ out_wh: ++ dput(wh_dentry); ++ out_unlock: ++ if (unlikely(err)) { ++ au_update_dbstart(dentry); ++ d_drop(dentry); ++ } ++ di_write_unlock(a->parent); ++ dput(a->src_parent); ++ aufs_read_and_write_unlock2(dentry, src_dentry); ++ kfree(a); ++ out: ++ return err; ++} ++ ++int aufs_mkdir(struct inode *dir, struct dentry *dentry, int mode) ++{ ++ int err, rerr; ++ aufs_bindex_t bindex; ++ unsigned char diropq; ++ struct au_pin pin; ++ struct path h_path; ++ struct dentry *wh_dentry, *parent, *opq_dentry; ++ struct mutex *h_mtx; ++ struct super_block *sb; ++ struct au_dtime dt; ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = AuWrDir_ADD_ENTRY | AuWrDir_ISDIR ++ }; ++ ++ IMustLock(dir); ++ ++ aufs_read_lock(dentry, AuLock_DW); ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ wh_dentry = lock_hdir_lkup_wh(dentry, &dt, /*src_dentry*/NULL, &pin, ++ &wr_dir_args); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ bindex = au_dbstart(dentry); ++ h_path.dentry = au_h_dptr(dentry, bindex); ++ h_path.mnt = au_sbr_mnt(sb, bindex); ++ err = vfsub_mkdir(au_pinned_h_dir(&pin), &h_path, mode); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ /* make the dir opaque */ ++ diropq = 0; ++ h_mtx = &h_path.dentry->d_inode->i_mutex; ++ if (wh_dentry ++ || au_opt_test(au_mntflags(sb), ALWAYS_DIROPQ)) { ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ opq_dentry = au_diropq_create(dentry, bindex); ++ mutex_unlock(h_mtx); ++ err = PTR_ERR(opq_dentry); ++ if (IS_ERR(opq_dentry)) ++ goto out_dir; ++ dput(opq_dentry); ++ diropq = 1; ++ } ++ ++ err = epilog(dir, bindex, wh_dentry, dentry); ++ if (!err) { ++ inc_nlink(dir); ++ goto out_unlock; /* success */ ++ } ++ ++ /* revert */ ++ if (diropq) { ++ AuLabel(revert opq); ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ rerr = au_diropq_remove(dentry, bindex); ++ mutex_unlock(h_mtx); ++ if (rerr) { ++ AuIOErr("%.*s reverting diropq failed(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ err = -EIO; ++ } ++ } ++ ++ out_dir: ++ AuLabel(revert dir); ++ rerr = vfsub_rmdir(au_pinned_h_dir(&pin), &h_path); ++ if (rerr) { ++ AuIOErr("%.*s reverting dir failed(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ err = -EIO; ++ } ++ d_drop(dentry); ++ au_dtime_revert(&dt); ++ out_unlock: ++ au_unpin(&pin); ++ dput(wh_dentry); ++ out: ++ if (unlikely(err)) { ++ au_update_dbstart(dentry); ++ d_drop(dentry); ++ } ++ di_write_unlock(parent); ++ aufs_read_unlock(dentry, AuLock_DW); ++ return err; ++} +diff -Naur a/fs/aufs/i_op.c b/fs/aufs/i_op.c +--- a/fs/aufs/i_op.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/i_op.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,874 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode operations (except add/del/rename) ++ */ ++ ++#include <linux/device_cgroup.h> ++#include <linux/fs_stack.h> ++#include <linux/mm.h> ++#include <linux/namei.h> ++#include <linux/security.h> ++#include <linux/uaccess.h> ++#include "aufs.h" ++ ++static int h_permission(struct inode *h_inode, int mask, ++ struct vfsmount *h_mnt, int brperm) ++{ ++ int err; ++ const unsigned char write_mask = !!(mask & (MAY_WRITE | MAY_APPEND)); ++ ++ err = -EACCES; ++ if ((write_mask && IS_IMMUTABLE(h_inode)) ++ || ((mask & MAY_EXEC) ++ && S_ISREG(h_inode->i_mode) ++ && ((h_mnt->mnt_flags & MNT_NOEXEC) ++ || !(h_inode->i_mode & S_IXUGO)))) ++ goto out; ++ ++ /* ++ * - skip the lower fs test in the case of write to ro branch. ++ * - nfs dir permission write check is optimized, but a policy for ++ * link/rename requires a real check. ++ */ ++ if ((write_mask && !au_br_writable(brperm)) ++ || (au_test_nfs(h_inode->i_sb) && S_ISDIR(h_inode->i_mode) ++ && write_mask && !(mask & MAY_READ)) ++ || !h_inode->i_op->permission) { ++ /* AuLabel(generic_permission); */ ++ err = generic_permission(h_inode, mask, NULL); ++ } else { ++ /* AuLabel(h_inode->permission); */ ++ err = h_inode->i_op->permission(h_inode, mask); ++ AuTraceErr(err); ++ } ++ ++ if (!err) ++ err = devcgroup_inode_permission(h_inode, mask); ++ if (!err) ++ err = security_inode_permission ++ (h_inode, mask & (MAY_READ | MAY_WRITE | MAY_EXEC ++ | MAY_APPEND)); ++ ++ out: ++ return err; ++} ++ ++static int aufs_permission(struct inode *inode, int mask) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ const unsigned char isdir = !!S_ISDIR(inode->i_mode); ++ const unsigned char write_mask = !!(mask & (MAY_WRITE | MAY_APPEND)); ++ struct inode *h_inode; ++ struct super_block *sb; ++ struct au_branch *br; ++ ++ sb = inode->i_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ii_read_lock_child(inode); ++ ++ if (!isdir || write_mask) { ++ h_inode = au_h_iptr(inode, au_ibstart(inode)); ++ AuDebugOn(!h_inode ++ || ((h_inode->i_mode & S_IFMT) ++ != (inode->i_mode & S_IFMT))); ++ err = 0; ++ bindex = au_ibstart(inode); ++ br = au_sbr(sb, bindex); ++ err = h_permission(h_inode, mask, br->br_mnt, br->br_perm); ++ ++ if (write_mask && !err) { ++ /* test whether the upper writable branch exists */ ++ err = -EROFS; ++ for (; bindex >= 0; bindex--) ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = 0; ++ break; ++ } ++ } ++ goto out; ++ } ++ ++ /* non-write to dir */ ++ err = 0; ++ bend = au_ibend(inode); ++ for (bindex = au_ibstart(inode); !err && bindex <= bend; bindex++) { ++ h_inode = au_h_iptr(inode, bindex); ++ if (h_inode) { ++ AuDebugOn(!S_ISDIR(h_inode->i_mode)); ++ br = au_sbr(sb, bindex); ++ err = h_permission(h_inode, mask, br->br_mnt, ++ br->br_perm); ++ } ++ } ++ ++ out: ++ ii_read_unlock(inode); ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct dentry *aufs_lookup(struct inode *dir, struct dentry *dentry, ++ struct nameidata *nd) ++{ ++ struct dentry *ret, *parent; ++ struct inode *inode, *h_inode; ++ struct mutex *mtx; ++ struct super_block *sb; ++ int err, npositive; ++ aufs_bindex_t bstart; ++ ++ /* temporary workaround for a bug in NFSD readdir */ ++ if (!au_test_nfsd(current)) ++ IMustLock(dir); ++ else ++ WARN_ONCE(!mutex_is_locked(&dir->i_mutex), ++ "a known problem of NFSD readdir since 2.6.28\n"); ++ ++ sb = dir->i_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ err = au_alloc_dinfo(dentry); ++ ret = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_read_lock_parent(parent, AuLock_IR); ++ npositive = au_lkup_dentry(dentry, au_dbstart(parent), /*type*/0, nd); ++ di_read_unlock(parent, AuLock_IR); ++ err = npositive; ++ ret = ERR_PTR(err); ++ if (unlikely(err < 0)) ++ goto out_unlock; ++ ++ inode = NULL; ++ if (npositive) { ++ bstart = au_dbstart(dentry); ++ h_inode = au_h_dptr(dentry, bstart)->d_inode; ++ if (!S_ISDIR(h_inode->i_mode)) { ++ /* ++ * stop 'race'-ing between hardlinks under different ++ * parents. ++ */ ++ mtx = &au_sbr(sb, bstart)->br_xino.xi_nondir_mtx; ++ mutex_lock(mtx); ++ inode = au_new_inode(dentry, /*must_new*/0); ++ mutex_unlock(mtx); ++ } else ++ inode = au_new_inode(dentry, /*must_new*/0); ++ ret = (void *)inode; ++ } ++ if (IS_ERR(inode)) ++ goto out_unlock; ++ ++ ret = d_splice_alias(inode, dentry); ++ if (unlikely(IS_ERR(ret) && inode)) ++ ii_write_unlock(inode); ++ au_store_oflag(nd, inode); ++ ++ out_unlock: ++ di_write_unlock(dentry); ++ out: ++ si_read_unlock(sb); ++ return ret; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent, ++ const unsigned char add_entry, aufs_bindex_t bcpup, ++ aufs_bindex_t bstart) ++{ ++ int err; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ ++ if (add_entry) { ++ au_update_dbstart(dentry); ++ IMustLock(parent->d_inode); ++ } else ++ di_write_lock_parent(parent); ++ ++ err = 0; ++ if (!au_h_dptr(parent, bcpup)) { ++ if (bstart < bcpup) ++ err = au_cpdown_dirs(dentry, bcpup); ++ else ++ err = au_cpup_dirs(dentry, bcpup); ++ } ++ if (!err && add_entry) { ++ h_parent = au_h_dptr(parent, bcpup); ++ h_dir = h_parent->d_inode; ++ mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_PARENT); ++ err = au_lkup_neg(dentry, bcpup); ++ /* todo: no unlock here */ ++ mutex_unlock(&h_dir->i_mutex); ++ if (bstart < bcpup && au_dbstart(dentry) < 0) { ++ au_set_dbstart(dentry, 0); ++ au_update_dbrange(dentry, /*do_put_zero*/0); ++ } ++ } ++ ++ if (!add_entry) ++ di_write_unlock(parent); ++ if (!err) ++ err = bcpup; /* success */ ++ ++ return err; ++} ++ ++/* ++ * decide the branch and the parent dir where we will create a new entry. ++ * returns new bindex or an error. ++ * copyup the parent dir if needed. ++ */ ++int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry, ++ struct au_wr_dir_args *args) ++{ ++ int err; ++ aufs_bindex_t bcpup, bstart, src_bstart; ++ const unsigned char add_entry = !!au_ftest_wrdir(args->flags, ++ ADD_ENTRY); ++ struct super_block *sb; ++ struct dentry *parent; ++ struct au_sbinfo *sbinfo; ++ ++ sb = dentry->d_sb; ++ sbinfo = au_sbi(sb); ++ parent = dget_parent(dentry); ++ bstart = au_dbstart(dentry); ++ bcpup = bstart; ++ if (args->force_btgt < 0) { ++ if (src_dentry) { ++ src_bstart = au_dbstart(src_dentry); ++ if (src_bstart < bstart) ++ bcpup = src_bstart; ++ } else if (add_entry) { ++ err = AuWbrCreate(sbinfo, dentry, ++ au_ftest_wrdir(args->flags, ISDIR)); ++ bcpup = err; ++ } ++ ++ if (bcpup < 0 || au_test_ro(sb, bcpup, dentry->d_inode)) { ++ if (add_entry) ++ err = AuWbrCopyup(sbinfo, dentry); ++ else { ++ if (!IS_ROOT(dentry)) { ++ di_read_lock_parent(parent, !AuLock_IR); ++ err = AuWbrCopyup(sbinfo, dentry); ++ di_read_unlock(parent, !AuLock_IR); ++ } else ++ err = AuWbrCopyup(sbinfo, dentry); ++ } ++ bcpup = err; ++ if (unlikely(err < 0)) ++ goto out; ++ } ++ } else { ++ bcpup = args->force_btgt; ++ AuDebugOn(au_test_ro(sb, bcpup, dentry->d_inode)); ++ } ++ AuDbg("bstart %d, bcpup %d\n", bstart, bcpup); ++ if (bstart < bcpup) ++ au_update_dbrange(dentry, /*do_put_zero*/1); ++ ++ err = bcpup; ++ if (bcpup == bstart) ++ goto out; /* success */ ++ ++ /* copyup the new parent into the branch we process */ ++ err = au_wr_dir_cpup(dentry, parent, add_entry, bcpup, bstart); ++ ++ out: ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry *au_pinned_h_parent(struct au_pin *pin) ++{ ++ if (pin && pin->parent) ++ return au_h_dptr(pin->parent, pin->bindex); ++ return NULL; ++} ++ ++void au_unpin(struct au_pin *p) ++{ ++ if (au_ftest_pin(p->flags, MNT_WRITE)) ++ mnt_drop_write(p->h_mnt); ++ if (!p->hdir) ++ return; ++ ++ au_hin_imtx_unlock(p->hdir); ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_unlock(p->parent, AuLock_IR); ++ iput(p->hdir->hi_inode); ++ dput(p->parent); ++ p->parent = NULL; ++ p->hdir = NULL; ++ p->h_mnt = NULL; ++} ++ ++int au_do_pin(struct au_pin *p) ++{ ++ int err; ++ struct super_block *sb; ++ struct dentry *h_dentry, *h_parent; ++ struct au_branch *br; ++ struct inode *h_dir; ++ ++ err = 0; ++ sb = p->dentry->d_sb; ++ br = au_sbr(sb, p->bindex); ++ if (IS_ROOT(p->dentry)) { ++ if (au_ftest_pin(p->flags, MNT_WRITE)) { ++ p->h_mnt = br->br_mnt; ++ err = mnt_want_write(p->h_mnt); ++ if (unlikely(err)) { ++ au_fclr_pin(p->flags, MNT_WRITE); ++ goto out_err; ++ } ++ } ++ goto out; ++ } ++ ++ h_dentry = NULL; ++ if (p->bindex <= au_dbend(p->dentry)) ++ h_dentry = au_h_dptr(p->dentry, p->bindex); ++ ++ p->parent = dget_parent(p->dentry); ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_lock(p->parent, AuLock_IR, p->lsc_di); ++ ++ h_dir = NULL; ++ h_parent = au_h_dptr(p->parent, p->bindex); ++ p->hdir = au_hi(p->parent->d_inode, p->bindex); ++ if (p->hdir) ++ h_dir = p->hdir->hi_inode; ++ ++ /* udba case */ ++ if (unlikely(!p->hdir || !h_dir)) { ++ err = au_busy_or_stale(); ++ if (!au_ftest_pin(p->flags, DI_LOCKED)) ++ di_read_unlock(p->parent, AuLock_IR); ++ dput(p->parent); ++ p->parent = NULL; ++ goto out_err; ++ } ++ ++ au_igrab(h_dir); ++ au_hin_imtx_lock_nested(p->hdir, p->lsc_hi); ++ ++ if (h_dentry) { ++ err = au_h_verify(h_dentry, p->udba, h_dir, h_parent, br); ++ if (unlikely(err)) { ++ au_fclr_pin(p->flags, MNT_WRITE); ++ goto out_unpin; ++ } ++ } ++ ++ if (au_ftest_pin(p->flags, MNT_WRITE)) { ++ p->h_mnt = br->br_mnt; ++ err = mnt_want_write(p->h_mnt); ++ if (unlikely(err)) { ++ au_fclr_pin(p->flags, MNT_WRITE); ++ goto out_unpin; ++ } ++ } ++ goto out; /* success */ ++ ++ out_unpin: ++ au_unpin(p); ++ out_err: ++ AuErr("err %d\n", err); ++ err = au_busy_or_stale(); ++ out: ++ return err; ++} ++ ++void au_pin_init(struct au_pin *p, struct dentry *dentry, ++ aufs_bindex_t bindex, int lsc_di, int lsc_hi, ++ unsigned int udba, unsigned char flags) ++{ ++ p->dentry = dentry; ++ p->udba = udba; ++ p->lsc_di = lsc_di; ++ p->lsc_hi = lsc_hi; ++ p->flags = flags; ++ p->bindex = bindex; ++ ++ p->parent = NULL; ++ p->hdir = NULL; ++ p->h_mnt = NULL; ++} ++ ++int au_pin(struct au_pin *pin, struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int udba, unsigned char flags) ++{ ++ au_pin_init(pin, dentry, bindex, AuLsc_DI_PARENT, AuLsc_I_PARENT2, ++ udba, flags); ++ return au_do_pin(pin); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AuIcpup_DID_CPUP 1 ++#define au_ftest_icpup(flags, name) ((flags) & AuIcpup_##name) ++#define au_fset_icpup(flags, name) { (flags) |= AuIcpup_##name; } ++#define au_fclr_icpup(flags, name) { (flags) &= ~AuIcpup_##name; } ++ ++struct au_icpup_args { ++ unsigned char flags; ++ unsigned char pin_flags; ++ aufs_bindex_t btgt; ++ struct au_pin pin; ++ struct path h_path; ++ struct inode *h_inode; ++}; ++ ++static int au_lock_and_icpup(struct dentry *dentry, struct iattr *ia, ++ struct au_icpup_args *a) ++{ ++ int err; ++ unsigned int udba; ++ loff_t sz; ++ aufs_bindex_t bstart; ++ struct dentry *hi_wh, *parent; ++ struct inode *inode; ++ struct au_wr_dir_args wr_dir_args = { ++ .force_btgt = -1, ++ .flags = 0 ++ }; ++ ++ di_write_lock_child(dentry); ++ bstart = au_dbstart(dentry); ++ inode = dentry->d_inode; ++ if (S_ISDIR(inode->i_mode)) ++ au_fset_wrdir(wr_dir_args.flags, ISDIR); ++ /* plink or hi_wh() case */ ++ if (bstart != au_ibstart(inode)) ++ wr_dir_args.force_btgt = au_ibstart(inode); ++ err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args); ++ if (unlikely(err < 0)) ++ goto out_dentry; ++ a->btgt = err; ++ if (err != bstart) ++ au_fset_icpup(a->flags, DID_CPUP); ++ ++ err = 0; ++ a->pin_flags = AuPin_MNT_WRITE; ++ parent = NULL; ++ if (!IS_ROOT(dentry)) { ++ au_fset_pin(a->pin_flags, DI_LOCKED); ++ parent = dget_parent(dentry); ++ di_write_lock_parent(parent); ++ } ++ ++ udba = au_opt_udba(dentry->d_sb); ++ if (d_unhashed(dentry) || (ia->ia_valid & ATTR_FILE)) ++ udba = AuOpt_UDBA_NONE; ++ err = au_pin(&a->pin, dentry, a->btgt, udba, a->pin_flags); ++ if (unlikely(err)) { ++ if (parent) { ++ di_write_unlock(parent); ++ dput(parent); ++ } ++ goto out_dentry; ++ } ++ a->h_path.dentry = au_h_dptr(dentry, bstart); ++ a->h_inode = a->h_path.dentry->d_inode; ++ mutex_lock_nested(&a->h_inode->i_mutex, AuLsc_I_CHILD); ++ sz = -1; ++ if ((ia->ia_valid & ATTR_SIZE) && ia->ia_size < i_size_read(a->h_inode)) ++ sz = ia->ia_size; ++ ++ hi_wh = NULL; ++ if (au_ftest_icpup(a->flags, DID_CPUP) && d_unhashed(dentry)) { ++ hi_wh = au_hi_wh(inode, a->btgt); ++ if (!hi_wh) { ++ err = au_sio_cpup_wh(dentry, a->btgt, sz, /*file*/NULL); ++ if (unlikely(err)) ++ goto out_unlock; ++ hi_wh = au_hi_wh(inode, a->btgt); ++ /* todo: revalidate hi_wh? */ ++ } ++ } ++ ++ if (parent) { ++ au_pin_set_parent_lflag(&a->pin, /*lflag*/0); ++ di_downgrade_lock(parent, AuLock_IR); ++ dput(parent); ++ } ++ if (!au_ftest_icpup(a->flags, DID_CPUP)) ++ goto out; /* success */ ++ ++ if (!d_unhashed(dentry)) { ++ err = au_sio_cpup_simple(dentry, a->btgt, sz, AuCpup_DTIME); ++ if (!err) ++ a->h_path.dentry = au_h_dptr(dentry, a->btgt); ++ } else if (!hi_wh) ++ a->h_path.dentry = au_h_dptr(dentry, a->btgt); ++ else ++ a->h_path.dentry = hi_wh; /* do not dget here */ ++ ++ out_unlock: ++ mutex_unlock(&a->h_inode->i_mutex); ++ a->h_inode = a->h_path.dentry->d_inode; ++ if (!err) { ++ mutex_lock_nested(&a->h_inode->i_mutex, AuLsc_I_CHILD); ++ goto out; /* success */ ++ } ++ ++ au_unpin(&a->pin); ++ ++ out_dentry: ++ di_write_unlock(dentry); ++ out: ++ return err; ++} ++ ++static int aufs_setattr(struct dentry *dentry, struct iattr *ia) ++{ ++ int err; ++ struct inode *inode; ++ struct super_block *sb; ++ struct file *file; ++ struct au_icpup_args *a; ++ ++ err = -ENOMEM; ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ inode = dentry->d_inode; ++ IMustLock(inode); ++ sb = dentry->d_sb; ++ si_read_lock(sb, AuLock_FLUSH); ++ ++ file = NULL; ++ if (ia->ia_valid & ATTR_FILE) { ++ /* currently ftruncate(2) only */ ++ file = ia->ia_file; ++ fi_write_lock(file); ++ ia->ia_file = au_h_fptr(file, au_fbstart(file)); ++ } ++ ++ if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) ++ ia->ia_valid &= ~ATTR_MODE; ++ ++ err = au_lock_and_icpup(dentry, ia, a); ++ if (unlikely(err < 0)) ++ goto out_si; ++ if (au_ftest_icpup(a->flags, DID_CPUP)) { ++ ia->ia_file = NULL; ++ ia->ia_valid &= ~ATTR_FILE; ++ } ++ ++ a->h_path.mnt = au_sbr_mnt(sb, a->btgt); ++ if (ia->ia_valid & ATTR_SIZE) { ++ struct file *f; ++ ++ if (ia->ia_size < i_size_read(inode)) { ++ /* unmap only */ ++ err = vmtruncate(inode, ia->ia_size); ++ if (unlikely(err)) ++ goto out_unlock; ++ } ++ ++ f = NULL; ++ if (ia->ia_valid & ATTR_FILE) ++ f = ia->ia_file; ++ mutex_unlock(&a->h_inode->i_mutex); ++ err = vfsub_trunc(&a->h_path, ia->ia_size, ia->ia_valid, f); ++ mutex_lock_nested(&a->h_inode->i_mutex, AuLsc_I_CHILD); ++ } else ++ err = vfsub_notify_change(&a->h_path, ia); ++ if (!err) ++ au_cpup_attr_changeable(inode); ++ ++ out_unlock: ++ mutex_unlock(&a->h_inode->i_mutex); ++ au_unpin(&a->pin); ++ di_write_unlock(dentry); ++ out_si: ++ if (file) { ++ fi_write_unlock(file); ++ ia->ia_file = file; ++ ia->ia_valid |= ATTR_FILE; ++ } ++ si_read_unlock(sb); ++ kfree(a); ++ out: ++ return err; ++} ++ ++static int au_getattr_lock_reval(struct dentry *dentry, unsigned int sigen) ++{ ++ int err; ++ struct inode *inode; ++ struct dentry *parent; ++ ++ err = 0; ++ inode = dentry->d_inode; ++ di_write_lock_child(dentry); ++ if (au_digen(dentry) != sigen || au_iigen(inode) != sigen) { ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ /* returns a number of positive dentries */ ++ err = au_refresh_hdentry(dentry, inode->i_mode & S_IFMT); ++ if (err > 0) ++ err = au_refresh_hinode(inode, dentry); ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++ if (unlikely(!err)) ++ err = -EIO; ++ } ++ di_downgrade_lock(dentry, AuLock_IR); ++ ++ return err; ++} ++ ++static void au_refresh_iattr(struct inode *inode, struct kstat *st, ++ unsigned int nlink) ++{ ++ inode->i_mode = st->mode; ++ inode->i_uid = st->uid; ++ inode->i_gid = st->gid; ++ inode->i_atime = st->atime; ++ inode->i_mtime = st->mtime; ++ inode->i_ctime = st->ctime; ++ ++ au_cpup_attr_nlink(inode, /*force*/0); ++ if (S_ISDIR(inode->i_mode)) { ++ inode->i_nlink -= nlink; ++ inode->i_nlink += st->nlink; ++ } ++ ++ spin_lock(&inode->i_lock); ++ inode->i_blocks = st->blocks; ++ i_size_write(inode, st->size); ++ spin_unlock(&inode->i_lock); ++} ++ ++static int aufs_getattr(struct vfsmount *mnt __maybe_unused, ++ struct dentry *dentry, struct kstat *st) ++{ ++ int err; ++ unsigned int mnt_flags; ++ aufs_bindex_t bindex; ++ unsigned char udba_none, positive, did_lock; ++ struct super_block *sb, *h_sb; ++ struct inode *inode; ++ struct vfsmount *h_mnt; ++ struct dentry *h_dentry; ++ ++ err = 0; ++ did_lock = 0; ++ sb = dentry->d_sb; ++ inode = dentry->d_inode; ++ si_read_lock(sb, AuLock_FLUSH); ++ if (IS_ROOT(dentry)) { ++ /* lock free root dinfo */ ++ h_dentry = dget(au_di(dentry)->di_hdentry->hd_dentry); ++ h_mnt = au_sbr_mnt(sb, 0); ++ goto getattr; ++ } ++ ++ did_lock = 1; ++ mnt_flags = au_mntflags(sb); ++ udba_none = !!au_opt_test(mnt_flags, UDBA_NONE); ++ ++ /* support fstat(2) */ ++ if (!d_unhashed(dentry) && !udba_none) { ++ unsigned int sigen = au_sigen(sb); ++ if (au_digen(dentry) == sigen && au_iigen(inode) == sigen) ++ di_read_lock_child(dentry, AuLock_IR); ++ else { ++ err = au_getattr_lock_reval(dentry, sigen); ++ if (unlikely(err)) ++ goto out; ++ } ++ } else ++ di_read_lock_child(dentry, AuLock_IR); ++ ++ bindex = au_ibstart(inode); ++ h_mnt = au_sbr_mnt(sb, bindex); ++ h_sb = h_mnt->mnt_sb; ++ if (!au_test_fs_bad_iattr(h_sb) && udba_none) ++ goto out_fill; /* success */ ++ ++ if (au_dbstart(dentry) == bindex) ++ h_dentry = dget(au_h_dptr(dentry, bindex)); ++ else if (au_opt_test(mnt_flags, PLINK) && au_plink_test(inode)) { ++ h_dentry = au_plink_lkup(inode, bindex); ++ if (IS_ERR(h_dentry)) ++ goto out_fill; /* pretending success */ ++ } else ++ /* illegally overlapped or something */ ++ goto out_fill; /* pretending success */ ++ ++ getattr: ++ positive = !!h_dentry->d_inode; ++ if (positive) ++ err = vfs_getattr(h_mnt, h_dentry, st); ++ dput(h_dentry); ++ if (!err) { ++ if (positive) ++ au_refresh_iattr(inode, st, h_dentry->d_inode->i_nlink); ++ goto out_fill; /* success */ ++ } ++ goto out; ++ ++ out_fill: ++ generic_fillattr(inode, st); ++ out: ++ if (did_lock) ++ di_read_unlock(dentry, AuLock_IR); ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int h_readlink(struct dentry *dentry, int bindex, char __user *buf, ++ int bufsiz) ++{ ++ int err; ++ struct super_block *sb; ++ struct dentry *h_dentry; ++ ++ err = -EINVAL; ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (unlikely(/* !h_dentry ++ || !h_dentry->d_inode ++ || !h_dentry->d_inode->i_op ++ || */ !h_dentry->d_inode->i_op->readlink)) ++ goto out; ++ ++ err = security_inode_readlink(h_dentry); ++ if (unlikely(err)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ if (!au_test_ro(sb, bindex, dentry->d_inode)) { ++ vfsub_touch_atime(au_sbr_mnt(sb, bindex), h_dentry); ++ fsstack_copy_attr_atime(dentry->d_inode, h_dentry->d_inode); ++ } ++ err = h_dentry->d_inode->i_op->readlink(h_dentry, buf, bufsiz); ++ ++ out: ++ return err; ++} ++ ++static int aufs_readlink(struct dentry *dentry, char __user *buf, int bufsiz) ++{ ++ int err; ++ ++ aufs_read_lock(dentry, AuLock_IR); ++ err = h_readlink(dentry, au_dbstart(dentry), buf, bufsiz); ++ aufs_read_unlock(dentry, AuLock_IR); ++ ++ return err; ++} ++ ++static void *aufs_follow_link(struct dentry *dentry, struct nameidata *nd) ++{ ++ int err; ++ char *buf; ++ mm_segment_t old_fs; ++ ++ err = -ENOMEM; ++ buf = __getname(); ++ if (unlikely(!buf)) ++ goto out; ++ ++ aufs_read_lock(dentry, AuLock_IR); ++ old_fs = get_fs(); ++ set_fs(KERNEL_DS); ++ err = h_readlink(dentry, au_dbstart(dentry), (char __user *)buf, ++ PATH_MAX); ++ set_fs(old_fs); ++ aufs_read_unlock(dentry, AuLock_IR); ++ ++ if (err >= 0) { ++ buf[err] = 0; ++ /* will be freed by put_link */ ++ nd_set_link(nd, buf); ++ return NULL; /* success */ ++ } ++ __putname(buf); ++ ++ out: ++ path_put(&nd->path); ++ AuTraceErr(err); ++ return ERR_PTR(err); ++} ++ ++static void aufs_put_link(struct dentry *dentry __maybe_unused, ++ struct nameidata *nd, void *cookie __maybe_unused) ++{ ++ __putname(nd_get_link(nd)); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void aufs_truncate_range(struct inode *inode __maybe_unused, ++ loff_t start __maybe_unused, ++ loff_t end __maybe_unused) ++{ ++ AuUnsupport(); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct inode_operations aufs_symlink_iop = { ++ .permission = aufs_permission, ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr, ++ .readlink = aufs_readlink, ++ .follow_link = aufs_follow_link, ++ .put_link = aufs_put_link ++}; ++ ++struct inode_operations aufs_dir_iop = { ++ .create = aufs_create, ++ .lookup = aufs_lookup, ++ .link = aufs_link, ++ .unlink = aufs_unlink, ++ .symlink = aufs_symlink, ++ .mkdir = aufs_mkdir, ++ .rmdir = aufs_rmdir, ++ .mknod = aufs_mknod, ++ .rename = aufs_rename, ++ ++ .permission = aufs_permission, ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr ++}; ++ ++struct inode_operations aufs_iop = { ++ .permission = aufs_permission, ++ .setattr = aufs_setattr, ++ .getattr = aufs_getattr, ++ .truncate_range = aufs_truncate_range ++}; +diff -Naur a/fs/aufs/i_op_del.c b/fs/aufs/i_op_del.c +--- a/fs/aufs/i_op_del.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/i_op_del.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,466 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode operations (del entry) ++ */ ++ ++#include "aufs.h" ++ ++/* ++ * decide if a new whiteout for @dentry is necessary or not. ++ * when it is necessary, prepare the parent dir for the upper branch whose ++ * branch index is @bcpup for creation. the actual creation of the whiteout will ++ * be done by caller. ++ * return value: ++ * 0: wh is unnecessary ++ * plus: wh is necessary ++ * minus: error ++ */ ++int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup) ++{ ++ int need_wh, err; ++ aufs_bindex_t bstart; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ bstart = au_dbstart(dentry); ++ if (*bcpup < 0) { ++ *bcpup = bstart; ++ if (au_test_ro(sb, bstart, dentry->d_inode)) { ++ err = AuWbrCopyup(au_sbi(sb), dentry); ++ *bcpup = err; ++ if (unlikely(err < 0)) ++ goto out; ++ } ++ } else ++ AuDebugOn(bstart < *bcpup ++ || au_test_ro(sb, *bcpup, dentry->d_inode)); ++ AuDbg("bcpup %d, bstart %d\n", *bcpup, bstart); ++ ++ if (*bcpup != bstart) { ++ err = au_cpup_dirs(dentry, *bcpup); ++ if (unlikely(err)) ++ goto out; ++ need_wh = 1; ++ } else { ++ aufs_bindex_t old_bend, new_bend, bdiropq = -1; ++ ++ old_bend = au_dbend(dentry); ++ if (isdir) { ++ bdiropq = au_dbdiropq(dentry); ++ au_set_dbdiropq(dentry, -1); ++ } ++ need_wh = au_lkup_dentry(dentry, bstart + 1, /*type*/0, ++ /*nd*/NULL); ++ err = need_wh; ++ if (isdir) ++ au_set_dbdiropq(dentry, bdiropq); ++ if (unlikely(err < 0)) ++ goto out; ++ new_bend = au_dbend(dentry); ++ if (!need_wh && old_bend != new_bend) { ++ au_set_h_dptr(dentry, new_bend, NULL); ++ au_set_dbend(dentry, old_bend); ++ } ++ } ++ AuDbg("need_wh %d\n", need_wh); ++ err = need_wh; ++ ++ out: ++ return err; ++} ++ ++/* ++ * simple tests for the del-entry operations. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++int au_may_del(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent, int isdir) ++{ ++ int err; ++ umode_t h_mode; ++ struct dentry *h_dentry, *h_latest; ++ struct inode *h_inode; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ h_inode = h_dentry->d_inode; ++ if (dentry->d_inode) { ++ err = -ENOENT; ++ if (unlikely(!h_inode || !h_inode->i_nlink)) ++ goto out; ++ ++ h_mode = h_inode->i_mode; ++ if (!isdir) { ++ err = -EISDIR; ++ if (unlikely(S_ISDIR(h_mode))) ++ goto out; ++ } else if (unlikely(!S_ISDIR(h_mode))) { ++ err = -ENOTDIR; ++ goto out; ++ } ++ } else { ++ /* rename(2) case */ ++ err = -EIO; ++ if (unlikely(h_inode)) ++ goto out; ++ } ++ ++ err = -ENOENT; ++ /* expected parent dir is locked */ ++ if (unlikely(h_parent != h_dentry->d_parent)) ++ goto out; ++ err = 0; ++ ++ /* ++ * rmdir a dir may break the consistency on some filesystem. ++ * let's try heavy test. ++ */ ++ err = -EACCES; ++ if (unlikely(au_test_h_perm(h_parent->d_inode, MAY_EXEC | MAY_WRITE))) ++ goto out; ++ ++ h_latest = au_sio_lkup_one(&dentry->d_name, h_parent, ++ au_sbr(dentry->d_sb, bindex)); ++ err = -EIO; ++ if (IS_ERR(h_latest)) ++ goto out; ++ if (h_latest == h_dentry) ++ err = 0; ++ dput(h_latest); ++ ++ out: ++ return err; ++} ++ ++/* ++ * decide the branch where we operate for @dentry. the branch index will be set ++ * @rbcpup. after diciding it, 'pin' it and store the timestamps of the parent ++ * dir for reverting. ++ * when a new whiteout is necessary, create it. ++ */ ++static struct dentry* ++lock_hdir_create_wh(struct dentry *dentry, int isdir, aufs_bindex_t *rbcpup, ++ struct au_dtime *dt, struct au_pin *pin) ++{ ++ struct dentry *wh_dentry; ++ struct super_block *sb; ++ struct path h_path; ++ int err, need_wh; ++ unsigned int udba; ++ aufs_bindex_t bcpup; ++ ++ need_wh = au_wr_dir_need_wh(dentry, isdir, rbcpup); ++ wh_dentry = ERR_PTR(need_wh); ++ if (unlikely(need_wh < 0)) ++ goto out; ++ ++ sb = dentry->d_sb; ++ udba = au_opt_udba(sb); ++ bcpup = *rbcpup; ++ err = au_pin(pin, dentry, bcpup, udba, ++ AuPin_DI_LOCKED | AuPin_MNT_WRITE); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out; ++ ++ h_path.dentry = au_pinned_h_parent(pin); ++ if (udba != AuOpt_UDBA_NONE ++ && au_dbstart(dentry) == bcpup) { ++ err = au_may_del(dentry, bcpup, h_path.dentry, isdir); ++ wh_dentry = ERR_PTR(err); ++ if (unlikely(err)) ++ goto out_unpin; ++ } ++ ++ h_path.mnt = au_sbr_mnt(sb, bcpup); ++ au_dtime_store(dt, au_pinned_parent(pin), &h_path); ++ wh_dentry = NULL; ++ if (!need_wh) ++ goto out; /* success, no need to create whiteout */ ++ ++ wh_dentry = au_wh_create(dentry, bcpup, h_path.dentry); ++ if (!IS_ERR(wh_dentry)) ++ goto out; /* success */ ++ /* returns with the parent is locked and wh_dentry is dget-ed */ ++ ++ out_unpin: ++ au_unpin(pin); ++ out: ++ return wh_dentry; ++} ++ ++/* ++ * when removing a dir, rename it to a unique temporary whiteout-ed name first ++ * in order to be revertible and save time for removing many child whiteouts ++ * under the dir. ++ * returns 1 when there are too many child whiteout and caller should remove ++ * them asynchronously. returns 0 when the number of children is enough small to ++ * remove now or the branch fs is a remote fs. ++ * otherwise return an error. ++ */ ++static int renwh_and_rmdir(struct dentry *dentry, aufs_bindex_t bindex, ++ struct au_nhash *whlist, struct inode *dir) ++{ ++ int rmdir_later, err, dirwh; ++ struct dentry *h_dentry; ++ struct super_block *sb; ++ ++ sb = dentry->d_sb; ++ h_dentry = au_h_dptr(dentry, bindex); ++ err = au_whtmp_ren(h_dentry, au_sbr(sb, bindex)); ++ if (unlikely(err)) ++ goto out; ++ ++ /* stop monitoring */ ++ au_hin_free(au_hi(dentry->d_inode, bindex)); ++ ++ if (!au_test_fs_remote(h_dentry->d_sb)) { ++ dirwh = au_sbi(sb)->si_dirwh; ++ rmdir_later = (dirwh <= 1); ++ if (!rmdir_later) ++ rmdir_later = au_nhash_test_longer_wh(whlist, bindex, ++ dirwh); ++ if (rmdir_later) ++ return rmdir_later; ++ } ++ ++ err = au_whtmp_rmdir(dir, bindex, h_dentry, whlist); ++ if (unlikely(err)) { ++ AuIOErr("rmdir %.*s, b%d failed, %d. ignored\n", ++ AuDLNPair(h_dentry), bindex, err); ++ err = 0; ++ } ++ ++ out: ++ return err; ++} ++ ++/* ++ * final procedure for deleting a entry. ++ * maintain dentry and iattr. ++ */ ++static void epilog(struct inode *dir, struct dentry *dentry, ++ aufs_bindex_t bindex) ++{ ++ struct inode *inode; ++ ++ inode = dentry->d_inode; ++ d_drop(dentry); ++ inode->i_ctime = dir->i_ctime; ++ ++ if (atomic_read(&dentry->d_count) == 1) { ++ au_set_h_dptr(dentry, au_dbstart(dentry), NULL); ++ au_update_dbstart(dentry); ++ } ++ if (au_ibstart(dir) == bindex) ++ au_cpup_attr_timesizes(dir); ++ dir->i_version++; ++} ++ ++/* ++ * when an error happened, remove the created whiteout and revert everything. ++ */ ++static int do_revert(int err, struct inode *dir, aufs_bindex_t bwh, ++ struct dentry *wh_dentry, struct dentry *dentry, ++ struct au_dtime *dt) ++{ ++ int rerr; ++ struct path h_path = { ++ .dentry = wh_dentry, ++ .mnt = au_sbr_mnt(dir->i_sb, bwh) ++ }; ++ ++ rerr = au_wh_unlink_dentry(au_h_iptr(dir, bwh), &h_path, dentry); ++ if (!rerr) { ++ au_set_dbwh(dentry, bwh); ++ au_dtime_revert(dt); ++ return 0; ++ } ++ ++ AuIOErr("%.*s reverting whiteout failed(%d, %d)\n", ++ AuDLNPair(dentry), err, rerr); ++ return -EIO; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int aufs_unlink(struct inode *dir, struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bwh, bindex, bstart; ++ struct au_dtime dt; ++ struct au_pin pin; ++ struct path h_path; ++ struct inode *inode, *h_dir; ++ struct dentry *parent, *wh_dentry; ++ ++ IMustLock(dir); ++ inode = dentry->d_inode; ++ if (unlikely(!inode)) ++ return -ENOENT; /* possible? */ ++ IMustLock(inode); ++ ++ aufs_read_lock(dentry, AuLock_DW); ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ ++ bstart = au_dbstart(dentry); ++ bwh = au_dbwh(dentry); ++ bindex = -1; ++ wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/0, &bindex, &dt, &pin); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ h_path.mnt = au_sbr_mnt(dentry->d_sb, bstart); ++ h_path.dentry = au_h_dptr(dentry, bstart); ++ dget(h_path.dentry); ++ if (bindex == bstart) { ++ h_dir = au_pinned_h_dir(&pin); ++ err = vfsub_unlink(h_dir, &h_path, /*force*/0); ++ } else { ++ /* dir inode is locked */ ++ h_dir = wh_dentry->d_parent->d_inode; ++ IMustLock(h_dir); ++ err = 0; ++ } ++ ++ if (!err) { ++ drop_nlink(inode); ++ epilog(dir, dentry, bindex); ++ ++ /* update target timestamps */ ++ if (bindex == bstart) { ++ vfsub_update_h_iattr(&h_path, /*did*/NULL); /*ignore*/ ++ inode->i_ctime = h_path.dentry->d_inode->i_ctime; ++ } else ++ /* todo: this timestamp may be reverted later */ ++ inode->i_ctime = h_dir->i_ctime; ++ goto out_unlock; /* success */ ++ } ++ ++ /* revert */ ++ if (wh_dentry) { ++ int rerr; ++ ++ rerr = do_revert(err, dir, bwh, wh_dentry, dentry, &dt); ++ if (rerr) ++ err = rerr; ++ } ++ ++ out_unlock: ++ au_unpin(&pin); ++ dput(wh_dentry); ++ dput(h_path.dentry); ++ out: ++ di_write_unlock(parent); ++ aufs_read_unlock(dentry, AuLock_DW); ++ return err; ++} ++ ++int aufs_rmdir(struct inode *dir, struct dentry *dentry) ++{ ++ int err, rmdir_later; ++ aufs_bindex_t bwh, bindex, bstart; ++ struct au_dtime dt; ++ struct au_pin pin; ++ struct inode *inode; ++ struct dentry *parent, *wh_dentry, *h_dentry; ++ struct au_whtmp_rmdir *args; ++ ++ IMustLock(dir); ++ inode = dentry->d_inode; ++ err = -ENOENT; /* possible? */ ++ if (unlikely(!inode)) ++ goto out; ++ IMustLock(inode); ++ ++ err = -ENOMEM; ++ args = au_whtmp_rmdir_alloc(dir->i_sb, GFP_NOFS); ++ if (unlikely(!args)) ++ goto out; ++ ++ aufs_read_lock(dentry, AuLock_DW | AuLock_FLUSH); ++ parent = dentry->d_parent; /* dir inode is locked */ ++ di_write_lock_parent(parent); ++ err = au_test_empty(dentry, &args->whlist); ++ if (unlikely(err)) ++ goto out_args; ++ ++ bstart = au_dbstart(dentry); ++ bwh = au_dbwh(dentry); ++ bindex = -1; ++ wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/1, &bindex, &dt, &pin); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out_args; ++ ++ h_dentry = au_h_dptr(dentry, bstart); ++ dget(h_dentry); ++ rmdir_later = 0; ++ if (bindex == bstart) { ++ err = renwh_and_rmdir(dentry, bstart, &args->whlist, dir); ++ if (err > 0) { ++ rmdir_later = err; ++ err = 0; ++ } ++ } else { ++ /* stop monitoring */ ++ au_hin_free(au_hi(inode, bstart)); ++ ++ /* dir inode is locked */ ++ IMustLock(wh_dentry->d_parent->d_inode); ++ err = 0; ++ } ++ ++ if (!err) { ++ clear_nlink(inode); ++ au_set_dbdiropq(dentry, -1); ++ epilog(dir, dentry, bindex); ++ ++ if (rmdir_later) { ++ au_whtmp_kick_rmdir(dir, bstart, h_dentry, args); ++ args = NULL; ++ } ++ ++ goto out_unlock; /* success */ ++ } ++ ++ /* revert */ ++ AuLabel(revert); ++ if (wh_dentry) { ++ int rerr; ++ ++ rerr = do_revert(err, dir, bwh, wh_dentry, dentry, &dt); ++ if (rerr) ++ err = rerr; ++ } ++ ++ out_unlock: ++ au_unpin(&pin); ++ dput(wh_dentry); ++ dput(h_dentry); ++ out_args: ++ di_write_unlock(parent); ++ aufs_read_unlock(dentry, AuLock_DW); ++ if (args) ++ au_whtmp_rmdir_free(args); ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/i_op_ren.c b/fs/aufs/i_op_ren.c +--- a/fs/aufs/i_op_ren.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/i_op_ren.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,942 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * inode operation (rename entry) ++ * todo: this is crazy monster ++ */ ++ ++#include "aufs.h" ++ ++enum { AuSRC, AuDST, AuSrcDst }; ++enum { AuPARENT, AuCHILD, AuParentChild }; ++ ++#define AuRen_ISDIR 1 ++#define AuRen_ISSAMEDIR (1 << 1) ++#define AuRen_WHSRC (1 << 2) ++#define AuRen_WHDST (1 << 3) ++#define AuRen_MNT_WRITE (1 << 4) ++#define AuRen_DT_DSTDIR (1 << 5) ++#define AuRen_DIROPQ (1 << 6) ++#define AuRen_CPUP (1 << 7) ++#define au_ftest_ren(flags, name) ((flags) & AuRen_##name) ++#define au_fset_ren(flags, name) { (flags) |= AuRen_##name; } ++#define au_fclr_ren(flags, name) { (flags) &= ~AuRen_##name; } ++ ++struct au_ren_args { ++ struct { ++ struct dentry *dentry, *h_dentry, *parent, *h_parent, ++ *wh_dentry; ++ struct inode *dir, *inode; ++ struct au_hinode *hdir; ++ struct au_dtime dt[AuParentChild]; ++ aufs_bindex_t bstart; ++ } sd[AuSrcDst]; ++ ++#define src_dentry sd[AuSRC].dentry ++#define src_dir sd[AuSRC].dir ++#define src_inode sd[AuSRC].inode ++#define src_h_dentry sd[AuSRC].h_dentry ++#define src_parent sd[AuSRC].parent ++#define src_h_parent sd[AuSRC].h_parent ++#define src_wh_dentry sd[AuSRC].wh_dentry ++#define src_hdir sd[AuSRC].hdir ++#define src_h_dir sd[AuSRC].hdir->hi_inode ++#define src_dt sd[AuSRC].dt ++#define src_bstart sd[AuSRC].bstart ++ ++#define dst_dentry sd[AuDST].dentry ++#define dst_dir sd[AuDST].dir ++#define dst_inode sd[AuDST].inode ++#define dst_h_dentry sd[AuDST].h_dentry ++#define dst_parent sd[AuDST].parent ++#define dst_h_parent sd[AuDST].h_parent ++#define dst_wh_dentry sd[AuDST].wh_dentry ++#define dst_hdir sd[AuDST].hdir ++#define dst_h_dir sd[AuDST].hdir->hi_inode ++#define dst_dt sd[AuDST].dt ++#define dst_bstart sd[AuDST].bstart ++ ++ struct dentry *h_trap; ++ struct au_branch *br; ++ struct au_hinode *src_hinode; ++ struct path h_path; ++ struct au_nhash whlist; ++ aufs_bindex_t btgt; ++ ++ unsigned int flags; ++ ++ struct au_whtmp_rmdir *thargs; ++ struct dentry *h_dst; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * functions for reverting. ++ * when an error happened in a single rename systemcall, we should revert ++ * everything as if nothing happend. ++ * we don't need to revert the copied-up/down the parent dir since they are ++ * harmless. ++ */ ++ ++#define RevertFailure(fmt, args...) do { \ ++ AuIOErr("revert failure: " fmt " (%d, %d)\n", \ ++ ##args, err, rerr); \ ++ err = -EIO; \ ++} while (0) ++ ++static void au_ren_rev_diropq(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ au_hin_imtx_lock_nested(a->src_hinode, AuLsc_I_CHILD); ++ rerr = au_diropq_remove(a->src_dentry, a->btgt); ++ au_hin_imtx_unlock(a->src_hinode); ++ if (rerr) ++ RevertFailure("remove diropq %.*s", AuDLNPair(a->src_dentry)); ++} ++ ++ ++static void au_ren_rev_rename(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ a->h_path.dentry = au_lkup_one(&a->src_dentry->d_name, a->src_h_parent, ++ a->br, /*nd*/NULL); ++ rerr = PTR_ERR(a->h_path.dentry); ++ if (IS_ERR(a->h_path.dentry)) { ++ RevertFailure("au_lkup_one %.*s", AuDLNPair(a->src_dentry)); ++ return; ++ } ++ ++ rerr = vfsub_rename(a->dst_h_dir, ++ au_h_dptr(a->src_dentry, a->btgt), ++ a->src_h_dir, &a->h_path); ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ /* au_set_h_dptr(a->src_dentry, a->btgt, NULL); */ ++ if (rerr) ++ RevertFailure("rename %.*s", AuDLNPair(a->src_dentry)); ++} ++ ++static void au_ren_rev_cpup(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ a->h_path.dentry = a->dst_h_dentry; ++ rerr = vfsub_unlink(a->dst_h_dir, &a->h_path, /*force*/0); ++ au_set_h_dptr(a->src_dentry, a->btgt, NULL); ++ au_set_dbstart(a->src_dentry, a->src_bstart); ++ if (rerr) ++ RevertFailure("unlink %.*s", AuDLNPair(a->dst_h_dentry)); ++} ++ ++ ++static void au_ren_rev_whtmp(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ a->h_path.dentry = au_lkup_one(&a->dst_dentry->d_name, a->dst_h_parent, ++ a->br, /*nd*/NULL); ++ rerr = PTR_ERR(a->h_path.dentry); ++ if (IS_ERR(a->h_path.dentry)) { ++ RevertFailure("lookup %.*s", AuDLNPair(a->dst_dentry)); ++ return; ++ } ++ if (a->h_path.dentry->d_inode) { ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ return; ++ } ++ ++ rerr = vfsub_rename(a->dst_h_dir, a->h_dst, a->dst_h_dir, &a->h_path); ++ d_drop(a->h_path.dentry); ++ dput(a->h_path.dentry); ++ if (!rerr) { ++ au_set_h_dptr(a->dst_dentry, a->btgt, NULL); ++ au_set_h_dptr(a->dst_dentry, a->btgt, dget(a->h_dst)); ++ } else ++ RevertFailure("rename %.*s", AuDLNPair(a->h_dst)); ++} ++ ++static void au_ren_rev_whsrc(int err, struct au_ren_args *a) ++{ ++ int rerr; ++ ++ a->h_path.dentry = a->src_wh_dentry; ++ rerr = au_wh_unlink_dentry(a->src_h_dir, &a->h_path, a->src_dentry); ++ if (rerr) ++ RevertFailure("unlink %.*s", AuDLNPair(a->src_wh_dentry)); ++} ++ ++static void au_ren_rev_drop(struct au_ren_args *a) ++{ ++ struct dentry *d, *h_d; ++ int i; ++ aufs_bindex_t bend, bindex; ++ ++ for (i = 0; i < AuSrcDst; i++) { ++ d = a->sd[i].dentry; ++ d_drop(d); ++ bend = au_dbend(d); ++ for (bindex = au_dbstart(d); bindex <= bend; bindex++) { ++ h_d = au_h_dptr(d, bindex); ++ if (h_d) ++ d_drop(h_d); ++ } ++ } ++ ++ au_update_dbstart(a->dst_dentry); ++ if (a->thargs) ++ d_drop(a->h_dst); ++} ++#undef RevertFailure ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * when we have to copyup the renaming entry, do it with the rename-target name ++ * in order to minimize the cost (the later actual rename is unnecessary). ++ * otherwise rename it on the target branch. ++ */ ++static int au_ren_or_cpup(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *d; ++ ++ d = a->src_dentry; ++ if (au_dbstart(d) == a->btgt) { ++ a->h_path.dentry = a->dst_h_dentry; ++ if (au_ftest_ren(a->flags, DIROPQ) ++ && au_dbdiropq(d) == a->btgt) ++ au_fclr_ren(a->flags, DIROPQ); ++ AuDebugOn(au_dbstart(d) != a->btgt); ++ err = vfsub_rename(a->src_h_dir, au_h_dptr(d, a->btgt), ++ a->dst_h_dir, &a->h_path); ++ } else { ++ struct mutex *h_mtx = &a->src_h_dentry->d_inode->i_mutex; ++ ++ au_fset_ren(a->flags, CPUP); ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ au_set_dbstart(d, a->btgt); ++ au_set_h_dptr(d, a->btgt, dget(a->dst_h_dentry)); ++ err = au_sio_cpup_single(d, a->btgt, a->src_bstart, -1, ++ !AuCpup_DTIME, a->dst_parent); ++ if (unlikely(err)) { ++ au_set_h_dptr(d, a->btgt, NULL); ++ au_set_dbstart(d, a->src_bstart); ++ } ++ mutex_unlock(h_mtx); ++ } ++ ++ return err; ++} ++ ++/* cf. aufs_rmdir() */ ++static int au_ren_del_whtmp(struct au_ren_args *a) ++{ ++ int err; ++ struct inode *dir; ++ ++ dir = a->dst_dir; ++ if (!au_nhash_test_longer_wh(&a->whlist, a->btgt, ++ au_sbi(dir->i_sb)->si_dirwh) ++ || au_test_fs_remote(a->h_dst->d_sb)) { ++ err = au_whtmp_rmdir(dir, a->btgt, a->h_dst, &a->whlist); ++ if (unlikely(err)) ++ AuWarn("failed removing whtmp dir %.*s (%d), " ++ "ignored.\n", AuDLNPair(a->h_dst), err); ++ } else { ++ au_nhash_wh_free(&a->thargs->whlist); ++ a->thargs->whlist = a->whlist; ++ a->whlist.nh_num = 0; ++ au_whtmp_kick_rmdir(dir, a->btgt, a->h_dst, a->thargs); ++ dput(a->h_dst); ++ a->thargs = NULL; ++ } ++ ++ return 0; ++} ++ ++/* make it 'opaque' dir. */ ++static int au_ren_diropq(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *diropq; ++ ++ err = 0; ++ a->src_hinode = au_hi(a->src_inode, a->btgt); ++ au_hin_imtx_lock_nested(a->src_hinode, AuLsc_I_CHILD); ++ diropq = au_diropq_create(a->src_dentry, a->btgt); ++ au_hin_imtx_unlock(a->src_hinode); ++ if (IS_ERR(diropq)) ++ err = PTR_ERR(diropq); ++ dput(diropq); ++ ++ return err; ++} ++ ++static int do_rename(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *d, *h_d; ++ ++ /* prepare workqueue args for asynchronous rmdir */ ++ h_d = a->dst_h_dentry; ++ if (au_ftest_ren(a->flags, ISDIR) && h_d->d_inode) { ++ err = -ENOMEM; ++ a->thargs = au_whtmp_rmdir_alloc(a->src_dentry->d_sb, GFP_NOFS); ++ if (unlikely(!a->thargs)) ++ goto out; ++ a->h_dst = dget(h_d); ++ } ++ ++ /* create whiteout for src_dentry */ ++ if (au_ftest_ren(a->flags, WHSRC)) { ++ a->src_wh_dentry ++ = au_wh_create(a->src_dentry, a->btgt, a->src_h_parent); ++ err = PTR_ERR(a->src_wh_dentry); ++ if (IS_ERR(a->src_wh_dentry)) ++ goto out_thargs; ++ } ++ ++ /* lookup whiteout for dentry */ ++ if (au_ftest_ren(a->flags, WHDST)) { ++ h_d = au_wh_lkup(a->dst_h_parent, &a->dst_dentry->d_name, ++ a->br); ++ err = PTR_ERR(h_d); ++ if (IS_ERR(h_d)) ++ goto out_whsrc; ++ if (!h_d->d_inode) ++ dput(h_d); ++ else ++ a->dst_wh_dentry = h_d; ++ } ++ ++ /* rename dentry to tmpwh */ ++ if (a->thargs) { ++ err = au_whtmp_ren(a->dst_h_dentry, a->br); ++ if (unlikely(err)) ++ goto out_whdst; ++ ++ d = a->dst_dentry; ++ au_set_h_dptr(d, a->btgt, NULL); ++ err = au_lkup_neg(d, a->btgt); ++ if (unlikely(err)) ++ goto out_whtmp; ++ a->dst_h_dentry = au_h_dptr(d, a->btgt); ++ } ++ ++ /* cpup src */ ++ if (a->dst_h_dentry->d_inode && a->src_bstart != a->btgt) { ++ struct mutex *h_mtx = &a->src_h_dentry->d_inode->i_mutex; ++ ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ err = au_sio_cpup_simple(a->src_dentry, a->btgt, -1, ++ !AuCpup_DTIME); ++ mutex_unlock(h_mtx); ++ if (unlikely(err)) ++ goto out_whtmp; ++ } ++ ++ /* rename by vfs_rename or cpup */ ++ d = a->dst_dentry; ++ if (au_ftest_ren(a->flags, ISDIR) ++ && (a->dst_wh_dentry ++ || au_dbdiropq(d) == a->btgt ++ /* hide the lower to keep xino */ ++ || a->btgt < au_dbend(d) ++ || au_opt_test(au_mntflags(d->d_sb), ALWAYS_DIROPQ))) ++ au_fset_ren(a->flags, DIROPQ); ++ err = au_ren_or_cpup(a); ++ if (unlikely(err)) ++ /* leave the copied-up one */ ++ goto out_whtmp; ++ ++ /* make dir opaque */ ++ if (au_ftest_ren(a->flags, DIROPQ)) { ++ err = au_ren_diropq(a); ++ if (unlikely(err)) ++ goto out_rename; ++ } ++ ++ /* update target timestamps */ ++ AuDebugOn(au_dbstart(a->src_dentry) != a->btgt); ++ a->h_path.dentry = au_h_dptr(a->src_dentry, a->btgt); ++ vfsub_update_h_iattr(&a->h_path, /*did*/NULL); /*ignore*/ ++ a->src_inode->i_ctime = a->h_path.dentry->d_inode->i_ctime; ++ ++ /* remove whiteout for dentry */ ++ if (a->dst_wh_dentry) { ++ a->h_path.dentry = a->dst_wh_dentry; ++ err = au_wh_unlink_dentry(a->dst_h_dir, &a->h_path, ++ a->dst_dentry); ++ if (unlikely(err)) ++ goto out_diropq; ++ } ++ ++ /* remove whtmp */ ++ if (a->thargs) ++ au_ren_del_whtmp(a); /* ignore this error */ ++ ++ err = 0; ++ goto out_success; ++ ++ out_diropq: ++ if (au_ftest_ren(a->flags, DIROPQ)) ++ au_ren_rev_diropq(err, a); ++ out_rename: ++ if (!au_ftest_ren(a->flags, CPUP)) ++ au_ren_rev_rename(err, a); ++ else ++ au_ren_rev_cpup(err, a); ++ out_whtmp: ++ if (a->thargs) ++ au_ren_rev_whtmp(err, a); ++ out_whdst: ++ dput(a->dst_wh_dentry); ++ a->dst_wh_dentry = NULL; ++ out_whsrc: ++ if (a->src_wh_dentry) ++ au_ren_rev_whsrc(err, a); ++ au_ren_rev_drop(a); ++ out_success: ++ dput(a->src_wh_dentry); ++ dput(a->dst_wh_dentry); ++ out_thargs: ++ if (a->thargs) { ++ dput(a->h_dst); ++ au_whtmp_rmdir_free(a->thargs); ++ a->thargs = NULL; ++ } ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * test if @dentry dir can be rename destination or not. ++ * success means, it is a logically empty dir. ++ */ ++static int may_rename_dstdir(struct dentry *dentry, struct au_nhash *whlist) ++{ ++ return au_test_empty(dentry, whlist); ++} ++ ++/* ++ * test if @dentry dir can be rename source or not. ++ * if it can, return 0 and @children is filled. ++ * success means, ++ * - it is a logically empty dir. ++ * - or, it exists on writable branch and has no children including whiteouts ++ * on the lower branch. ++ */ ++static int may_rename_srcdir(struct dentry *dentry, aufs_bindex_t btgt) ++{ ++ int err; ++ aufs_bindex_t bstart; ++ ++ bstart = au_dbstart(dentry); ++ if (bstart != btgt) { ++ struct au_nhash whlist; ++ ++ err = au_nhash_alloc(&whlist, au_sbi(dentry->d_sb)->si_rdhash, ++ GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_test_empty(dentry, &whlist); ++ au_nhash_wh_free(&whlist); ++ goto out; ++ } ++ ++ if (bstart == au_dbtaildir(dentry)) ++ return 0; /* success */ ++ ++ err = au_test_empty_lower(dentry); ++ ++ out: ++ if (err == -ENOTEMPTY) { ++ AuWarn1("renaming dir who has child(ren) on multiple branches," ++ " is not supported\n"); ++ err = -EXDEV; ++ } ++ return err; ++} ++ ++/* side effect: sets whlist and h_dentry */ ++static int au_ren_may_dir(struct au_ren_args *a) ++{ ++ int err; ++ struct dentry *d; ++ ++ d = a->dst_dentry; ++ err = au_nhash_alloc(&a->whlist, au_sbi(d->d_sb)->si_rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ ++ err = 0; ++ if (au_ftest_ren(a->flags, ISDIR) && a->dst_inode) { ++ au_set_dbstart(d, a->dst_bstart); ++ err = may_rename_dstdir(d, &a->whlist); ++ au_set_dbstart(d, a->btgt); ++ } ++ a->dst_h_dentry = au_h_dptr(d, au_dbstart(d)); ++ if (unlikely(err)) ++ goto out; ++ ++ d = a->src_dentry; ++ a->src_h_dentry = au_h_dptr(d, au_dbstart(d)); ++ if (au_ftest_ren(a->flags, ISDIR)) { ++ err = may_rename_srcdir(d, a->btgt); ++ if (unlikely(err)) { ++ au_nhash_wh_free(&a->whlist); ++ a->whlist.nh_num = 0; ++ } ++ } ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * simple tests for rename. ++ * following the checks in vfs, plus the parent-child relationship. ++ */ ++static int au_may_ren(struct au_ren_args *a) ++{ ++ int err, isdir; ++ struct inode *h_inode; ++ ++ if (a->src_bstart == a->btgt) { ++ err = au_may_del(a->src_dentry, a->btgt, a->src_h_parent, ++ au_ftest_ren(a->flags, ISDIR)); ++ if (unlikely(err)) ++ goto out; ++ err = -EINVAL; ++ if (unlikely(a->src_h_dentry == a->h_trap)) ++ goto out; ++ } ++ ++ err = 0; ++ if (a->dst_bstart != a->btgt) ++ goto out; ++ ++ err = -EIO; ++ h_inode = a->dst_h_dentry->d_inode; ++ isdir = !!au_ftest_ren(a->flags, ISDIR); ++ if (!a->dst_dentry->d_inode) { ++ if (unlikely(h_inode)) ++ goto out; ++ err = au_may_add(a->dst_dentry, a->btgt, a->dst_h_parent, ++ isdir); ++ } else { ++ if (unlikely(!h_inode || !h_inode->i_nlink)) ++ goto out; ++ err = au_may_del(a->dst_dentry, a->btgt, a->dst_h_parent, ++ isdir); ++ if (unlikely(err)) ++ goto out; ++ err = -ENOTEMPTY; ++ if (unlikely(a->dst_h_dentry == a->h_trap)) ++ goto out; ++ err = 0; ++ } ++ ++ out: ++ if (unlikely(err == -ENOENT || err == -EEXIST)) ++ err = -EIO; ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * locking order ++ * (VFS) ++ * - src_dir and dir by lock_rename() ++ * - inode if exitsts ++ * (aufs) ++ * - lock all ++ * + src_dentry and dentry by aufs_read_and_write_lock2() which calls, ++ * + si_read_lock ++ * + di_write_lock2_child() ++ * + di_write_lock_child() ++ * + ii_write_lock_child() ++ * + di_write_lock_child2() ++ * + ii_write_lock_child2() ++ * + src_parent and parent ++ * + di_write_lock_parent() ++ * + ii_write_lock_parent() ++ * + di_write_lock_parent2() ++ * + ii_write_lock_parent2() ++ * + lower src_dir and dir by vfsub_lock_rename() ++ * + verify the every relationships between child and parent. if any ++ * of them failed, unlock all and return -EBUSY. ++ */ ++static void au_ren_unlock(struct au_ren_args *a) ++{ ++ struct super_block *sb; ++ ++ sb = a->dst_dentry->d_sb; ++ if (au_ftest_ren(a->flags, MNT_WRITE)) ++ mnt_drop_write(a->br->br_mnt); ++ vfsub_unlock_rename(a->src_h_parent, a->src_hdir, ++ a->dst_h_parent, a->dst_hdir); ++} ++ ++static int au_ren_lock(struct au_ren_args *a) ++{ ++ int err; ++ unsigned int udba; ++ ++ err = 0; ++ a->src_h_parent = au_h_dptr(a->src_parent, a->btgt); ++ a->src_hdir = au_hi(a->src_dir, a->btgt); ++ a->dst_h_parent = au_h_dptr(a->dst_parent, a->btgt); ++ a->dst_hdir = au_hi(a->dst_dir, a->btgt); ++ a->h_trap = vfsub_lock_rename(a->src_h_parent, a->src_hdir, ++ a->dst_h_parent, a->dst_hdir); ++ udba = au_opt_udba(a->src_dentry->d_sb); ++ if (au_dbstart(a->src_dentry) == a->btgt) ++ err = au_h_verify(a->src_h_dentry, udba, ++ a->src_h_parent->d_inode, a->src_h_parent, ++ a->br); ++ if (!err && au_dbstart(a->dst_dentry) == a->btgt) ++ err = au_h_verify(a->dst_h_dentry, udba, ++ a->dst_h_parent->d_inode, a->dst_h_parent, ++ a->br); ++ if (!err) { ++ err = mnt_want_write(a->br->br_mnt); ++ if (unlikely(err)) ++ goto out_unlock; ++ au_fset_ren(a->flags, MNT_WRITE); ++ goto out; /* success */ ++ } ++ ++ err = au_busy_or_stale(); ++ ++ out_unlock: ++ au_ren_unlock(a); ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void au_ren_refresh_dir(struct au_ren_args *a) ++{ ++ struct inode *dir; ++ ++ dir = a->dst_dir; ++ dir->i_version++; ++ if (au_ftest_ren(a->flags, ISDIR)) { ++ /* is this updating defined in POSIX? */ ++ au_cpup_attr_timesizes(a->src_inode); ++ au_cpup_attr_nlink(dir, /*force*/1); ++ if (a->dst_inode) { ++ clear_nlink(a->dst_inode); ++ au_cpup_attr_timesizes(a->dst_inode); ++ } ++ } ++ if (au_ibstart(dir) == a->btgt) ++ au_cpup_attr_timesizes(dir); ++ ++ if (au_ftest_ren(a->flags, ISSAMEDIR)) ++ return; ++ ++ dir = a->src_dir; ++ dir->i_version++; ++ if (au_ftest_ren(a->flags, ISDIR)) ++ au_cpup_attr_nlink(dir, /*force*/1); ++ if (au_ibstart(dir) == a->btgt) ++ au_cpup_attr_timesizes(dir); ++} ++ ++static void au_ren_refresh(struct au_ren_args *a) ++{ ++ aufs_bindex_t bend, bindex; ++ struct dentry *d, *h_d; ++ struct inode *i, *h_i; ++ struct super_block *sb; ++ ++ d = a->src_dentry; ++ au_set_dbwh(d, -1); ++ bend = au_dbend(d); ++ for (bindex = a->btgt + 1; bindex <= bend; bindex++) { ++ h_d = au_h_dptr(d, bindex); ++ if (h_d) ++ au_set_h_dptr(d, bindex, NULL); ++ } ++ au_set_dbend(d, a->btgt); ++ ++ sb = d->d_sb; ++ i = a->src_inode; ++ if (au_opt_test(au_mntflags(sb), PLINK) && au_plink_test(i)) ++ return; /* success */ ++ ++ bend = au_ibend(i); ++ for (bindex = a->btgt + 1; bindex <= bend; bindex++) { ++ h_i = au_h_iptr(i, bindex); ++ if (h_i) { ++ au_xino_write0(sb, bindex, h_i->i_ino, 0); ++ /* ignore this error */ ++ au_set_h_iptr(i, bindex, NULL, 0); ++ } ++ } ++ au_set_ibend(i, a->btgt); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* mainly for link(2) and rename(2) */ ++int au_wbr(struct dentry *dentry, aufs_bindex_t btgt) ++{ ++ aufs_bindex_t bdiropq, bwh; ++ struct dentry *parent; ++ struct au_branch *br; ++ ++ parent = dentry->d_parent; ++ IMustLock(parent->d_inode); /* dir is locked */ ++ ++ bdiropq = au_dbdiropq(parent); ++ bwh = au_dbwh(dentry); ++ br = au_sbr(dentry->d_sb, btgt); ++ if (au_br_rdonly(br) ++ || (0 <= bdiropq && bdiropq < btgt) ++ || (0 <= bwh && bwh < btgt)) ++ btgt = -1; ++ ++ AuDbg("btgt %d\n", btgt); ++ return btgt; ++} ++ ++/* sets src_bstart, dst_bstart and btgt */ ++static int au_ren_wbr(struct au_ren_args *a) ++{ ++ int err; ++ struct au_wr_dir_args wr_dir_args = { ++ /* .force_btgt = -1, */ ++ .flags = AuWrDir_ADD_ENTRY ++ }; ++ ++ a->src_bstart = au_dbstart(a->src_dentry); ++ a->dst_bstart = au_dbstart(a->dst_dentry); ++ if (au_ftest_ren(a->flags, ISDIR)) ++ au_fset_wrdir(wr_dir_args.flags, ISDIR); ++ wr_dir_args.force_btgt = a->src_bstart; ++ if (a->dst_inode && a->dst_bstart < a->src_bstart) ++ wr_dir_args.force_btgt = a->dst_bstart; ++ wr_dir_args.force_btgt = au_wbr(a->dst_dentry, wr_dir_args.force_btgt); ++ err = au_wr_dir(a->dst_dentry, a->src_dentry, &wr_dir_args); ++ a->btgt = err; ++ ++ return err; ++} ++ ++static void au_ren_dt(struct au_ren_args *a) ++{ ++ a->h_path.dentry = a->src_h_parent; ++ au_dtime_store(a->src_dt + AuPARENT, a->src_parent, &a->h_path); ++ if (!au_ftest_ren(a->flags, ISSAMEDIR)) { ++ a->h_path.dentry = a->dst_h_parent; ++ au_dtime_store(a->dst_dt + AuPARENT, a->dst_parent, &a->h_path); ++ } ++ ++ au_fclr_ren(a->flags, DT_DSTDIR); ++ if (!au_ftest_ren(a->flags, ISDIR)) ++ return; ++ ++ a->h_path.dentry = a->src_h_dentry; ++ au_dtime_store(a->src_dt + AuCHILD, a->src_dentry, &a->h_path); ++ if (a->dst_h_dentry->d_inode) { ++ au_fset_ren(a->flags, DT_DSTDIR); ++ a->h_path.dentry = a->dst_h_dentry; ++ au_dtime_store(a->dst_dt + AuCHILD, a->dst_dentry, &a->h_path); ++ } ++} ++ ++static void au_ren_rev_dt(int err, struct au_ren_args *a) ++{ ++ struct dentry *h_d; ++ struct mutex *h_mtx; ++ ++ au_dtime_revert(a->src_dt + AuPARENT); ++ if (!au_ftest_ren(a->flags, ISSAMEDIR)) ++ au_dtime_revert(a->dst_dt + AuPARENT); ++ ++ if (au_ftest_ren(a->flags, ISDIR) && err != -EIO) { ++ h_d = a->src_dt[AuCHILD].dt_h_path.dentry; ++ h_mtx = &h_d->d_inode->i_mutex; ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ au_dtime_revert(a->src_dt + AuCHILD); ++ mutex_unlock(h_mtx); ++ ++ if (au_ftest_ren(a->flags, DT_DSTDIR)) { ++ h_d = a->dst_dt[AuCHILD].dt_h_path.dentry; ++ h_mtx = &h_d->d_inode->i_mutex; ++ mutex_lock_nested(h_mtx, AuLsc_I_CHILD); ++ au_dtime_revert(a->dst_dt + AuCHILD); ++ mutex_unlock(h_mtx); ++ } ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int aufs_rename(struct inode *_src_dir, struct dentry *_src_dentry, ++ struct inode *_dst_dir, struct dentry *_dst_dentry) ++{ ++ int err; ++ /* reduce stack space */ ++ struct au_ren_args *a; ++ ++ IMustLock(_src_dir); ++ IMustLock(_dst_dir); ++ ++ err = -ENOMEM; ++ BUILD_BUG_ON(sizeof(*a) > PAGE_SIZE); ++ a = kzalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ a->src_dir = _src_dir; ++ a->src_dentry = _src_dentry; ++ a->src_inode = a->src_dentry->d_inode; ++ a->src_parent = a->src_dentry->d_parent; /* dir inode is locked */ ++ a->dst_dir = _dst_dir; ++ a->dst_dentry = _dst_dentry; ++ a->dst_inode = a->dst_dentry->d_inode; ++ a->dst_parent = a->dst_dentry->d_parent; /* dir inode is locked */ ++ if (a->dst_inode) { ++ IMustLock(a->dst_inode); ++ au_igrab(a->dst_inode); ++ } ++ ++ err = -ENOTDIR; ++ if (S_ISDIR(a->src_inode->i_mode)) { ++ au_fset_ren(a->flags, ISDIR); ++ if (unlikely(a->dst_inode && !S_ISDIR(a->dst_inode->i_mode))) ++ goto out_free; ++ aufs_read_and_write_lock2(a->dst_dentry, a->src_dentry, ++ AuLock_DIR | AuLock_FLUSH); ++ } else ++ aufs_read_and_write_lock2(a->dst_dentry, a->src_dentry, ++ AuLock_FLUSH); ++ ++ au_fset_ren(a->flags, ISSAMEDIR); /* temporary */ ++ di_write_lock_parent(a->dst_parent); ++ ++ /* which branch we process */ ++ err = au_ren_wbr(a); ++ if (unlikely(err < 0)) ++ goto out_unlock; ++ a->br = au_sbr(a->dst_dentry->d_sb, a->btgt); ++ a->h_path.mnt = a->br->br_mnt; ++ ++ /* are they available to be renamed */ ++ err = au_ren_may_dir(a); ++ if (unlikely(err)) ++ goto out_unlock; ++ ++ /* prepare the writable parent dir on the same branch */ ++ if (a->dst_bstart == a->btgt) { ++ au_fset_ren(a->flags, WHDST); ++ } else { ++ err = au_cpup_dirs(a->dst_dentry, a->btgt); ++ if (unlikely(err)) ++ goto out_children; ++ } ++ ++ if (a->src_dir != a->dst_dir) { ++ /* ++ * this temporary unlock is safe, ++ * because both dir->i_mutex are locked. ++ */ ++ di_write_unlock(a->dst_parent); ++ di_write_lock_parent(a->src_parent); ++ err = au_wr_dir_need_wh(a->src_dentry, ++ au_ftest_ren(a->flags, ISDIR), ++ &a->btgt); ++ di_write_unlock(a->src_parent); ++ di_write_lock2_parent(a->src_parent, a->dst_parent, /*isdir*/1); ++ au_fclr_ren(a->flags, ISSAMEDIR); ++ } else ++ err = au_wr_dir_need_wh(a->src_dentry, ++ au_ftest_ren(a->flags, ISDIR), ++ &a->btgt); ++ if (unlikely(err < 0)) ++ goto out_children; ++ if (err) ++ au_fset_ren(a->flags, WHSRC); ++ ++ /* lock them all */ ++ err = au_ren_lock(a); ++ if (unlikely(err)) ++ goto out_children; ++ ++ if (!au_opt_test(au_mntflags(a->dst_dir->i_sb), UDBA_NONE)) { ++ err = au_may_ren(a); ++ if (unlikely(err)) ++ goto out_hdir; ++ } ++ ++ /* store timestamps to be revertible */ ++ au_ren_dt(a); ++ ++ /* here we go */ ++ err = do_rename(a); ++ if (unlikely(err)) ++ goto out_dt; ++ ++ /* update dir attributes */ ++ au_ren_refresh_dir(a); ++ ++ /* dput/iput all lower dentries */ ++ au_ren_refresh(a); ++ ++ goto out_hdir; /* success */ ++ ++ out_dt: ++ au_ren_rev_dt(err, a); ++ out_hdir: ++ au_ren_unlock(a); ++ out_children: ++ au_nhash_wh_free(&a->whlist); ++ out_unlock: ++ if (unlikely(err && au_ftest_ren(a->flags, ISDIR))) { ++ au_update_dbstart(a->dst_dentry); ++ d_drop(a->dst_dentry); ++ } ++ if (!err) ++ d_move(a->src_dentry, a->dst_dentry); ++ if (au_ftest_ren(a->flags, ISSAMEDIR)) ++ di_write_unlock(a->dst_parent); ++ else ++ di_write_unlock2(a->src_parent, a->dst_parent); ++ aufs_read_and_write_unlock2(a->dst_dentry, a->src_dentry); ++ out_free: ++ iput(a->dst_inode); ++ if (a->thargs) ++ au_whtmp_rmdir_free(a->thargs); ++ kfree(a); ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/Kconfig b/fs/aufs/Kconfig +--- a/fs/aufs/Kconfig 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/Kconfig 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,117 @@ ++config AUFS_FS ++ tristate "Aufs (Advanced multi layered unification filesystem) support" ++ depends on EXPERIMENTAL ++ help ++ Aufs is a stackable unification filesystem such as Unionfs, ++ which unifies several directories and provides a merged single ++ directory. ++ In the early days, aufs was entirely re-designed and ++ re-implemented Unionfs Version 1.x series. Introducing many ++ original ideas, approaches and improvements, it becomes totally ++ different from Unionfs while keeping the basic features. ++ ++if AUFS_FS ++choice ++ prompt "Maximum number of branches" ++ default AUFS_BRANCH_MAX_127 ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_127 ++ bool "127" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_511 ++ bool "511" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_1023 ++ bool "1023" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++config AUFS_BRANCH_MAX_32767 ++ bool "32767" ++ help ++ Specifies the maximum number of branches (or member directories) ++ in a single aufs. The larger value consumes more system ++ resources and has a minor impact to performance. ++endchoice ++ ++config AUFS_HINOTIFY ++ bool "Use inotify to detect actions on a branch" ++ depends on INOTIFY ++ help ++ If you want to modify files on branches directly, eg. bypassing aufs, ++ and want aufs to detect the changes of them fully, then enable this ++ option and use 'udba=inotify' mount option. ++ It will have a negative impact to the performance. ++ See detail in aufs.5. ++ ++config AUFS_EXPORT ++ bool "NFS-exportable aufs" ++ depends on (AUFS_FS = y && EXPORTFS = y) || (AUFS_FS = m && EXPORTFS) ++ help ++ If you want to export your mounted aufs via NFS, then enable this ++ option. There are several requirements for this configuration. ++ See detail in aufs.5. ++ ++config AUFS_SHWH ++ bool "Show whiteouts" ++ help ++ If you want to make the whiteouts in aufs visible, then enable ++ this option and specify 'shwh' mount option. Although it may ++ sounds like philosophy or something, but in technically it ++ simply shows the name of whiteout with keeping its behaviour. ++ ++config AUFS_BR_RAMFS ++ bool "Ramfs (initramfs/rootfs) as an aufs branch" ++ help ++ If you want to use ramfs as an aufs branch fs, then enable this ++ option. Generally tmpfs is recommended. ++ Aufs prohibited them to be a branch fs by default, because ++ initramfs becomes unusable after switch_root or something ++ generally. If you sets initramfs as an aufs branch and boot your ++ system by switch_root, you will meet a problem easily since the ++ files in initramfs may be inaccessible. ++ Unless you are going to use ramfs as an aufs branch fs without ++ switch_root or something, leave it N. ++ ++config AUFS_DEBUG ++ bool "Debug aufs" ++ help ++ Enable this to compile aufs internal debug code. ++ It will have a negative impact to the performance. ++ ++config AUFS_MAGIC_SYSRQ ++ bool ++ depends on AUFS_DEBUG && MAGIC_SYSRQ ++ default y ++ help ++ Automatic configuration for internal use. ++ When aufs supports Magic SysRq, enabled automatically. ++ ++config AUFS_BDEV_LOOP ++ bool ++ depends on BLK_DEV_LOOP ++ default y ++ help ++ Automatic configuration for internal use. ++ Convert =[ym] into =y. ++ ++config AUFS_INO_T_64 ++ bool ++ depends on AUFS_EXPORT ++ depends on 64BIT && !(ALPHA || S390) ++ default y ++ help ++ Automatic configuration for internal use. ++ /* typedef unsigned long/int __kernel_ino_t */ ++ /* alpha and s390x are int */ ++endif +diff -Naur a/fs/aufs/loop.c b/fs/aufs/loop.c +--- a/fs/aufs/loop.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/loop.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,55 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * support for loopback block device as a branch ++ */ ++ ++#include <linux/loop.h> ++#include "aufs.h" ++ ++/* ++ * test if two lower dentries have overlapping branches. ++ */ ++int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_d1, ++ struct dentry *h_d2) ++{ ++ struct inode *h_inode; ++ struct loop_device *l; ++ ++ h_inode = h_d1->d_inode; ++ if (MAJOR(h_inode->i_sb->s_dev) != LOOP_MAJOR) ++ return 0; ++ ++ l = h_inode->i_sb->s_bdev->bd_disk->private_data; ++ h_d1 = l->lo_backing_file->f_dentry; ++ /* h_d1 can be local NFS. in this case aufs cannot detect the loop */ ++ if (unlikely(h_d1->d_sb == sb)) ++ return 1; ++ return !!au_test_subdir(h_d1, h_d2); ++} ++ ++/* true if a kernel thread named 'loop[0-9].*' accesses a file */ ++int au_test_loopback_kthread(void) ++{ ++ const char c = current->comm[4]; ++ ++ return current->mm == NULL ++ && '0' <= c && c <= '9' ++ && strncmp(current->comm, "loop", 4) == 0; ++} +diff -Naur a/fs/aufs/loop.h b/fs/aufs/loop.h +--- a/fs/aufs/loop.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/loop.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,51 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * support for loopback mount as a branch ++ */ ++ ++#ifndef __AUFS_LOOP_H__ ++#define __AUFS_LOOP_H__ ++ ++#ifdef __KERNEL__ ++ ++struct dentry; ++struct super_block; ++ ++#ifdef CONFIG_AUFS_BDEV_LOOP ++/* loop.c */ ++int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_d1, ++ struct dentry *h_d2); ++int au_test_loopback_kthread(void); ++#else ++static inline ++int au_test_loopback_overlap(struct super_block *sb, struct dentry *h_d1, ++ struct dentry *h_d2) ++{ ++ return 0; ++} ++ ++static inline int au_test_loopback_kthread(void) ++{ ++ return 0; ++} ++#endif /* BLK_DEV_LOOP */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_LOOP_H__ */ +diff -Naur a/fs/aufs/magic.mk b/fs/aufs/magic.mk +--- a/fs/aufs/magic.mk 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/magic.mk 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,52 @@ ++ ++# defined in ${srctree}/fs/fuse/inode.c ++# tristate ++ifdef CONFIG_FUSE_FS ++ccflags-y += -DFUSE_SUPER_MAGIC=0x65735546 ++endif ++ ++# defined in ${srctree}/fs/ocfs2/ocfs2_fs.h ++# tristate ++ifdef CONFIG_OCFS2_FS ++ccflags-y += -DOCFS2_SUPER_MAGIC=0x7461636f ++endif ++ ++# defined in ${srctree}/fs/ocfs2/dlm/userdlm.h ++# tristate ++ifdef CONFIG_OCFS2_FS_O2CB ++ccflags-y += -DDLMFS_MAGIC=0x76a9f425 ++endif ++ ++# defined in ${srctree}/fs/ramfs/inode.c ++# always true ++ccflags-y += -DRAMFS_MAGIC=0x858458f6 ++ ++# defined in ${srctree}/fs/cifs/cifsfs.c ++# tristate ++ifdef CONFIG_CIFS_FS ++ccflags-y += -DCIFS_MAGIC_NUMBER=0xFF534D42 ++endif ++ ++# defined in ${srctree}/fs/xfs/xfs_sb.h ++# tristate ++ifdef CONFIG_XFS_FS ++ccflags-y += -DXFS_SB_MAGIC=0x58465342 ++endif ++ ++# defined in ${srctree}/fs/configfs/mount.c ++# tristate ++ifdef CONFIG_CONFIGFS_FS ++ccflags-y += -DCONFIGFS_MAGIC=0x62656570 ++endif ++ ++# defined in ${srctree}/fs/9p/v9fs.h ++# tristate ++ifdef CONFIG_9P_FS ++ccflags-y += -DV9FS_MAGIC=0x01021997 ++endif ++ ++# defined in ${srctree}/fs/ubifs/ubifs.h ++# tristate ++ifdef CONFIG_UBIFS_FS ++ccflags-y += -DUBIFS_SUPER_MAGIC=0x24051905 ++endif +diff -Naur a/fs/aufs/Makefile b/fs/aufs/Makefile +--- a/fs/aufs/Makefile 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/Makefile 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,22 @@ ++ ++include ${src}/magic.mk ++-include ${src}/priv_def.mk ++ ++obj-$(CONFIG_AUFS_FS) += aufs.o ++aufs-y := module.o sbinfo.o super.o branch.o xino.o sysaufs.o opts.o \ ++ wkq.o vfsub.o dcsub.o \ ++ cpup.o whout.o plink.o wbr_policy.o \ ++ dinfo.o dentry.o \ ++ finfo.o file.o f_op.o \ ++ dir.o vdir.o \ ++ iinfo.o inode.o i_op.o i_op_add.o i_op_del.o i_op_ren.o \ ++ ioctl.o ++ ++# all are boolean ++aufs-$(CONFIG_SYSFS) += sysfs.o ++aufs-$(CONFIG_DEBUG_FS) += dbgaufs.o ++aufs-$(CONFIG_AUFS_BDEV_LOOP) += loop.o ++aufs-$(CONFIG_AUFS_HINOTIFY) += hinotify.o ++aufs-$(CONFIG_AUFS_EXPORT) += export.o ++aufs-$(CONFIG_AUFS_DEBUG) += debug.o ++aufs-$(CONFIG_AUFS_MAGIC_SYSRQ) += sysrq.o +diff -Naur a/fs/aufs/module.c b/fs/aufs/module.c +--- a/fs/aufs/module.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/module.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,173 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * module global variables and operations ++ */ ++ ++#include <linux/module.h> ++#include <linux/seq_file.h> ++#include "aufs.h" ++ ++void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp) ++{ ++ if (new_sz <= nused) ++ return p; ++ ++ p = krealloc(p, new_sz, gfp); ++ if (p) ++ memset(p + nused, 0, new_sz - nused); ++ return p; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * aufs caches ++ */ ++struct kmem_cache *au_cachep[AuCache_Last]; ++static int __init au_cache_init(void) ++{ ++ au_cachep[AuCache_DINFO] = AuCache(au_dinfo); ++ if (au_cachep[AuCache_DINFO]) ++ au_cachep[AuCache_ICNTNR] = AuCache(au_icntnr); ++ if (au_cachep[AuCache_ICNTNR]) ++ au_cachep[AuCache_FINFO] = AuCache(au_finfo); ++ if (au_cachep[AuCache_FINFO]) ++ au_cachep[AuCache_VDIR] = AuCache(au_vdir); ++ if (au_cachep[AuCache_VDIR]) ++ au_cachep[AuCache_DEHSTR] = AuCache(au_vdir_dehstr); ++ if (au_cachep[AuCache_DEHSTR]) ++ return 0; ++ ++ return -ENOMEM; ++} ++ ++static void au_cache_fin(void) ++{ ++ int i; ++ for (i = 0; i < AuCache_Last; i++) ++ if (au_cachep[i]) { ++ kmem_cache_destroy(au_cachep[i]); ++ au_cachep[i] = NULL; ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_dir_roflags; ++ ++/* ++ * functions for module interface. ++ */ ++MODULE_LICENSE("GPL"); ++/* MODULE_LICENSE("GPL v2"); */ ++MODULE_AUTHOR("Junjiro R. Okajima <aufs-users@lists.sourceforge.net>"); ++MODULE_DESCRIPTION(AUFS_NAME ++ " -- Advanced multi layered unification filesystem"); ++MODULE_VERSION(AUFS_VERSION); ++ ++/* it should be 'byte', but param_set_byte() prints it by "%c" */ ++short aufs_nwkq = AUFS_NWKQ_DEF; ++MODULE_PARM_DESC(nwkq, "the number of workqueue thread, " AUFS_WKQ_NAME); ++module_param_named(nwkq, aufs_nwkq, short, S_IRUGO); ++ ++/* this module parameter has no meaning when SYSFS is disabled */ ++int sysaufs_brs = 1; ++MODULE_PARM_DESC(brs, "use <sysfs>/fs/aufs/si_*/brN"); ++module_param_named(brs, sysaufs_brs, int, S_IRUGO); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static char au_esc_chars[0x20 + 3]; /* 0x01-0x20, backslash, del, and NULL */ ++ ++int au_seq_path(struct seq_file *seq, struct path *path) ++{ ++ return seq_path(seq, path, au_esc_chars); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int __init aufs_init(void) ++{ ++ int err, i; ++ char *p; ++ ++ p = au_esc_chars; ++ for (i = 1; i <= ' '; i++) ++ *p++ = i; ++ *p++ = '\\'; ++ *p++ = '\x7f'; ++ *p = 0; ++ ++ au_dir_roflags = au_file_roflags(O_DIRECTORY | O_LARGEFILE); ++ ++ sysaufs_brs_init(); ++ au_debug_init(); ++ ++ err = -EINVAL; ++ if (unlikely(aufs_nwkq <= 0)) ++ goto out; ++ ++ err = sysaufs_init(); ++ if (unlikely(err)) ++ goto out; ++ err = au_wkq_init(); ++ if (unlikely(err)) ++ goto out_sysaufs; ++ err = au_hinotify_init(); ++ if (unlikely(err)) ++ goto out_wkq; ++ err = au_sysrq_init(); ++ if (unlikely(err)) ++ goto out_hin; ++ err = au_cache_init(); ++ if (unlikely(err)) ++ goto out_sysrq; ++ err = register_filesystem(&aufs_fs_type); ++ if (unlikely(err)) ++ goto out_cache; ++ pr_info(AUFS_NAME " " AUFS_VERSION "\n"); ++ goto out; /* success */ ++ ++ out_cache: ++ au_cache_fin(); ++ out_sysrq: ++ au_sysrq_fin(); ++ out_hin: ++ au_hinotify_fin(); ++ out_wkq: ++ au_wkq_fin(); ++ out_sysaufs: ++ sysaufs_fin(); ++ out: ++ return err; ++} ++ ++static void __exit aufs_exit(void) ++{ ++ unregister_filesystem(&aufs_fs_type); ++ au_cache_fin(); ++ au_sysrq_fin(); ++ au_hinotify_fin(); ++ au_wkq_fin(); ++ sysaufs_fin(); ++} ++ ++module_init(aufs_init); ++module_exit(aufs_exit); +diff -Naur a/fs/aufs/module.h b/fs/aufs/module.h +--- a/fs/aufs/module.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/module.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,78 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * module initialization and module-global ++ */ ++ ++#ifndef __AUFS_MODULE_H__ ++#define __AUFS_MODULE_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/slab.h> ++ ++struct path; ++struct seq_file; ++ ++/* module parameters */ ++extern short aufs_nwkq; ++extern int sysaufs_brs; ++ ++/* ---------------------------------------------------------------------- */ ++ ++extern int au_dir_roflags; ++ ++void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp); ++int au_seq_path(struct seq_file *seq, struct path *path); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* kmem cache */ ++enum { ++ AuCache_DINFO, ++ AuCache_ICNTNR, ++ AuCache_FINFO, ++ AuCache_VDIR, ++ AuCache_DEHSTR, ++#ifdef CONFIG_AUFS_HINOTIFY ++ AuCache_HINOTIFY, ++#endif ++ AuCache_Last ++}; ++ ++#define AuCache(type) KMEM_CACHE(type, SLAB_RECLAIM_ACCOUNT) ++ ++extern struct kmem_cache *au_cachep[]; ++ ++#define AuCacheFuncs(name, index) \ ++static inline void *au_cache_alloc_##name(void) \ ++{ return kmem_cache_alloc(au_cachep[AuCache_##index], GFP_NOFS); } \ ++static inline void au_cache_free_##name(void *p) \ ++{ kmem_cache_free(au_cachep[AuCache_##index], p); } ++ ++AuCacheFuncs(dinfo, DINFO); ++AuCacheFuncs(icntnr, ICNTNR); ++AuCacheFuncs(finfo, FINFO); ++AuCacheFuncs(vdir, VDIR); ++AuCacheFuncs(dehstr, DEHSTR); ++ ++/* ---------------------------------------------------------------------- */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_MODULE_H__ */ +diff -Naur a/fs/aufs/opts.c b/fs/aufs/opts.c +--- a/fs/aufs/opts.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/opts.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,1533 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * mount options/flags ++ */ ++ ++#include <linux/file.h> ++#include <linux/namei.h> ++#include <linux/types.h> /* a distribution requires */ ++#include <linux/parser.h> ++#include "aufs.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++enum { ++ Opt_br, ++ Opt_add, Opt_del, Opt_mod, Opt_reorder, Opt_append, Opt_prepend, ++ Opt_idel, Opt_imod, Opt_ireorder, ++ Opt_dirwh, Opt_rdcache, Opt_rdblk, Opt_rdhash, Opt_rendir, ++ Opt_rdblk_def, Opt_rdhash_def, ++ Opt_xino, Opt_zxino, Opt_noxino, ++ Opt_trunc_xino, Opt_trunc_xino_v, Opt_notrunc_xino, ++ Opt_trunc_xino_path, Opt_itrunc_xino, ++ Opt_trunc_xib, Opt_notrunc_xib, ++ Opt_shwh, Opt_noshwh, ++ Opt_plink, Opt_noplink, Opt_list_plink, ++ Opt_udba, ++ /* Opt_lock, Opt_unlock, */ ++ Opt_cmd, Opt_cmd_args, ++ Opt_diropq_a, Opt_diropq_w, ++ Opt_warn_perm, Opt_nowarn_perm, ++ Opt_wbr_copyup, Opt_wbr_create, ++ Opt_refrof, Opt_norefrof, ++ Opt_verbose, Opt_noverbose, ++ Opt_sum, Opt_nosum, Opt_wsum, ++ Opt_tail, Opt_ignore, Opt_ignore_silent, Opt_err ++}; ++ ++static match_table_t options = { ++ {Opt_br, "br=%s"}, ++ {Opt_br, "br:%s"}, ++ ++ {Opt_add, "add=%d:%s"}, ++ {Opt_add, "add:%d:%s"}, ++ {Opt_add, "ins=%d:%s"}, ++ {Opt_add, "ins:%d:%s"}, ++ {Opt_append, "append=%s"}, ++ {Opt_append, "append:%s"}, ++ {Opt_prepend, "prepend=%s"}, ++ {Opt_prepend, "prepend:%s"}, ++ ++ {Opt_del, "del=%s"}, ++ {Opt_del, "del:%s"}, ++ /* {Opt_idel, "idel:%d"}, */ ++ {Opt_mod, "mod=%s"}, ++ {Opt_mod, "mod:%s"}, ++ /* {Opt_imod, "imod:%d:%s"}, */ ++ ++ {Opt_dirwh, "dirwh=%d"}, ++ ++ {Opt_xino, "xino=%s"}, ++ {Opt_noxino, "noxino"}, ++ {Opt_trunc_xino, "trunc_xino"}, ++ {Opt_trunc_xino_v, "trunc_xino_v=%d:%d"}, ++ {Opt_notrunc_xino, "notrunc_xino"}, ++ {Opt_trunc_xino_path, "trunc_xino=%s"}, ++ {Opt_itrunc_xino, "itrunc_xino=%d"}, ++ /* {Opt_zxino, "zxino=%s"}, */ ++ {Opt_trunc_xib, "trunc_xib"}, ++ {Opt_notrunc_xib, "notrunc_xib"}, ++ ++ {Opt_plink, "plink"}, ++ {Opt_noplink, "noplink"}, ++#ifdef CONFIG_AUFS_DEBUG ++ {Opt_list_plink, "list_plink"}, ++#endif ++ ++ {Opt_udba, "udba=%s"}, ++ ++ {Opt_diropq_a, "diropq=always"}, ++ {Opt_diropq_a, "diropq=a"}, ++ {Opt_diropq_w, "diropq=whiteouted"}, ++ {Opt_diropq_w, "diropq=w"}, ++ ++ {Opt_warn_perm, "warn_perm"}, ++ {Opt_nowarn_perm, "nowarn_perm"}, ++ ++ /* keep them temporary */ ++ {Opt_ignore_silent, "coo=%s"}, ++ {Opt_ignore_silent, "nodlgt"}, ++ {Opt_ignore_silent, "nodirperm1"}, ++ {Opt_ignore_silent, "clean_plink"}, ++ ++#ifdef CONFIG_AUFS_SHWH ++ {Opt_shwh, "shwh"}, ++#endif ++ {Opt_noshwh, "noshwh"}, ++ ++ {Opt_rendir, "rendir=%d"}, ++ ++ {Opt_refrof, "refrof"}, ++ {Opt_norefrof, "norefrof"}, ++ ++ {Opt_verbose, "verbose"}, ++ {Opt_verbose, "v"}, ++ {Opt_noverbose, "noverbose"}, ++ {Opt_noverbose, "quiet"}, ++ {Opt_noverbose, "q"}, ++ {Opt_noverbose, "silent"}, ++ ++ {Opt_sum, "sum"}, ++ {Opt_nosum, "nosum"}, ++ {Opt_wsum, "wsum"}, ++ ++ {Opt_rdcache, "rdcache=%d"}, ++ {Opt_rdblk, "rdblk=%d"}, ++ {Opt_rdblk_def, "rdblk=def"}, ++ {Opt_rdhash, "rdhash=%d"}, ++ {Opt_rdhash_def, "rdhash=def"}, ++ ++ {Opt_wbr_create, "create=%s"}, ++ {Opt_wbr_create, "create_policy=%s"}, ++ {Opt_wbr_copyup, "cpup=%s"}, ++ {Opt_wbr_copyup, "copyup=%s"}, ++ {Opt_wbr_copyup, "copyup_policy=%s"}, ++ ++ /* internal use for the scripts */ ++ {Opt_ignore_silent, "si=%s"}, ++ ++ {Opt_br, "dirs=%s"}, ++ {Opt_ignore, "debug=%d"}, ++ {Opt_ignore, "delete=whiteout"}, ++ {Opt_ignore, "delete=all"}, ++ {Opt_ignore, "imap=%s"}, ++ ++ {Opt_err, NULL} ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static const char *au_parser_pattern(int val, struct match_token *token) ++{ ++ while (token->pattern) { ++ if (token->token == val) ++ return token->pattern; ++ token++; ++ } ++ BUG(); ++ return "??"; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t brperms = { ++ {AuBrPerm_RO, AUFS_BRPERM_RO}, ++ {AuBrPerm_RR, AUFS_BRPERM_RR}, ++ {AuBrPerm_RW, AUFS_BRPERM_RW}, ++ ++ {AuBrPerm_ROWH, AUFS_BRPERM_ROWH}, ++ {AuBrPerm_RRWH, AUFS_BRPERM_RRWH}, ++ {AuBrPerm_RWNoLinkWH, AUFS_BRPERM_RWNLWH}, ++ ++ {AuBrPerm_ROWH, "nfsro"}, ++ {AuBrPerm_RO, NULL} ++}; ++ ++static int br_perm_val(char *perm) ++{ ++ int val; ++ substring_t args[MAX_OPT_ARGS]; ++ ++ val = match_token(perm, brperms, args); ++ return val; ++} ++ ++const char *au_optstr_br_perm(int brperm) ++{ ++ return au_parser_pattern(brperm, (void *)brperms); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t udbalevel = { ++ {AuOpt_UDBA_REVAL, "reval"}, ++ {AuOpt_UDBA_NONE, "none"}, ++#ifdef CONFIG_AUFS_HINOTIFY ++ {AuOpt_UDBA_HINOTIFY, "inotify"}, ++#endif ++ {-1, NULL} ++}; ++ ++static int udba_val(char *str) ++{ ++ substring_t args[MAX_OPT_ARGS]; ++ ++ return match_token(str, udbalevel, args); ++} ++ ++const char *au_optstr_udba(int udba) ++{ ++ return au_parser_pattern(udba, (void *)udbalevel); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static match_table_t au_wbr_create_policy = { ++ {AuWbrCreate_TDP, "tdp"}, ++ {AuWbrCreate_TDP, "top-down-parent"}, ++ {AuWbrCreate_RR, "rr"}, ++ {AuWbrCreate_RR, "round-robin"}, ++ {AuWbrCreate_MFS, "mfs"}, ++ {AuWbrCreate_MFS, "most-free-space"}, ++ {AuWbrCreate_MFSV, "mfs:%d"}, ++ {AuWbrCreate_MFSV, "most-free-space:%d"}, ++ ++ {AuWbrCreate_MFSRR, "mfsrr:%d"}, ++ {AuWbrCreate_MFSRRV, "mfsrr:%d:%d"}, ++ {AuWbrCreate_PMFS, "pmfs"}, ++ {AuWbrCreate_PMFSV, "pmfs:%d"}, ++ ++ {-1, NULL} ++}; ++ ++/* ++ * cf. linux/lib/parser.c and cmdline.c ++ * gave up calling memparse() since it uses simple_strtoull() instead of ++ * strict_...(). ++ */ ++static int au_match_ull(substring_t *s, unsigned long long *result) ++{ ++ int err; ++ unsigned int len; ++ char a[32]; ++ ++ err = -ERANGE; ++ len = s->to - s->from; ++ if (len + 1 <= sizeof(a)) { ++ memcpy(a, s->from, len); ++ a[len] = '\0'; ++ err = strict_strtoull(a, 0, result); ++ } ++ return err; ++} ++ ++static int au_wbr_mfs_wmark(substring_t *arg, char *str, ++ struct au_opt_wbr_create *create) ++{ ++ int err; ++ unsigned long long ull; ++ ++ err = 0; ++ if (!au_match_ull(arg, &ull)) ++ create->mfsrr_watermark = ull; ++ else { ++ AuErr("bad integer in %s\n", str); ++ err = -EINVAL; ++ } ++ ++ return err; ++} ++ ++static int au_wbr_mfs_sec(substring_t *arg, char *str, ++ struct au_opt_wbr_create *create) ++{ ++ int n, err; ++ ++ err = 0; ++ if (!match_int(arg, &n) && 0 <= n) ++ create->mfs_second = n; ++ else { ++ AuErr("bad integer in %s\n", str); ++ err = -EINVAL; ++ } ++ ++ return err; ++} ++ ++static int au_wbr_create_val(char *str, struct au_opt_wbr_create *create) ++{ ++ int err, e; ++ substring_t args[MAX_OPT_ARGS]; ++ ++ err = match_token(str, au_wbr_create_policy, args); ++ create->wbr_create = err; ++ switch (err) { ++ case AuWbrCreate_MFSRRV: ++ e = au_wbr_mfs_wmark(&args[0], str, create); ++ if (!e) ++ e = au_wbr_mfs_sec(&args[1], str, create); ++ if (unlikely(e)) ++ err = e; ++ break; ++ case AuWbrCreate_MFSRR: ++ e = au_wbr_mfs_wmark(&args[0], str, create); ++ if (unlikely(e)) { ++ err = e; ++ break; ++ } ++ /*FALLTHROUGH*/ ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_PMFS: ++ create->mfs_second = AUFS_MFS_SECOND_DEF; ++ break; ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFSV: ++ e = au_wbr_mfs_sec(&args[0], str, create); ++ if (unlikely(e)) ++ err = e; ++ break; ++ } ++ ++ return err; ++} ++ ++const char *au_optstr_wbr_create(int wbr_create) ++{ ++ return au_parser_pattern(wbr_create, (void *)au_wbr_create_policy); ++} ++ ++static match_table_t au_wbr_copyup_policy = { ++ {AuWbrCopyup_TDP, "tdp"}, ++ {AuWbrCopyup_TDP, "top-down-parent"}, ++ {AuWbrCopyup_BUP, "bup"}, ++ {AuWbrCopyup_BUP, "bottom-up-parent"}, ++ {AuWbrCopyup_BU, "bu"}, ++ {AuWbrCopyup_BU, "bottom-up"}, ++ {-1, NULL} ++}; ++ ++static int au_wbr_copyup_val(char *str) ++{ ++ substring_t args[MAX_OPT_ARGS]; ++ ++ return match_token(str, au_wbr_copyup_policy, args); ++} ++ ++const char *au_optstr_wbr_copyup(int wbr_copyup) ++{ ++ return au_parser_pattern(wbr_copyup, (void *)au_wbr_copyup_policy); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static const int lkup_dirflags = LOOKUP_FOLLOW | LOOKUP_DIRECTORY; ++ ++static void dump_opts(struct au_opts *opts) ++{ ++#ifdef CONFIG_AUFS_DEBUG ++ /* reduce stack space */ ++ union { ++ struct au_opt_add *add; ++ struct au_opt_del *del; ++ struct au_opt_mod *mod; ++ struct au_opt_xino *xino; ++ struct au_opt_xino_itrunc *xino_itrunc; ++ struct au_opt_wbr_create *create; ++ } u; ++ struct au_opt *opt; ++ ++ opt = opts->opt; ++ while (opt->type != Opt_tail) { ++ switch (opt->type) { ++ case Opt_add: ++ u.add = &opt->add; ++ AuDbg("add {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_del: ++ case Opt_idel: ++ u.del = &opt->del; ++ AuDbg("del {%s, %p}\n", ++ u.del->pathname, u.del->h_path.dentry); ++ break; ++ case Opt_mod: ++ case Opt_imod: ++ u.mod = &opt->mod; ++ AuDbg("mod {%s, 0x%x, %p}\n", ++ u.mod->path, u.mod->perm, u.mod->h_root); ++ break; ++ case Opt_append: ++ u.add = &opt->add; ++ AuDbg("append {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_prepend: ++ u.add = &opt->add; ++ AuDbg("prepend {b%d, %s, 0x%x, %p}\n", ++ u.add->bindex, u.add->pathname, u.add->perm, ++ u.add->path.dentry); ++ break; ++ case Opt_dirwh: ++ AuDbg("dirwh %d\n", opt->dirwh); ++ break; ++ case Opt_rdcache: ++ AuDbg("rdcache %d\n", opt->rdcache); ++ break; ++ case Opt_rdblk: ++ AuDbg("rdblk %u\n", opt->rdblk); ++ break; ++ case Opt_rdblk_def: ++ AuDbg("rdblk_def\n"); ++ break; ++ case Opt_rdhash: ++ AuDbg("rdhash %u\n", opt->rdhash); ++ break; ++ case Opt_rdhash_def: ++ AuDbg("rdhash_def\n"); ++ break; ++ case Opt_xino: ++ u.xino = &opt->xino; ++ AuDbg("xino {%s %.*s}\n", ++ u.xino->path, ++ AuDLNPair(u.xino->file->f_dentry)); ++ break; ++ case Opt_trunc_xino: ++ AuLabel(trunc_xino); ++ break; ++ case Opt_notrunc_xino: ++ AuLabel(notrunc_xino); ++ break; ++ case Opt_trunc_xino_path: ++ case Opt_itrunc_xino: ++ u.xino_itrunc = &opt->xino_itrunc; ++ AuDbg("trunc_xino %d\n", u.xino_itrunc->bindex); ++ break; ++ ++ case Opt_noxino: ++ AuLabel(noxino); ++ break; ++ case Opt_trunc_xib: ++ AuLabel(trunc_xib); ++ break; ++ case Opt_notrunc_xib: ++ AuLabel(notrunc_xib); ++ break; ++ case Opt_shwh: ++ AuLabel(shwh); ++ break; ++ case Opt_noshwh: ++ AuLabel(noshwh); ++ break; ++ case Opt_plink: ++ AuLabel(plink); ++ break; ++ case Opt_noplink: ++ AuLabel(noplink); ++ break; ++ case Opt_list_plink: ++ AuLabel(list_plink); ++ break; ++ case Opt_udba: ++ AuDbg("udba %d, %s\n", ++ opt->udba, au_optstr_udba(opt->udba)); ++ break; ++ case Opt_diropq_a: ++ AuLabel(diropq_a); ++ break; ++ case Opt_diropq_w: ++ AuLabel(diropq_w); ++ break; ++ case Opt_warn_perm: ++ AuLabel(warn_perm); ++ break; ++ case Opt_nowarn_perm: ++ AuLabel(nowarn_perm); ++ break; ++ case Opt_refrof: ++ AuLabel(refrof); ++ break; ++ case Opt_norefrof: ++ AuLabel(norefrof); ++ break; ++ case Opt_verbose: ++ AuLabel(verbose); ++ break; ++ case Opt_noverbose: ++ AuLabel(noverbose); ++ break; ++ case Opt_sum: ++ AuLabel(sum); ++ break; ++ case Opt_nosum: ++ AuLabel(nosum); ++ break; ++ case Opt_wsum: ++ AuLabel(wsum); ++ break; ++ case Opt_wbr_create: ++ u.create = &opt->wbr_create; ++ AuDbg("create %d, %s\n", u.create->wbr_create, ++ au_optstr_wbr_create(u.create->wbr_create)); ++ switch (u.create->wbr_create) { ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFSV: ++ AuDbg("%d sec\n", u.create->mfs_second); ++ break; ++ case AuWbrCreate_MFSRR: ++ AuDbg("%llu watermark\n", ++ u.create->mfsrr_watermark); ++ break; ++ case AuWbrCreate_MFSRRV: ++ AuDbg("%llu watermark, %d sec\n", ++ u.create->mfsrr_watermark, ++ u.create->mfs_second); ++ break; ++ } ++ break; ++ case Opt_wbr_copyup: ++ AuDbg("copyup %d, %s\n", opt->wbr_copyup, ++ au_optstr_wbr_copyup(opt->wbr_copyup)); ++ break; ++ default: ++ BUG(); ++ } ++ opt++; ++ } ++#endif ++} ++ ++void au_opts_free(struct au_opts *opts) ++{ ++ struct au_opt *opt; ++ ++ opt = opts->opt; ++ while (opt->type != Opt_tail) { ++ switch (opt->type) { ++ case Opt_add: ++ case Opt_append: ++ case Opt_prepend: ++ path_put(&opt->add.path); ++ break; ++ case Opt_del: ++ case Opt_idel: ++ path_put(&opt->del.h_path); ++ break; ++ case Opt_mod: ++ case Opt_imod: ++ dput(opt->mod.h_root); ++ break; ++ case Opt_xino: ++ fput(opt->xino.file); ++ break; ++ } ++ opt++; ++ } ++} ++ ++static int opt_add(struct au_opt *opt, char *opt_str, unsigned long sb_flags, ++ aufs_bindex_t bindex) ++{ ++ int err; ++ struct au_opt_add *add = &opt->add; ++ char *p; ++ ++ add->bindex = bindex; ++ add->perm = AuBrPerm_Last; ++ add->pathname = opt_str; ++ p = strchr(opt_str, '='); ++ if (p) { ++ *p++ = 0; ++ if (*p) ++ add->perm = br_perm_val(p); ++ } ++ ++ err = vfsub_kern_path(add->pathname, lkup_dirflags, &add->path); ++ if (!err) { ++ if (!p) { ++ add->perm = AuBrPerm_RO; ++ if (au_test_fs_rr(add->path.dentry->d_sb)) ++ add->perm = AuBrPerm_RR; ++ else if (!bindex && !(sb_flags & MS_RDONLY)) ++ add->perm = AuBrPerm_RW; ++ } ++ opt->type = Opt_add; ++ goto out; ++ } ++ AuErr("lookup failed %s (%d)\n", add->pathname, err); ++ err = -EINVAL; ++ ++ out: ++ return err; ++} ++ ++static int au_opts_parse_del(struct au_opt_del *del, substring_t args[]) ++{ ++ int err; ++ ++ del->pathname = args[0].from; ++ AuDbg("del path %s\n", del->pathname); ++ ++ err = vfsub_kern_path(del->pathname, lkup_dirflags, &del->h_path); ++ if (unlikely(err)) ++ AuErr("lookup failed %s (%d)\n", del->pathname, err); ++ ++ return err; ++} ++ ++#if 0 /* reserved for future use */ ++static int au_opts_parse_idel(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_opt_del *del, substring_t args[]) ++{ ++ int err; ++ struct dentry *root; ++ ++ err = -EINVAL; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (bindex < 0 || au_sbend(sb) < bindex) { ++ AuErr("out of bounds, %d\n", bindex); ++ goto out; ++ } ++ ++ err = 0; ++ del->h_path.dentry = dget(au_h_dptr(root, bindex)); ++ del->h_path.mnt = mntget(au_sbr_mnt(sb, bindex)); ++ ++ out: ++ aufs_read_unlock(root, !AuLock_IR); ++ return err; ++} ++#endif ++ ++static int au_opts_parse_mod(struct au_opt_mod *mod, substring_t args[]) ++{ ++ int err; ++ struct path path; ++ char *p; ++ ++ err = -EINVAL; ++ mod->path = args[0].from; ++ p = strchr(mod->path, '='); ++ if (unlikely(!p)) { ++ AuErr("no permssion %s\n", args[0].from); ++ goto out; ++ } ++ ++ *p++ = 0; ++ err = vfsub_kern_path(mod->path, lkup_dirflags, &path); ++ if (unlikely(err)) { ++ AuErr("lookup failed %s (%d)\n", mod->path, err); ++ goto out; ++ } ++ ++ mod->perm = br_perm_val(p); ++ AuDbg("mod path %s, perm 0x%x, %s\n", mod->path, mod->perm, p); ++ mod->h_root = dget(path.dentry); ++ path_put(&path); ++ ++ out: ++ return err; ++} ++ ++#if 0 /* reserved for future use */ ++static int au_opts_parse_imod(struct super_block *sb, aufs_bindex_t bindex, ++ struct au_opt_mod *mod, substring_t args[]) ++{ ++ int err; ++ struct dentry *root; ++ ++ err = -EINVAL; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (bindex < 0 || au_sbend(sb) < bindex) { ++ AuErr("out of bounds, %d\n", bindex); ++ goto out; ++ } ++ ++ err = 0; ++ mod->perm = br_perm_val(args[1].from); ++ AuDbg("mod path %s, perm 0x%x, %s\n", ++ mod->path, mod->perm, args[1].from); ++ mod->h_root = dget(au_h_dptr(root, bindex)); ++ ++ out: ++ aufs_read_unlock(root, !AuLock_IR); ++ return err; ++} ++#endif ++ ++static int au_opts_parse_xino(struct super_block *sb, struct au_opt_xino *xino, ++ substring_t args[]) ++{ ++ int err; ++ struct file *file; ++ ++ file = au_xino_create(sb, args[0].from, /*silent*/0); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ ++ err = -EINVAL; ++ if (unlikely(file->f_dentry->d_sb == sb)) { ++ fput(file); ++ AuErr("%s must be outside\n", args[0].from); ++ goto out; ++ } ++ ++ err = 0; ++ xino->file = file; ++ xino->path = args[0].from; ++ ++ out: ++ return err; ++} ++ ++static ++int au_opts_parse_xino_itrunc_path(struct super_block *sb, ++ struct au_opt_xino_itrunc *xino_itrunc, ++ substring_t args[]) ++{ ++ int err; ++ aufs_bindex_t bend, bindex; ++ struct path path; ++ struct dentry *root; ++ ++ err = vfsub_kern_path(args[0].from, lkup_dirflags, &path); ++ if (unlikely(err)) { ++ AuErr("lookup failed %s (%d)\n", args[0].from, err); ++ goto out; ++ } ++ ++ xino_itrunc->bindex = -1; ++ root = sb->s_root; ++ aufs_read_lock(root, AuLock_FLUSH); ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex <= bend; bindex++) { ++ if (au_h_dptr(root, bindex) == path.dentry) { ++ xino_itrunc->bindex = bindex; ++ break; ++ } ++ } ++ aufs_read_unlock(root, !AuLock_IR); ++ path_put(&path); ++ ++ if (unlikely(xino_itrunc->bindex < 0)) { ++ AuErr("no such branch %s\n", args[0].from); ++ err = -EINVAL; ++ } ++ ++ out: ++ return err; ++} ++ ++/* called without aufs lock */ ++int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts) ++{ ++ int err, n, token; ++ aufs_bindex_t bindex; ++ unsigned char skipped; ++ struct dentry *root; ++ struct au_opt *opt, *opt_tail; ++ char *opt_str; ++ /* reduce the stack space */ ++ union { ++ struct au_opt_xino_itrunc *xino_itrunc; ++ struct au_opt_wbr_create *create; ++ } u; ++ struct { ++ substring_t args[MAX_OPT_ARGS]; ++ } *a; ++ ++ err = -ENOMEM; ++ a = kmalloc(sizeof(*a), GFP_NOFS); ++ if (unlikely(!a)) ++ goto out; ++ ++ root = sb->s_root; ++ err = 0; ++ bindex = 0; ++ opt = opts->opt; ++ opt_tail = opt + opts->max_opt - 1; ++ opt->type = Opt_tail; ++ while (!err && (opt_str = strsep(&str, ",")) && *opt_str) { ++ err = -EINVAL; ++ skipped = 0; ++ token = match_token(opt_str, options, a->args); ++ switch (token) { ++ case Opt_br: ++ err = 0; ++ while (!err && (opt_str = strsep(&a->args[0].from, ":")) ++ && *opt_str) { ++ err = opt_add(opt, opt_str, opts->sb_flags, ++ bindex++); ++ if (unlikely(!err && ++opt > opt_tail)) { ++ err = -E2BIG; ++ break; ++ } ++ opt->type = Opt_tail; ++ skipped = 1; ++ } ++ break; ++ case Opt_add: ++ if (unlikely(match_int(&a->args[0], &n))) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ bindex = n; ++ err = opt_add(opt, a->args[1].from, opts->sb_flags, ++ bindex); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_append: ++ err = opt_add(opt, a->args[0].from, opts->sb_flags, ++ /*dummy bindex*/1); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_prepend: ++ err = opt_add(opt, a->args[0].from, opts->sb_flags, ++ /*bindex*/0); ++ if (!err) ++ opt->type = token; ++ break; ++ case Opt_del: ++ err = au_opts_parse_del(&opt->del, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#if 0 /* reserved for future use */ ++ case Opt_idel: ++ del->pathname = "(indexed)"; ++ if (unlikely(match_int(&args[0], &n))) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ err = au_opts_parse_idel(sb, n, &opt->del, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#endif ++ case Opt_mod: ++ err = au_opts_parse_mod(&opt->mod, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#ifdef IMOD /* reserved for future use */ ++ case Opt_imod: ++ u.mod->path = "(indexed)"; ++ if (unlikely(match_int(&a->args[0], &n))) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ err = au_opts_parse_imod(sb, n, &opt->mod, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++#endif ++ case Opt_xino: ++ err = au_opts_parse_xino(sb, &opt->xino, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++ ++ case Opt_trunc_xino_path: ++ err = au_opts_parse_xino_itrunc_path ++ (sb, &opt->xino_itrunc, a->args); ++ if (!err) ++ opt->type = token; ++ break; ++ ++ case Opt_itrunc_xino: ++ u.xino_itrunc = &opt->xino_itrunc; ++ if (unlikely(match_int(&a->args[0], &n))) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ u.xino_itrunc->bindex = n; ++ aufs_read_lock(root, AuLock_FLUSH); ++ if (n < 0 || au_sbend(sb) < n) { ++ AuErr("out of bounds, %d\n", n); ++ aufs_read_unlock(root, !AuLock_IR); ++ break; ++ } ++ aufs_read_unlock(root, !AuLock_IR); ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_dirwh: ++ if (unlikely(match_int(&a->args[0], &opt->dirwh))) ++ break; ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_rdcache: ++ if (unlikely(match_int(&a->args[0], &opt->rdcache))) ++ break; ++ err = 0; ++ opt->type = token; ++ break; ++ case Opt_rdblk: ++ if (unlikely(match_int(&a->args[0], &n) ++ || n <= 0 ++ || n > KMALLOC_MAX_SIZE)) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ if (unlikely(n < NAME_MAX)) { ++ AuErr("rdblk must be larger than %d\n", ++ NAME_MAX); ++ break; ++ } ++ opt->rdblk = n; ++ err = 0; ++ opt->type = token; ++ break; ++ case Opt_rdhash: ++ if (unlikely(match_int(&a->args[0], &n) ++ || n <= 0 ++ || n * sizeof(struct hlist_head) ++ > KMALLOC_MAX_SIZE)) { ++ AuErr("bad integer in %s\n", opt_str); ++ break; ++ } ++ opt->rdhash = n; ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_trunc_xino: ++ case Opt_notrunc_xino: ++ case Opt_noxino: ++ case Opt_trunc_xib: ++ case Opt_notrunc_xib: ++ case Opt_shwh: ++ case Opt_noshwh: ++ case Opt_plink: ++ case Opt_noplink: ++ case Opt_list_plink: ++ case Opt_diropq_a: ++ case Opt_diropq_w: ++ case Opt_warn_perm: ++ case Opt_nowarn_perm: ++ case Opt_refrof: ++ case Opt_norefrof: ++ case Opt_verbose: ++ case Opt_noverbose: ++ case Opt_sum: ++ case Opt_nosum: ++ case Opt_wsum: ++ case Opt_rdblk_def: ++ case Opt_rdhash_def: ++ err = 0; ++ opt->type = token; ++ break; ++ ++ case Opt_udba: ++ opt->udba = udba_val(a->args[0].from); ++ if (opt->udba >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ AuErr("wrong value, %s\n", opt_str); ++ break; ++ ++ case Opt_wbr_create: ++ u.create = &opt->wbr_create; ++ u.create->wbr_create ++ = au_wbr_create_val(a->args[0].from, u.create); ++ if (u.create->wbr_create >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ AuErr("wrong value, %s\n", opt_str); ++ break; ++ case Opt_wbr_copyup: ++ opt->wbr_copyup = au_wbr_copyup_val(a->args[0].from); ++ if (opt->wbr_copyup >= 0) { ++ err = 0; ++ opt->type = token; ++ } else ++ AuErr("wrong value, %s\n", opt_str); ++ break; ++ ++ case Opt_ignore: ++ AuWarn("ignored %s\n", opt_str); ++ /*FALLTHROUGH*/ ++ case Opt_ignore_silent: ++ skipped = 1; ++ err = 0; ++ break; ++ case Opt_err: ++ AuErr("unknown option %s\n", opt_str); ++ break; ++ } ++ ++ if (!err && !skipped) { ++ if (unlikely(++opt > opt_tail)) { ++ err = -E2BIG; ++ opt--; ++ opt->type = Opt_tail; ++ break; ++ } ++ opt->type = Opt_tail; ++ } ++ } ++ ++ kfree(a); ++ dump_opts(opts); ++ if (unlikely(err)) ++ au_opts_free(opts); ++ ++ out: ++ return err; ++} ++ ++static int au_opt_wbr_create(struct super_block *sb, ++ struct au_opt_wbr_create *create) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ err = 1; /* handled */ ++ sbinfo = au_sbi(sb); ++ if (sbinfo->si_wbr_create_ops->fin) { ++ err = sbinfo->si_wbr_create_ops->fin(sb); ++ if (!err) ++ err = 1; ++ } ++ ++ sbinfo->si_wbr_create = create->wbr_create; ++ sbinfo->si_wbr_create_ops = au_wbr_create_ops + create->wbr_create; ++ switch (create->wbr_create) { ++ case AuWbrCreate_MFSRRV: ++ case AuWbrCreate_MFSRR: ++ sbinfo->si_wbr_mfs.mfsrr_watermark = create->mfsrr_watermark; ++ /*FALLTHROUGH*/ ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_MFSV: ++ case AuWbrCreate_PMFS: ++ case AuWbrCreate_PMFSV: ++ sbinfo->si_wbr_mfs.mfs_expire = create->mfs_second * HZ; ++ break; ++ } ++ ++ if (sbinfo->si_wbr_create_ops->init) ++ sbinfo->si_wbr_create_ops->init(sb); /* ignore */ ++ ++ return err; ++} ++ ++/* ++ * returns, ++ * plus: processed without an error ++ * zero: unprocessed ++ */ ++static int au_opt_simple(struct super_block *sb, struct au_opt *opt, ++ struct au_opts *opts) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ err = 1; /* handled */ ++ sbinfo = au_sbi(sb); ++ switch (opt->type) { ++ case Opt_udba: ++ sbinfo->si_mntflags &= ~AuOptMask_UDBA; ++ sbinfo->si_mntflags |= opt->udba; ++ opts->given_udba |= opt->udba; ++ break; ++ ++ case Opt_plink: ++ au_opt_set(sbinfo->si_mntflags, PLINK); ++ break; ++ case Opt_noplink: ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) ++ au_plink_put(sb); ++ au_opt_clr(sbinfo->si_mntflags, PLINK); ++ break; ++ case Opt_list_plink: ++ if (au_opt_test(sbinfo->si_mntflags, PLINK)) ++ au_plink_list(sb); ++ break; ++ ++ case Opt_diropq_a: ++ au_opt_set(sbinfo->si_mntflags, ALWAYS_DIROPQ); ++ break; ++ case Opt_diropq_w: ++ au_opt_clr(sbinfo->si_mntflags, ALWAYS_DIROPQ); ++ break; ++ ++ case Opt_warn_perm: ++ au_opt_set(sbinfo->si_mntflags, WARN_PERM); ++ break; ++ case Opt_nowarn_perm: ++ au_opt_clr(sbinfo->si_mntflags, WARN_PERM); ++ break; ++ ++ case Opt_refrof: ++ au_opt_set(sbinfo->si_mntflags, REFROF); ++ break; ++ case Opt_norefrof: ++ au_opt_clr(sbinfo->si_mntflags, REFROF); ++ break; ++ ++ case Opt_verbose: ++ au_opt_set(sbinfo->si_mntflags, VERBOSE); ++ break; ++ case Opt_noverbose: ++ au_opt_clr(sbinfo->si_mntflags, VERBOSE); ++ break; ++ ++ case Opt_sum: ++ au_opt_set(sbinfo->si_mntflags, SUM); ++ break; ++ case Opt_wsum: ++ au_opt_clr(sbinfo->si_mntflags, SUM); ++ au_opt_set(sbinfo->si_mntflags, SUM_W); ++ case Opt_nosum: ++ au_opt_clr(sbinfo->si_mntflags, SUM); ++ au_opt_clr(sbinfo->si_mntflags, SUM_W); ++ break; ++ ++ case Opt_wbr_create: ++ err = au_opt_wbr_create(sb, &opt->wbr_create); ++ break; ++ case Opt_wbr_copyup: ++ sbinfo->si_wbr_copyup = opt->wbr_copyup; ++ sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + opt->wbr_copyup; ++ break; ++ ++ case Opt_dirwh: ++ sbinfo->si_dirwh = opt->dirwh; ++ break; ++ ++ case Opt_rdcache: ++ sbinfo->si_rdcache = opt->rdcache * HZ; ++ break; ++ case Opt_rdblk: ++ sbinfo->si_rdblk = opt->rdblk; ++ break; ++ case Opt_rdblk_def: ++ sbinfo->si_rdblk = AUFS_RDBLK_DEF; ++ break; ++ case Opt_rdhash: ++ sbinfo->si_rdhash = opt->rdhash; ++ break; ++ case Opt_rdhash_def: ++ sbinfo->si_rdhash = AUFS_RDHASH_DEF; ++ break; ++ ++ case Opt_shwh: ++ au_opt_set(sbinfo->si_mntflags, SHWH); ++ break; ++ case Opt_noshwh: ++ au_opt_clr(sbinfo->si_mntflags, SHWH); ++ break; ++ ++ case Opt_trunc_xino: ++ au_opt_set(sbinfo->si_mntflags, TRUNC_XINO); ++ break; ++ case Opt_notrunc_xino: ++ au_opt_clr(sbinfo->si_mntflags, TRUNC_XINO); ++ break; ++ ++ case Opt_trunc_xino_path: ++ case Opt_itrunc_xino: ++ err = au_xino_trunc(sb, opt->xino_itrunc.bindex); ++ if (!err) ++ err = 1; ++ break; ++ ++ case Opt_trunc_xib: ++ au_fset_opts(opts->flags, TRUNC_XIB); ++ break; ++ case Opt_notrunc_xib: ++ au_fclr_opts(opts->flags, TRUNC_XIB); ++ break; ++ ++ default: ++ err = 0; ++ break; ++ } ++ ++ return err; ++} ++ ++/* ++ * returns tri-state. ++ * plus: processed without an error ++ * zero: unprocessed ++ * minus: error ++ */ ++static int au_opt_br(struct super_block *sb, struct au_opt *opt, ++ struct au_opts *opts) ++{ ++ int err, do_refresh; ++ ++ err = 0; ++ switch (opt->type) { ++ case Opt_append: ++ opt->add.bindex = au_sbend(sb) + 1; ++ if (opt->add.bindex < 0) ++ opt->add.bindex = 0; ++ goto add; ++ case Opt_prepend: ++ opt->add.bindex = 0; ++ add: ++ case Opt_add: ++ err = au_br_add(sb, &opt->add, ++ au_ftest_opts(opts->flags, REMOUNT)); ++ if (!err) { ++ err = 1; ++ au_fset_opts(opts->flags, REFRESH_DIR); ++ if (au_br_whable(opt->add.perm)) ++ au_fset_opts(opts->flags, REFRESH_NONDIR); ++ } ++ break; ++ ++ case Opt_del: ++ case Opt_idel: ++ err = au_br_del(sb, &opt->del, ++ au_ftest_opts(opts->flags, REMOUNT)); ++ if (!err) { ++ err = 1; ++ au_fset_opts(opts->flags, TRUNC_XIB); ++ au_fset_opts(opts->flags, REFRESH_DIR); ++ au_fset_opts(opts->flags, REFRESH_NONDIR); ++ } ++ break; ++ ++ case Opt_mod: ++ case Opt_imod: ++ err = au_br_mod(sb, &opt->mod, ++ au_ftest_opts(opts->flags, REMOUNT), ++ &do_refresh); ++ if (!err) { ++ err = 1; ++ if (do_refresh) { ++ au_fset_opts(opts->flags, REFRESH_DIR); ++ au_fset_opts(opts->flags, REFRESH_NONDIR); ++ } ++ } ++ break; ++ } ++ ++ return err; ++} ++ ++static int au_opt_xino(struct super_block *sb, struct au_opt *opt, ++ struct au_opt_xino **opt_xino, ++ struct au_opts *opts) ++{ ++ int err; ++ aufs_bindex_t bend, bindex; ++ struct dentry *root, *parent, *h_root; ++ ++ err = 0; ++ switch (opt->type) { ++ case Opt_xino: ++ err = au_xino_set(sb, &opt->xino, ++ !!au_ftest_opts(opts->flags, REMOUNT)); ++ if (unlikely(err)) ++ break; ++ ++ *opt_xino = &opt->xino; ++ au_xino_brid_set(sb, -1); ++ ++ /* safe d_parent access */ ++ parent = opt->xino.file->f_dentry->d_parent; ++ root = sb->s_root; ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex <= bend; bindex++) { ++ h_root = au_h_dptr(root, bindex); ++ if (h_root == parent) { ++ au_xino_brid_set(sb, au_sbr_id(sb, bindex)); ++ break; ++ } ++ } ++ break; ++ ++ case Opt_noxino: ++ au_xino_clr(sb); ++ au_xino_brid_set(sb, -1); ++ *opt_xino = (void *)-1; ++ break; ++ } ++ ++ return err; ++} ++ ++int au_opts_verify(struct super_block *sb, unsigned long sb_flags, ++ unsigned int pending) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ unsigned char do_plink, skip, do_free; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ struct dentry *root; ++ struct inode *dir, *h_dir; ++ struct au_sbinfo *sbinfo; ++ struct au_hinode *hdir; ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!(sbinfo->si_mntflags & AuOptMask_UDBA)); ++ ++ if (!(sb_flags & MS_RDONLY)) { ++ if (unlikely(!au_br_writable(au_sbr_perm(sb, 0)))) ++ AuWarn("first branch should be rw\n"); ++ if (unlikely(au_opt_test(sbinfo->si_mntflags, SHWH))) ++ AuWarn("shwh should be used with ro\n"); ++ } ++ ++ if (au_opt_test((sbinfo->si_mntflags | pending), UDBA_HINOTIFY) ++ && !au_opt_test(sbinfo->si_mntflags, XINO)) ++ AuWarn("udba=inotify requires xino\n"); ++ ++ err = 0; ++ root = sb->s_root; ++ dir = sb->s_root->d_inode; ++ do_plink = !!au_opt_test(sbinfo->si_mntflags, PLINK); ++ bend = au_sbend(sb); ++ for (bindex = 0; !err && bindex <= bend; bindex++) { ++ skip = 0; ++ h_dir = au_h_iptr(dir, bindex); ++ br = au_sbr(sb, bindex); ++ do_free = 0; ++ ++ wbr = br->br_wbr; ++ if (wbr) ++ wbr_wh_read_lock(wbr); ++ ++ switch (br->br_perm) { ++ case AuBrPerm_RO: ++ case AuBrPerm_ROWH: ++ case AuBrPerm_RR: ++ case AuBrPerm_RRWH: ++ do_free = !!wbr; ++ skip = (!wbr ++ || (!wbr->wbr_whbase ++ && !wbr->wbr_plink ++ && !wbr->wbr_orph)); ++ break; ++ ++ case AuBrPerm_RWNoLinkWH: ++ /* skip = (!br->br_whbase && !br->br_orph); */ ++ skip = (!wbr || !wbr->wbr_whbase); ++ if (skip && wbr) { ++ if (do_plink) ++ skip = !!wbr->wbr_plink; ++ else ++ skip = !wbr->wbr_plink; ++ } ++ break; ++ ++ case AuBrPerm_RW: ++ /* skip = (br->br_whbase && br->br_ohph); */ ++ skip = (wbr && wbr->wbr_whbase); ++ if (skip) { ++ if (do_plink) ++ skip = !!wbr->wbr_plink; ++ else ++ skip = !wbr->wbr_plink; ++ } ++ break; ++ ++ default: ++ BUG(); ++ } ++ if (wbr) ++ wbr_wh_read_unlock(wbr); ++ ++ if (skip) ++ continue; ++ ++ hdir = au_hi(dir, bindex); ++ au_hin_imtx_lock_nested(hdir, AuLsc_I_PARENT); ++ if (wbr) ++ wbr_wh_write_lock(wbr); ++ err = au_wh_init(au_h_dptr(root, bindex), br, sb); ++ if (wbr) ++ wbr_wh_write_unlock(wbr); ++ au_hin_imtx_unlock(hdir); ++ ++ if (!err && do_free) { ++ kfree(wbr); ++ br->br_wbr = NULL; ++ } ++ } ++ ++ return err; ++} ++ ++int au_opts_mount(struct super_block *sb, struct au_opts *opts) ++{ ++ int err; ++ unsigned int tmp; ++ aufs_bindex_t bend; ++ struct au_opt *opt; ++ struct au_opt_xino *opt_xino, xino; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ opt_xino = NULL; ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) ++ err = au_opt_simple(sb, opt++, opts); ++ if (err > 0) ++ err = 0; ++ else if (unlikely(err < 0)) ++ goto out; ++ ++ /* disable xino and udba temporary */ ++ sbinfo = au_sbi(sb); ++ tmp = sbinfo->si_mntflags; ++ au_opt_clr(sbinfo->si_mntflags, XINO); ++ au_opt_set_udba(sbinfo->si_mntflags, UDBA_REVAL); ++ ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) ++ err = au_opt_br(sb, opt++, opts); ++ if (err > 0) ++ err = 0; ++ else if (unlikely(err < 0)) ++ goto out; ++ ++ bend = au_sbend(sb); ++ if (unlikely(bend < 0)) { ++ err = -EINVAL; ++ AuErr("no branches\n"); ++ goto out; ++ } ++ ++ if (au_opt_test(tmp, XINO)) ++ au_opt_set(sbinfo->si_mntflags, XINO); ++ opt = opts->opt; ++ while (!err && opt->type != Opt_tail) ++ err = au_opt_xino(sb, opt++, &opt_xino, opts); ++ if (unlikely(err)) ++ goto out; ++ ++ err = au_opts_verify(sb, sb->s_flags, tmp); ++ if (unlikely(err)) ++ goto out; ++ ++ /* restore xino */ ++ if (au_opt_test(tmp, XINO) && !opt_xino) { ++ xino.file = au_xino_def(sb); ++ err = PTR_ERR(xino.file); ++ if (IS_ERR(xino.file)) ++ goto out; ++ ++ err = au_xino_set(sb, &xino, /*remount*/0); ++ fput(xino.file); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ /* restore udba */ ++ sbinfo->si_mntflags &= ~AuOptMask_UDBA; ++ sbinfo->si_mntflags |= (tmp & AuOptMask_UDBA); ++ if (au_opt_test(tmp, UDBA_HINOTIFY)) { ++ struct inode *dir = sb->s_root->d_inode; ++ au_reset_hinotify(dir, ++ au_hi_flags(dir, /*isdir*/1) & ~AuHi_XINO); ++ } ++ ++ out: ++ return err; ++} ++ ++int au_opts_remount(struct super_block *sb, struct au_opts *opts) ++{ ++ int err, rerr; ++ struct inode *dir; ++ struct au_opt_xino *opt_xino; ++ struct au_opt *opt; ++ struct au_sbinfo *sbinfo; ++ ++ dir = sb->s_root->d_inode; ++ sbinfo = au_sbi(sb); ++ err = 0; ++ opt_xino = NULL; ++ opt = opts->opt; ++ while (err >= 0 && opt->type != Opt_tail) { ++ err = au_opt_simple(sb, opt, opts); ++ if (!err) ++ err = au_opt_br(sb, opt, opts); ++ if (!err) ++ err = au_opt_xino(sb, opt, &opt_xino, opts); ++ opt++; ++ } ++ if (err > 0) ++ err = 0; ++ AuTraceErr(err); ++ /* go on even err */ ++ ++ rerr = au_opts_verify(sb, opts->sb_flags, /*pending*/0); ++ if (unlikely(rerr && !err)) ++ err = rerr; ++ ++ if (au_ftest_opts(opts->flags, TRUNC_XIB)) { ++ rerr = au_xib_trunc(sb); ++ if (unlikely(rerr && !err)) ++ err = rerr; ++ } ++ ++ /* will be handled by the caller */ ++ if (!au_ftest_opts(opts->flags, REFRESH_DIR) ++ && (opts->given_udba || au_opt_test(sbinfo->si_mntflags, XINO))) ++ au_fset_opts(opts->flags, REFRESH_DIR); ++ ++ AuDbg("status 0x%x\n", opts->flags); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++unsigned int au_opt_udba(struct super_block *sb) ++{ ++ return au_mntflags(sb) & AuOptMask_UDBA; ++} +diff -Naur a/fs/aufs/opts.h b/fs/aufs/opts.h +--- a/fs/aufs/opts.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/opts.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,196 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * mount options/flags ++ */ ++ ++#ifndef __AUFS_OPTS_H__ ++#define __AUFS_OPTS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/path.h> ++#include <linux/aufs_type.h> ++ ++struct file; ++struct super_block; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* mount flags */ ++#define AuOpt_XINO 1 /* external inode number bitmap ++ and translation table */ ++#define AuOpt_TRUNC_XINO (1 << 1) /* truncate xino files */ ++#define AuOpt_UDBA_NONE (1 << 2) /* users direct branch access */ ++#define AuOpt_UDBA_REVAL (1 << 3) ++#define AuOpt_UDBA_HINOTIFY (1 << 4) ++#define AuOpt_SHWH (1 << 5) /* show whiteout */ ++#define AuOpt_PLINK (1 << 6) /* pseudo-link */ ++#define AuOpt_DIRPERM1 (1 << 7) /* unimplemented */ ++#define AuOpt_REFROF (1 << 8) /* unimplemented */ ++#define AuOpt_ALWAYS_DIROPQ (1 << 9) /* policy to creating diropq */ ++#define AuOpt_SUM (1 << 10) /* summation for statfs(2) */ ++#define AuOpt_SUM_W (1 << 11) /* unimplemented */ ++#define AuOpt_WARN_PERM (1 << 12) /* warn when add-branch */ ++#define AuOpt_VERBOSE (1 << 13) /* busy inode when del-branch */ ++ ++#ifndef CONFIG_AUFS_HINOTIFY ++#undef AuOpt_UDBA_HINOTIFY ++#define AuOpt_UDBA_HINOTIFY 0 ++#endif ++#ifndef CONFIG_AUFS_SHWH ++#undef AuOpt_SHWH ++#define AuOpt_SHWH 0 ++#endif ++ ++#define AuOpt_Def (AuOpt_XINO \ ++ | AuOpt_UDBA_REVAL \ ++ | AuOpt_PLINK \ ++ /* | AuOpt_DIRPERM1 */ \ ++ | AuOpt_WARN_PERM) ++#define AuOptMask_UDBA (AuOpt_UDBA_NONE \ ++ | AuOpt_UDBA_REVAL \ ++ | AuOpt_UDBA_HINOTIFY) ++ ++#define au_opt_test(flags, name) (flags & AuOpt_##name) ++#define au_opt_set(flags, name) do { \ ++ BUILD_BUG_ON(AuOpt_##name & AuOptMask_UDBA); \ ++ ((flags) |= AuOpt_##name); \ ++} while (0) ++#define au_opt_set_udba(flags, name) do { \ ++ (flags) &= ~AuOptMask_UDBA; \ ++ ((flags) |= AuOpt_##name); \ ++} while (0) ++#define au_opt_clr(flags, name) { ((flags) &= ~AuOpt_##name); } ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies to select one among multiple writable branches */ ++enum { ++ AuWbrCreate_TDP, /* top down parent */ ++ AuWbrCreate_RR, /* round robin */ ++ AuWbrCreate_MFS, /* most free space */ ++ AuWbrCreate_MFSV, /* mfs with seconds */ ++ AuWbrCreate_MFSRR, /* mfs then rr */ ++ AuWbrCreate_MFSRRV, /* mfs then rr with seconds */ ++ AuWbrCreate_PMFS, /* parent and mfs */ ++ AuWbrCreate_PMFSV, /* parent and mfs with seconds */ ++ ++ AuWbrCreate_Def = AuWbrCreate_TDP ++}; ++ ++enum { ++ AuWbrCopyup_TDP, /* top down parent */ ++ AuWbrCopyup_BUP, /* bottom up parent */ ++ AuWbrCopyup_BU, /* bottom up */ ++ ++ AuWbrCopyup_Def = AuWbrCopyup_TDP ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_opt_add { ++ aufs_bindex_t bindex; ++ char *pathname; ++ int perm; ++ struct path path; ++}; ++ ++struct au_opt_del { ++ char *pathname; ++ struct path h_path; ++}; ++ ++struct au_opt_mod { ++ char *path; ++ int perm; ++ struct dentry *h_root; ++}; ++ ++struct au_opt_xino { ++ char *path; ++ struct file *file; ++}; ++ ++struct au_opt_xino_itrunc { ++ aufs_bindex_t bindex; ++}; ++ ++struct au_opt_wbr_create { ++ int wbr_create; ++ int mfs_second; ++ unsigned long long mfsrr_watermark; ++}; ++ ++struct au_opt { ++ int type; ++ union { ++ struct au_opt_xino xino; ++ struct au_opt_xino_itrunc xino_itrunc; ++ struct au_opt_add add; ++ struct au_opt_del del; ++ struct au_opt_mod mod; ++ int dirwh; ++ int rdcache; ++ unsigned int rdblk; ++ unsigned int rdhash; ++ int udba; ++ struct au_opt_wbr_create wbr_create; ++ int wbr_copyup; ++ }; ++}; ++ ++/* opts flags */ ++#define AuOpts_REMOUNT 1 ++#define AuOpts_REFRESH_DIR (1 << 1) ++#define AuOpts_REFRESH_NONDIR (1 << 2) ++#define AuOpts_TRUNC_XIB (1 << 3) ++#define au_ftest_opts(flags, name) ((flags) & AuOpts_##name) ++#define au_fset_opts(flags, name) { (flags) |= AuOpts_##name; } ++#define au_fclr_opts(flags, name) { (flags) &= ~AuOpts_##name; } ++ ++struct au_opts { ++ struct au_opt *opt; ++ int max_opt; ++ ++ unsigned int given_udba; ++ unsigned int flags; ++ unsigned long sb_flags; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++const char *au_optstr_br_perm(int brperm); ++const char *au_optstr_udba(int udba); ++const char *au_optstr_wbr_copyup(int wbr_copyup); ++const char *au_optstr_wbr_create(int wbr_create); ++ ++void au_opts_free(struct au_opts *opts); ++int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts); ++int au_opts_verify(struct super_block *sb, unsigned long sb_flags, ++ unsigned int pending); ++int au_opts_mount(struct super_block *sb, struct au_opts *opts); ++int au_opts_remount(struct super_block *sb, struct au_opts *opts); ++ ++unsigned int au_opt_udba(struct super_block *sb); ++ ++/* ---------------------------------------------------------------------- */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_OPTS_H__ */ +diff -Naur a/fs/aufs/plink.c b/fs/aufs/plink.c +--- a/fs/aufs/plink.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/plink.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,344 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * pseudo-link ++ */ ++ ++#include "aufs.h" ++ ++/* ++ * during a user process maintains the pseudo-links, ++ * prohibit adding a new plink and branch manipulation. ++ */ ++void au_plink_block_maintain(struct super_block *sb) ++{ ++ struct au_sbinfo *sbi = au_sbi(sb); ++ /* gave up wake_up_bit() */ ++ wait_event(sbi->si_plink_wq, !au_ftest_si(sbi, MAINTAIN_PLINK)); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct pseudo_link { ++ struct list_head list; ++ struct inode *inode; ++}; ++ ++#ifdef CONFIG_AUFS_DEBUG ++void au_plink_list(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ struct list_head *plink_list; ++ struct pseudo_link *plink; ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ ++ plink_list = &sbinfo->si_plink.head; ++ spin_lock(&sbinfo->si_plink.spin); ++ list_for_each_entry(plink, plink_list, list) ++ AuDbg("%lu\n", plink->inode->i_ino); ++ spin_unlock(&sbinfo->si_plink.spin); ++} ++#endif ++ ++/* is the inode pseudo-linked? */ ++int au_plink_test(struct inode *inode) ++{ ++ int found; ++ struct au_sbinfo *sbinfo; ++ struct list_head *plink_list; ++ struct pseudo_link *plink; ++ ++ sbinfo = au_sbi(inode->i_sb); ++ AuDebugOn(!au_opt_test(au_mntflags(inode->i_sb), PLINK)); ++ ++ found = 0; ++ plink_list = &sbinfo->si_plink.head; ++ spin_lock(&sbinfo->si_plink.spin); ++ list_for_each_entry(plink, plink_list, list) ++ if (plink->inode == inode) { ++ found = 1; ++ break; ++ } ++ spin_unlock(&sbinfo->si_plink.spin); ++ return found; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * generate a name for plink. ++ * the file will be stored under AUFS_WH_PLINKDIR. ++ */ ++/* 20 is max digits length of ulong 64 */ ++#define PLINK_NAME_LEN ((20 + 1) * 2) ++ ++static int plink_name(char *name, int len, struct inode *inode, ++ aufs_bindex_t bindex) ++{ ++ int rlen; ++ struct inode *h_inode; ++ ++ h_inode = au_h_iptr(inode, bindex); ++ rlen = snprintf(name, len, "%lu.%lu", inode->i_ino, h_inode->i_ino); ++ return rlen; ++} ++ ++/* lookup the plink-ed @inode under the branch at @bindex */ ++struct dentry *au_plink_lkup(struct inode *inode, aufs_bindex_t bindex) ++{ ++ struct dentry *h_dentry, *h_parent; ++ struct au_branch *br; ++ struct inode *h_dir; ++ char a[PLINK_NAME_LEN]; ++ struct qstr tgtname = { ++ .name = a ++ }; ++ ++ br = au_sbr(inode->i_sb, bindex); ++ h_parent = br->br_wbr->wbr_plink; ++ h_dir = h_parent->d_inode; ++ tgtname.len = plink_name(a, sizeof(a), inode, bindex); ++ ++ /* always superio. */ ++ mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_CHILD2); ++ h_dentry = au_sio_lkup_one(&tgtname, h_parent, br); ++ mutex_unlock(&h_dir->i_mutex); ++ return h_dentry; ++} ++ ++/* create a pseudo-link */ ++static int do_whplink(struct qstr *tgt, struct dentry *h_parent, ++ struct dentry *h_dentry, struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = br->br_mnt ++ }; ++ struct inode *h_dir; ++ ++ h_dir = h_parent->d_inode; ++ again: ++ h_path.dentry = au_lkup_one(tgt, h_parent, br, /*nd*/NULL); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ err = 0; ++ /* wh.plink dir is not monitored */ ++ if (h_path.dentry->d_inode ++ && h_path.dentry->d_inode != h_dentry->d_inode) { ++ err = vfsub_unlink(h_dir, &h_path, /*force*/0); ++ dput(h_path.dentry); ++ h_path.dentry = NULL; ++ if (!err) ++ goto again; ++ } ++ if (!err && !h_path.dentry->d_inode) ++ err = vfsub_link(h_dentry, h_dir, &h_path); ++ dput(h_path.dentry); ++ ++ out: ++ return err; ++} ++ ++struct do_whplink_args { ++ int *errp; ++ struct qstr *tgt; ++ struct dentry *h_parent; ++ struct dentry *h_dentry; ++ struct au_branch *br; ++}; ++ ++static void call_do_whplink(void *args) ++{ ++ struct do_whplink_args *a = args; ++ *a->errp = do_whplink(a->tgt, a->h_parent, a->h_dentry, a->br); ++} ++ ++static int whplink(struct dentry *h_dentry, struct inode *inode, ++ aufs_bindex_t bindex, struct au_branch *br) ++{ ++ int err, wkq_err; ++ struct au_wbr *wbr; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ char a[PLINK_NAME_LEN]; ++ struct qstr tgtname = { ++ .name = a ++ }; ++ ++ wbr = au_sbr(inode->i_sb, bindex)->br_wbr; ++ h_parent = wbr->wbr_plink; ++ h_dir = h_parent->d_inode; ++ tgtname.len = plink_name(a, sizeof(a), inode, bindex); ++ ++ /* always superio. */ ++ mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_CHILD2); ++ if (!au_test_wkq(current)) { ++ struct do_whplink_args args = { ++ .errp = &err, ++ .tgt = &tgtname, ++ .h_parent = h_parent, ++ .h_dentry = h_dentry, ++ .br = br ++ }; ++ wkq_err = au_wkq_wait(call_do_whplink, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } else ++ err = do_whplink(&tgtname, h_parent, h_dentry, br); ++ mutex_unlock(&h_dir->i_mutex); ++ ++ return err; ++} ++ ++/* free a single plink */ ++static void do_put_plink(struct pseudo_link *plink, int do_del) ++{ ++ iput(plink->inode); ++ if (do_del) ++ list_del(&plink->list); ++ kfree(plink); ++} ++ ++/* ++ * create a new pseudo-link for @h_dentry on @bindex. ++ * the linked inode is held in aufs @inode. ++ */ ++void au_plink_append(struct inode *inode, aufs_bindex_t bindex, ++ struct dentry *h_dentry) ++{ ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ struct list_head *plink_list; ++ struct pseudo_link *plink; ++ int found, err, cnt; ++ ++ sb = inode->i_sb; ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ ++ err = 0; ++ cnt = 0; ++ found = 0; ++ plink_list = &sbinfo->si_plink.head; ++ spin_lock(&sbinfo->si_plink.spin); ++ list_for_each_entry(plink, plink_list, list) { ++ cnt++; ++ if (plink->inode == inode) { ++ found = 1; ++ break; ++ } ++ } ++ if (found) { ++ spin_unlock(&sbinfo->si_plink.spin); ++ return; ++ } ++ ++ plink = NULL; ++ if (!found) { ++ plink = kmalloc(sizeof(*plink), GFP_ATOMIC); ++ if (plink) { ++ plink->inode = au_igrab(inode); ++ list_add(&plink->list, plink_list); ++ cnt++; ++ } else ++ err = -ENOMEM; ++ } ++ spin_unlock(&sbinfo->si_plink.spin); ++ ++ if (!err) { ++ au_plink_block_maintain(sb); ++ err = whplink(h_dentry, inode, bindex, au_sbr(sb, bindex)); ++ } ++ ++ if (unlikely(cnt > AUFS_PLINK_WARN)) ++ AuWarn1("unexpectedly many pseudo links, %d\n", cnt); ++ if (unlikely(err)) { ++ AuWarn("err %d, damaged pseudo link.\n", err); ++ if (!found && plink) ++ do_put_plink(plink, /*do_del*/1); ++ } ++} ++ ++/* free all plinks */ ++void au_plink_put(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ struct list_head *plink_list; ++ struct pseudo_link *plink, *tmp; ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ ++ plink_list = &sbinfo->si_plink.head; ++ /* no spin_lock since sbinfo is write-locked */ ++ list_for_each_entry_safe(plink, tmp, plink_list, list) ++ do_put_plink(plink, 0); ++ INIT_LIST_HEAD(plink_list); ++} ++ ++/* free the plinks on a branch specified by @br_id */ ++void au_plink_half_refresh(struct super_block *sb, aufs_bindex_t br_id) ++{ ++ struct au_sbinfo *sbinfo; ++ struct list_head *plink_list; ++ struct pseudo_link *plink, *tmp; ++ struct inode *inode; ++ aufs_bindex_t bstart, bend, bindex; ++ unsigned char do_put; ++ ++ sbinfo = au_sbi(sb); ++ AuDebugOn(!au_opt_test(au_mntflags(sb), PLINK)); ++ ++ plink_list = &sbinfo->si_plink.head; ++ /* no spin_lock since sbinfo is write-locked */ ++ list_for_each_entry_safe(plink, tmp, plink_list, list) { ++ do_put = 0; ++ inode = au_igrab(plink->inode); ++ ii_write_lock_child(inode); ++ bstart = au_ibstart(inode); ++ bend = au_ibend(inode); ++ if (bstart >= 0) { ++ for (bindex = bstart; bindex <= bend; bindex++) { ++ if (!au_h_iptr(inode, bindex) ++ || au_ii_br_id(inode, bindex) != br_id) ++ continue; ++ au_set_h_iptr(inode, bindex, NULL, 0); ++ do_put = 1; ++ break; ++ } ++ } else ++ do_put_plink(plink, 1); ++ ++ if (do_put) { ++ for (bindex = bstart; bindex <= bend; bindex++) ++ if (au_h_iptr(inode, bindex)) { ++ do_put = 0; ++ break; ++ } ++ if (do_put) ++ do_put_plink(plink, 1); ++ } ++ ii_write_unlock(inode); ++ iput(inode); ++ } ++} +diff -Naur a/fs/aufs/rwsem.h b/fs/aufs/rwsem.h +--- a/fs/aufs/rwsem.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/rwsem.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,61 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * simple read-write semaphore wrappers ++ */ ++ ++#ifndef __AUFS_RWSEM_H__ ++#define __AUFS_RWSEM_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/rwsem.h> ++ ++#define au_rwsem_destroy(rw) AuDebugOn(rwsem_is_locked(rw)) ++#define AuRwMustNoWaiters(rw) AuDebugOn(!list_empty(&(rw)->wait_list)) ++ ++#define AuSimpleLockRwsemFuncs(prefix, param, rwsem) \ ++static inline void prefix##_read_lock(param) \ ++{ down_read(rwsem); } \ ++static inline void prefix##_write_lock(param) \ ++{ down_write(rwsem); } \ ++static inline int prefix##_read_trylock(param) \ ++{ return down_read_trylock(rwsem); } \ ++static inline int prefix##_write_trylock(param) \ ++{ return down_write_trylock(rwsem); } ++/* why is not _nested version defined */ ++/* static inline void prefix##_read_trylock_nested(param, lsc) ++{ down_write_trylock_nested(rwsem, lsc)); } ++static inline void prefix##_write_trylock_nestd(param, lsc) ++{ down_write_trylock_nested(rwsem, lsc); } */ ++ ++#define AuSimpleUnlockRwsemFuncs(prefix, param, rwsem) \ ++static inline void prefix##_read_unlock(param) \ ++{ up_read(rwsem); } \ ++static inline void prefix##_write_unlock(param) \ ++{ up_write(rwsem); } \ ++static inline void prefix##_downgrade_lock(param) \ ++{ downgrade_write(rwsem); } ++ ++#define AuSimpleRwsemFuncs(prefix, param, rwsem) \ ++ AuSimpleLockRwsemFuncs(prefix, param, rwsem) \ ++ AuSimpleUnlockRwsemFuncs(prefix, param, rwsem) ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_RWSEM_H__ */ +diff -Naur a/fs/aufs/sbinfo.c b/fs/aufs/sbinfo.c +--- a/fs/aufs/sbinfo.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/sbinfo.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,203 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * superblock private data ++ */ ++ ++#include "aufs.h" ++ ++/* ++ * they are necessary regardless sysfs is disabled. ++ */ ++void au_si_free(struct kobject *kobj) ++{ ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ ++ sbinfo = container_of(kobj, struct au_sbinfo, si_kobj); ++ AuDebugOn(!list_empty(&sbinfo->si_plink.head)); ++ ++ sb = sbinfo->si_sb; ++ si_write_lock(sb); ++ au_xino_clr(sb); ++ au_br_free(sbinfo); ++ kfree(sbinfo->si_branch); ++ mutex_destroy(&sbinfo->si_xib_mtx); ++ si_write_unlock(sb); ++ au_rwsem_destroy(&sbinfo->si_rwsem); ++ ++ kfree(sbinfo); ++} ++ ++int au_si_alloc(struct super_block *sb) ++{ ++ int err; ++ struct au_sbinfo *sbinfo; ++ ++ err = -ENOMEM; ++ sbinfo = kmalloc(sizeof(*sbinfo), GFP_NOFS); ++ if (unlikely(!sbinfo)) ++ goto out; ++ ++ /* will be reallocated separately */ ++ sbinfo->si_branch = kzalloc(sizeof(*sbinfo->si_branch), GFP_NOFS); ++ if (unlikely(!sbinfo->si_branch)) ++ goto out_sbinfo; ++ ++ memset(&sbinfo->si_kobj, 0, sizeof(sbinfo->si_kobj)); ++ err = sysaufs_si_init(sbinfo); ++ if (unlikely(err)) ++ goto out_br; ++ ++ au_nwt_init(&sbinfo->si_nowait); ++ init_rwsem(&sbinfo->si_rwsem); ++ down_write(&sbinfo->si_rwsem); ++ sbinfo->si_generation = 0; ++ sbinfo->au_si_status = 0; ++ sbinfo->si_bend = -1; ++ sbinfo->si_last_br_id = 0; ++ ++ sbinfo->si_wbr_copyup = AuWbrCopyup_Def; ++ sbinfo->si_wbr_create = AuWbrCreate_Def; ++ sbinfo->si_wbr_copyup_ops = au_wbr_copyup_ops + AuWbrCopyup_Def; ++ sbinfo->si_wbr_create_ops = au_wbr_create_ops + AuWbrCreate_Def; ++ ++ sbinfo->si_mntflags = AuOpt_Def; ++ ++ sbinfo->si_xread = NULL; ++ sbinfo->si_xwrite = NULL; ++ sbinfo->si_xib = NULL; ++ mutex_init(&sbinfo->si_xib_mtx); ++ sbinfo->si_xib_buf = NULL; ++ sbinfo->si_xino_brid = -1; ++ /* leave si_xib_last_pindex and si_xib_next_bit */ ++ ++ sbinfo->si_rdcache = AUFS_RDCACHE_DEF * HZ; ++ sbinfo->si_rdblk = AUFS_RDBLK_DEF; ++ sbinfo->si_rdhash = AUFS_RDHASH_DEF; ++ sbinfo->si_dirwh = AUFS_DIRWH_DEF; ++ ++ au_spl_init(&sbinfo->si_plink); ++ init_waitqueue_head(&sbinfo->si_plink_wq); ++ ++ /* leave other members for sysaufs and si_mnt. */ ++ sbinfo->si_sb = sb; ++ sb->s_fs_info = sbinfo; ++ au_debug_sbinfo_init(sbinfo); ++ return 0; /* success */ ++ ++ out_br: ++ kfree(sbinfo->si_branch); ++ out_sbinfo: ++ kfree(sbinfo); ++ out: ++ return err; ++} ++ ++int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr) ++{ ++ int err, sz; ++ struct au_branch **brp; ++ ++ err = -ENOMEM; ++ sz = sizeof(*brp) * (sbinfo->si_bend + 1); ++ if (unlikely(!sz)) ++ sz = sizeof(*brp); ++ brp = au_kzrealloc(sbinfo->si_branch, sz, sizeof(*brp) * nbr, GFP_NOFS); ++ if (brp) { ++ sbinfo->si_branch = brp; ++ err = 0; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++unsigned int au_sigen_inc(struct super_block *sb) ++{ ++ unsigned int gen; ++ ++ gen = ++au_sbi(sb)->si_generation; ++ au_update_digen(sb->s_root); ++ au_update_iigen(sb->s_root->d_inode); ++ sb->s_root->d_inode->i_version++; ++ return gen; ++} ++ ++aufs_bindex_t au_new_br_id(struct super_block *sb) ++{ ++ aufs_bindex_t br_id; ++ int i; ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ for (i = 0; i <= AUFS_BRANCH_MAX; i++) { ++ br_id = ++sbinfo->si_last_br_id; ++ if (br_id && au_br_index(sb, br_id) < 0) ++ return br_id; ++ } ++ ++ return -1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dentry and super_block lock. call at entry point */ ++void aufs_read_lock(struct dentry *dentry, int flags) ++{ ++ si_read_lock(dentry->d_sb, flags); ++ if (au_ftest_lock(flags, DW)) ++ di_write_lock_child(dentry); ++ else ++ di_read_lock_child(dentry, flags); ++} ++ ++void aufs_read_unlock(struct dentry *dentry, int flags) ++{ ++ if (au_ftest_lock(flags, DW)) ++ di_write_unlock(dentry); ++ else ++ di_read_unlock(dentry, flags); ++ si_read_unlock(dentry->d_sb); ++} ++ ++void aufs_write_lock(struct dentry *dentry) ++{ ++ si_write_lock(dentry->d_sb); ++ di_write_lock_child(dentry); ++} ++ ++void aufs_write_unlock(struct dentry *dentry) ++{ ++ di_write_unlock(dentry); ++ si_write_unlock(dentry->d_sb); ++} ++ ++void aufs_read_and_write_lock2(struct dentry *d1, struct dentry *d2, int flags) ++{ ++ si_read_lock(d1->d_sb, flags); ++ di_write_lock2_child(d1, d2, au_ftest_lock(flags, DIR)); ++} ++ ++void aufs_read_and_write_unlock2(struct dentry *d1, struct dentry *d2) ++{ ++ di_write_unlock2(d1, d2); ++ si_read_unlock(d1->d_sb); ++} +diff -Naur a/fs/aufs/spl.h b/fs/aufs/spl.h +--- a/fs/aufs/spl.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/spl.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,57 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * simple list protected by a spinlock ++ */ ++ ++#ifndef __AUFS_SPL_H__ ++#define __AUFS_SPL_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/spinlock.h> ++#include <linux/list.h> ++ ++struct au_splhead { ++ spinlock_t spin; ++ struct list_head head; ++}; ++ ++static inline void au_spl_init(struct au_splhead *spl) ++{ ++ spin_lock_init(&spl->spin); ++ INIT_LIST_HEAD(&spl->head); ++} ++ ++static inline void au_spl_add(struct list_head *list, struct au_splhead *spl) ++{ ++ spin_lock(&spl->spin); ++ list_add(list, &spl->head); ++ spin_unlock(&spl->spin); ++} ++ ++static inline void au_spl_del(struct list_head *list, struct au_splhead *spl) ++{ ++ spin_lock(&spl->spin); ++ list_del(list); ++ spin_unlock(&spl->spin); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_SPL_H__ */ +diff -Naur a/fs/aufs/super.c b/fs/aufs/super.c +--- a/fs/aufs/super.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/super.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,870 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * mount and super_block operations ++ */ ++ ++#include <linux/buffer_head.h> ++#include <linux/module.h> ++#include <linux/seq_file.h> ++#include <linux/statfs.h> ++#include "aufs.h" ++ ++/* ++ * super_operations ++ */ ++static struct inode *aufs_alloc_inode(struct super_block *sb __maybe_unused) ++{ ++ struct au_icntnr *c; ++ ++ c = au_cache_alloc_icntnr(); ++ if (c) { ++ inode_init_once(&c->vfs_inode); ++ c->vfs_inode.i_version = 1; /* sigen(sb); */ ++ c->iinfo.ii_hinode = NULL; ++ return &c->vfs_inode; ++ } ++ return NULL; ++} ++ ++static void aufs_destroy_inode(struct inode *inode) ++{ ++ au_iinfo_fin(inode); ++ au_cache_free_icntnr(container_of(inode, struct au_icntnr, vfs_inode)); ++} ++ ++struct inode *au_iget_locked(struct super_block *sb, ino_t ino) ++{ ++ struct inode *inode; ++ int err; ++ ++ inode = iget_locked(sb, ino); ++ if (unlikely(!inode)) { ++ inode = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ if (!(inode->i_state & I_NEW)) ++ goto out; ++ ++ err = au_xigen_new(inode); ++ if (!err) ++ err = au_iinfo_init(inode); ++ if (!err) ++ inode->i_version++; ++ else { ++ iget_failed(inode); ++ inode = ERR_PTR(err); ++ } ++ ++ out: ++ /* never return NULL */ ++ AuDebugOn(!inode); ++ AuTraceErrPtr(inode); ++ return inode; ++} ++ ++/* lock free root dinfo */ ++static int au_show_brs(struct seq_file *seq, struct super_block *sb) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ struct path path; ++ struct au_hdentry *hd; ++ struct au_branch *br; ++ ++ err = 0; ++ bend = au_sbend(sb); ++ hd = au_di(sb->s_root)->di_hdentry; ++ for (bindex = 0; !err && bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ path.mnt = br->br_mnt; ++ path.dentry = hd[bindex].hd_dentry; ++ err = au_seq_path(seq, &path); ++ if (err > 0) ++ err = seq_printf(seq, "=%s", ++ au_optstr_br_perm(br->br_perm)); ++ if (!err && bindex != bend) ++ err = seq_putc(seq, ':'); ++ } ++ ++ return err; ++} ++ ++static void au_show_wbr_create(struct seq_file *m, int v, ++ struct au_sbinfo *sbinfo) ++{ ++ const char *pat; ++ ++ seq_printf(m, ",create="); ++ pat = au_optstr_wbr_create(v); ++ switch (v) { ++ case AuWbrCreate_TDP: ++ case AuWbrCreate_RR: ++ case AuWbrCreate_MFS: ++ case AuWbrCreate_PMFS: ++ seq_printf(m, pat); ++ break; ++ case AuWbrCreate_MFSV: ++ seq_printf(m, /*pat*/"mfs:%lu", ++ sbinfo->si_wbr_mfs.mfs_expire / HZ); ++ break; ++ case AuWbrCreate_PMFSV: ++ seq_printf(m, /*pat*/"pmfs:%lu", ++ sbinfo->si_wbr_mfs.mfs_expire / HZ); ++ break; ++ case AuWbrCreate_MFSRR: ++ seq_printf(m, /*pat*/"mfsrr:%llu", ++ sbinfo->si_wbr_mfs.mfsrr_watermark); ++ break; ++ case AuWbrCreate_MFSRRV: ++ seq_printf(m, /*pat*/"mfsrr:%llu:%lu", ++ sbinfo->si_wbr_mfs.mfsrr_watermark, ++ sbinfo->si_wbr_mfs.mfs_expire / HZ); ++ break; ++ } ++} ++ ++static int au_show_xino(struct seq_file *seq, struct vfsmount *mnt) ++{ ++#ifdef CONFIG_SYSFS ++ return 0; ++#else ++ int err; ++ const int len = sizeof(AUFS_XINO_FNAME) - 1; ++ aufs_bindex_t bindex, brid; ++ struct super_block *sb; ++ struct qstr *name; ++ struct file *f; ++ struct dentry *d, *h_root; ++ ++ err = 0; ++ sb = mnt->mnt_sb; ++ f = au_sbi(sb)->si_xib; ++ if (!f) ++ goto out; ++ ++ /* stop printing the default xino path on the first writable branch */ ++ h_root = NULL; ++ brid = au_xino_brid(sb); ++ if (brid >= 0) { ++ bindex = au_br_index(sb, brid); ++ h_root = au_di(sb->s_root)->di_hdentry[0 + bindex].hd_dentry; ++ } ++ d = f->f_dentry; ++ name = &d->d_name; ++ /* safe ->d_parent because the file is unlinked */ ++ if (d->d_parent == h_root ++ && name->len == len ++ && !memcmp(name->name, AUFS_XINO_FNAME, len)) ++ goto out; ++ ++ seq_puts(seq, ",xino="); ++ err = au_xino_path(seq, f); ++ ++ out: ++ return err; ++#endif ++} ++ ++/* seq_file will re-call me in case of too long string */ ++static int aufs_show_options(struct seq_file *m, struct vfsmount *mnt) ++{ ++ int err, n; ++ unsigned int mnt_flags, v; ++ struct super_block *sb; ++ struct au_sbinfo *sbinfo; ++ ++#define AuBool(name, str) do { \ ++ v = au_opt_test(mnt_flags, name); \ ++ if (v != au_opt_test(AuOpt_Def, name)) \ ++ seq_printf(m, ",%s" #str, v ? "" : "no"); \ ++} while (0) ++ ++#define AuStr(name, str) do { \ ++ v = mnt_flags & AuOptMask_##name; \ ++ if (v != (AuOpt_Def & AuOptMask_##name)) \ ++ seq_printf(m, "," #str "=%s", au_optstr_##str(v)); \ ++} while (0) ++ ++#define AuUInt(name, str, val) do { \ ++ if (val != AUFS_##name##_DEF) \ ++ seq_printf(m, "," #str "=%u", val); \ ++} while (0) ++ ++ /* lock free root dinfo */ ++ sb = mnt->mnt_sb; ++ si_noflush_read_lock(sb); ++ sbinfo = au_sbi(sb); ++ seq_printf(m, ",si=%lx", sysaufs_si_id(sbinfo)); ++ ++ mnt_flags = au_mntflags(sb); ++ if (au_opt_test(mnt_flags, XINO)) { ++ err = au_show_xino(m, mnt); ++ if (unlikely(err)) ++ goto out; ++ } else ++ seq_puts(m, ",noxino"); ++ ++ AuBool(TRUNC_XINO, trunc_xino); ++ AuStr(UDBA, udba); ++ AuBool(SHWH, shwh); ++ AuBool(PLINK, plink); ++ /* AuBool(DIRPERM1, dirperm1); */ ++ /* AuBool(REFROF, refrof); */ ++ ++ v = sbinfo->si_wbr_create; ++ if (v != AuWbrCreate_Def) ++ au_show_wbr_create(m, v, sbinfo); ++ ++ v = sbinfo->si_wbr_copyup; ++ if (v != AuWbrCopyup_Def) ++ seq_printf(m, ",cpup=%s", au_optstr_wbr_copyup(v)); ++ ++ v = au_opt_test(mnt_flags, ALWAYS_DIROPQ); ++ if (v != au_opt_test(AuOpt_Def, ALWAYS_DIROPQ)) ++ seq_printf(m, ",diropq=%c", v ? 'a' : 'w'); ++ ++ AuUInt(DIRWH, dirwh, sbinfo->si_dirwh); ++ ++ n = sbinfo->si_rdcache / HZ; ++ AuUInt(RDCACHE, rdcache, n); ++ ++ AuUInt(RDBLK, rdblk, sbinfo->si_rdblk); ++ AuUInt(RDHASH, rdhash, sbinfo->si_rdhash); ++ ++ AuBool(SUM, sum); ++ /* AuBool(SUM_W, wsum); */ ++ AuBool(WARN_PERM, warn_perm); ++ AuBool(VERBOSE, verbose); ++ ++ out: ++ /* be sure to print "br:" last */ ++ if (!sysaufs_brs) { ++ seq_puts(m, ",br:"); ++ au_show_brs(m, sb); ++ } ++ si_read_unlock(sb); ++ return 0; ++ ++#undef Deleted ++#undef AuBool ++#undef AuStr ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* sum mode which returns the summation for statfs(2) */ ++ ++static u64 au_add_till_max(u64 a, u64 b) ++{ ++ u64 old; ++ ++ old = a; ++ a += b; ++ if (old < a) ++ return a; ++ return ULLONG_MAX; ++} ++ ++static int au_statfs_sum(struct super_block *sb, struct kstatfs *buf) ++{ ++ int err; ++ u64 blocks, bfree, bavail, files, ffree; ++ aufs_bindex_t bend, bindex, i; ++ unsigned char shared; ++ struct vfsmount *h_mnt; ++ struct super_block *h_sb; ++ ++ blocks = 0; ++ bfree = 0; ++ bavail = 0; ++ files = 0; ++ ffree = 0; ++ ++ err = 0; ++ bend = au_sbend(sb); ++ for (bindex = bend; bindex >= 0; bindex--) { ++ h_mnt = au_sbr_mnt(sb, bindex); ++ h_sb = h_mnt->mnt_sb; ++ shared = 0; ++ for (i = bindex + 1; !shared && i <= bend; i++) ++ shared = (au_sbr_sb(sb, i) == h_sb); ++ if (shared) ++ continue; ++ ++ /* sb->s_root for NFS is unreliable */ ++ err = vfs_statfs(h_mnt->mnt_root, buf); ++ if (unlikely(err)) ++ goto out; ++ ++ blocks = au_add_till_max(blocks, buf->f_blocks); ++ bfree = au_add_till_max(bfree, buf->f_bfree); ++ bavail = au_add_till_max(bavail, buf->f_bavail); ++ files = au_add_till_max(files, buf->f_files); ++ ffree = au_add_till_max(ffree, buf->f_ffree); ++ } ++ ++ buf->f_blocks = blocks; ++ buf->f_bfree = bfree; ++ buf->f_bavail = bavail; ++ buf->f_files = files; ++ buf->f_ffree = ffree; ++ ++ out: ++ return err; ++} ++ ++static int aufs_statfs(struct dentry *dentry, struct kstatfs *buf) ++{ ++ int err; ++ struct super_block *sb; ++ ++ /* lock free root dinfo */ ++ sb = dentry->d_sb; ++ si_noflush_read_lock(sb); ++ if (!au_opt_test(au_mntflags(sb), SUM)) ++ /* sb->s_root for NFS is unreliable */ ++ err = vfs_statfs(au_sbr_mnt(sb, 0)->mnt_root, buf); ++ else ++ err = au_statfs_sum(sb, buf); ++ si_read_unlock(sb); ++ ++ if (!err) { ++ buf->f_type = AUFS_SUPER_MAGIC; ++ buf->f_namelen -= AUFS_WH_PFX_LEN; ++ memset(&buf->f_fsid, 0, sizeof(buf->f_fsid)); ++ } ++ /* buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1; */ ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* try flushing the lower fs at aufs remount/unmount time */ ++ ++static void au_fsync_br(struct super_block *sb) ++{ ++ aufs_bindex_t bend, bindex; ++ int brperm; ++ struct au_branch *br; ++ struct super_block *h_sb; ++ ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex < bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ brperm = br->br_perm; ++ if (brperm == AuBrPerm_RR || brperm == AuBrPerm_RRWH) ++ continue; ++ h_sb = br->br_mnt->mnt_sb; ++ if (bdev_read_only(h_sb->s_bdev)) ++ continue; ++ ++ lockdep_off(); ++ down_write(&h_sb->s_umount); ++ shrink_dcache_sb(h_sb); ++ fsync_super(h_sb); ++ up_write(&h_sb->s_umount); ++ lockdep_on(); ++ } ++} ++ ++/* ++ * this IS NOT for super_operations. ++ * I guess it will be reverted someday. ++ */ ++static void aufs_umount_begin(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ if (!sbinfo) ++ return; ++ ++ si_write_lock(sb); ++ au_fsync_br(sb); ++ if (au_opt_test(au_mntflags(sb), PLINK)) ++ au_plink_put(sb); ++ if (sbinfo->si_wbr_create_ops->fin) ++ sbinfo->si_wbr_create_ops->fin(sb); ++ si_write_unlock(sb); ++} ++ ++/* final actions when unmounting a file system */ ++static void aufs_put_super(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ if (!sbinfo) ++ return; ++ ++ aufs_umount_begin(sb); ++ dbgaufs_si_fin(sbinfo); ++ kobject_put(&sbinfo->si_kobj); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * refresh dentry and inode at remount time. ++ */ ++static int do_refresh(struct dentry *dentry, mode_t type, ++ unsigned int dir_flags) ++{ ++ int err; ++ struct dentry *parent; ++ ++ di_write_lock_child(dentry); ++ parent = dget_parent(dentry); ++ di_read_lock_parent(parent, AuLock_IR); ++ ++ /* returns the number of positive dentries */ ++ err = au_refresh_hdentry(dentry, type); ++ if (err >= 0) { ++ struct inode *inode = dentry->d_inode; ++ err = au_refresh_hinode(inode, dentry); ++ if (!err && type == S_IFDIR) ++ au_reset_hinotify(inode, dir_flags); ++ } ++ if (unlikely(err)) ++ AuErr("unrecoverable error %d, %.*s\n", err, AuDLNPair(dentry)); ++ ++ di_read_unlock(parent, AuLock_IR); ++ dput(parent); ++ di_write_unlock(dentry); ++ ++ return err; ++} ++ ++static int test_dir(struct dentry *dentry, void *arg __maybe_unused) ++{ ++ return S_ISDIR(dentry->d_inode->i_mode); ++} ++ ++/* gave up consolidating with refresh_nondir() */ ++static int refresh_dir(struct dentry *root, unsigned int sigen) ++{ ++ int err, i, j, ndentry, e; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ struct inode *inode; ++ const unsigned int flags = au_hi_flags(root->d_inode, /*isdir*/1); ++ ++ err = 0; ++ list_for_each_entry(inode, &root->d_sb->s_inodes, i_sb_list) ++ if (S_ISDIR(inode->i_mode) && au_iigen(inode) != sigen) { ++ ii_write_lock_child(inode); ++ e = au_refresh_hinode_self(inode, /*do_attr*/1); ++ ii_write_unlock(inode); ++ if (unlikely(e)) { ++ AuDbg("e %d, i%lu\n", e, inode->i_ino); ++ if (!err) ++ err = e; ++ /* go on even if err */ ++ } ++ } ++ ++ e = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(e)) { ++ if (!err) ++ err = e; ++ goto out; ++ } ++ e = au_dcsub_pages(&dpages, root, test_dir, NULL); ++ if (unlikely(e)) { ++ if (!err) ++ err = e; ++ goto out_dpages; ++ } ++ ++ for (i = 0; !e && i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; !e && j < ndentry; j++) { ++ struct dentry *d; ++ ++ d = dentries[j]; ++ au_dbg_verify_dir_parent(d, sigen); ++ if (au_digen(d) != sigen) { ++ e = do_refresh(d, S_IFDIR, flags); ++ if (unlikely(e && !err)) ++ err = e; ++ /* break on err */ ++ } ++ } ++ } ++ ++ out_dpages: ++ au_dpages_free(&dpages); ++ out: ++ return err; ++} ++ ++static int test_nondir(struct dentry *dentry, void *arg __maybe_unused) ++{ ++ return !S_ISDIR(dentry->d_inode->i_mode); ++} ++ ++static int refresh_nondir(struct dentry *root, unsigned int sigen, ++ int do_dentry) ++{ ++ int err, i, j, ndentry, e; ++ struct au_dcsub_pages dpages; ++ struct au_dpage *dpage; ++ struct dentry **dentries; ++ struct inode *inode; ++ ++ err = 0; ++ list_for_each_entry(inode, &root->d_sb->s_inodes, i_sb_list) ++ if (!S_ISDIR(inode->i_mode) && au_iigen(inode) != sigen) { ++ ii_write_lock_child(inode); ++ e = au_refresh_hinode_self(inode, /*do_attr*/1); ++ ii_write_unlock(inode); ++ if (unlikely(e)) { ++ AuDbg("e %d, i%lu\n", e, inode->i_ino); ++ if (!err) ++ err = e; ++ /* go on even if err */ ++ } ++ } ++ ++ if (!do_dentry) ++ goto out; ++ ++ e = au_dpages_init(&dpages, GFP_NOFS); ++ if (unlikely(e)) { ++ if (!err) ++ err = e; ++ goto out; ++ } ++ e = au_dcsub_pages(&dpages, root, test_nondir, NULL); ++ if (unlikely(e)) { ++ if (!err) ++ err = e; ++ goto out_dpages; ++ } ++ ++ for (i = 0; i < dpages.ndpage; i++) { ++ dpage = dpages.dpages + i; ++ dentries = dpage->dentries; ++ ndentry = dpage->ndentry; ++ for (j = 0; j < ndentry; j++) { ++ struct dentry *d; ++ ++ d = dentries[j]; ++ au_dbg_verify_nondir_parent(d, sigen); ++ inode = d->d_inode; ++ if (inode && au_digen(d) != sigen) { ++ e = do_refresh(d, inode->i_mode & S_IFMT, ++ /*dir_flags*/0); ++ if (unlikely(e && !err)) ++ err = e; ++ /* go on even err */ ++ } ++ } ++ } ++ ++ out_dpages: ++ au_dpages_free(&dpages); ++ out: ++ return err; ++} ++ ++static void au_remount_refresh(struct super_block *sb, unsigned int flags) ++{ ++ int err; ++ unsigned int sigen; ++ struct au_sbinfo *sbinfo; ++ struct dentry *root; ++ struct inode *inode; ++ ++ au_sigen_inc(sb); ++ sigen = au_sigen(sb); ++ sbinfo = au_sbi(sb); ++ au_fclr_si(sbinfo, FAILED_REFRESH_DIRS); ++ ++ root = sb->s_root; ++ DiMustNoWaiters(root); ++ inode = root->d_inode; ++ IiMustNoWaiters(inode); ++ au_reset_hinotify(inode, au_hi_flags(inode, /*isdir*/1)); ++ di_write_unlock(root); ++ ++ err = refresh_dir(root, sigen); ++ if (unlikely(err)) { ++ au_fset_si(sbinfo, FAILED_REFRESH_DIRS); ++ AuWarn("Refreshing directories failed, ignored (%d)\n", err); ++ } ++ ++ if (au_ftest_opts(flags, REFRESH_NONDIR)) { ++ err = refresh_nondir(root, sigen, !err); ++ if (unlikely(err)) ++ AuWarn("Refreshing non-directories failed, ignored" ++ "(%d)\n", err); ++ } ++ ++ /* aufs_write_lock() calls ..._child() */ ++ di_write_lock_child(root); ++ au_cpup_attr_all(root->d_inode, /*force*/1); ++} ++ ++/* stop extra interpretation of errno in mount(8), and strange error messages */ ++static int cvt_err(int err) ++{ ++ AuTraceErr(err); ++ ++ switch (err) { ++ case -ENOENT: ++ case -ENOTDIR: ++ case -EEXIST: ++ case -EIO: ++ err = -EINVAL; ++ } ++ return err; ++} ++ ++static int aufs_remount_fs(struct super_block *sb, int *flags, char *data) ++{ ++ int err; ++ struct au_opts opts; ++ struct dentry *root; ++ struct inode *inode; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ root = sb->s_root; ++ if (!data || !*data) { ++ aufs_write_lock(root); ++ err = au_opts_verify(sb, *flags, /*pending*/0); ++ if (!err) ++ au_fsync_br(sb); ++ aufs_write_unlock(root); ++ goto out; ++ } ++ ++ err = -ENOMEM; ++ memset(&opts, 0, sizeof(opts)); ++ opts.opt = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!opts.opt)) ++ goto out; ++ opts.max_opt = PAGE_SIZE / sizeof(*opts.opt); ++ opts.flags = AuOpts_REMOUNT; ++ opts.sb_flags = *flags; ++ ++ /* parse it before aufs lock */ ++ err = au_opts_parse(sb, data, &opts); ++ if (unlikely(err)) ++ goto out_opts; ++ ++ sbinfo = au_sbi(sb); ++ inode = root->d_inode; ++ mutex_lock(&inode->i_mutex); ++ aufs_write_lock(root); ++ au_fsync_br(sb); ++ ++ /* au_opts_remount() may return an error */ ++ err = au_opts_remount(sb, &opts); ++ au_opts_free(&opts); ++ ++ if (au_ftest_opts(opts.flags, REFRESH_DIR) ++ || au_ftest_opts(opts.flags, REFRESH_NONDIR)) ++ au_remount_refresh(sb, opts.flags); ++ ++ aufs_write_unlock(root); ++ mutex_unlock(&inode->i_mutex); ++ ++ out_opts: ++ free_page((unsigned long)opts.opt); ++ out: ++ err = cvt_err(err); ++ AuTraceErr(err); ++ return err; ++} ++ ++static struct super_operations aufs_sop = { ++ .alloc_inode = aufs_alloc_inode, ++ .destroy_inode = aufs_destroy_inode, ++ .drop_inode = generic_delete_inode, ++ .show_options = aufs_show_options, ++ .statfs = aufs_statfs, ++ .put_super = aufs_put_super, ++ .remount_fs = aufs_remount_fs ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int alloc_root(struct super_block *sb) ++{ ++ int err; ++ struct inode *inode; ++ struct dentry *root; ++ ++ err = -ENOMEM; ++ inode = au_iget_locked(sb, AUFS_ROOT_INO); ++ err = PTR_ERR(inode); ++ if (IS_ERR(inode)) ++ goto out; ++ ++ inode->i_op = &aufs_dir_iop; ++ inode->i_fop = &aufs_dir_fop; ++ inode->i_mode = S_IFDIR; ++ inode->i_nlink = 2; ++ unlock_new_inode(inode); ++ ++ root = d_alloc_root(inode); ++ if (unlikely(!root)) ++ goto out_iput; ++ err = PTR_ERR(root); ++ if (IS_ERR(root)) ++ goto out_iput; ++ ++ err = au_alloc_dinfo(root); ++ if (!err) { ++ sb->s_root = root; ++ return 0; /* success */ ++ } ++ dput(root); ++ goto out; /* do not iput */ ++ ++ out_iput: ++ iget_failed(inode); ++ iput(inode); ++ out: ++ return err; ++ ++} ++ ++static int aufs_fill_super(struct super_block *sb, void *raw_data, ++ int silent __maybe_unused) ++{ ++ int err; ++ struct au_opts opts; ++ struct dentry *root; ++ struct inode *inode; ++ char *arg = raw_data; ++ ++ if (unlikely(!arg || !*arg)) { ++ err = -EINVAL; ++ AuErr("no arg\n"); ++ goto out; ++ } ++ ++ err = -ENOMEM; ++ memset(&opts, 0, sizeof(opts)); ++ opts.opt = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!opts.opt)) ++ goto out; ++ opts.max_opt = PAGE_SIZE / sizeof(*opts.opt); ++ opts.sb_flags = sb->s_flags; ++ ++ err = au_si_alloc(sb); ++ if (unlikely(err)) ++ goto out_opts; ++ ++ /* all timestamps always follow the ones on the branch */ ++ sb->s_flags |= MS_NOATIME | MS_NODIRATIME; ++ sb->s_op = &aufs_sop; ++ sb->s_magic = AUFS_SUPER_MAGIC; ++ sb->s_maxbytes = 0; ++ au_export_init(sb); ++ ++ err = alloc_root(sb); ++ if (unlikely(err)) { ++ si_write_unlock(sb); ++ goto out_info; ++ } ++ root = sb->s_root; ++ inode = root->d_inode; ++ ++ /* ++ * actually we can parse options regardless aufs lock here. ++ * but at remount time, parsing must be done before aufs lock. ++ * so we follow the same rule. ++ */ ++ ii_write_lock_parent(inode); ++ aufs_write_unlock(root); ++ err = au_opts_parse(sb, arg, &opts); ++ if (unlikely(err)) ++ goto out_root; ++ ++ /* lock vfs_inode first, then aufs. */ ++ mutex_lock(&inode->i_mutex); ++ inode->i_op = &aufs_dir_iop; ++ inode->i_fop = &aufs_dir_fop; ++ aufs_write_lock(root); ++ err = au_opts_mount(sb, &opts); ++ au_opts_free(&opts); ++ if (unlikely(err)) ++ goto out_unlock; ++ aufs_write_unlock(root); ++ mutex_unlock(&inode->i_mutex); ++ goto out_opts; /* success */ ++ ++ out_unlock: ++ aufs_write_unlock(root); ++ mutex_unlock(&inode->i_mutex); ++ out_root: ++ dput(root); ++ sb->s_root = NULL; ++ out_info: ++ kobject_put(&au_sbi(sb)->si_kobj); ++ sb->s_fs_info = NULL; ++ out_opts: ++ free_page((unsigned long)opts.opt); ++ out: ++ AuTraceErr(err); ++ err = cvt_err(err); ++ AuTraceErr(err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int aufs_get_sb(struct file_system_type *fs_type, int flags, ++ const char *dev_name __maybe_unused, void *raw_data, ++ struct vfsmount *mnt) ++{ ++ int err; ++ struct super_block *sb; ++ ++ /* all timestamps always follow the ones on the branch */ ++ /* mnt->mnt_flags |= MNT_NOATIME | MNT_NODIRATIME; */ ++ err = get_sb_nodev(fs_type, flags, raw_data, aufs_fill_super, mnt); ++ if (!err) { ++ sb = mnt->mnt_sb; ++ si_write_lock(sb); ++ sysaufs_brs_add(sb, 0); ++ si_write_unlock(sb); ++ } ++ return err; ++} ++ ++struct file_system_type aufs_fs_type = { ++ .name = AUFS_FSTYPE, ++ .fs_flags = ++ FS_RENAME_DOES_D_MOVE /* a race between rename and others */ ++ | FS_REVAL_DOT, /* for NFS branch and udba */ ++ .get_sb = aufs_get_sb, ++ .kill_sb = generic_shutdown_super, ++ /* no need to __module_get() and module_put(). */ ++ .owner = THIS_MODULE, ++}; +diff -Naur a/fs/aufs/super.h b/fs/aufs/super.h +--- a/fs/aufs/super.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/super.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,359 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * super_block operations ++ */ ++ ++#ifndef __AUFS_SUPER_H__ ++#define __AUFS_SUPER_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/aufs_type.h> ++#include "rwsem.h" ++#include "spl.h" ++#include "wkq.h" ++ ++typedef ssize_t (*au_readf_t)(struct file *, char __user *, size_t, loff_t *); ++typedef ssize_t (*au_writef_t)(struct file *, const char __user *, size_t, ++ loff_t *); ++ ++/* policies to select one among multiple writable branches */ ++struct au_wbr_copyup_operations { ++ int (*copyup)(struct dentry *dentry); ++}; ++ ++struct au_wbr_create_operations { ++ int (*create)(struct dentry *dentry, int isdir); ++ int (*init)(struct super_block *sb); ++ int (*fin)(struct super_block *sb); ++}; ++ ++struct au_wbr_mfs { ++ struct mutex mfs_lock; /* protect this structure */ ++ unsigned long mfs_jiffy; ++ unsigned long mfs_expire; ++ aufs_bindex_t mfs_bindex; ++ ++ unsigned long long mfsrr_bytes; ++ unsigned long long mfsrr_watermark; ++}; ++ ++/* sbinfo status flags */ ++/* ++ * set true when refresh_dirs() failed at remount time. ++ * then try refreshing dirs at access time again. ++ * if it is false, refreshing dirs at access time is unnecesary ++ */ ++#define AuSi_FAILED_REFRESH_DIRS 1 ++#define AuSi_MAINTAIN_PLINK (1 << 1) /* ioctl */ ++#define au_ftest_si(sbinfo, name) ((sbinfo)->au_si_status & AuSi_##name) ++#define au_fset_si(sbinfo, name) \ ++ { (sbinfo)->au_si_status |= AuSi_##name; } ++#define au_fclr_si(sbinfo, name) \ ++ { (sbinfo)->au_si_status &= ~AuSi_##name; } ++ ++struct au_branch; ++struct au_sbinfo { ++ /* nowait tasks in the system-wide workqueue */ ++ struct au_nowait_tasks si_nowait; ++ ++ struct rw_semaphore si_rwsem; ++ ++ /* branch management */ ++ unsigned int si_generation; ++ ++ /* see above flags */ ++ unsigned char au_si_status; ++ ++ aufs_bindex_t si_bend; ++ aufs_bindex_t si_last_br_id; ++ struct au_branch **si_branch; ++ ++ /* policy to select a writable branch */ ++ unsigned char si_wbr_copyup; ++ unsigned char si_wbr_create; ++ struct au_wbr_copyup_operations *si_wbr_copyup_ops; ++ struct au_wbr_create_operations *si_wbr_create_ops; ++ ++ /* round robin */ ++ atomic_t si_wbr_rr_next; ++ ++ /* most free space */ ++ struct au_wbr_mfs si_wbr_mfs; ++ ++ /* mount flags */ ++ /* include/asm-ia64/siginfo.h defines a macro named si_flags */ ++ unsigned int si_mntflags; ++ ++ /* external inode number (bitmap and translation table) */ ++ au_readf_t si_xread; ++ au_writef_t si_xwrite; ++ struct file *si_xib; ++ struct mutex si_xib_mtx; /* protect xib members */ ++ unsigned long *si_xib_buf; ++ unsigned long si_xib_last_pindex; ++ int si_xib_next_bit; ++ aufs_bindex_t si_xino_brid; ++ /* reserved for future use */ ++ /* unsigned long long si_xib_limit; */ /* Max xib file size */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++ /* i_generation */ ++ struct file *si_xigen; ++ atomic_t si_xigen_next; ++#endif ++ ++ /* vdir parameters */ ++ unsigned long si_rdcache; /* max cache time in HZ */ ++ unsigned int si_rdblk; /* deblk size */ ++ unsigned int si_rdhash; /* hash size */ ++ ++ /* ++ * If the number of whiteouts are larger than si_dirwh, leave all of ++ * them after au_whtmp_ren to reduce the cost of rmdir(2). ++ * future fsck.aufs or kernel thread will remove them later. ++ * Otherwise, remove all whiteouts and the dir in rmdir(2). ++ */ ++ unsigned int si_dirwh; ++ ++ /* ++ * rename(2) a directory with all children. ++ */ ++ /* reserved for future use */ ++ /* int si_rendir; */ ++ ++ /* pseudo_link list */ ++ struct au_splhead si_plink; ++ wait_queue_head_t si_plink_wq; ++ ++ /* ++ * sysfs and lifetime management. ++ * this is not a small structure and it may be a waste of memory in case ++ * of sysfs is disabled, particulary when many aufs-es are mounted. ++ * but using sysfs is majority. ++ */ ++ struct kobject si_kobj; ++#ifdef CONFIG_DEBUG_FS ++ struct dentry *si_dbgaufs, *si_dbgaufs_xib; ++#ifdef CONFIG_AUFS_EXPORT ++ struct dentry *si_dbgaufs_xigen; ++#endif ++#endif ++ ++ /* dirty, necessary for unmounting, sysfs and sysrq */ ++ struct super_block *si_sb; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policy to select one among writable branches */ ++#define AuWbrCopyup(sbinfo, args...) \ ++ ((sbinfo)->si_wbr_copyup_ops->copyup(args)) ++#define AuWbrCreate(sbinfo, args...) \ ++ ((sbinfo)->si_wbr_create_ops->create(args)) ++ ++/* flags for si_read_lock()/aufs_read_lock()/di_read_lock() */ ++#define AuLock_DW 1 /* write-lock dentry */ ++#define AuLock_IR (1 << 1) /* read-lock inode */ ++#define AuLock_IW (1 << 2) /* write-lock inode */ ++#define AuLock_FLUSH (1 << 3) /* wait for 'nowait' tasks */ ++#define AuLock_DIR (1 << 4) /* target is a dir */ ++#define au_ftest_lock(flags, name) ((flags) & AuLock_##name) ++#define au_fset_lock(flags, name) { (flags) |= AuLock_##name; } ++#define au_fclr_lock(flags, name) { (flags) &= ~AuLock_##name; } ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* super.c */ ++extern struct file_system_type aufs_fs_type; ++struct inode *au_iget_locked(struct super_block *sb, ino_t ino); ++ ++/* sbinfo.c */ ++void au_si_free(struct kobject *kobj); ++int au_si_alloc(struct super_block *sb); ++int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr); ++ ++unsigned int au_sigen_inc(struct super_block *sb); ++aufs_bindex_t au_new_br_id(struct super_block *sb); ++ ++void aufs_read_lock(struct dentry *dentry, int flags); ++void aufs_read_unlock(struct dentry *dentry, int flags); ++void aufs_write_lock(struct dentry *dentry); ++void aufs_write_unlock(struct dentry *dentry); ++void aufs_read_and_write_lock2(struct dentry *d1, struct dentry *d2, int isdir); ++void aufs_read_and_write_unlock2(struct dentry *d1, struct dentry *d2); ++ ++/* wbr_policy.c */ ++extern struct au_wbr_copyup_operations au_wbr_copyup_ops[]; ++extern struct au_wbr_create_operations au_wbr_create_ops[]; ++int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct au_sbinfo *au_sbi(struct super_block *sb) ++{ ++ return sb->s_fs_info; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_EXPORT ++void au_export_init(struct super_block *sb); ++ ++static inline int au_test_nfsd(struct task_struct *tsk) ++{ ++ return !tsk->mm && !strcmp(tsk->comm, "nfsd"); ++} ++ ++int au_xigen_inc(struct inode *inode); ++int au_xigen_new(struct inode *inode); ++int au_xigen_set(struct super_block *sb, struct file *base); ++void au_xigen_clr(struct super_block *sb); ++ ++static inline int au_busy_or_stale(void) ++{ ++ if (!au_test_nfsd(current)) ++ return -EBUSY; ++ return -ESTALE; ++} ++#else ++static inline void au_export_init(struct super_block *sb) ++{ ++ /* nothing */ ++} ++ ++static inline int au_test_nfsd(struct task_struct *tsk) ++{ ++ return 0; ++} ++ ++static inline int au_xigen_inc(struct inode *inode) ++{ ++ return 0; ++} ++ ++static inline int au_xigen_new(struct inode *inode) ++{ ++ return 0; ++} ++ ++static inline int au_xigen_set(struct super_block *sb, struct file *base) ++{ ++ return 0; ++} ++ ++static inline void au_xigen_clr(struct super_block *sb) ++{ ++ /* empty */ ++} ++ ++static inline int au_busy_or_stale(void) ++{ ++ return -EBUSY; ++} ++#endif /* CONFIG_AUFS_EXPORT */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline void dbgaufs_si_null(struct au_sbinfo *sbinfo) ++{ ++#ifdef CONFIG_DEBUG_FS ++ sbinfo->si_dbgaufs = NULL; ++ sbinfo->si_dbgaufs_xib = NULL; ++#ifdef CONFIG_AUFS_EXPORT ++ sbinfo->si_dbgaufs_xigen = NULL; ++#endif ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock superblock. mainly for entry point functions */ ++/* ++ * si_noflush_read_lock, si_noflush_write_lock, ++ * si_read_unlock, si_write_unlock, si_downgrade_lock ++ */ ++AuSimpleLockRwsemFuncs(si_noflush, struct super_block *sb, ++ &au_sbi(sb)->si_rwsem); ++AuSimpleUnlockRwsemFuncs(si, struct super_block *sb, &au_sbi(sb)->si_rwsem); ++ ++static inline void si_read_lock(struct super_block *sb, int flags) ++{ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ si_noflush_read_lock(sb); ++} ++ ++static inline void si_write_lock(struct super_block *sb) ++{ ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ si_noflush_write_lock(sb); ++} ++ ++static inline int si_read_trylock(struct super_block *sb, int flags) ++{ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ return si_noflush_read_trylock(sb); ++} ++ ++static inline int si_write_trylock(struct super_block *sb, int flags) ++{ ++ if (au_ftest_lock(flags, FLUSH)) ++ au_nwt_flush(&au_sbi(sb)->si_nowait); ++ return si_noflush_write_trylock(sb); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline aufs_bindex_t au_sbend(struct super_block *sb) ++{ ++ return au_sbi(sb)->si_bend; ++} ++ ++static inline unsigned int au_mntflags(struct super_block *sb) ++{ ++ return au_sbi(sb)->si_mntflags; ++} ++ ++static inline unsigned int au_sigen(struct super_block *sb) ++{ ++ return au_sbi(sb)->si_generation; ++} ++ ++static inline struct au_branch *au_sbr(struct super_block *sb, ++ aufs_bindex_t bindex) ++{ ++ return au_sbi(sb)->si_branch[0 + bindex]; ++} ++ ++static inline void au_xino_brid_set(struct super_block *sb, aufs_bindex_t brid) ++{ ++ au_sbi(sb)->si_xino_brid = brid; ++} ++ ++static inline aufs_bindex_t au_xino_brid(struct super_block *sb) ++{ ++ return au_sbi(sb)->si_xino_brid; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_SUPER_H__ */ +diff -Naur a/fs/aufs/sysaufs.c b/fs/aufs/sysaufs.c +--- a/fs/aufs/sysaufs.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/sysaufs.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,104 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sysfs interface and lifetime management ++ * they are necessary regardless sysfs is disabled. ++ */ ++ ++#include <linux/fs.h> ++#include <linux/random.h> ++#include <linux/sysfs.h> ++#include "aufs.h" ++ ++unsigned long sysaufs_si_mask; ++struct kset *sysaufs_ket; ++ ++#define AuSiAttr(_name) { \ ++ .attr = { .name = __stringify(_name), .mode = 0444 }, \ ++ .show = sysaufs_si_##_name, \ ++} ++ ++static struct sysaufs_si_attr sysaufs_si_attr_xi_path = AuSiAttr(xi_path); ++struct attribute *sysaufs_si_attrs[] = { ++ &sysaufs_si_attr_xi_path.attr, ++ NULL, ++}; ++ ++static struct sysfs_ops au_sbi_ops = { ++ .show = sysaufs_si_show ++}; ++ ++static struct kobj_type au_sbi_ktype = { ++ .release = au_si_free, ++ .sysfs_ops = &au_sbi_ops, ++ .default_attrs = sysaufs_si_attrs ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int sysaufs_si_init(struct au_sbinfo *sbinfo) ++{ ++ int err; ++ ++ sbinfo->si_kobj.kset = sysaufs_ket; ++ /* cf. sysaufs_name() */ ++ err = kobject_init_and_add ++ (&sbinfo->si_kobj, &au_sbi_ktype, /*&sysaufs_ket->kobj*/NULL, ++ SysaufsSiNamePrefix "%lx", sysaufs_si_id(sbinfo)); ++ ++ dbgaufs_si_null(sbinfo); ++ if (!err) { ++ err = dbgaufs_si_init(sbinfo); ++ if (unlikely(err)) ++ kobject_put(&sbinfo->si_kobj); ++ } ++ return err; ++} ++ ++void sysaufs_fin(void) ++{ ++ dbgaufs_fin(); ++ sysfs_remove_group(&sysaufs_ket->kobj, sysaufs_attr_group); ++ kset_unregister(sysaufs_ket); ++} ++ ++int __init sysaufs_init(void) ++{ ++ int err; ++ ++ do { ++ get_random_bytes(&sysaufs_si_mask, sizeof(sysaufs_si_mask)); ++ } while (!sysaufs_si_mask); ++ ++ sysaufs_ket = kset_create_and_add(AUFS_NAME, NULL, fs_kobj); ++ err = PTR_ERR(sysaufs_ket); ++ if (IS_ERR(sysaufs_ket)) ++ goto out; ++ err = sysfs_create_group(&sysaufs_ket->kobj, sysaufs_attr_group); ++ if (unlikely(err)) { ++ kset_unregister(sysaufs_ket); ++ goto out; ++ } ++ ++ err = dbgaufs_init(); ++ if (unlikely(err)) ++ sysaufs_fin(); ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/sysaufs.h b/fs/aufs/sysaufs.h +--- a/fs/aufs/sysaufs.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/sysaufs.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,120 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sysfs interface and mount lifetime management ++ */ ++ ++#ifndef __SYSAUFS_H__ ++#define __SYSAUFS_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/sysfs.h> ++#include <linux/aufs_type.h> ++#include "module.h" ++ ++struct super_block; ++struct au_sbinfo; ++ ++struct sysaufs_si_attr { ++ struct attribute attr; ++ int (*show)(struct seq_file *seq, struct super_block *sb); ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* sysaufs.c */ ++extern unsigned long sysaufs_si_mask; ++extern struct kset *sysaufs_ket; ++extern struct attribute *sysaufs_si_attrs[]; ++int sysaufs_si_init(struct au_sbinfo *sbinfo); ++int __init sysaufs_init(void); ++void sysaufs_fin(void); ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* some people doesn't like to show a pointer in kernel */ ++static inline unsigned long sysaufs_si_id(struct au_sbinfo *sbinfo) ++{ ++ return sysaufs_si_mask ^ (unsigned long)sbinfo; ++} ++ ++#define SysaufsSiNamePrefix "si_" ++#define SysaufsSiNameLen (sizeof(SysaufsSiNamePrefix) + 16) ++static inline void sysaufs_name(struct au_sbinfo *sbinfo, char *name) ++{ ++ snprintf(name, SysaufsSiNameLen, SysaufsSiNamePrefix "%lx", ++ sysaufs_si_id(sbinfo)); ++} ++ ++struct au_branch; ++#ifdef CONFIG_SYSFS ++/* sysfs.c */ ++extern struct attribute_group *sysaufs_attr_group; ++ ++int sysaufs_si_xi_path(struct seq_file *seq, struct super_block *sb); ++ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr, ++ char *buf); ++ ++void sysaufs_br_init(struct au_branch *br); ++void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex); ++void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex); ++ ++#define sysaufs_brs_init() do {} while (0) ++ ++#else ++#define sysaufs_attr_group NULL ++ ++static inline ++int sysaufs_si_xi_path(struct seq_file *seq, struct super_block *sb) ++{ ++ return 0; ++} ++ ++static inline ++ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr, ++ char *buf) ++{ ++ return 0; ++} ++ ++static inline void sysaufs_br_init(struct au_branch *br) ++{ ++ /* empty */ ++} ++ ++static inline void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ /* nothing */ ++} ++ ++static inline void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ /* nothing */ ++} ++ ++static inline void sysaufs_brs_init(void) ++{ ++ sysaufs_brs = 0; ++} ++ ++#endif /* CONFIG_SYSFS */ ++ ++#endif /* __KERNEL__ */ ++#endif /* __SYSAUFS_H__ */ +diff -Naur a/fs/aufs/sysfs.c b/fs/aufs/sysfs.c +--- a/fs/aufs/sysfs.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/sysfs.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,208 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sysfs interface ++ */ ++ ++#include <linux/fs.h> ++#include <linux/module.h> ++#include <linux/seq_file.h> ++#include <linux/sysfs.h> ++#include "aufs.h" ++ ++static struct attribute *au_attr[] = { ++ NULL, /* need to NULL terminate the list of attributes */ ++}; ++ ++static struct attribute_group sysaufs_attr_group_body = { ++ .attrs = au_attr ++}; ++ ++struct attribute_group *sysaufs_attr_group = &sysaufs_attr_group_body; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int sysaufs_si_xi_path(struct seq_file *seq, struct super_block *sb) ++{ ++ int err; ++ ++ err = 0; ++ if (au_opt_test(au_mntflags(sb), XINO)) { ++ err = au_xino_path(seq, au_sbi(sb)->si_xib); ++ seq_putc(seq, '\n'); ++ } ++ return err; ++} ++ ++/* ++ * the lifetime of branch is independent from the entry under sysfs. ++ * sysfs handles the lifetime of the entry, and never call ->show() after it is ++ * unlinked. ++ */ ++static int sysaufs_si_br(struct seq_file *seq, struct super_block *sb, ++ aufs_bindex_t bindex) ++{ ++ struct path path; ++ struct dentry *root; ++ struct au_branch *br; ++ ++ AuDbg("b%d\n", bindex); ++ ++ root = sb->s_root; ++ di_read_lock_parent(root, !AuLock_IR); ++ br = au_sbr(sb, bindex); ++ path.mnt = br->br_mnt; ++ path.dentry = au_h_dptr(root, bindex); ++ au_seq_path(seq, &path); ++ di_read_unlock(root, !AuLock_IR); ++ seq_printf(seq, "=%s\n", au_optstr_br_perm(br->br_perm)); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static struct seq_file *au_seq(char *p, ssize_t len) ++{ ++ struct seq_file *seq; ++ ++ seq = kzalloc(sizeof(*seq), GFP_NOFS); ++ if (seq) { ++ /* mutex_init(&seq.lock); */ ++ seq->buf = p; ++ seq->size = len; ++ return seq; /* success */ ++ } ++ ++ seq = ERR_PTR(-ENOMEM); ++ return seq; ++} ++ ++#define SysaufsBr_PREFIX "br" ++ ++/* todo: file size may exceed PAGE_SIZE */ ++ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr, ++ char *buf) ++{ ++ ssize_t err; ++ long l; ++ aufs_bindex_t bend; ++ struct au_sbinfo *sbinfo; ++ struct super_block *sb; ++ struct seq_file *seq; ++ char *name; ++ struct attribute **cattr; ++ ++ sbinfo = container_of(kobj, struct au_sbinfo, si_kobj); ++ sb = sbinfo->si_sb; ++ si_noflush_read_lock(sb); ++ ++ seq = au_seq(buf, PAGE_SIZE); ++ err = PTR_ERR(seq); ++ if (IS_ERR(seq)) ++ goto out; ++ ++ name = (void *)attr->name; ++ cattr = sysaufs_si_attrs; ++ while (*cattr) { ++ if (!strcmp(name, (*cattr)->name)) { ++ err = container_of(*cattr, struct sysaufs_si_attr, attr) ++ ->show(seq, sb); ++ goto out_seq; ++ } ++ cattr++; ++ } ++ ++ bend = au_sbend(sb); ++ if (!strncmp(name, SysaufsBr_PREFIX, sizeof(SysaufsBr_PREFIX) - 1)) { ++ name += sizeof(SysaufsBr_PREFIX) - 1; ++ err = strict_strtol(name, 10, &l); ++ if (!err) { ++ if (l <= bend) ++ err = sysaufs_si_br(seq, sb, (aufs_bindex_t)l); ++ else ++ err = -ENOENT; ++ } ++ goto out_seq; ++ } ++ BUG(); ++ ++ out_seq: ++ if (!err) { ++ err = seq->count; ++ /* sysfs limit */ ++ if (unlikely(err == PAGE_SIZE)) ++ err = -EFBIG; ++ } ++ kfree(seq); ++ out: ++ si_read_unlock(sb); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void sysaufs_br_init(struct au_branch *br) ++{ ++ br->br_attr.name = br->br_name; ++ br->br_attr.mode = S_IRUGO; ++ br->br_attr.owner = THIS_MODULE; ++} ++ ++void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ struct au_branch *br; ++ struct kobject *kobj; ++ aufs_bindex_t bend; ++ ++ dbgaufs_brs_del(sb, bindex); ++ ++ if (!sysaufs_brs) ++ return; ++ ++ kobj = &au_sbi(sb)->si_kobj; ++ bend = au_sbend(sb); ++ for (; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ sysfs_remove_file(kobj, &br->br_attr); ++ } ++} ++ ++void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ int err; ++ aufs_bindex_t bend; ++ struct kobject *kobj; ++ struct au_branch *br; ++ ++ dbgaufs_brs_add(sb, bindex); ++ ++ if (!sysaufs_brs) ++ return; ++ ++ kobj = &au_sbi(sb)->si_kobj; ++ bend = au_sbend(sb); ++ for (; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ snprintf(br->br_name, sizeof(br->br_name), SysaufsBr_PREFIX ++ "%d", bindex); ++ err = sysfs_create_file(kobj, &br->br_attr); ++ if (unlikely(err)) ++ AuWarn("failed %s under sysfs(%d)\n", br->br_name, err); ++ } ++} +diff -Naur a/fs/aufs/sysrq.c b/fs/aufs/sysrq.c +--- a/fs/aufs/sysrq.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/sysrq.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,115 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * magic sysrq hanlder ++ */ ++ ++#include <linux/fs.h> ++#include <linux/module.h> ++#include <linux/moduleparam.h> ++/* #include <linux/sysrq.h> */ ++#include "aufs.h" ++ ++/* ---------------------------------------------------------------------- */ ++ ++static void sysrq_sb(struct super_block *sb) ++{ ++ char *plevel; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ plevel = au_plevel; ++ au_plevel = KERN_WARNING; ++ au_debug(1); ++ ++ sbinfo = au_sbi(sb); ++ pr_warning("si=%lx\n", sysaufs_si_id(sbinfo)); ++ pr_warning(AUFS_NAME ": superblock\n"); ++ au_dpri_sb(sb); ++ pr_warning(AUFS_NAME ": root dentry\n"); ++ au_dpri_dentry(sb->s_root); ++ pr_warning(AUFS_NAME ": root inode\n"); ++ au_dpri_inode(sb->s_root->d_inode); ++#if 0 ++ struct inode *i; ++ pr_warning(AUFS_NAME ": isolated inode\n"); ++ list_for_each_entry(i, &sb->s_inodes, i_sb_list) ++ if (list_empty(&i->i_dentry)) ++ au_dpri_inode(i); ++#endif ++ pr_warning(AUFS_NAME ": files\n"); ++ list_for_each_entry(file, &sb->s_files, f_u.fu_list) ++ if (!special_file(file->f_dentry->d_inode->i_mode)) ++ au_dpri_file(file); ++ ++ au_plevel = plevel; ++ au_debug(0); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* module parameter */ ++static char *aufs_sysrq_key = "a"; ++module_param_named(sysrq, aufs_sysrq_key, charp, S_IRUGO); ++MODULE_PARM_DESC(sysrq, "MagicSysRq key for " AUFS_NAME); ++ ++static void au_sysrq(int key __maybe_unused, ++ struct tty_struct *tty __maybe_unused) ++{ ++ struct kobject *kobj; ++ struct au_sbinfo *sbinfo; ++ ++ /* spin_lock(&sysaufs_ket->list_lock); */ ++ list_for_each_entry(kobj, &sysaufs_ket->list, entry) { ++ sbinfo = container_of(kobj, struct au_sbinfo, si_kobj); ++ sysrq_sb(sbinfo->si_sb); ++ } ++ /* spin_unlock(&sysaufs_ket->list_lock); */ ++} ++ ++static struct sysrq_key_op au_sysrq_op = { ++ .handler = au_sysrq, ++ .help_msg = "Aufs", ++ .action_msg = "Aufs", ++ .enable_mask = SYSRQ_ENABLE_DUMP ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++int __init au_sysrq_init(void) ++{ ++ int err; ++ char key; ++ ++ err = -1; ++ key = *aufs_sysrq_key; ++ if ('a' <= key && key <= 'z') ++ err = register_sysrq_key(key, &au_sysrq_op); ++ if (unlikely(err)) ++ AuErr("err %d, sysrq=%c\n", err, key); ++ return err; ++} ++ ++void au_sysrq_fin(void) ++{ ++ int err; ++ err = unregister_sysrq_key(*aufs_sysrq_key, &au_sysrq_op); ++ if (unlikely(err)) ++ AuErr("err %d (ignored)\n", err); ++} +diff -Naur a/fs/aufs/vdir.c b/fs/aufs/vdir.c +--- a/fs/aufs/vdir.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/vdir.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,876 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * virtual or vertical directory ++ */ ++ ++#include <linux/hash.h> ++#include "aufs.h" ++ ++static unsigned int calc_size(int nlen) ++{ ++ BUILD_BUG_ON(sizeof(ino_t) != sizeof(long)); ++ return ALIGN(sizeof(struct au_vdir_de) + nlen, sizeof(ino_t)); ++} ++ ++static int set_deblk_end(union au_vdir_deblk_p *p, ++ union au_vdir_deblk_p *deblk_end) ++{ ++ if (calc_size(0) <= deblk_end->deblk - p->deblk) { ++ p->de->de_str.len = 0; ++ /* smp_mb(); */ ++ return 0; ++ } ++ return -1; /* error */ ++} ++ ++/* returns true or false */ ++static int is_deblk_end(union au_vdir_deblk_p *p, ++ union au_vdir_deblk_p *deblk_end) ++{ ++ if (calc_size(0) <= deblk_end->deblk - p->deblk) ++ return !p->de->de_str.len; ++ return 1; ++} ++ ++static unsigned char *last_deblk(struct au_vdir *vdir) ++{ ++ return vdir->vd_deblk[vdir->vd_nblk - 1]; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * the allocated memory has to be freed by ++ * au_nhash_wh_free() or au_nhash_de_free(). ++ */ ++int au_nhash_alloc(struct au_nhash *nhash, unsigned int num_hash, gfp_t gfp) ++{ ++ struct hlist_head *head; ++ unsigned int u; ++ ++ head = kmalloc(sizeof(*nhash->nh_head) * num_hash, gfp); ++ if (head) { ++ nhash->nh_num = num_hash; ++ nhash->nh_head = head; ++ for (u = 0; u < num_hash; u++) ++ INIT_HLIST_HEAD(head++); ++ return 0; /* success */ ++ } ++ ++ return -ENOMEM; ++} ++ ++static void nhash_count(struct hlist_head *head) ++{ ++#if 0 ++ unsigned long n; ++ struct hlist_node *pos; ++ ++ n = 0; ++ hlist_for_each(pos, head) ++ n++; ++ AuInfo("%lu\n", n); ++#endif ++} ++ ++static void au_nhash_wh_do_free(struct hlist_head *head) ++{ ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos, *node; ++ ++ hlist_for_each_entry_safe(tpos, pos, node, head, wh_hash) { ++ /* hlist_del(pos); */ ++ kfree(tpos); ++ } ++} ++ ++static void au_nhash_de_do_free(struct hlist_head *head) ++{ ++ struct au_vdir_dehstr *tpos; ++ struct hlist_node *pos, *node; ++ ++ hlist_for_each_entry_safe(tpos, pos, node, head, hash) { ++ /* hlist_del(pos); */ ++ au_cache_free_dehstr(tpos); ++ } ++} ++ ++static void au_nhash_do_free(struct au_nhash *nhash, ++ void (*free)(struct hlist_head *head)) ++{ ++ unsigned int u, n; ++ struct hlist_head *head; ++ ++ n = nhash->nh_num; ++ head = nhash->nh_head; ++ for (u = 0; u < n; u++) { ++ nhash_count(head); ++ free(head++); ++ } ++ kfree(nhash->nh_head); ++} ++ ++void au_nhash_wh_free(struct au_nhash *whlist) ++{ ++ au_nhash_do_free(whlist, au_nhash_wh_do_free); ++} ++ ++static void au_nhash_de_free(struct au_nhash *delist) ++{ ++ au_nhash_do_free(delist, au_nhash_de_do_free); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_nhash_test_longer_wh(struct au_nhash *whlist, aufs_bindex_t btgt, ++ int limit) ++{ ++ int num; ++ unsigned int u, n; ++ struct hlist_head *head; ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos; ++ ++ num = 0; ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (u = 0; u < n; u++) { ++ hlist_for_each_entry(tpos, pos, head, wh_hash) ++ if (tpos->wh_bindex == btgt && ++num > limit) ++ return 1; ++ head++; ++ } ++ return 0; ++} ++ ++static struct hlist_head *au_name_hash(struct au_nhash *nhash, ++ unsigned char *name, ++ unsigned int len) ++{ ++ unsigned int v; ++ /* const unsigned int magic_bit = 12; */ ++ ++ v = 0; ++ while (len--) ++ v += *name++; ++ /* v = hash_long(v, magic_bit); */ ++ v %= nhash->nh_num; ++ return nhash->nh_head + v; ++} ++ ++static int au_nhash_test_name(struct au_vdir_destr *str, const char *name, ++ int nlen) ++{ ++ return str->len == nlen && !memcmp(str->name, name, nlen); ++} ++ ++/* returns found or not */ ++int au_nhash_test_known_wh(struct au_nhash *whlist, char *name, int nlen) ++{ ++ struct hlist_head *head; ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos; ++ struct au_vdir_destr *str; ++ ++ head = au_name_hash(whlist, name, nlen); ++ hlist_for_each_entry(tpos, pos, head, wh_hash) { ++ str = &tpos->wh_str; ++ AuDbg("%.*s\n", str->len, str->name); ++ if (au_nhash_test_name(str, name, nlen)) ++ return 1; ++ } ++ return 0; ++} ++ ++/* returns found(true) or not */ ++static int test_known(struct au_nhash *delist, char *name, int nlen) ++{ ++ struct hlist_head *head; ++ struct au_vdir_dehstr *tpos; ++ struct hlist_node *pos; ++ struct au_vdir_destr *str; ++ ++ head = au_name_hash(delist, name, nlen); ++ hlist_for_each_entry(tpos, pos, head, hash) { ++ str = tpos->str; ++ AuDbg("%.*s\n", str->len, str->name); ++ if (au_nhash_test_name(str, name, nlen)) ++ return 1; ++ } ++ return 0; ++} ++ ++static void au_shwh_init_wh(struct au_vdir_wh *wh, ino_t ino, ++ unsigned char d_type) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ wh->wh_ino = ino; ++ wh->wh_type = d_type; ++#endif ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_nhash_append_wh(struct au_nhash *whlist, char *name, int nlen, ino_t ino, ++ unsigned int d_type, aufs_bindex_t bindex, ++ unsigned char shwh) ++{ ++ int err; ++ struct au_vdir_destr *str; ++ struct au_vdir_wh *wh; ++ ++ AuDbg("%.*s\n", nlen, name); ++ err = -ENOMEM; ++ wh = kmalloc(sizeof(*wh) + nlen, GFP_NOFS); ++ if (unlikely(!wh)) ++ goto out; ++ ++ err = 0; ++ wh->wh_bindex = bindex; ++ if (shwh) ++ au_shwh_init_wh(wh, ino, d_type); ++ str = &wh->wh_str; ++ str->len = nlen; ++ memcpy(str->name, name, nlen); ++ hlist_add_head(&wh->wh_hash, au_name_hash(whlist, name, nlen)); ++ /* smp_mb(); */ ++ ++ out: ++ return err; ++} ++ ++static int append_deblk(struct au_vdir *vdir) ++{ ++ int err; ++ unsigned long ul; ++ const unsigned int deblk_sz = vdir->vd_deblk_sz; ++ union au_vdir_deblk_p p, deblk_end; ++ unsigned char **o; ++ ++ err = -ENOMEM; ++ o = krealloc(vdir->vd_deblk, sizeof(*o) * (vdir->vd_nblk + 1), ++ GFP_NOFS); ++ if (unlikely(!o)) ++ goto out; ++ ++ vdir->vd_deblk = o; ++ p.deblk = kmalloc(deblk_sz, GFP_NOFS); ++ if (p.deblk) { ++ ul = vdir->vd_nblk++; ++ vdir->vd_deblk[ul] = p.deblk; ++ vdir->vd_last.ul = ul; ++ vdir->vd_last.p.deblk = p.deblk; ++ deblk_end.deblk = p.deblk + deblk_sz; ++ err = set_deblk_end(&p, &deblk_end); ++ } ++ ++ out: ++ return err; ++} ++ ++static int append_de(struct au_vdir *vdir, char *name, int nlen, ino_t ino, ++ unsigned int d_type, struct au_nhash *delist) ++{ ++ int err; ++ unsigned int sz; ++ const unsigned int deblk_sz = vdir->vd_deblk_sz; ++ union au_vdir_deblk_p p, *room, deblk_end; ++ struct au_vdir_dehstr *dehstr; ++ ++ p.deblk = last_deblk(vdir); ++ deblk_end.deblk = p.deblk + deblk_sz; ++ room = &vdir->vd_last.p; ++ AuDebugOn(room->deblk < p.deblk || deblk_end.deblk <= room->deblk ++ || !is_deblk_end(room, &deblk_end)); ++ ++ sz = calc_size(nlen); ++ if (unlikely(sz > deblk_end.deblk - room->deblk)) { ++ err = append_deblk(vdir); ++ if (unlikely(err)) ++ goto out; ++ ++ p.deblk = last_deblk(vdir); ++ deblk_end.deblk = p.deblk + deblk_sz; ++ /* smp_mb(); */ ++ AuDebugOn(room->deblk != p.deblk); ++ } ++ ++ err = -ENOMEM; ++ dehstr = au_cache_alloc_dehstr(); ++ if (unlikely(!dehstr)) ++ goto out; ++ ++ dehstr->str = &room->de->de_str; ++ hlist_add_head(&dehstr->hash, au_name_hash(delist, name, nlen)); ++ room->de->de_ino = ino; ++ room->de->de_type = d_type; ++ room->de->de_str.len = nlen; ++ memcpy(room->de->de_str.name, name, nlen); ++ ++ err = 0; ++ room->deblk += sz; ++ if (unlikely(set_deblk_end(room, &deblk_end))) ++ err = append_deblk(vdir); ++ /* smp_mb(); */ ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_vdir_free(struct au_vdir *vdir) ++{ ++ unsigned char **deblk; ++ ++ deblk = vdir->vd_deblk; ++ while (vdir->vd_nblk--) ++ kfree(*deblk++); ++ kfree(vdir->vd_deblk); ++ au_cache_free_vdir(vdir); ++} ++ ++static struct au_vdir *alloc_vdir(struct super_block *sb) ++{ ++ struct au_vdir *vdir; ++ int err; ++ ++ err = -ENOMEM; ++ vdir = au_cache_alloc_vdir(); ++ if (unlikely(!vdir)) ++ goto out; ++ ++ vdir->vd_deblk = kzalloc(sizeof(*vdir->vd_deblk), GFP_NOFS); ++ if (unlikely(!vdir->vd_deblk)) ++ goto out_free; ++ ++ vdir->vd_deblk_sz = au_sbi(sb)->si_rdblk; ++ vdir->vd_nblk = 0; ++ vdir->vd_version = 0; ++ vdir->vd_jiffy = 0; ++ err = append_deblk(vdir); ++ if (!err) ++ return vdir; /* success */ ++ ++ kfree(vdir->vd_deblk); ++ ++ out_free: ++ au_cache_free_vdir(vdir); ++ out: ++ vdir = ERR_PTR(err); ++ return vdir; ++} ++ ++static int reinit_vdir(struct au_vdir *vdir) ++{ ++ int err; ++ union au_vdir_deblk_p p, deblk_end; ++ ++ while (vdir->vd_nblk > 1) { ++ kfree(vdir->vd_deblk[vdir->vd_nblk - 1]); ++ /* vdir->vd_deblk[vdir->vd_nblk - 1] = NULL; */ ++ vdir->vd_nblk--; ++ } ++ p.deblk = vdir->vd_deblk[0]; ++ deblk_end.deblk = p.deblk + vdir->vd_deblk_sz; ++ err = set_deblk_end(&p, &deblk_end); ++ /* keep vd_dblk_sz */ ++ vdir->vd_last.ul = 0; ++ vdir->vd_last.p.deblk = vdir->vd_deblk[0]; ++ vdir->vd_version = 0; ++ vdir->vd_jiffy = 0; ++ /* smp_mb(); */ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_ino(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ unsigned int d_type, ino_t *ino) ++{ ++ int err; ++ struct mutex *mtx; ++ const int isdir = (d_type == DT_DIR); ++ ++ /* prevent hardlinks from race condition */ ++ mtx = NULL; ++ if (!isdir) { ++ mtx = &au_sbr(sb, bindex)->br_xino.xi_nondir_mtx; ++ mutex_lock(mtx); ++ } ++ err = au_xino_read(sb, bindex, h_ino, ino); ++ if (unlikely(err)) ++ goto out; ++ ++ if (!*ino) { ++ err = -EIO; ++ *ino = au_xino_new_ino(sb); ++ if (unlikely(!*ino)) ++ goto out; ++ err = au_xino_write(sb, bindex, h_ino, *ino); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ out: ++ if (!isdir) ++ mutex_unlock(mtx); ++ return err; ++} ++ ++static int au_wh_ino(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ unsigned int d_type, ino_t *ino) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ return au_ino(sb, bindex, h_ino, d_type, ino); ++#else ++ return 0; ++#endif ++} ++ ++#define AuFillVdir_CALLED 1 ++#define AuFillVdir_WHABLE (1 << 1) ++#define AuFillVdir_SHWH (1 << 2) ++#define au_ftest_fillvdir(flags, name) ((flags) & AuFillVdir_##name) ++#define au_fset_fillvdir(flags, name) { (flags) |= AuFillVdir_##name; } ++#define au_fclr_fillvdir(flags, name) { (flags) &= ~AuFillVdir_##name; } ++ ++#ifndef CONFIG_AUFS_SHWH ++#undef AuFillVdir_SHWH ++#define AuFillVdir_SHWH 0 ++#endif ++ ++struct fillvdir_arg { ++ struct file *file; ++ struct au_vdir *vdir; ++ struct au_nhash delist; ++ struct au_nhash whlist; ++ aufs_bindex_t bindex; ++ unsigned int flags; ++ int err; ++}; ++ ++static int fillvdir(void *__arg, const char *__name, int nlen, ++ loff_t offset __maybe_unused, u64 h_ino, ++ unsigned int d_type) ++{ ++ struct fillvdir_arg *arg = __arg; ++ char *name = (void *)__name; ++ struct super_block *sb; ++ ino_t ino; ++ const unsigned char shwh = !!au_ftest_fillvdir(arg->flags, SHWH); ++ ++ arg->err = 0; ++ sb = arg->file->f_dentry->d_sb; ++ au_fset_fillvdir(arg->flags, CALLED); ++ /* smp_mb(); */ ++ if (nlen <= AUFS_WH_PFX_LEN ++ || memcmp(name, AUFS_WH_PFX, AUFS_WH_PFX_LEN)) { ++ if (test_known(&arg->delist, name, nlen) ++ || au_nhash_test_known_wh(&arg->whlist, name, nlen)) ++ goto out; /* already exists or whiteouted */ ++ ++ sb = arg->file->f_dentry->d_sb; ++ arg->err = au_ino(sb, arg->bindex, h_ino, d_type, &ino); ++ if (!arg->err) ++ arg->err = append_de(arg->vdir, name, nlen, ino, ++ d_type, &arg->delist); ++ } else if (au_ftest_fillvdir(arg->flags, WHABLE)) { ++ name += AUFS_WH_PFX_LEN; ++ nlen -= AUFS_WH_PFX_LEN; ++ if (au_nhash_test_known_wh(&arg->whlist, name, nlen)) ++ goto out; /* already whiteouted */ ++ ++ if (shwh) ++ arg->err = au_wh_ino(sb, arg->bindex, h_ino, d_type, ++ &ino); ++ if (!arg->err) ++ arg->err = au_nhash_append_wh ++ (&arg->whlist, name, nlen, ino, d_type, ++ arg->bindex, shwh); ++ } ++ ++ out: ++ if (!arg->err) ++ arg->vdir->vd_jiffy = jiffies; ++ /* smp_mb(); */ ++ AuTraceErr(arg->err); ++ return arg->err; ++} ++ ++static int au_handle_shwh(struct super_block *sb, struct au_vdir *vdir, ++ struct au_nhash *whlist, struct au_nhash *delist) ++{ ++#ifdef CONFIG_AUFS_SHWH ++ int err; ++ unsigned int nh, u; ++ struct hlist_head *head; ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos, *n; ++ char *p, *o; ++ struct au_vdir_destr *destr; ++ ++ AuDebugOn(!au_opt_test(au_mntflags(sb), SHWH)); ++ ++ err = -ENOMEM; ++ o = p = __getname(); ++ if (unlikely(!p)) ++ goto out; ++ ++ err = 0; ++ nh = whlist->nh_num; ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ p += AUFS_WH_PFX_LEN; ++ for (u = 0; u < nh; u++) { ++ head = whlist->nh_head + u; ++ hlist_for_each_entry_safe(tpos, pos, n, head, wh_hash) { ++ destr = &tpos->wh_str; ++ memcpy(p, destr->name, destr->len); ++ err = append_de(vdir, o, destr->len + AUFS_WH_PFX_LEN, ++ tpos->wh_ino, tpos->wh_type, delist); ++ if (unlikely(err)) ++ break; ++ } ++ } ++ ++ __putname(o); ++ ++ out: ++ AuTraceErr(err); ++ return err; ++#else ++ return 0; ++#endif ++} ++ ++static int au_do_read_vdir(struct fillvdir_arg *arg) ++{ ++ int err; ++ unsigned int rdhash; ++ loff_t offset; ++ aufs_bindex_t bend, bindex, bstart; ++ unsigned char shwh; ++ struct file *hf, *file; ++ struct super_block *sb; ++ ++ file = arg->file; ++ sb = file->f_dentry->d_sb; ++ rdhash = au_sbi(sb)->si_rdhash; ++ err = au_nhash_alloc(&arg->delist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out; ++ err = au_nhash_alloc(&arg->whlist, rdhash, GFP_NOFS); ++ if (unlikely(err)) ++ goto out_delist; ++ ++ err = 0; ++ arg->flags = 0; ++ shwh = 0; ++ if (au_opt_test(au_mntflags(sb), SHWH)) { ++ shwh = 1; ++ au_fset_fillvdir(arg->flags, SHWH); ++ } ++ bstart = au_fbstart(file); ++ bend = au_fbend(file); ++ for (bindex = bstart; !err && bindex <= bend; bindex++) { ++ hf = au_h_fptr(file, bindex); ++ if (!hf) ++ continue; ++ ++ offset = vfsub_llseek(hf, 0, SEEK_SET); ++ err = offset; ++ if (unlikely(offset)) ++ break; ++ ++ arg->bindex = bindex; ++ au_fclr_fillvdir(arg->flags, WHABLE); ++ if (shwh ++ || (bindex != bend ++ && au_br_whable(au_sbr_perm(sb, bindex)))) ++ au_fset_fillvdir(arg->flags, WHABLE); ++ do { ++ arg->err = 0; ++ au_fclr_fillvdir(arg->flags, CALLED); ++ /* smp_mb(); */ ++ err = vfsub_readdir(hf, fillvdir, arg); ++ if (err >= 0) ++ err = arg->err; ++ } while (!err && au_ftest_fillvdir(arg->flags, CALLED)); ++ } ++ ++ if (!err && shwh) ++ err = au_handle_shwh(sb, arg->vdir, &arg->whlist, &arg->delist); ++ ++ au_nhash_wh_free(&arg->whlist); ++ ++ out_delist: ++ au_nhash_de_free(&arg->delist); ++ out: ++ return err; ++} ++ ++static int read_vdir(struct file *file, int may_read) ++{ ++ int err; ++ unsigned long expire; ++ unsigned char do_read; ++ struct fillvdir_arg arg; ++ struct inode *inode; ++ struct au_vdir *vdir, *allocated; ++ ++ err = 0; ++ inode = file->f_dentry->d_inode; ++ IMustLock(inode); ++ allocated = NULL; ++ do_read = 0; ++ expire = au_sbi(inode->i_sb)->si_rdcache; ++ vdir = au_ivdir(inode); ++ if (!vdir) { ++ do_read = 1; ++ vdir = alloc_vdir(inode->i_sb); ++ err = PTR_ERR(vdir); ++ if (IS_ERR(vdir)) ++ goto out; ++ err = 0; ++ allocated = vdir; ++ } else if (may_read ++ && (inode->i_version != vdir->vd_version ++ || time_after(jiffies, vdir->vd_jiffy + expire))) { ++ do_read = 1; ++ err = reinit_vdir(vdir); ++ if (unlikely(err)) ++ goto out; ++ } ++ ++ if (!do_read) ++ return 0; /* success */ ++ ++ arg.file = file; ++ arg.vdir = vdir; ++ err = au_do_read_vdir(&arg); ++ if (!err) { ++ /* file->f_pos = 0; */ ++ vdir->vd_version = inode->i_version; ++ vdir->vd_last.ul = 0; ++ vdir->vd_last.p.deblk = vdir->vd_deblk[0]; ++ if (allocated) ++ au_set_ivdir(inode, allocated); ++ } else if (allocated) ++ au_vdir_free(allocated); ++ ++ out: ++ return err; ++} ++ ++static int copy_vdir(struct au_vdir *tgt, struct au_vdir *src) ++{ ++ int err, rerr; ++ unsigned long ul, n; ++ const unsigned int deblk_sz = src->vd_deblk_sz; ++ ++ AuDebugOn(tgt->vd_nblk != 1); ++ ++ err = -ENOMEM; ++ if (tgt->vd_nblk < src->vd_nblk) { ++ unsigned char **p; ++ ++ p = krealloc(tgt->vd_deblk, sizeof(*p) * src->vd_nblk, ++ GFP_NOFS); ++ if (unlikely(!p)) ++ goto out; ++ tgt->vd_deblk = p; ++ } ++ ++ tgt->vd_nblk = src->vd_nblk; ++ tgt->vd_deblk_sz = deblk_sz; ++ memcpy(tgt->vd_deblk[0], src->vd_deblk[0], deblk_sz); ++ /* tgt->vd_last.i = 0; */ ++ /* tgt->vd_last.p.deblk = tgt->vd_deblk[0]; */ ++ tgt->vd_version = src->vd_version; ++ tgt->vd_jiffy = src->vd_jiffy; ++ ++ n = src->vd_nblk; ++ for (ul = 1; ul < n; ul++) { ++ tgt->vd_deblk[ul] = kmemdup(src->vd_deblk[ul], deblk_sz, ++ GFP_NOFS); ++ if (unlikely(!tgt->vd_deblk[ul])) ++ goto out; ++ } ++ /* smp_mb(); */ ++ return 0; /* success */ ++ ++ out: ++ rerr = reinit_vdir(tgt); ++ BUG_ON(rerr); ++ return err; ++} ++ ++int au_vdir_init(struct file *file) ++{ ++ int err; ++ struct inode *inode; ++ struct au_vdir *vdir_cache, *allocated; ++ ++ err = read_vdir(file, !file->f_pos); ++ if (unlikely(err)) ++ goto out; ++ ++ allocated = NULL; ++ vdir_cache = au_fvdir_cache(file); ++ if (!vdir_cache) { ++ vdir_cache = alloc_vdir(file->f_dentry->d_sb); ++ err = PTR_ERR(vdir_cache); ++ if (IS_ERR(vdir_cache)) ++ goto out; ++ allocated = vdir_cache; ++ } else if (!file->f_pos && vdir_cache->vd_version != file->f_version) { ++ err = reinit_vdir(vdir_cache); ++ if (unlikely(err)) ++ goto out; ++ } else ++ return 0; /* success */ ++ ++ inode = file->f_dentry->d_inode; ++ err = copy_vdir(vdir_cache, au_ivdir(inode)); ++ if (!err) { ++ file->f_version = inode->i_version; ++ if (allocated) ++ au_set_fvdir_cache(file, allocated); ++ } else if (allocated) ++ au_vdir_free(allocated); ++ ++ out: ++ return err; ++} ++ ++static loff_t calc_offset(struct au_vdir *vdir) ++{ ++ loff_t offset; ++ union au_vdir_deblk_p p; ++ ++ p.deblk = vdir->vd_deblk[vdir->vd_last.ul]; ++ offset = vdir->vd_last.p.deblk - p.deblk; ++ offset += vdir->vd_deblk_sz * vdir->vd_last.ul; ++ return offset; ++} ++ ++/* returns true or false */ ++static int seek_vdir(struct file *file) ++{ ++ int valid; ++ unsigned int deblk_sz; ++ unsigned long ul, n; ++ loff_t offset; ++ union au_vdir_deblk_p p, deblk_end; ++ struct au_vdir *vdir_cache; ++ ++ valid = 1; ++ vdir_cache = au_fvdir_cache(file); ++ offset = calc_offset(vdir_cache); ++ AuDbg("offset %lld\n", offset); ++ if (file->f_pos == offset) ++ goto out; ++ ++ vdir_cache->vd_last.ul = 0; ++ vdir_cache->vd_last.p.deblk = vdir_cache->vd_deblk[0]; ++ if (!file->f_pos) ++ goto out; ++ ++ valid = 0; ++ deblk_sz = vdir_cache->vd_deblk_sz; ++ ul = div64_u64(file->f_pos, deblk_sz); ++ AuDbg("ul %lu\n", ul); ++ if (ul >= vdir_cache->vd_nblk) ++ goto out; ++ ++ n = vdir_cache->vd_nblk; ++ for (; ul < n; ul++) { ++ p.deblk = vdir_cache->vd_deblk[ul]; ++ deblk_end.deblk = p.deblk + deblk_sz; ++ offset = ul; ++ offset *= deblk_sz; ++ while (!is_deblk_end(&p, &deblk_end) && offset < file->f_pos) { ++ unsigned int l; ++ ++ l = calc_size(p.de->de_str.len); ++ offset += l; ++ p.deblk += l; ++ } ++ if (!is_deblk_end(&p, &deblk_end)) { ++ valid = 1; ++ vdir_cache->vd_last.ul = ul; ++ vdir_cache->vd_last.p = p; ++ break; ++ } ++ } ++ ++ out: ++ /* smp_mb(); */ ++ AuTraceErr(!valid); ++ return valid; ++} ++ ++int au_vdir_fill_de(struct file *file, void *dirent, filldir_t filldir) ++{ ++ int err; ++ unsigned int l, deblk_sz; ++ union au_vdir_deblk_p deblk_end; ++ struct au_vdir *vdir_cache; ++ struct au_vdir_de *de; ++ ++ vdir_cache = au_fvdir_cache(file); ++ if (!seek_vdir(file)) ++ return 0; ++ ++ deblk_sz = vdir_cache->vd_deblk_sz; ++ while (1) { ++ deblk_end.deblk = vdir_cache->vd_deblk[vdir_cache->vd_last.ul]; ++ deblk_end.deblk += deblk_sz; ++ while (!is_deblk_end(&vdir_cache->vd_last.p, &deblk_end)) { ++ de = vdir_cache->vd_last.p.de; ++ AuDbg("%.*s, off%lld, i%lu, dt%d\n", ++ de->de_str.len, de->de_str.name, file->f_pos, ++ (unsigned long)de->de_ino, de->de_type); ++ err = filldir(dirent, de->de_str.name, de->de_str.len, ++ file->f_pos, de->de_ino, de->de_type); ++ if (unlikely(err)) { ++ AuTraceErr(err); ++ /* todo: ignore the error caused by udba? */ ++ /* return err; */ ++ return 0; ++ } ++ ++ l = calc_size(de->de_str.len); ++ vdir_cache->vd_last.p.deblk += l; ++ file->f_pos += l; ++ } ++ if (vdir_cache->vd_last.ul < vdir_cache->vd_nblk - 1) { ++ vdir_cache->vd_last.ul++; ++ vdir_cache->vd_last.p.deblk ++ = vdir_cache->vd_deblk[vdir_cache->vd_last.ul]; ++ file->f_pos = deblk_sz * vdir_cache->vd_last.ul; ++ continue; ++ } ++ break; ++ } ++ ++ /* smp_mb(); */ ++ return 0; ++} +diff -Naur a/fs/aufs/vfsub.c b/fs/aufs/vfsub.c +--- a/fs/aufs/vfsub.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/vfsub.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,736 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sub-routines for VFS ++ */ ++ ++#include <linux/namei.h> ++#include <linux/security.h> ++#include <linux/splice.h> ++#include <linux/uaccess.h> ++#include "aufs.h" ++ ++int vfsub_update_h_iattr(struct path *h_path, int *did) ++{ ++ int err; ++ struct kstat st; ++ struct super_block *h_sb; ++ ++ /* for remote fs, leave work for its getattr or d_revalidate */ ++ /* for bad i_attr fs, handle them in aufs_getattr() */ ++ /* still some fs may acquire i_mutex. we need to skip them */ ++ err = 0; ++ if (!did) ++ did = &err; ++ h_sb = h_path->dentry->d_sb; ++ *did = (!au_test_fs_remote(h_sb) && au_test_fs_refresh_iattr(h_sb)); ++ if (*did) ++ err = vfs_getattr(h_path->mnt, h_path->dentry, &st); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct file *vfsub_filp_open(const char *path, int oflags, int mode) ++{ ++ struct file *file; ++ ++ lockdep_off(); ++ file = filp_open(path, oflags, mode); ++ lockdep_on(); ++ if (IS_ERR(file)) ++ goto out; ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ ++ out: ++ return file; ++} ++ ++int vfsub_kern_path(const char *name, unsigned int flags, struct path *path) ++{ ++ int err; ++ ++ /* lockdep_off(); */ ++ err = kern_path(name, flags, path); ++ /* lockdep_on(); */ ++ if (!err && path->dentry->d_inode) ++ vfsub_update_h_iattr(path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent, ++ int len) ++{ ++ struct path path = { ++ .mnt = NULL ++ }; ++ ++ IMustLock(parent->d_inode); ++ ++ path.dentry = lookup_one_len(name, parent, len); ++ if (IS_ERR(path.dentry)) ++ goto out; ++ if (path.dentry->d_inode) ++ vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/ ++ ++ out: ++ return path.dentry; ++} ++ ++struct dentry *vfsub_lookup_hash(struct nameidata *nd) ++{ ++ struct path path = { ++ .mnt = nd->path.mnt ++ }; ++ ++ IMustLock(nd->path.dentry->d_inode); ++ ++ path.dentry = lookup_hash(nd); ++ if (!IS_ERR(path.dentry) && path.dentry->d_inode) ++ vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/ ++ ++ return path.dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2) ++{ ++ struct dentry *d; ++ ++ lockdep_off(); ++ d = lock_rename(d1, d2); ++ lockdep_on(); ++ au_hin_suspend(hdir1); ++ if (hdir1 != hdir2) ++ au_hin_suspend(hdir2); ++ ++ return d; ++} ++ ++void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2) ++{ ++ au_hin_resume(hdir1); ++ if (hdir1 != hdir2) ++ au_hin_resume(hdir2); ++ lockdep_off(); ++ unlock_rename(d1, d2); ++ lockdep_on(); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_create(struct inode *dir, struct path *path, int mode) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mknod(path, path->dentry, mode, 0); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ if (au_test_fs_null_nd(dir->i_sb)) ++ err = vfs_create(dir, path->dentry, mode, NULL); ++ else { ++ struct nameidata h_nd; ++ ++ memset(&h_nd, 0, sizeof(h_nd)); ++ h_nd.flags = LOOKUP_CREATE; ++ h_nd.intent.open.flags = O_CREAT ++ | vfsub_fmode_to_uint(FMODE_READ); ++ h_nd.intent.open.create_mode = mode; ++ h_nd.path.dentry = path->dentry->d_parent; ++ h_nd.path.mnt = path->mnt; ++ path_get(&h_nd.path); ++ err = vfs_create(dir, path->dentry, mode, &h_nd); ++ path_put(&h_nd.path); ++ } ++ ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++int vfsub_symlink(struct inode *dir, struct path *path, const char *symname) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_symlink(path, path->dentry, symname); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ err = vfs_symlink(dir, path->dentry, symname); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++int vfsub_mknod(struct inode *dir, struct path *path, int mode, dev_t dev) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mknod(path, path->dentry, mode, dev); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ err = vfs_mknod(dir, path->dentry, mode, dev); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++static int au_test_nlink(struct inode *inode) ++{ ++ const unsigned int link_max = UINT_MAX >> 1; /* rough margin */ ++ ++ if (!au_test_fs_no_limit_nlink(inode->i_sb) ++ || inode->i_nlink < link_max) ++ return 0; ++ return -EMLINK; ++} ++ ++int vfsub_link(struct dentry *src_dentry, struct inode *dir, struct path *path) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ err = au_test_nlink(src_dentry->d_inode); ++ if (unlikely(err)) ++ return err; ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_link(src_dentry, path, path->dentry); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_link(src_dentry, dir, path->dentry); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ /* fuse has different memory inode for the same inumber */ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ tmp.dentry = src_dentry; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry, ++ struct inode *dir, struct path *path) ++{ ++ int err; ++ struct path tmp = { ++ .mnt = path->mnt ++ }; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ IMustLock(src_dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ tmp.dentry = src_dentry->d_parent; ++ err = security_path_rename(&tmp, src_dentry, path, path->dentry); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_rename(src_dir, src_dentry, dir, path->dentry); ++ lockdep_on(); ++ if (!err) { ++ int did; ++ ++ tmp.dentry = d->d_parent; ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = src_dentry; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ tmp.dentry = src_dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++int vfsub_mkdir(struct inode *dir, struct path *path, int mode) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_mkdir(path, path->dentry, mode); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ err = vfs_mkdir(dir, path->dentry, mode); ++ if (!err) { ++ struct path tmp = *path; ++ int did; ++ ++ vfsub_update_h_iattr(&tmp, &did); ++ if (did) { ++ tmp.dentry = path->dentry->d_parent; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); ++ } ++ /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++int vfsub_rmdir(struct inode *dir, struct path *path) ++{ ++ int err; ++ struct dentry *d; ++ ++ IMustLock(dir); ++ ++ d = path->dentry; ++ path->dentry = d->d_parent; ++ err = security_path_rmdir(path, path->dentry); ++ path->dentry = d; ++ if (unlikely(err)) ++ goto out; ++ ++ lockdep_off(); ++ err = vfs_rmdir(dir, path->dentry); ++ lockdep_on(); ++ if (!err) { ++ struct path tmp = { ++ .dentry = path->dentry->d_parent, ++ .mnt = path->mnt ++ }; ++ ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); /*ignore*/ ++ } ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ ++ err = vfs_read(file, ubuf, count, ppos); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++/* todo: kernel_read()? */ ++ssize_t vfsub_read_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ err = vfsub_read_u(file, (char __user *)kbuf, count, ppos); ++ set_fs(oldfs); ++ return err; ++} ++ ++ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count, ++ loff_t *ppos) ++{ ++ ssize_t err; ++ ++ lockdep_off(); ++ err = vfs_write(file, ubuf, count, ppos); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, loff_t *ppos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ err = vfsub_write_u(file, (const char __user *)kbuf, count, ppos); ++ set_fs(oldfs); ++ return err; ++} ++ ++int vfsub_readdir(struct file *file, filldir_t filldir, void *arg) ++{ ++ int err; ++ ++ lockdep_off(); ++ err = vfs_readdir(file, filldir, arg); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++long vfsub_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags) ++{ ++ long err; ++ ++ lockdep_off(); ++ err = do_splice_to(in, ppos, pipe, len, flags); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&in->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags) ++{ ++ long err; ++ ++ lockdep_off(); ++ err = do_splice_from(pipe, out, ppos, len, flags); ++ lockdep_on(); ++ if (err >= 0) ++ vfsub_update_h_iattr(&out->f_path, /*did*/NULL); /*ignore*/ ++ return err; ++} ++ ++/* cf. open.c:do_sys_truncate() and do_sys_ftruncate() */ ++int vfsub_trunc(struct path *h_path, loff_t length, unsigned int attr, ++ struct file *h_file) ++{ ++ int err; ++ struct inode *h_inode; ++ ++ h_inode = h_path->dentry->d_inode; ++ if (!h_file) { ++ err = mnt_want_write(h_path->mnt); ++ if (err) ++ goto out; ++ err = inode_permission(h_inode, MAY_WRITE); ++ if (err) ++ goto out_mnt; ++ err = get_write_access(h_inode); ++ if (err) ++ goto out_mnt; ++ err = break_lease(h_inode, vfsub_fmode_to_uint(FMODE_WRITE)); ++ if (err) ++ goto out_inode; ++ } ++ ++ err = locks_verify_truncate(h_inode, h_file, length); ++ if (!err) ++ err = security_path_truncate(h_path, length, attr); ++ if (!err) { ++ lockdep_off(); ++ err = do_truncate(h_path->dentry, length, attr, h_file); ++ lockdep_on(); ++ } ++ ++ out_inode: ++ if (!h_file) ++ put_write_access(h_inode); ++ out_mnt: ++ if (!h_file) ++ mnt_drop_write(h_path->mnt); ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_vfsub_mkdir_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++ int mode; ++}; ++ ++static void au_call_vfsub_mkdir(void *args) ++{ ++ struct au_vfsub_mkdir_args *a = args; ++ *a->errp = vfsub_mkdir(a->dir, a->path, a->mode); ++} ++ ++int vfsub_sio_mkdir(struct inode *dir, struct path *path, int mode) ++{ ++ int err, do_sio, wkq_err; ++ ++ do_sio = au_test_h_perm_sio(dir, MAY_EXEC | MAY_WRITE); ++ if (!do_sio) ++ err = vfsub_mkdir(dir, path, mode); ++ else { ++ struct au_vfsub_mkdir_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path, ++ .mode = mode ++ }; ++ wkq_err = au_wkq_wait(au_call_vfsub_mkdir, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++ ++struct au_vfsub_rmdir_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++}; ++ ++static void au_call_vfsub_rmdir(void *args) ++{ ++ struct au_vfsub_rmdir_args *a = args; ++ *a->errp = vfsub_rmdir(a->dir, a->path); ++} ++ ++int vfsub_sio_rmdir(struct inode *dir, struct path *path) ++{ ++ int err, do_sio, wkq_err; ++ ++ do_sio = au_test_h_perm_sio(dir, MAY_EXEC | MAY_WRITE); ++ if (!do_sio) ++ err = vfsub_rmdir(dir, path); ++ else { ++ struct au_vfsub_rmdir_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path ++ }; ++ wkq_err = au_wkq_wait(au_call_vfsub_rmdir, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct notify_change_args { ++ int *errp; ++ struct path *path; ++ struct iattr *ia; ++}; ++ ++static void call_notify_change(void *args) ++{ ++ struct notify_change_args *a = args; ++ struct inode *h_inode; ++ ++ h_inode = a->path->dentry->d_inode; ++ IMustLock(h_inode); ++ ++ *a->errp = -EPERM; ++ if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) { ++ lockdep_off(); ++ *a->errp = notify_change(a->path->dentry, a->ia); ++ lockdep_on(); ++ if (!*a->errp) ++ vfsub_update_h_iattr(a->path, /*did*/NULL); /*ignore*/ ++ } ++ AuTraceErr(*a->errp); ++} ++ ++int vfsub_notify_change(struct path *path, struct iattr *ia) ++{ ++ int err; ++ struct notify_change_args args = { ++ .errp = &err, ++ .path = path, ++ .ia = ia ++ }; ++ ++ call_notify_change(&args); ++ ++ return err; ++} ++ ++int vfsub_sio_notify_change(struct path *path, struct iattr *ia) ++{ ++ int err, wkq_err; ++ struct notify_change_args args = { ++ .errp = &err, ++ .path = path, ++ .ia = ia ++ }; ++ ++ wkq_err = au_wkq_wait(call_notify_change, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct unlink_args { ++ int *errp; ++ struct inode *dir; ++ struct path *path; ++}; ++ ++static void call_unlink(void *args) ++{ ++ struct unlink_args *a = args; ++ struct dentry *d = a->path->dentry; ++ struct inode *h_inode; ++ const int stop_sillyrename = (au_test_nfs(d->d_sb) ++ && atomic_read(&d->d_count) == 1); ++ ++ IMustLock(a->dir); ++ ++ a->path->dentry = d->d_parent; ++ *a->errp = security_path_unlink(a->path, d); ++ a->path->dentry = d; ++ if (unlikely(*a->errp)) ++ return; ++ ++ if (!stop_sillyrename) ++ dget(d); ++ h_inode = d->d_inode; ++ if (h_inode) ++ atomic_inc(&h_inode->i_count); ++ ++ lockdep_off(); ++ *a->errp = vfs_unlink(a->dir, d); ++ lockdep_on(); ++ if (!*a->errp) { ++ struct path tmp = { ++ .dentry = d->d_parent, ++ .mnt = a->path->mnt ++ }; ++ vfsub_update_h_iattr(&tmp, /*did*/NULL); /*ignore*/ ++ } ++ ++ if (!stop_sillyrename) ++ dput(d); ++ if (h_inode) ++ iput(h_inode); ++ ++ AuTraceErr(*a->errp); ++} ++ ++/* ++ * @dir: must be locked. ++ * @dentry: target dentry. ++ */ ++int vfsub_unlink(struct inode *dir, struct path *path, int force) ++{ ++ int err; ++ struct unlink_args args = { ++ .errp = &err, ++ .dir = dir, ++ .path = path ++ }; ++ ++ if (!force) ++ call_unlink(&args); ++ else { ++ int wkq_err; ++ ++ wkq_err = au_wkq_wait(call_unlink, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ ++ return err; ++} +diff -Naur a/fs/aufs/vfsub.h b/fs/aufs/vfsub.h +--- a/fs/aufs/vfsub.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/vfsub.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,171 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * sub-routines for VFS ++ */ ++ ++#ifndef __AUFS_VFSUB_H__ ++#define __AUFS_VFSUB_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/fs.h> ++#include <linux/fs_stack.h> ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* lock subclass for lower inode */ ++/* default MAX_LOCKDEP_SUBCLASSES(8) is not enough */ ++/* reduce? gave up. */ ++enum { ++ AuLsc_I_Begin = I_MUTEX_QUOTA, /* 4 */ ++ AuLsc_I_PARENT, /* lower inode, parent first */ ++ AuLsc_I_PARENT2, /* copyup dirs */ ++ AuLsc_I_CHILD, ++ AuLsc_I_CHILD2, ++ AuLsc_I_End ++}; ++ ++/* to debug easier, do not make them inlined functions */ ++#define MtxMustLock(mtx) AuDebugOn(!mutex_is_locked(mtx)) ++#define IMustLock(i) MtxMustLock(&(i)->i_mutex) ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline void vfsub_copy_inode_size(struct inode *inode, ++ struct inode *h_inode) ++{ ++ spin_lock(&inode->i_lock); ++ fsstack_copy_inode_size(inode, h_inode); ++ spin_unlock(&inode->i_lock); ++} ++ ++int vfsub_update_h_iattr(struct path *h_path, int *did); ++struct file *vfsub_filp_open(const char *path, int oflags, int mode); ++int vfsub_kern_path(const char *name, unsigned int flags, struct path *path); ++struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent, ++ int len); ++struct dentry *vfsub_lookup_hash(struct nameidata *nd); ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_hinode; ++struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2); ++void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1, ++ struct dentry *d2, struct au_hinode *hdir2); ++ ++int vfsub_create(struct inode *dir, struct path *path, int mode); ++int vfsub_symlink(struct inode *dir, struct path *path, ++ const char *symname); ++int vfsub_mknod(struct inode *dir, struct path *path, int mode, dev_t dev); ++int vfsub_link(struct dentry *src_dentry, struct inode *dir, ++ struct path *path); ++int vfsub_rename(struct inode *src_hdir, struct dentry *src_dentry, ++ struct inode *hdir, struct path *path); ++int vfsub_mkdir(struct inode *dir, struct path *path, int mode); ++int vfsub_rmdir(struct inode *dir, struct path *path); ++ ++/* ---------------------------------------------------------------------- */ ++ ++ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_read_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count, ++ loff_t *ppos); ++ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, ++ loff_t *ppos); ++int vfsub_readdir(struct file *file, filldir_t filldir, void *arg); ++ ++static inline void vfsub_file_accessed(struct file *h_file) ++{ ++ file_accessed(h_file); ++ vfsub_update_h_iattr(&h_file->f_path, /*did*/NULL); /*ignore*/ ++} ++ ++static inline void vfsub_touch_atime(struct vfsmount *h_mnt, ++ struct dentry *h_dentry) ++{ ++ struct path h_path = { ++ .dentry = h_dentry, ++ .mnt = h_mnt ++ }; ++ touch_atime(h_mnt, h_dentry); ++ vfsub_update_h_iattr(&h_path, /*did*/NULL); /*ignore*/ ++} ++ ++long vfsub_splice_to(struct file *in, loff_t *ppos, ++ struct pipe_inode_info *pipe, size_t len, ++ unsigned int flags); ++long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out, ++ loff_t *ppos, size_t len, unsigned int flags); ++int vfsub_trunc(struct path *h_path, loff_t length, unsigned int attr, ++ struct file *h_file); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline loff_t vfsub_llseek(struct file *file, loff_t offset, int origin) ++{ ++ loff_t err; ++ ++ lockdep_off(); ++ err = vfs_llseek(file, offset, origin); ++ lockdep_on(); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* dirty workaround for strict type of fmode_t */ ++union vfsub_fmu { ++ fmode_t fm; ++ unsigned int ui; ++}; ++ ++static inline unsigned int vfsub_fmode_to_uint(fmode_t fm) ++{ ++ union vfsub_fmu u = { ++ .fm = fm ++ }; ++ ++ BUILD_BUG_ON(sizeof(u.fm) != sizeof(u.ui)); ++ ++ return u.ui; ++} ++ ++static inline fmode_t vfsub_uint_to_fmode(unsigned int ui) ++{ ++ union vfsub_fmu u = { ++ .ui = ui ++ }; ++ ++ return u.fm; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int vfsub_sio_mkdir(struct inode *dir, struct path *path, int mode); ++int vfsub_sio_rmdir(struct inode *dir, struct path *path); ++int vfsub_sio_notify_change(struct path *path, struct iattr *ia); ++int vfsub_notify_change(struct path *path, struct iattr *ia); ++int vfsub_unlink(struct inode *dir, struct path *path, int force); ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_VFSUB_H__ */ +diff -Naur a/fs/aufs/wbr_policy.c b/fs/aufs/wbr_policy.c +--- a/fs/aufs/wbr_policy.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/wbr_policy.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,637 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * policies for selecting one among multiple writable branches ++ */ ++ ++#include <linux/statfs.h> ++#include "aufs.h" ++ ++/* subset of cpup_attr() */ ++static noinline_for_stack ++int au_cpdown_attr(struct path *h_path, struct dentry *h_src) ++{ ++ int err, sbits; ++ struct iattr ia; ++ struct inode *h_isrc; ++ ++ h_isrc = h_src->d_inode; ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE | ATTR_UID | ATTR_GID; ++ ia.ia_mode = h_isrc->i_mode; ++ ia.ia_uid = h_isrc->i_uid; ++ ia.ia_gid = h_isrc->i_gid; ++ sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID)); ++ au_cpup_attr_flags(h_path->dentry->d_inode, h_isrc); ++ err = vfsub_sio_notify_change(h_path, &ia); ++ ++ /* is this nfs only? */ ++ if (!err && sbits && au_test_nfs(h_path->dentry->d_sb)) { ++ ia.ia_valid = ATTR_FORCE | ATTR_MODE; ++ ia.ia_mode = h_isrc->i_mode; ++ err = vfsub_sio_notify_change(h_path, &ia); ++ } ++ ++ return err; ++} ++ ++#define AuCpdown_PARENT_OPQ 1 ++#define AuCpdown_WHED (1 << 1) ++#define AuCpdown_MADE_DIR (1 << 2) ++#define AuCpdown_DIROPQ (1 << 3) ++#define au_ftest_cpdown(flags, name) ((flags) & AuCpdown_##name) ++#define au_fset_cpdown(flags, name) { (flags) |= AuCpdown_##name; } ++#define au_fclr_cpdown(flags, name) { (flags) &= ~AuCpdown_##name; } ++ ++struct au_cpdown_dir_args { ++ struct dentry *parent; ++ unsigned int flags; ++}; ++ ++static int au_cpdown_dir_opq(struct dentry *dentry, aufs_bindex_t bdst, ++ struct au_cpdown_dir_args *a) ++{ ++ int err; ++ struct dentry *opq_dentry; ++ ++ opq_dentry = au_diropq_create(dentry, bdst); ++ err = PTR_ERR(opq_dentry); ++ if (IS_ERR(opq_dentry)) ++ goto out; ++ dput(opq_dentry); ++ au_fset_cpdown(a->flags, DIROPQ); ++ ++ out: ++ return err; ++} ++ ++static int au_cpdown_dir_wh(struct dentry *dentry, struct dentry *h_parent, ++ struct inode *dir, aufs_bindex_t bdst) ++{ ++ int err; ++ struct path h_path; ++ struct au_branch *br; ++ ++ br = au_sbr(dentry->d_sb, bdst); ++ h_path.dentry = au_wh_lkup(h_parent, &dentry->d_name, br); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ err = 0; ++ if (h_path.dentry->d_inode) { ++ h_path.mnt = br->br_mnt; ++ err = au_wh_unlink_dentry(au_h_iptr(dir, bdst), &h_path, ++ dentry); ++ } ++ dput(h_path.dentry); ++ ++ out: ++ return err; ++} ++ ++static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst, ++ struct dentry *h_parent, void *arg) ++{ ++ int err, rerr; ++ aufs_bindex_t bend, bopq, bstart; ++ unsigned char parent_opq; ++ struct path h_path; ++ struct dentry *parent; ++ struct inode *h_dir, *h_inode, *inode, *dir; ++ struct au_cpdown_dir_args *args = arg; ++ ++ bstart = au_dbstart(dentry); ++ /* dentry is di-locked */ ++ parent = dget_parent(dentry); ++ dir = parent->d_inode; ++ h_dir = h_parent->d_inode; ++ AuDebugOn(h_dir != au_h_iptr(dir, bdst)); ++ IMustLock(h_dir); ++ ++ err = au_lkup_neg(dentry, bdst); ++ if (unlikely(err < 0)) ++ goto out; ++ h_path.dentry = au_h_dptr(dentry, bdst); ++ h_path.mnt = au_sbr_mnt(dentry->d_sb, bdst); ++ err = vfsub_sio_mkdir(au_h_iptr(dir, bdst), &h_path, ++ S_IRWXU | S_IRUGO | S_IXUGO); ++ if (unlikely(err)) ++ goto out_put; ++ au_fset_cpdown(args->flags, MADE_DIR); ++ ++ bend = au_dbend(dentry); ++ bopq = au_dbdiropq(dentry); ++ au_fclr_cpdown(args->flags, WHED); ++ au_fclr_cpdown(args->flags, DIROPQ); ++ if (au_dbwh(dentry) == bdst) ++ au_fset_cpdown(args->flags, WHED); ++ if (!au_ftest_cpdown(args->flags, PARENT_OPQ) && bopq <= bdst) ++ au_fset_cpdown(args->flags, PARENT_OPQ); ++ parent_opq = (au_ftest_cpdown(args->flags, PARENT_OPQ) ++ && args->parent == dentry); ++ h_inode = h_path.dentry->d_inode; ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ if (au_ftest_cpdown(args->flags, WHED)) { ++ err = au_cpdown_dir_opq(dentry, bdst, args); ++ if (unlikely(err)) { ++ mutex_unlock(&h_inode->i_mutex); ++ goto out_dir; ++ } ++ } ++ ++ err = au_cpdown_attr(&h_path, au_h_dptr(dentry, bstart)); ++ mutex_unlock(&h_inode->i_mutex); ++ if (unlikely(err)) ++ goto out_opq; ++ ++ if (au_ftest_cpdown(args->flags, WHED)) { ++ err = au_cpdown_dir_wh(dentry, h_parent, dir, bdst); ++ if (unlikely(err)) ++ goto out_opq; ++ } ++ ++ inode = dentry->d_inode; ++ if (au_ibend(inode) < bdst) ++ au_set_ibend(inode, bdst); ++ au_set_h_iptr(inode, bdst, au_igrab(h_inode), ++ au_hi_flags(inode, /*isdir*/1)); ++ goto out; /* success */ ++ ++ /* revert */ ++ out_opq: ++ if (au_ftest_cpdown(args->flags, DIROPQ)) { ++ mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD); ++ rerr = au_diropq_remove(dentry, bdst); ++ mutex_unlock(&h_inode->i_mutex); ++ if (unlikely(rerr)) { ++ AuIOErr("failed removing diropq for %.*s b%d (%d)\n", ++ AuDLNPair(dentry), bdst, rerr); ++ err = -EIO; ++ goto out; ++ } ++ } ++ out_dir: ++ if (au_ftest_cpdown(args->flags, MADE_DIR)) { ++ rerr = vfsub_sio_rmdir(au_h_iptr(dir, bdst), &h_path); ++ if (unlikely(rerr)) { ++ AuIOErr("failed removing %.*s b%d (%d)\n", ++ AuDLNPair(dentry), bdst, rerr); ++ err = -EIO; ++ } ++ } ++ out_put: ++ au_set_h_dptr(dentry, bdst, NULL); ++ if (au_dbend(dentry) == bdst) ++ au_update_dbend(dentry); ++ out: ++ dput(parent); ++ return err; ++} ++ ++int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst) ++{ ++ int err; ++ struct au_cpdown_dir_args args = { ++ .parent = dget_parent(dentry), ++ .flags = 0 ++ }; ++ ++ err = au_cp_dirs(dentry, bdst, au_cpdown_dir, &args); ++ dput(args.parent); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies for create */ ++ ++static int au_wbr_bu(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ for (; bindex >= 0; bindex--) ++ if (!au_br_rdonly(au_sbr(sb, bindex))) ++ return bindex; ++ return -EROFS; ++} ++ ++/* top down parent */ ++static int au_wbr_create_tdp(struct dentry *dentry, int isdir __maybe_unused) ++{ ++ int err; ++ aufs_bindex_t bstart, bindex; ++ struct super_block *sb; ++ struct dentry *parent, *h_parent; ++ ++ sb = dentry->d_sb; ++ bstart = au_dbstart(dentry); ++ err = bstart; ++ if (!au_br_rdonly(au_sbr(sb, bstart))) ++ goto out; ++ ++ err = -EROFS; ++ parent = dget_parent(dentry); ++ for (bindex = au_dbstart(parent); bindex < bstart; bindex++) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || !h_parent->d_inode) ++ continue; ++ ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = bindex; ++ break; ++ } ++ } ++ dput(parent); ++ ++ /* bottom up here */ ++ if (unlikely(err < 0)) ++ err = au_wbr_bu(sb, bstart - 1); ++ ++ out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* an exception for the policy other than tdp */ ++static int au_wbr_create_exp(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bwh, bdiropq; ++ struct dentry *parent; ++ ++ err = -1; ++ bwh = au_dbwh(dentry); ++ parent = dget_parent(dentry); ++ bdiropq = au_dbdiropq(parent); ++ if (bwh >= 0) { ++ if (bdiropq >= 0) ++ err = min(bdiropq, bwh); ++ else ++ err = bwh; ++ AuDbg("%d\n", err); ++ } else if (bdiropq >= 0) { ++ err = bdiropq; ++ AuDbg("%d\n", err); ++ } ++ dput(parent); ++ ++ if (err >= 0 && au_br_rdonly(au_sbr(dentry->d_sb, err))) ++ err = -1; ++ ++ AuDbg("%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* round robin */ ++static int au_wbr_create_init_rr(struct super_block *sb) ++{ ++ int err; ++ ++ err = au_wbr_bu(sb, au_sbend(sb)); ++ atomic_set(&au_sbi(sb)->si_wbr_rr_next, -err); /* less important */ ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_rr(struct dentry *dentry, int isdir) ++{ ++ int err, nbr; ++ unsigned int u; ++ aufs_bindex_t bindex, bend; ++ struct super_block *sb; ++ atomic_t *next; ++ ++ err = au_wbr_create_exp(dentry); ++ if (err >= 0) ++ goto out; ++ ++ sb = dentry->d_sb; ++ next = &au_sbi(sb)->si_wbr_rr_next; ++ bend = au_sbend(sb); ++ nbr = bend + 1; ++ for (bindex = 0; bindex <= bend; bindex++) { ++ if (!isdir) { ++ err = atomic_dec_return(next) + 1; ++ /* modulo for 0 is meaningless */ ++ if (unlikely(!err)) ++ err = atomic_dec_return(next) + 1; ++ } else ++ err = atomic_read(next); ++ AuDbg("%d\n", err); ++ u = err; ++ err = u % nbr; ++ AuDbg("%d\n", err); ++ if (!au_br_rdonly(au_sbr(sb, err))) ++ break; ++ err = -EROFS; ++ } ++ ++ out: ++ AuDbg("%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* most free space */ ++static void au_mfs(struct dentry *dentry) ++{ ++ struct super_block *sb; ++ struct au_branch *br; ++ struct au_wbr_mfs *mfs; ++ aufs_bindex_t bindex, bend; ++ int err; ++ unsigned long long b, bavail; ++ /* reduce the stack usage */ ++ struct kstatfs *st; ++ ++ st = kmalloc(sizeof(*st), GFP_NOFS); ++ if (unlikely(!st)) { ++ AuWarn1("failed updating mfs(%d), ignored\n", -ENOMEM); ++ return; ++ } ++ ++ bavail = 0; ++ sb = dentry->d_sb; ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mfs->mfs_bindex = -EROFS; ++ mfs->mfsrr_bytes = 0; ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_rdonly(br)) ++ continue; ++ ++ /* sb->s_root for NFS is unreliable */ ++ err = vfs_statfs(br->br_mnt->mnt_root, st); ++ if (unlikely(err)) { ++ AuWarn1("failed statfs, b%d, %d\n", bindex, err); ++ continue; ++ } ++ ++ /* when the available size is equal, select the lower one */ ++ BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail) ++ || sizeof(b) < sizeof(st->f_bsize)); ++ b = st->f_bavail * st->f_bsize; ++ br->br_wbr->wbr_bytes = b; ++ if (b >= bavail) { ++ bavail = b; ++ mfs->mfs_bindex = bindex; ++ mfs->mfs_jiffy = jiffies; ++ } ++ } ++ ++ mfs->mfsrr_bytes = bavail; ++ AuDbg("b%d\n", mfs->mfs_bindex); ++ kfree(st); ++} ++ ++static int au_wbr_create_mfs(struct dentry *dentry, int isdir __maybe_unused) ++{ ++ int err; ++ struct super_block *sb; ++ struct au_wbr_mfs *mfs; ++ ++ err = au_wbr_create_exp(dentry); ++ if (err >= 0) ++ goto out; ++ ++ sb = dentry->d_sb; ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_lock(&mfs->mfs_lock); ++ if (time_after(jiffies, mfs->mfs_jiffy + mfs->mfs_expire) ++ || mfs->mfs_bindex < 0 ++ || au_br_rdonly(au_sbr(sb, mfs->mfs_bindex))) ++ au_mfs(dentry); ++ mutex_unlock(&mfs->mfs_lock); ++ err = mfs->mfs_bindex; ++ ++ out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_init_mfs(struct super_block *sb) ++{ ++ struct au_wbr_mfs *mfs; ++ ++ mfs = &au_sbi(sb)->si_wbr_mfs; ++ mutex_init(&mfs->mfs_lock); ++ mfs->mfs_jiffy = 0; ++ mfs->mfs_bindex = -EROFS; ++ ++ return 0; ++} ++ ++static int au_wbr_create_fin_mfs(struct super_block *sb __maybe_unused) ++{ ++ mutex_destroy(&au_sbi(sb)->si_wbr_mfs.mfs_lock); ++ return 0; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* most free space and then round robin */ ++static int au_wbr_create_mfsrr(struct dentry *dentry, int isdir) ++{ ++ int err; ++ struct au_wbr_mfs *mfs; ++ ++ err = au_wbr_create_mfs(dentry, isdir); ++ if (err >= 0) { ++ mfs = &au_sbi(dentry->d_sb)->si_wbr_mfs; ++ if (mfs->mfsrr_bytes < mfs->mfsrr_watermark) ++ err = au_wbr_create_rr(dentry, isdir); ++ } ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++static int au_wbr_create_init_mfsrr(struct super_block *sb) ++{ ++ int err; ++ ++ au_wbr_create_init_mfs(sb); /* ignore */ ++ err = au_wbr_create_init_rr(sb); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* top down parent and most free space */ ++static int au_wbr_create_pmfs(struct dentry *dentry, int isdir) ++{ ++ int err, e2; ++ unsigned long long b; ++ aufs_bindex_t bindex, bstart, bend; ++ struct super_block *sb; ++ struct dentry *parent, *h_parent; ++ struct au_branch *br; ++ ++ err = au_wbr_create_tdp(dentry, isdir); ++ if (unlikely(err < 0)) ++ goto out; ++ parent = dget_parent(dentry); ++ bstart = au_dbstart(parent); ++ bend = au_dbtaildir(parent); ++ if (bstart == bend) ++ goto out_parent; /* success */ ++ ++ e2 = au_wbr_create_mfs(dentry, isdir); ++ if (e2 < 0) ++ goto out_parent; /* success */ ++ ++ /* when the available size is equal, select upper one */ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, err); ++ b = br->br_wbr->wbr_bytes; ++ AuDbg("b%d, %llu\n", err, b); ++ ++ for (bindex = bstart; bindex <= bend; bindex++) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || !h_parent->d_inode) ++ continue; ++ ++ br = au_sbr(sb, bindex); ++ if (!au_br_rdonly(br) && br->br_wbr->wbr_bytes > b) { ++ b = br->br_wbr->wbr_bytes; ++ err = bindex; ++ AuDbg("b%d, %llu\n", err, b); ++ } ++ } ++ ++ out_parent: ++ dput(parent); ++ out: ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* policies for copyup */ ++ ++/* top down parent */ ++static int au_wbr_copyup_tdp(struct dentry *dentry) ++{ ++ return au_wbr_create_tdp(dentry, /*isdir, anything is ok*/0); ++} ++ ++/* bottom up parent */ ++static int au_wbr_copyup_bup(struct dentry *dentry) ++{ ++ int err; ++ aufs_bindex_t bindex, bstart; ++ struct dentry *parent, *h_parent; ++ struct super_block *sb; ++ ++ err = -EROFS; ++ sb = dentry->d_sb; ++ parent = dget_parent(dentry); ++ bstart = au_dbstart(parent); ++ for (bindex = au_dbstart(dentry); bindex >= bstart; bindex--) { ++ h_parent = au_h_dptr(parent, bindex); ++ if (!h_parent || !h_parent->d_inode) ++ continue; ++ ++ if (!au_br_rdonly(au_sbr(sb, bindex))) { ++ err = bindex; ++ break; ++ } ++ } ++ dput(parent); ++ ++ /* bottom up here */ ++ if (unlikely(err < 0)) ++ err = au_wbr_bu(sb, bstart - 1); ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* bottom up */ ++static int au_wbr_copyup_bu(struct dentry *dentry) ++{ ++ int err; ++ ++ err = au_wbr_bu(dentry->d_sb, au_dbstart(dentry)); ++ ++ AuDbg("b%d\n", err); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_wbr_copyup_operations au_wbr_copyup_ops[] = { ++ [AuWbrCopyup_TDP] = { ++ .copyup = au_wbr_copyup_tdp ++ }, ++ [AuWbrCopyup_BUP] = { ++ .copyup = au_wbr_copyup_bup ++ }, ++ [AuWbrCopyup_BU] = { ++ .copyup = au_wbr_copyup_bu ++ } ++}; ++ ++struct au_wbr_create_operations au_wbr_create_ops[] = { ++ [AuWbrCreate_TDP] = { ++ .create = au_wbr_create_tdp ++ }, ++ [AuWbrCreate_RR] = { ++ .create = au_wbr_create_rr, ++ .init = au_wbr_create_init_rr ++ }, ++ [AuWbrCreate_MFS] = { ++ .create = au_wbr_create_mfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSV] = { ++ .create = au_wbr_create_mfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSRR] = { ++ .create = au_wbr_create_mfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_MFSRRV] = { ++ .create = au_wbr_create_mfsrr, ++ .init = au_wbr_create_init_mfsrr, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFS] = { ++ .create = au_wbr_create_pmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ }, ++ [AuWbrCreate_PMFSV] = { ++ .create = au_wbr_create_pmfs, ++ .init = au_wbr_create_init_mfs, ++ .fin = au_wbr_create_fin_mfs ++ } ++}; +diff -Naur a/fs/aufs/whout.c b/fs/aufs/whout.c +--- a/fs/aufs/whout.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/whout.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,1042 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * whiteout for logical deletion and opaque directory ++ */ ++ ++#include <linux/fs.h> ++#include "aufs.h" ++ ++#define WH_MASK S_IRUGO ++ ++/* ++ * If a directory contains this file, then it is opaque. We start with the ++ * .wh. flag so that it is blocked by lookup. ++ */ ++static struct qstr diropq_name = { ++ .name = AUFS_WH_DIROPQ, ++ .len = sizeof(AUFS_WH_DIROPQ) - 1 ++}; ++ ++/* ++ * generate whiteout name, which is NOT terminated by NULL. ++ * @name: original d_name.name ++ * @len: original d_name.len ++ * @wh: whiteout qstr ++ * returns zero when succeeds, otherwise error. ++ * succeeded value as wh->name should be freed by kfree(). ++ */ ++int au_wh_name_alloc(struct qstr *wh, const struct qstr *name) ++{ ++ char *p; ++ ++ if (unlikely(name->len > PATH_MAX - AUFS_WH_PFX_LEN)) ++ return -ENAMETOOLONG; ++ ++ wh->len = name->len + AUFS_WH_PFX_LEN; ++ p = kmalloc(wh->len, GFP_NOFS); ++ wh->name = p; ++ if (p) { ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ memcpy(p + AUFS_WH_PFX_LEN, name->name, name->len); ++ /* smp_mb(); */ ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * test if the @wh_name exists under @h_parent. ++ * @try_sio specifies the necessary of super-io. ++ */ ++int au_wh_test(struct dentry *h_parent, struct qstr *wh_name, ++ struct au_branch *br, int try_sio) ++{ ++ int err; ++ struct dentry *wh_dentry; ++ struct inode *h_dir; ++ ++ h_dir = h_parent->d_inode; ++ if (!try_sio) ++ wh_dentry = au_lkup_one(wh_name, h_parent, br, /*nd*/NULL); ++ else ++ wh_dentry = au_sio_lkup_one(wh_name, h_parent, br); ++ err = PTR_ERR(wh_dentry); ++ if (IS_ERR(wh_dentry)) ++ goto out; ++ ++ err = 0; ++ if (!wh_dentry->d_inode) ++ goto out_wh; /* success */ ++ ++ err = 1; ++ if (S_ISREG(wh_dentry->d_inode->i_mode)) ++ goto out_wh; /* success */ ++ ++ err = -EIO; ++ AuIOErr("%.*s Invalid whiteout entry type 0%o.\n", ++ AuDLNPair(wh_dentry), wh_dentry->d_inode->i_mode); ++ ++ out_wh: ++ dput(wh_dentry); ++ out: ++ return err; ++} ++ ++/* ++ * test if the @h_dentry sets opaque or not. ++ */ ++int au_diropq_test(struct dentry *h_dentry, struct au_branch *br) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ h_dir = h_dentry->d_inode; ++ err = au_wh_test(h_dentry, &diropq_name, br, ++ au_test_h_perm_sio(h_dir, MAY_EXEC)); ++ return err; ++} ++ ++/* ++ * returns a negative dentry whose name is unique and temporary. ++ */ ++struct dentry *au_whtmp_lkup(struct dentry *h_parent, struct au_branch *br, ++ struct qstr *prefix) ++{ ++#define HEX_LEN 4 ++ struct dentry *dentry; ++ int i; ++ char defname[AUFS_WH_PFX_LEN * 2 + DNAME_INLINE_LEN_MIN + 1 ++ + HEX_LEN + 1], *name, *p; ++ static unsigned short cnt; ++ struct qstr qs; ++ ++ name = defname; ++ qs.len = sizeof(defname) - DNAME_INLINE_LEN_MIN + prefix->len - 1; ++ if (unlikely(prefix->len > DNAME_INLINE_LEN_MIN)) { ++ dentry = ERR_PTR(-ENAMETOOLONG); ++ if (unlikely(qs.len >= PATH_MAX)) ++ goto out; ++ dentry = ERR_PTR(-ENOMEM); ++ name = kmalloc(qs.len + 1, GFP_NOFS); ++ if (unlikely(!name)) ++ goto out; ++ } ++ ++ /* doubly whiteout-ed */ ++ memcpy(name, AUFS_WH_PFX AUFS_WH_PFX, AUFS_WH_PFX_LEN * 2); ++ p = name + AUFS_WH_PFX_LEN * 2; ++ memcpy(p, prefix->name, prefix->len); ++ p += prefix->len; ++ *p++ = '.'; ++ AuDebugOn(name + qs.len + 1 - p <= HEX_LEN); ++ ++ qs.name = name; ++ for (i = 0; i < 3; i++) { ++ sprintf(p, "%.*d", HEX_LEN, cnt++); ++ dentry = au_sio_lkup_one(&qs, h_parent, br); ++ if (IS_ERR(dentry) || !dentry->d_inode) ++ goto out_name; ++ dput(dentry); ++ } ++ /* AuWarn("could not get random name\n"); */ ++ dentry = ERR_PTR(-EEXIST); ++ AuDbg("%.*s\n", AuLNPair(&qs)); ++ BUG(); ++ ++ out_name: ++ if (name != defname) ++ kfree(name); ++ out: ++ return dentry; ++#undef HEX_LEN ++} ++ ++/* ++ * rename the @h_dentry on @br to the whiteouted temporary name. ++ */ ++int au_whtmp_ren(struct dentry *h_dentry, struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = br->br_mnt ++ }; ++ struct inode *h_dir; ++ struct dentry *h_parent; ++ ++ h_parent = h_dentry->d_parent; /* dir inode is locked */ ++ h_dir = h_parent->d_inode; ++ IMustLock(h_dir); ++ ++ h_path.dentry = au_whtmp_lkup(h_parent, br, &h_dentry->d_name); ++ err = PTR_ERR(h_path.dentry); ++ if (IS_ERR(h_path.dentry)) ++ goto out; ++ ++ /* under the same dir, no need to lock_rename() */ ++ err = vfsub_rename(h_dir, h_dentry, h_dir, &h_path); ++ AuTraceErr(err); ++ dput(h_path.dentry); ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * functions for removing a whiteout ++ */ ++ ++static int do_unlink_wh(struct inode *h_dir, struct path *h_path) ++{ ++ int force; ++ ++ /* ++ * forces superio when the dir has a sticky bit. ++ * this may be a violation of unix fs semantics. ++ */ ++ force = (h_dir->i_mode & S_ISVTX) ++ && h_path->dentry->d_inode->i_uid != current_fsuid(); ++ return vfsub_unlink(h_dir, h_path, force); ++} ++ ++int au_wh_unlink_dentry(struct inode *h_dir, struct path *h_path, ++ struct dentry *dentry) ++{ ++ int err; ++ ++ err = do_unlink_wh(h_dir, h_path); ++ if (!err && dentry) ++ au_set_dbwh(dentry, -1); ++ ++ return err; ++} ++ ++static int unlink_wh_name(struct dentry *h_parent, struct qstr *wh, ++ struct au_branch *br) ++{ ++ int err; ++ struct path h_path = { ++ .mnt = br->br_mnt ++ }; ++ ++ err = 0; ++ h_path.dentry = au_lkup_one(wh, h_parent, br, /*nd*/NULL); ++ if (IS_ERR(h_path.dentry)) ++ err = PTR_ERR(h_path.dentry); ++ else { ++ if (h_path.dentry->d_inode ++ && S_ISREG(h_path.dentry->d_inode->i_mode)) ++ err = do_unlink_wh(h_parent->d_inode, &h_path); ++ dput(h_path.dentry); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * initialize/clean whiteout for a branch ++ */ ++ ++static void au_wh_clean(struct inode *h_dir, struct path *whpath, ++ const int isdir) ++{ ++ int err; ++ ++ if (!whpath->dentry->d_inode) ++ return; ++ ++ err = mnt_want_write(whpath->mnt); ++ if (!err) { ++ if (isdir) ++ err = vfsub_rmdir(h_dir, whpath); ++ else ++ err = vfsub_unlink(h_dir, whpath, /*force*/0); ++ mnt_drop_write(whpath->mnt); ++ } ++ if (unlikely(err)) ++ AuWarn("failed removing %.*s (%d), ignored.\n", ++ AuDLNPair(whpath->dentry), err); ++} ++ ++static int test_linkable(struct dentry *h_root) ++{ ++ struct inode *h_dir = h_root->d_inode; ++ ++ if (h_dir->i_op->link) ++ return 0; ++ ++ AuErr("%.*s (%s) doesn't support link(2), use noplink and rw+nolwh\n", ++ AuDLNPair(h_root), au_sbtype(h_root->d_sb)); ++ return -ENOSYS; ++} ++ ++/* todo: should this mkdir be done in /sbin/mount.aufs helper? */ ++static int au_whdir(struct inode *h_dir, struct path *path) ++{ ++ int err; ++ ++ err = -EEXIST; ++ if (!path->dentry->d_inode) { ++ int mode = S_IRWXU; ++ ++ if (au_test_nfs(path->dentry->d_sb)) ++ mode |= S_IXUGO; ++ err = mnt_want_write(path->mnt); ++ if (!err) { ++ err = vfsub_mkdir(h_dir, path, mode); ++ mnt_drop_write(path->mnt); ++ } ++ } else if (S_ISDIR(path->dentry->d_inode->i_mode)) ++ err = 0; ++ else ++ AuErr("unknown %.*s exists\n", AuDLNPair(path->dentry)); ++ ++ return err; ++} ++ ++struct au_wh_base { ++ const struct qstr *name; ++ struct dentry *dentry; ++}; ++ ++static void au_wh_init_ro(struct inode *h_dir, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/0); ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++} ++ ++/* ++ * returns tri-state, ++ * minus: error, caller should print the mesage ++ * zero: succuess ++ * plus: error, caller should NOT print the mesage ++ */ ++static int au_wh_init_rw_nolink(struct dentry *h_root, struct au_wbr *wbr, ++ int do_plink, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ h_dir = h_root->d_inode; ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ au_wh_clean(h_dir, h_path, /*isdir*/0); ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ if (do_plink) { ++ err = test_linkable(h_root); ++ if (unlikely(err)) { ++ err = 1; ++ goto out; ++ } ++ ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_plink = dget(base[AuBrWh_PLINK].dentry); ++ } else ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_orph = dget(base[AuBrWh_ORPH].dentry); ++ ++ out: ++ return err; ++} ++ ++/* ++ * for the moment, aufs supports the branch filesystem which does not support ++ * link(2). testing on FAT which does not support i_op->setattr() fully either, ++ * copyup failed. finally, such filesystem will not be used as the writable ++ * branch. ++ * ++ * returns tri-state, see above. ++ */ ++static int au_wh_init_rw(struct dentry *h_root, struct au_wbr *wbr, ++ int do_plink, struct au_wh_base base[], ++ struct path *h_path) ++{ ++ int err; ++ struct inode *h_dir; ++ ++ err = test_linkable(h_root); ++ if (unlikely(err)) { ++ err = 1; ++ goto out; ++ } ++ ++ /* ++ * todo: should this create be done in /sbin/mount.aufs helper? ++ */ ++ err = -EEXIST; ++ h_dir = h_root->d_inode; ++ if (!base[AuBrWh_BASE].dentry->d_inode) { ++ err = mnt_want_write(h_path->mnt); ++ if (!err) { ++ h_path->dentry = base[AuBrWh_BASE].dentry; ++ err = vfsub_create(h_dir, h_path, WH_MASK); ++ mnt_drop_write(h_path->mnt); ++ } ++ } else if (S_ISREG(base[AuBrWh_BASE].dentry->d_inode->i_mode)) ++ err = 0; ++ else ++ AuErr("unknown %.*s/%.*s exists\n", ++ AuDLNPair(h_root), AuDLNPair(base[AuBrWh_BASE].dentry)); ++ if (unlikely(err)) ++ goto out; ++ ++ h_path->dentry = base[AuBrWh_PLINK].dentry; ++ if (do_plink) { ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_plink = dget(base[AuBrWh_PLINK].dentry); ++ } else ++ au_wh_clean(h_dir, h_path, /*isdir*/1); ++ wbr->wbr_whbase = dget(base[AuBrWh_BASE].dentry); ++ ++ h_path->dentry = base[AuBrWh_ORPH].dentry; ++ err = au_whdir(h_dir, h_path); ++ if (unlikely(err)) ++ goto out; ++ wbr->wbr_orph = dget(base[AuBrWh_ORPH].dentry); ++ ++ out: ++ return err; ++} ++ ++/* ++ * initialize the whiteout base file/dir for @br. ++ */ ++int au_wh_init(struct dentry *h_root, struct au_branch *br, ++ struct super_block *sb) ++{ ++ int err, i; ++ const unsigned char do_plink ++ = !!au_opt_test(au_mntflags(sb), PLINK); ++ struct path path = { ++ .mnt = br->br_mnt ++ }; ++ struct inode *h_dir; ++ struct au_wbr *wbr = br->br_wbr; ++ static const struct qstr base_name[] = { ++ [AuBrWh_BASE] = { ++ .name = AUFS_BASE_NAME, ++ .len = sizeof(AUFS_BASE_NAME) - 1 ++ }, ++ [AuBrWh_PLINK] = { ++ .name = AUFS_PLINKDIR_NAME, ++ .len = sizeof(AUFS_PLINKDIR_NAME) - 1 ++ }, ++ [AuBrWh_ORPH] = { ++ .name = AUFS_ORPHDIR_NAME, ++ .len = sizeof(AUFS_ORPHDIR_NAME) - 1 ++ } ++ }; ++ struct au_wh_base base[] = { ++ [AuBrWh_BASE] = { ++ .name = base_name + AuBrWh_BASE, ++ .dentry = NULL ++ }, ++ [AuBrWh_PLINK] = { ++ .name = base_name + AuBrWh_PLINK, ++ .dentry = NULL ++ }, ++ [AuBrWh_ORPH] = { ++ .name = base_name + AuBrWh_ORPH, ++ .dentry = NULL ++ } ++ }; ++ ++ ++ h_dir = h_root->d_inode; ++ for (i = 0; i < AuBrWh_Last; i++) { ++ /* doubly whiteouted */ ++ struct dentry *d; ++ ++ d = au_wh_lkup(h_root, (void *)base[i].name, br); ++ err = PTR_ERR(d); ++ if (IS_ERR(d)) ++ goto out; ++ ++ base[i].dentry = d; ++ AuDebugOn(wbr ++ && wbr->wbr_wh[i] ++ && wbr->wbr_wh[i] != base[i].dentry); ++ } ++ ++ if (wbr) ++ for (i = 0; i < AuBrWh_Last; i++) { ++ dput(wbr->wbr_wh[i]); ++ wbr->wbr_wh[i] = NULL; ++ } ++ ++ err = 0; ++ ++ switch (br->br_perm) { ++ case AuBrPerm_RO: ++ case AuBrPerm_ROWH: ++ case AuBrPerm_RR: ++ case AuBrPerm_RRWH: ++ au_wh_init_ro(h_dir, base, &path); ++ break; ++ ++ case AuBrPerm_RWNoLinkWH: ++ err = au_wh_init_rw_nolink(h_root, wbr, do_plink, base, &path); ++ if (err > 0) ++ goto out; ++ else if (err) ++ goto out_err; ++ break; ++ ++ case AuBrPerm_RW: ++ err = au_wh_init_rw(h_root, wbr, do_plink, base, &path); ++ if (err > 0) ++ goto out; ++ else if (err) ++ goto out_err; ++ break; ++ ++ default: ++ BUG(); ++ } ++ goto out; /* success */ ++ ++ out_err: ++ AuErr("an error(%d) on the writable branch %.*s(%s)\n", ++ err, AuDLNPair(h_root), au_sbtype(h_root->d_sb)); ++ out: ++ for (i = 0; i < AuBrWh_Last; i++) ++ dput(base[i].dentry); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++/* ++ * whiteouts are all hard-linked usually. ++ * when its link count reaches a ceiling, we create a new whiteout base ++ * asynchronously. ++ */ ++ ++struct reinit_br_wh { ++ struct super_block *sb; ++ struct au_branch *br; ++}; ++ ++static void reinit_br_wh(void *arg) ++{ ++ int err; ++ aufs_bindex_t bindex; ++ struct path h_path; ++ struct reinit_br_wh *a = arg; ++ struct au_wbr *wbr; ++ struct inode *dir; ++ struct dentry *h_root; ++ struct au_hinode *hdir; ++ ++ err = 0; ++ wbr = a->br->br_wbr; ++ /* big aufs lock */ ++ si_noflush_write_lock(a->sb); ++ if (!au_br_writable(a->br->br_perm)) ++ goto out; ++ bindex = au_br_index(a->sb, a->br->br_id); ++ if (unlikely(bindex < 0)) ++ goto out; ++ ++ dir = a->sb->s_root->d_inode; ++ /* ii_read_lock_parent(dir); */ ++ hdir = au_hi(dir, bindex); ++ h_root = au_h_dptr(a->sb->s_root, bindex); ++ ++ au_hin_imtx_lock_nested(hdir, AuLsc_I_PARENT); ++ wbr_wh_write_lock(wbr); ++ err = au_h_verify(wbr->wbr_whbase, au_opt_udba(a->sb), hdir->hi_inode, ++ h_root, a->br); ++ if (!err) { ++ err = mnt_want_write(a->br->br_mnt); ++ if (!err) { ++ h_path.dentry = wbr->wbr_whbase; ++ h_path.mnt = a->br->br_mnt; ++ err = vfsub_unlink(hdir->hi_inode, &h_path, /*force*/0); ++ mnt_drop_write(a->br->br_mnt); ++ } ++ } else { ++ AuWarn("%.*s is moved, ignored\n", AuDLNPair(wbr->wbr_whbase)); ++ err = 0; ++ } ++ dput(wbr->wbr_whbase); ++ wbr->wbr_whbase = NULL; ++ if (!err) ++ err = au_wh_init(h_root, a->br, a->sb); ++ wbr_wh_write_unlock(wbr); ++ au_hin_imtx_unlock(hdir); ++ /* ii_read_unlock(dir); */ ++ ++ out: ++ if (wbr) ++ atomic_dec(&wbr->wbr_wh_running); ++ atomic_dec(&a->br->br_count); ++ au_nwt_done(&au_sbi(a->sb)->si_nowait); ++ si_write_unlock(a->sb); ++ kfree(arg); ++ if (unlikely(err)) ++ AuIOErr("err %d\n", err); ++} ++ ++static void kick_reinit_br_wh(struct super_block *sb, struct au_branch *br) ++{ ++ int do_dec, wkq_err; ++ struct reinit_br_wh *arg; ++ ++ do_dec = 1; ++ if (atomic_inc_return(&br->br_wbr->wbr_wh_running) != 1) ++ goto out; ++ ++ /* ignore ENOMEM */ ++ arg = kmalloc(sizeof(*arg), GFP_NOFS); ++ if (arg) { ++ /* ++ * dec(wh_running), kfree(arg) and dec(br_count) ++ * in reinit function ++ */ ++ arg->sb = sb; ++ arg->br = br; ++ atomic_inc(&br->br_count); ++ wkq_err = au_wkq_nowait(reinit_br_wh, arg, sb); ++ if (unlikely(wkq_err)) { ++ atomic_dec(&br->br_wbr->wbr_wh_running); ++ atomic_dec(&br->br_count); ++ kfree(arg); ++ } ++ do_dec = 0; ++ } ++ ++ out: ++ if (do_dec) ++ atomic_dec(&br->br_wbr->wbr_wh_running); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create the whiteout @wh. ++ */ ++static int link_or_create_wh(struct super_block *sb, aufs_bindex_t bindex, ++ struct dentry *wh) ++{ ++ int err; ++ struct path h_path = { ++ .dentry = wh ++ }; ++ struct au_branch *br; ++ struct au_wbr *wbr; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ ++ h_parent = wh->d_parent; /* dir inode is locked */ ++ h_dir = h_parent->d_inode; ++ IMustLock(h_dir); ++ ++ br = au_sbr(sb, bindex); ++ h_path.mnt = br->br_mnt; ++ wbr = br->br_wbr; ++ wbr_wh_read_lock(wbr); ++ if (wbr->wbr_whbase) { ++ err = vfsub_link(wbr->wbr_whbase, h_dir, &h_path); ++ if (!err || err != -EMLINK) ++ goto out; ++ ++ /* link count full. re-initialize br_whbase. */ ++ kick_reinit_br_wh(sb, br); ++ } ++ ++ /* return this error in this context */ ++ err = vfsub_create(h_dir, &h_path, WH_MASK); ++ ++ out: ++ wbr_wh_read_unlock(wbr); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create or remove the diropq. ++ */ ++static struct dentry *do_diropq(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags) ++{ ++ struct dentry *opq_dentry, *h_dentry; ++ struct super_block *sb; ++ struct au_branch *br; ++ int err; ++ ++ sb = dentry->d_sb; ++ br = au_sbr(sb, bindex); ++ h_dentry = au_h_dptr(dentry, bindex); ++ opq_dentry = au_lkup_one(&diropq_name, h_dentry, br, /*nd*/NULL); ++ if (IS_ERR(opq_dentry)) ++ goto out; ++ ++ if (au_ftest_diropq(flags, CREATE)) { ++ err = link_or_create_wh(sb, bindex, opq_dentry); ++ if (!err) { ++ au_set_dbdiropq(dentry, bindex); ++ goto out; /* success */ ++ } ++ } else { ++ struct path tmp = { ++ .dentry = opq_dentry, ++ .mnt = br->br_mnt ++ }; ++ err = do_unlink_wh(au_h_iptr(dentry->d_inode, bindex), &tmp); ++ if (!err) ++ au_set_dbdiropq(dentry, -1); ++ } ++ dput(opq_dentry); ++ opq_dentry = ERR_PTR(err); ++ ++ out: ++ return opq_dentry; ++} ++ ++struct do_diropq_args { ++ struct dentry **errp; ++ struct dentry *dentry; ++ aufs_bindex_t bindex; ++ unsigned int flags; ++}; ++ ++static void call_do_diropq(void *args) ++{ ++ struct do_diropq_args *a = args; ++ *a->errp = do_diropq(a->dentry, a->bindex, a->flags); ++} ++ ++struct dentry *au_diropq_sio(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags) ++{ ++ struct dentry *diropq, *h_dentry; ++ ++ h_dentry = au_h_dptr(dentry, bindex); ++ if (!au_test_h_perm_sio(h_dentry->d_inode, MAY_EXEC | MAY_WRITE)) ++ diropq = do_diropq(dentry, bindex, flags); ++ else { ++ int wkq_err; ++ struct do_diropq_args args = { ++ .errp = &diropq, ++ .dentry = dentry, ++ .bindex = bindex, ++ .flags = flags ++ }; ++ ++ wkq_err = au_wkq_wait(call_do_diropq, &args); ++ if (unlikely(wkq_err)) ++ diropq = ERR_PTR(wkq_err); ++ } ++ ++ return diropq; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * lookup whiteout dentry. ++ * @h_parent: lower parent dentry which must exist and be locked ++ * @base_name: name of dentry which will be whiteouted ++ * returns dentry for whiteout. ++ */ ++struct dentry *au_wh_lkup(struct dentry *h_parent, struct qstr *base_name, ++ struct au_branch *br) ++{ ++ int err; ++ struct qstr wh_name; ++ struct dentry *wh_dentry; ++ ++ err = au_wh_name_alloc(&wh_name, base_name); ++ wh_dentry = ERR_PTR(err); ++ if (!err) { ++ wh_dentry = au_lkup_one(&wh_name, h_parent, br, /*nd*/NULL); ++ kfree(wh_name.name); ++ } ++ return wh_dentry; ++} ++ ++/* ++ * link/create a whiteout for @dentry on @bindex. ++ */ ++struct dentry *au_wh_create(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent) ++{ ++ struct dentry *wh_dentry; ++ struct super_block *sb; ++ int err; ++ ++ sb = dentry->d_sb; ++ wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, au_sbr(sb, bindex)); ++ if (!IS_ERR(wh_dentry) && !wh_dentry->d_inode) { ++ err = link_or_create_wh(sb, bindex, wh_dentry); ++ if (!err) ++ au_set_dbwh(dentry, bindex); ++ else { ++ dput(wh_dentry); ++ wh_dentry = ERR_PTR(err); ++ } ++ } ++ ++ return wh_dentry; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* Delete all whiteouts in this directory on branch bindex. */ ++static int del_wh_children(struct dentry *h_dentry, struct au_nhash *whlist, ++ aufs_bindex_t bindex, struct au_branch *br) ++{ ++ int err; ++ unsigned long ul, n; ++ struct qstr wh_name; ++ char *p; ++ struct hlist_head *head; ++ struct au_vdir_wh *tpos; ++ struct hlist_node *pos; ++ struct au_vdir_destr *str; ++ ++ err = -ENOMEM; ++ p = __getname(); ++ wh_name.name = p; ++ if (unlikely(!wh_name.name)) ++ goto out; ++ ++ err = 0; ++ memcpy(p, AUFS_WH_PFX, AUFS_WH_PFX_LEN); ++ p += AUFS_WH_PFX_LEN; ++ n = whlist->nh_num; ++ head = whlist->nh_head; ++ for (ul = 0; !err && ul < n; ul++, head++) { ++ hlist_for_each_entry(tpos, pos, head, wh_hash) { ++ if (tpos->wh_bindex != bindex) ++ continue; ++ ++ str = &tpos->wh_str; ++ if (str->len + AUFS_WH_PFX_LEN <= PATH_MAX) { ++ memcpy(p, str->name, str->len); ++ wh_name.len = AUFS_WH_PFX_LEN + str->len; ++ err = unlink_wh_name(h_dentry, &wh_name, br); ++ if (!err) ++ continue; ++ break; ++ } ++ AuIOErr("whiteout name too long %.*s\n", ++ str->len, str->name); ++ err = -EIO; ++ break; ++ } ++ } ++ __putname(wh_name.name); ++ ++ out: ++ return err; ++} ++ ++struct del_wh_children_args { ++ int *errp; ++ struct dentry *h_dentry; ++ struct au_nhash whlist; ++ aufs_bindex_t bindex; ++ struct au_branch *br; ++}; ++ ++static void call_del_wh_children(void *args) ++{ ++ struct del_wh_children_args *a = args; ++ *a->errp = del_wh_children(a->h_dentry, &a->whlist, a->bindex, a->br); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++struct au_whtmp_rmdir *au_whtmp_rmdir_alloc(struct super_block *sb, gfp_t gfp) ++{ ++ struct au_whtmp_rmdir *whtmp; ++ int err; ++ ++ whtmp = kmalloc(sizeof(*whtmp), gfp); ++ if (unlikely(!whtmp)) { ++ whtmp = ERR_PTR(-ENOMEM); ++ goto out; ++ } ++ ++ whtmp->dir = NULL; ++ whtmp->wh_dentry = NULL; ++ err = au_nhash_alloc(&whtmp->whlist, au_sbi(sb)->si_rdhash, gfp); ++ if (!err) ++ return whtmp; /* success */ ++ ++ kfree(whtmp); ++ whtmp = ERR_PTR(err); ++ ++ out: ++ return whtmp; ++} ++ ++void au_whtmp_rmdir_free(struct au_whtmp_rmdir *whtmp) ++{ ++ dput(whtmp->wh_dentry); ++ iput(whtmp->dir); ++ au_nhash_wh_free(&whtmp->whlist); ++ kfree(whtmp); ++} ++ ++/* ++ * rmdir the whiteouted temporary named dir @h_dentry. ++ * @whlist: whiteouted children. ++ */ ++int au_whtmp_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_nhash *whlist) ++{ ++ int err; ++ struct path h_tmp; ++ struct inode *wh_inode, *h_dir; ++ struct au_branch *br; ++ ++ h_dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */ ++ IMustLock(h_dir); ++ ++ br = au_sbr(dir->i_sb, bindex); ++ wh_inode = wh_dentry->d_inode; ++ mutex_lock_nested(&wh_inode->i_mutex, AuLsc_I_CHILD); ++ ++ /* ++ * someone else might change some whiteouts while we were sleeping. ++ * it means this whlist may have an obsoleted entry. ++ */ ++ if (!au_test_h_perm_sio(wh_inode, MAY_EXEC | MAY_WRITE)) ++ err = del_wh_children(wh_dentry, whlist, bindex, br); ++ else { ++ int wkq_err; ++ struct del_wh_children_args args = { ++ .errp = &err, ++ .h_dentry = wh_dentry, ++ .whlist = *whlist, ++ .bindex = bindex, ++ .br = br ++ }; ++ ++ wkq_err = au_wkq_wait(call_del_wh_children, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } ++ mutex_unlock(&wh_inode->i_mutex); ++ ++ if (!err) { ++ h_tmp.dentry = wh_dentry; ++ h_tmp.mnt = br->br_mnt; ++ err = vfsub_rmdir(h_dir, &h_tmp); ++ /* d_drop(h_dentry); */ ++ } ++ ++ if (!err) { ++ if (au_ibstart(dir) == bindex) { ++ au_cpup_attr_timesizes(dir); ++ drop_nlink(dir); ++ } ++ return 0; /* success */ ++ } ++ ++ AuWarn("failed removing %.*s(%d), ignored\n", ++ AuDLNPair(wh_dentry), err); ++ return err; ++} ++ ++static void call_rmdir_whtmp(void *args) ++{ ++ int err; ++ struct au_whtmp_rmdir *a = args; ++ struct super_block *sb; ++ struct dentry *h_parent; ++ struct inode *h_dir; ++ struct au_branch *br; ++ struct au_hinode *hdir; ++ ++ /* rmdir by nfsd may cause deadlock with this i_mutex */ ++ /* mutex_lock(&a->dir->i_mutex); */ ++ sb = a->dir->i_sb; ++ si_noflush_read_lock(sb); ++ err = au_test_ro(sb, a->bindex, NULL); ++ if (unlikely(err)) ++ goto out; ++ ++ err = -EIO; ++ br = au_sbr(sb, a->bindex); ++ ii_write_lock_parent(a->dir); ++ h_parent = dget_parent(a->wh_dentry); ++ h_dir = h_parent->d_inode; ++ hdir = au_hi(a->dir, a->bindex); ++ au_hin_imtx_lock_nested(hdir, AuLsc_I_PARENT); ++ err = au_h_verify(a->wh_dentry, au_opt_udba(sb), h_dir, h_parent, br); ++ if (!err) { ++ err = mnt_want_write(br->br_mnt); ++ if (!err) { ++ err = au_whtmp_rmdir(a->dir, a->bindex, a->wh_dentry, ++ &a->whlist); ++ mnt_drop_write(br->br_mnt); ++ } ++ } ++ au_hin_imtx_unlock(hdir); ++ dput(h_parent); ++ ii_write_unlock(a->dir); ++ ++ out: ++ /* mutex_unlock(&a->dir->i_mutex); */ ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ si_read_unlock(sb); ++ au_whtmp_rmdir_free(a); ++ if (unlikely(err)) ++ AuIOErr("err %d\n", err); ++} ++ ++void au_whtmp_kick_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_whtmp_rmdir *args) ++{ ++ int wkq_err; ++ ++ IMustLock(dir); ++ ++ /* all post-process will be done in do_rmdir_whtmp(). */ ++ args->dir = au_igrab(dir); ++ args->bindex = bindex; ++ args->wh_dentry = dget(wh_dentry); ++ wkq_err = au_wkq_nowait(call_rmdir_whtmp, args, dir->i_sb); ++ if (unlikely(wkq_err)) { ++ AuWarn("rmdir error %.*s (%d), ignored\n", ++ AuDLNPair(wh_dentry), wkq_err); ++ au_whtmp_rmdir_free(args); ++ } ++} +diff -Naur a/fs/aufs/whout.h b/fs/aufs/whout.h +--- a/fs/aufs/whout.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/whout.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,87 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * whiteout for logical deletion and opaque directory ++ */ ++ ++#ifndef __AUFS_WHOUT_H__ ++#define __AUFS_WHOUT_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/aufs_type.h> ++#include "dir.h" ++ ++/* whout.c */ ++int au_wh_name_alloc(struct qstr *wh, const struct qstr *name); ++struct au_branch; ++int au_wh_test(struct dentry *h_parent, struct qstr *wh_name, ++ struct au_branch *br, int try_sio); ++int au_diropq_test(struct dentry *h_dentry, struct au_branch *br); ++struct dentry *au_whtmp_lkup(struct dentry *h_parent, struct au_branch *br, ++ struct qstr *prefix); ++int au_whtmp_ren(struct dentry *h_dentry, struct au_branch *br); ++int au_wh_unlink_dentry(struct inode *h_dir, struct path *h_path, ++ struct dentry *dentry); ++int au_wh_init(struct dentry *h_parent, struct au_branch *br, ++ struct super_block *sb); ++ ++/* diropq flags */ ++#define AuDiropq_CREATE 1 ++#define au_ftest_diropq(flags, name) ((flags) & AuDiropq_##name) ++#define au_fset_diropq(flags, name) { (flags) |= AuDiropq_##name; } ++#define au_fclr_diropq(flags, name) { (flags) &= ~AuDiropq_##name; } ++ ++struct dentry *au_diropq_sio(struct dentry *dentry, aufs_bindex_t bindex, ++ unsigned int flags); ++struct dentry *au_wh_lkup(struct dentry *h_parent, struct qstr *base_name, ++ struct au_branch *br); ++struct dentry *au_wh_create(struct dentry *dentry, aufs_bindex_t bindex, ++ struct dentry *h_parent); ++ ++/* real rmdir for the whiteout-ed dir */ ++struct au_whtmp_rmdir { ++ struct inode *dir; ++ aufs_bindex_t bindex; ++ struct dentry *wh_dentry; ++ struct au_nhash whlist; ++}; ++ ++struct au_whtmp_rmdir *au_whtmp_rmdir_alloc(struct super_block *sb, gfp_t gfp); ++void au_whtmp_rmdir_free(struct au_whtmp_rmdir *whtmp); ++int au_whtmp_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_nhash *whlist); ++void au_whtmp_kick_rmdir(struct inode *dir, aufs_bindex_t bindex, ++ struct dentry *wh_dentry, struct au_whtmp_rmdir *args); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline struct dentry *au_diropq_create(struct dentry *dentry, ++ aufs_bindex_t bindex) ++{ ++ return au_diropq_sio(dentry, bindex, AuDiropq_CREATE); ++} ++ ++static inline int au_diropq_remove(struct dentry *dentry, aufs_bindex_t bindex) ++{ ++ return PTR_ERR(au_diropq_sio(dentry, bindex, !AuDiropq_CREATE)); ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_WHOUT_H__ */ +diff -Naur a/fs/aufs/wkq.c b/fs/aufs/wkq.c +--- a/fs/aufs/wkq.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/wkq.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,259 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * workqueue for asynchronous/super-io operations ++ * todo: try new dredential scheme ++ */ ++ ++#include <linux/module.h> ++#include "aufs.h" ++ ++/* internal workqueue named AUFS_WKQ_NAME */ ++static struct au_wkq { ++ struct workqueue_struct *q; ++ ++ /* balancing */ ++ atomic_t busy; ++} *au_wkq; ++ ++struct au_wkinfo { ++ struct work_struct wk; ++ struct super_block *sb; ++ ++ unsigned int flags; /* see wkq.h */ ++ ++ au_wkq_func_t func; ++ void *args; ++ ++ atomic_t *busyp; ++ struct completion *comp; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int enqueue(struct au_wkq *wkq, struct au_wkinfo *wkinfo) ++{ ++ wkinfo->busyp = &wkq->busy; ++ if (au_ftest_wkq(wkinfo->flags, WAIT)) ++ return !queue_work(wkq->q, &wkinfo->wk); ++ else ++ return !schedule_work(&wkinfo->wk); ++} ++ ++static void do_wkq(struct au_wkinfo *wkinfo) ++{ ++ unsigned int idle, n; ++ int i, idle_idx; ++ ++ while (1) { ++ if (au_ftest_wkq(wkinfo->flags, WAIT)) { ++ idle_idx = 0; ++ idle = UINT_MAX; ++ for (i = 0; i < aufs_nwkq; i++) { ++ n = atomic_inc_return(&au_wkq[i].busy); ++ if (n == 1 && !enqueue(au_wkq + i, wkinfo)) ++ return; /* success */ ++ ++ if (n < idle) { ++ idle_idx = i; ++ idle = n; ++ } ++ atomic_dec(&au_wkq[i].busy); ++ } ++ } else ++ idle_idx = aufs_nwkq; ++ ++ atomic_inc(&au_wkq[idle_idx].busy); ++ if (!enqueue(au_wkq + idle_idx, wkinfo)) ++ return; /* success */ ++ ++ /* impossible? */ ++ AuWarn1("failed to queue_work()\n"); ++ yield(); ++ } ++} ++ ++static void wkq_func(struct work_struct *wk) ++{ ++ struct au_wkinfo *wkinfo = container_of(wk, struct au_wkinfo, wk); ++ ++ wkinfo->func(wkinfo->args); ++ atomic_dec(wkinfo->busyp); ++ if (au_ftest_wkq(wkinfo->flags, WAIT)) ++ complete(wkinfo->comp); ++ else { ++ kobject_put(&au_sbi(wkinfo->sb)->si_kobj); ++ module_put(THIS_MODULE); ++ kfree(wkinfo); ++ } ++} ++ ++/* ++ * Since struct completion is large, try allocating it dynamically. ++ */ ++#if defined(CONFIG_4KSTACKS) || defined(AuTest4KSTACKS) ++#define AuWkqCompDeclare(name) struct completion *comp = NULL ++ ++static int au_wkq_comp_alloc(struct au_wkinfo *wkinfo, struct completion **comp) ++{ ++ *comp = kmalloc(sizeof(**comp), GFP_NOFS); ++ if (*comp) { ++ init_completion(*comp); ++ wkinfo->comp = *comp; ++ return 0; ++ } ++ return -ENOMEM; ++} ++ ++static void au_wkq_comp_free(struct completion *comp) ++{ ++ kfree(comp); ++} ++ ++#else ++ ++/* no braces */ ++#define AuWkqCompDeclare(name) \ ++ DECLARE_COMPLETION_ONSTACK(_ ## name); \ ++ struct completion *comp = &_ ## name ++ ++static int au_wkq_comp_alloc(struct au_wkinfo *wkinfo, struct completion **comp) ++{ ++ wkinfo->comp = *comp; ++ return 0; ++} ++ ++static void au_wkq_comp_free(struct completion *comp __maybe_unused) ++{ ++ /* empty */ ++} ++#endif /* 4KSTACKS */ ++ ++static void au_wkq_run(struct au_wkinfo *wkinfo) ++{ ++ au_dbg_verify_kthread(); ++ INIT_WORK(&wkinfo->wk, wkq_func); ++ do_wkq(wkinfo); ++} ++ ++int au_wkq_wait(au_wkq_func_t func, void *args) ++{ ++ int err; ++ AuWkqCompDeclare(comp); ++ struct au_wkinfo wkinfo = { ++ .flags = AuWkq_WAIT, ++ .func = func, ++ .args = args ++ }; ++ ++ err = au_wkq_comp_alloc(&wkinfo, &comp); ++ if (!err) { ++ au_wkq_run(&wkinfo); ++ /* no timeout, no interrupt */ ++ wait_for_completion(wkinfo.comp); ++ au_wkq_comp_free(comp); ++ } ++ ++ return err; ++ ++} ++ ++int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb) ++{ ++ int err; ++ struct au_wkinfo *wkinfo; ++ ++ atomic_inc(&au_sbi(sb)->si_nowait.nw_len); ++ ++ /* ++ * wkq_func() must free this wkinfo. ++ * it highly depends upon the implementation of workqueue. ++ */ ++ err = 0; ++ wkinfo = kmalloc(sizeof(*wkinfo), GFP_NOFS); ++ if (wkinfo) { ++ wkinfo->sb = sb; ++ wkinfo->flags = !AuWkq_WAIT; ++ wkinfo->func = func; ++ wkinfo->args = args; ++ wkinfo->comp = NULL; ++ kobject_get(&au_sbi(sb)->si_kobj); ++ __module_get(THIS_MODULE); ++ ++ au_wkq_run(wkinfo); ++ } else { ++ err = -ENOMEM; ++ atomic_dec(&au_sbi(sb)->si_nowait.nw_len); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++void au_nwt_init(struct au_nowait_tasks *nwt) ++{ ++ atomic_set(&nwt->nw_len, 0); ++ /* smp_mb();*/ /* atomic_set */ ++ init_waitqueue_head(&nwt->nw_wq); ++} ++ ++void au_wkq_fin(void) ++{ ++ int i; ++ ++ for (i = 0; i < aufs_nwkq; i++) ++ if (au_wkq[i].q && !IS_ERR(au_wkq[i].q)) ++ destroy_workqueue(au_wkq[i].q); ++ kfree(au_wkq); ++} ++ ++int __init au_wkq_init(void) ++{ ++ int err, i; ++ struct au_wkq *nowaitq; ++ ++ /* '+1' is for accounting of nowait queue */ ++ err = -ENOMEM; ++ au_wkq = kcalloc(aufs_nwkq + 1, sizeof(*au_wkq), GFP_NOFS); ++ if (unlikely(!au_wkq)) ++ goto out; ++ ++ err = 0; ++ for (i = 0; i < aufs_nwkq; i++) { ++ au_wkq[i].q = create_singlethread_workqueue(AUFS_WKQ_NAME); ++ if (au_wkq[i].q && !IS_ERR(au_wkq[i].q)) { ++ atomic_set(&au_wkq[i].busy, 0); ++ continue; ++ } ++ ++ err = PTR_ERR(au_wkq[i].q); ++ au_wkq_fin(); ++ goto out; ++ } ++ ++ /* nowait accounting */ ++ nowaitq = au_wkq + aufs_nwkq; ++ atomic_set(&nowaitq->busy, 0); ++ nowaitq->q = NULL; ++ /* smp_mb(); */ /* atomic_set */ ++ ++ out: ++ return err; ++} +diff -Naur a/fs/aufs/wkq.h b/fs/aufs/wkq.h +--- a/fs/aufs/wkq.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/wkq.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,82 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * workqueue for asynchronous/super-io operations ++ * todo: try new credentials management scheme ++ */ ++ ++#ifndef __AUFS_WKQ_H__ ++#define __AUFS_WKQ_H__ ++ ++#ifdef __KERNEL__ ++ ++#include <linux/sched.h> ++#include <linux/wait.h> ++#include <linux/aufs_type.h> ++ ++struct super_block; ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * in the next operation, wait for the 'nowait' tasks in system-wide workqueue ++ */ ++struct au_nowait_tasks { ++ atomic_t nw_len; ++ wait_queue_head_t nw_wq; ++}; ++ ++/* ---------------------------------------------------------------------- */ ++ ++typedef void (*au_wkq_func_t)(void *args); ++ ++/* wkq flags */ ++#define AuWkq_WAIT 1 ++#define au_ftest_wkq(flags, name) ((flags) & AuWkq_##name) ++#define au_fset_wkq(flags, name) { (flags) |= AuWkq_##name; } ++#define au_fclr_wkq(flags, name) { (flags) &= ~AuWkq_##name; } ++ ++/* wkq.c */ ++int au_wkq_wait(au_wkq_func_t func, void *args); ++int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb); ++void au_nwt_init(struct au_nowait_tasks *nwt); ++int __init au_wkq_init(void); ++void au_wkq_fin(void); ++ ++/* ---------------------------------------------------------------------- */ ++ ++static inline int au_test_wkq(struct task_struct *tsk) ++{ ++ return !tsk->mm && !strcmp(tsk->comm, AUFS_WKQ_NAME); ++} ++ ++static inline void au_nwt_done(struct au_nowait_tasks *nwt) ++{ ++ if (!atomic_dec_return(&nwt->nw_len)) ++ wake_up_all(&nwt->nw_wq); ++} ++ ++static inline int au_nwt_flush(struct au_nowait_tasks *nwt) ++{ ++ wait_event(nwt->nw_wq, !atomic_read(&nwt->nw_len)); ++ return 0; ++} ++ ++#endif /* __KERNEL__ */ ++#endif /* __AUFS_WKQ_H__ */ +diff -Naur a/fs/aufs/xino.c b/fs/aufs/xino.c +--- a/fs/aufs/xino.c 1969-12-31 16:00:00.000000000 -0800 ++++ b/fs/aufs/xino.c 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,1191 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * external inode number translation table and bitmap ++ */ ++ ++#include <linux/file.h> ++#include <linux/seq_file.h> ++#include <linux/uaccess.h> ++#include "aufs.h" ++ ++ssize_t xino_fread(au_readf_t func, struct file *file, void *buf, size_t size, ++ loff_t *pos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ do { ++ /* todo: signal_pending? */ ++ err = func(file, (char __user *)buf, size, pos); ++ } while (err == -EAGAIN || err == -EINTR); ++ set_fs(oldfs); ++ ++#if 0 /* reserved for future use */ ++ if (err > 0) ++ fsnotify_access(file->f_dentry); ++#endif ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static ssize_t do_xino_fwrite(au_writef_t func, struct file *file, void *buf, ++ size_t size, loff_t *pos) ++{ ++ ssize_t err; ++ mm_segment_t oldfs; ++ ++ oldfs = get_fs(); ++ set_fs(KERNEL_DS); ++ lockdep_off(); ++ do { ++ /* todo: signal_pending? */ ++ err = func(file, (const char __user *)buf, size, pos); ++ } while (err == -EAGAIN || err == -EINTR); ++ lockdep_on(); ++ set_fs(oldfs); ++ ++#if 0 /* reserved for future use */ ++ if (err > 0) ++ fsnotify_modify(file->f_dentry); ++#endif ++ ++ return err; ++} ++ ++struct do_xino_fwrite_args { ++ ssize_t *errp; ++ au_writef_t func; ++ struct file *file; ++ void *buf; ++ size_t size; ++ loff_t *pos; ++}; ++ ++static void call_do_xino_fwrite(void *args) ++{ ++ struct do_xino_fwrite_args *a = args; ++ *a->errp = do_xino_fwrite(a->func, a->file, a->buf, a->size, a->pos); ++} ++ ++ssize_t xino_fwrite(au_writef_t func, struct file *file, void *buf, size_t size, ++ loff_t *pos) ++{ ++ ssize_t err; ++ ++ /* todo: signal block and no wkq? */ ++ /* todo: new credential scheme */ ++ /* ++ * it breaks RLIMIT_FSIZE and normal user's limit, ++ * users should care about quota and real 'filesystem full.' ++ */ ++ if (!au_test_wkq(current)) { ++ int wkq_err; ++ struct do_xino_fwrite_args args = { ++ .errp = &err, ++ .func = func, ++ .file = file, ++ .buf = buf, ++ .size = size, ++ .pos = pos ++ }; ++ ++ wkq_err = au_wkq_wait(call_do_xino_fwrite, &args); ++ if (unlikely(wkq_err)) ++ err = wkq_err; ++ } else ++ err = do_xino_fwrite(func, file, buf, size, pos); ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create a new xinofile at the same place/path as @base_file. ++ */ ++struct file *au_xino_create2(struct file *base_file, struct file *copy_src) ++{ ++ struct file *file; ++ struct dentry *base, *dentry, *parent; ++ struct inode *dir; ++ struct qstr *name; ++ int err; ++ ++ base = base_file->f_dentry; ++ parent = base->d_parent; /* dir inode is locked */ ++ dir = parent->d_inode; ++ IMustLock(dir); ++ ++ file = ERR_PTR(-EINVAL); ++ name = &base->d_name; ++ dentry = vfsub_lookup_one_len(name->name, parent, name->len); ++ if (IS_ERR(dentry)) { ++ file = (void *)dentry; ++ AuErr("%.*s lookup err %ld\n", AuLNPair(name), PTR_ERR(dentry)); ++ goto out; ++ } ++ ++ /* no need to mnt_want_write() since we call dentry_open() later */ ++ err = vfs_create(dir, dentry, S_IRUGO | S_IWUGO, NULL); ++ if (unlikely(err)) { ++ file = ERR_PTR(err); ++ AuErr("%.*s create err %d\n", AuLNPair(name), err); ++ goto out_dput; ++ } ++ ++ file = dentry_open(dget(dentry), mntget(base_file->f_vfsmnt), ++ O_RDWR | O_CREAT | O_EXCL | O_LARGEFILE, ++ current_cred()); ++ if (IS_ERR(file)) { ++ AuErr("%.*s open err %ld\n", AuLNPair(name), PTR_ERR(file)); ++ goto out_dput; ++ } ++ ++ err = vfsub_unlink(dir, &file->f_path, /*force*/0); ++ if (unlikely(err)) { ++ AuErr("%.*s unlink err %d\n", AuLNPair(name), err); ++ goto out_fput; ++ } ++ ++ if (copy_src) { ++ /* no one can touch copy_src xino */ ++ err = au_copy_file(file, copy_src, ++ i_size_read(copy_src->f_dentry->d_inode)); ++ if (unlikely(err)) { ++ AuErr("%.*s copy err %d\n", AuLNPair(name), err); ++ goto out_fput; ++ } ++ } ++ goto out_dput; /* success */ ++ ++ out_fput: ++ fput(file); ++ file = ERR_PTR(err); ++ out_dput: ++ dput(dentry); ++ out: ++ return file; ++} ++ ++struct au_xino_lock_dir { ++ struct au_hinode *hdir; ++ struct dentry *parent; ++ struct mutex *mtx; ++}; ++ ++static void au_xino_lock_dir(struct super_block *sb, struct file *xino, ++ struct au_xino_lock_dir *ldir) ++{ ++ aufs_bindex_t brid, bindex; ++ ++ ldir->hdir = NULL; ++ bindex = -1; ++ brid = au_xino_brid(sb); ++ if (brid >= 0) ++ bindex = au_br_index(sb, brid); ++ if (bindex >= 0) { ++ ldir->hdir = au_hi(sb->s_root->d_inode, bindex); ++ au_hin_imtx_lock_nested(ldir->hdir, AuLsc_I_PARENT); ++ } else { ++ ldir->parent = dget_parent(xino->f_dentry); ++ ldir->mtx = &ldir->parent->d_inode->i_mutex; ++ mutex_lock_nested(ldir->mtx, AuLsc_I_PARENT); ++ } ++} ++ ++static void au_xino_unlock_dir(struct au_xino_lock_dir *ldir) ++{ ++ if (ldir->hdir) ++ au_hin_imtx_unlock(ldir->hdir); ++ else { ++ mutex_unlock(ldir->mtx); ++ dput(ldir->parent); ++ } ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* trucate xino files asynchronously */ ++ ++int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex) ++{ ++ int err; ++ aufs_bindex_t bi, bend; ++ struct au_branch *br; ++ struct file *new_xino, *file; ++ struct super_block *h_sb; ++ struct au_xino_lock_dir ldir; ++ ++ err = -EINVAL; ++ bend = au_sbend(sb); ++ if (unlikely(bindex < 0 || bend < bindex)) ++ goto out; ++ br = au_sbr(sb, bindex); ++ file = br->br_xino.xi_file; ++ if (!file) ++ goto out; ++ ++ au_xino_lock_dir(sb, file, &ldir); ++ /* mnt_want_write() is unnecessary here */ ++ new_xino = au_xino_create2(file, file); ++ au_xino_unlock_dir(&ldir); ++ err = PTR_ERR(new_xino); ++ if (IS_ERR(new_xino)) ++ goto out; ++ err = 0; ++ fput(file); ++ br->br_xino.xi_file = new_xino; ++ ++ h_sb = br->br_mnt->mnt_sb; ++ for (bi = 0; bi <= bend; bi++) { ++ if (unlikely(bi == bindex)) ++ continue; ++ br = au_sbr(sb, bi); ++ if (br->br_mnt->mnt_sb != h_sb) ++ continue; ++ ++ fput(br->br_xino.xi_file); ++ br->br_xino.xi_file = new_xino; ++ get_file(new_xino); ++ } ++ ++ out: ++ return err; ++} ++ ++struct xino_do_trunc_args { ++ struct super_block *sb; ++ struct au_branch *br; ++}; ++ ++static void xino_do_trunc(void *_args) ++{ ++ struct xino_do_trunc_args *args = _args; ++ struct super_block *sb; ++ struct au_branch *br; ++ struct inode *dir; ++ int err; ++ aufs_bindex_t bindex; ++ ++ err = 0; ++ sb = args->sb; ++ dir = sb->s_root->d_inode; ++ br = args->br; ++ ++ si_noflush_write_lock(sb); ++ ii_read_lock_parent(dir); ++ bindex = au_br_index(sb, br->br_id); ++ err = au_xino_trunc(sb, bindex); ++ if (unlikely(err)) ++ goto out; ++ ++ if (br->br_xino.xi_file->f_dentry->d_inode->i_blocks ++ >= br->br_xino_upper) ++ br->br_xino_upper += AUFS_XINO_TRUNC_STEP; ++ ++ out: ++ ii_read_unlock(dir); ++ if (unlikely(err)) ++ AuWarn("err b%d, (%d)\n", bindex, err); ++ atomic_dec(&br->br_xino_running); ++ atomic_dec(&br->br_count); ++ au_nwt_done(&au_sbi(sb)->si_nowait); ++ si_write_unlock(sb); ++ kfree(args); ++} ++ ++static void xino_try_trunc(struct super_block *sb, struct au_branch *br) ++{ ++ struct xino_do_trunc_args *args; ++ int wkq_err; ++ ++ if (br->br_xino.xi_file->f_dentry->d_inode->i_blocks ++ < br->br_xino_upper) ++ return; ++ ++ if (atomic_inc_return(&br->br_xino_running) > 1) ++ goto out; ++ ++ /* lock and kfree() will be called in trunc_xino() */ ++ args = kmalloc(sizeof(*args), GFP_NOFS); ++ if (unlikely(!args)) { ++ AuErr1("no memory\n"); ++ goto out_args; ++ } ++ ++ atomic_inc(&br->br_count); ++ args->sb = sb; ++ args->br = br; ++ wkq_err = au_wkq_nowait(xino_do_trunc, args, sb); ++ if (!wkq_err) ++ return; /* success */ ++ ++ AuErr("wkq %d\n", wkq_err); ++ atomic_dec(&br->br_count); ++ ++ out_args: ++ kfree(args); ++ out: ++ atomic_dec(&br->br_xino_running); ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++static int au_xino_do_write(au_writef_t write, struct file *file, ++ ino_t h_ino, ino_t ino) ++{ ++ loff_t pos; ++ ssize_t sz; ++ ++ pos = h_ino; ++ if (unlikely(au_loff_max / sizeof(ino) - 1 < pos)) { ++ AuIOErr1("too large hi%lu\n", (unsigned long)h_ino); ++ return -EFBIG; ++ } ++ pos *= sizeof(ino); ++ sz = xino_fwrite(write, file, &ino, sizeof(ino), &pos); ++ if (sz == sizeof(ino)) ++ return 0; /* success */ ++ ++ AuIOErr("write failed (%zd)\n", sz); ++ return -EIO; ++} ++ ++/* ++ * write @ino to the xinofile for the specified branch{@sb, @bindex} ++ * at the position of @h_ino. ++ * even if @ino is zero, it is written to the xinofile and means no entry. ++ * if the size of the xino file on a specific filesystem exceeds the watermark, ++ * try truncating it. ++ */ ++int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino) ++{ ++ int err; ++ unsigned int mnt_flags; ++ struct au_branch *br; ++ ++ BUILD_BUG_ON(sizeof(long long) != sizeof(au_loff_max) ++ || ((loff_t)-1) > 0); ++ ++ mnt_flags = au_mntflags(sb); ++ if (!au_opt_test(mnt_flags, XINO)) ++ return 0; ++ ++ br = au_sbr(sb, bindex); ++ err = au_xino_do_write(au_sbi(sb)->si_xwrite, br->br_xino.xi_file, ++ h_ino, ino); ++ if (!err) { ++ if (au_opt_test(mnt_flags, TRUNC_XINO) ++ && au_test_fs_trunc_xino(br->br_mnt->mnt_sb)) ++ xino_try_trunc(sb, br); ++ return 0; /* success */ ++ } ++ ++ AuIOErr("write failed (%d)\n", err); ++ return -EIO; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* aufs inode number bitmap */ ++ ++static const int page_bits = (int)PAGE_SIZE * BITS_PER_BYTE; ++static ino_t xib_calc_ino(unsigned long pindex, int bit) ++{ ++ ino_t ino; ++ ++ AuDebugOn(bit < 0 || page_bits <= bit); ++ ino = AUFS_FIRST_INO + pindex * page_bits + bit; ++ return ino; ++} ++ ++static void xib_calc_bit(ino_t ino, unsigned long *pindex, int *bit) ++{ ++ AuDebugOn(ino < AUFS_FIRST_INO); ++ ino -= AUFS_FIRST_INO; ++ *pindex = ino / page_bits; ++ *bit = ino % page_bits; ++} ++ ++static int xib_pindex(struct super_block *sb, unsigned long pindex) ++{ ++ int err; ++ loff_t pos; ++ ssize_t sz; ++ struct au_sbinfo *sbinfo; ++ struct file *xib; ++ unsigned long *p; ++ ++ sbinfo = au_sbi(sb); ++ MtxMustLock(&sbinfo->si_xib_mtx); ++ AuDebugOn(pindex > ULONG_MAX / PAGE_SIZE ++ || !au_opt_test(sbinfo->si_mntflags, XINO)); ++ ++ if (pindex == sbinfo->si_xib_last_pindex) ++ return 0; ++ ++ xib = sbinfo->si_xib; ++ p = sbinfo->si_xib_buf; ++ pos = sbinfo->si_xib_last_pindex; ++ pos *= PAGE_SIZE; ++ sz = xino_fwrite(sbinfo->si_xwrite, xib, p, PAGE_SIZE, &pos); ++ if (unlikely(sz != PAGE_SIZE)) ++ goto out; ++ ++ pos = pindex; ++ pos *= PAGE_SIZE; ++ if (i_size_read(xib->f_dentry->d_inode) >= pos + PAGE_SIZE) ++ sz = xino_fread(sbinfo->si_xread, xib, p, PAGE_SIZE, &pos); ++ else { ++ memset(p, 0, PAGE_SIZE); ++ sz = xino_fwrite(sbinfo->si_xwrite, xib, p, PAGE_SIZE, &pos); ++ } ++ if (sz == PAGE_SIZE) { ++ sbinfo->si_xib_last_pindex = pindex; ++ return 0; /* success */ ++ } ++ ++ out: ++ AuIOErr1("write failed (%zd)\n", sz); ++ err = sz; ++ if (sz >= 0) ++ err = -EIO; ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_xino_write0(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t ino) ++{ ++ int err, bit; ++ unsigned long pindex; ++ struct au_sbinfo *sbinfo; ++ ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return 0; ++ ++ err = 0; ++ if (ino) { ++ sbinfo = au_sbi(sb); ++ xib_calc_bit(ino, &pindex, &bit); ++ AuDebugOn(page_bits <= bit); ++ mutex_lock(&sbinfo->si_xib_mtx); ++ err = xib_pindex(sb, pindex); ++ if (!err) { ++ clear_bit(bit, sbinfo->si_xib_buf); ++ sbinfo->si_xib_next_bit = bit; ++ } ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ } ++ ++ if (!err) ++ err = au_xino_write(sb, bindex, h_ino, 0); ++ return err; ++} ++ ++/* get an unused inode number from bitmap */ ++ino_t au_xino_new_ino(struct super_block *sb) ++{ ++ ino_t ino; ++ unsigned long *p, pindex, ul, pend; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ int free_bit, err; ++ ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return iunique(sb, AUFS_FIRST_INO); ++ ++ sbinfo = au_sbi(sb); ++ mutex_lock(&sbinfo->si_xib_mtx); ++ p = sbinfo->si_xib_buf; ++ free_bit = sbinfo->si_xib_next_bit; ++ if (free_bit < page_bits && !test_bit(free_bit, p)) ++ goto out; /* success */ ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ ++ pindex = sbinfo->si_xib_last_pindex; ++ for (ul = pindex - 1; ul < ULONG_MAX; ul--) { ++ err = xib_pindex(sb, ul); ++ if (unlikely(err)) ++ goto out_err; ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ } ++ ++ file = sbinfo->si_xib; ++ pend = i_size_read(file->f_dentry->d_inode) / PAGE_SIZE; ++ for (ul = pindex + 1; ul <= pend; ul++) { ++ err = xib_pindex(sb, ul); ++ if (unlikely(err)) ++ goto out_err; ++ free_bit = find_first_zero_bit(p, page_bits); ++ if (free_bit < page_bits) ++ goto out; /* success */ ++ } ++ BUG(); ++ ++ out: ++ set_bit(free_bit, p); ++ sbinfo->si_xib_next_bit++; ++ pindex = sbinfo->si_xib_last_pindex; ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ ino = xib_calc_ino(pindex, free_bit); ++ AuDbg("i%lu\n", (unsigned long)ino); ++ return ino; ++ out_err: ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ AuDbg("i0\n"); ++ return 0; ++} ++ ++/* ++ * read @ino from xinofile for the specified branch{@sb, @bindex} ++ * at the position of @h_ino. ++ * if @ino does not exist and @do_new is true, get new one. ++ */ ++int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino, ++ ino_t *ino) ++{ ++ int err; ++ ssize_t sz; ++ loff_t pos; ++ struct file *file; ++ struct au_sbinfo *sbinfo; ++ ++ *ino = 0; ++ if (!au_opt_test(au_mntflags(sb), XINO)) ++ return 0; /* no xino */ ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ pos = h_ino; ++ if (unlikely(au_loff_max / sizeof(*ino) - 1 < pos)) { ++ AuIOErr1("too large hi%lu\n", (unsigned long)h_ino); ++ return -EFBIG; ++ } ++ pos *= sizeof(*ino); ++ ++ file = au_sbr(sb, bindex)->br_xino.xi_file; ++ if (i_size_read(file->f_dentry->d_inode) < pos + sizeof(*ino)) ++ return 0; /* no ino */ ++ ++ sz = xino_fread(sbinfo->si_xread, file, ino, sizeof(*ino), &pos); ++ if (sz == sizeof(*ino)) ++ return 0; /* success */ ++ ++ err = sz; ++ if (unlikely(sz >= 0)) { ++ err = -EIO; ++ AuIOErr("xino read error (%zd)\n", sz); ++ } ++ ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* create and set a new xino file */ ++ ++struct file *au_xino_create(struct super_block *sb, char *fname, int silent) ++{ ++ struct file *file; ++ struct dentry *h_parent, *d; ++ struct inode *h_dir; ++ int err; ++ ++ /* ++ * at mount-time, and the xino file is the default path, ++ * hinotify is disabled so we have no inotify events to ignore. ++ * when a user specified the xino, we cannot get au_hdir to be ignored. ++ */ ++ file = vfsub_filp_open(fname, O_RDWR | O_CREAT | O_EXCL | O_LARGEFILE, ++ S_IRUGO | S_IWUGO); ++ if (IS_ERR(file)) { ++ if (!silent) ++ AuErr("open %s(%ld)\n", fname, PTR_ERR(file)); ++ return file; ++ } ++ ++ /* keep file count */ ++ h_parent = dget_parent(file->f_dentry); ++ h_dir = h_parent->d_inode; ++ mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_PARENT); ++ /* mnt_want_write() is unnecessary here */ ++ err = vfsub_unlink(h_dir, &file->f_path, /*force*/0); ++ mutex_unlock(&h_dir->i_mutex); ++ dput(h_parent); ++ if (unlikely(err)) { ++ if (!silent) ++ AuErr("unlink %s(%d)\n", fname, err); ++ goto out; ++ } ++ ++ err = -EINVAL; ++ d = file->f_dentry; ++ if (unlikely(sb == d->d_sb)) { ++ if (!silent) ++ AuErr("%s must be outside\n", fname); ++ goto out; ++ } ++ if (unlikely(au_test_fs_bad_xino(d->d_sb))) { ++ if (!silent) ++ AuErr("xino doesn't support %s(%s)\n", ++ fname, au_sbtype(d->d_sb)); ++ goto out; ++ } ++ return file; /* success */ ++ ++ out: ++ fput(file); ++ file = ERR_PTR(err); ++ return file; ++} ++ ++/* ++ * find another branch who is on the same filesystem of the specified ++ * branch{@btgt}. search until @bend. ++ */ ++static int is_sb_shared(struct super_block *sb, aufs_bindex_t btgt, ++ aufs_bindex_t bend) ++{ ++ aufs_bindex_t bindex; ++ struct super_block *tgt_sb = au_sbr_sb(sb, btgt); ++ ++ for (bindex = 0; bindex < btgt; bindex++) ++ if (unlikely(tgt_sb == au_sbr_sb(sb, bindex))) ++ return bindex; ++ for (bindex++; bindex <= bend; bindex++) ++ if (unlikely(tgt_sb == au_sbr_sb(sb, bindex))) ++ return bindex; ++ return -1; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * initialize the xinofile for the specified branch @br ++ * at the place/path where @base_file indicates. ++ * test whether another branch is on the same filesystem or not, ++ * if @do_test is true. ++ */ ++int au_xino_br(struct super_block *sb, struct au_branch *br, ino_t h_ino, ++ struct file *base_file, int do_test) ++{ ++ int err; ++ ino_t ino; ++ aufs_bindex_t bend, bindex; ++ struct au_branch *shared_br, *b; ++ struct file *file; ++ struct super_block *tgt_sb; ++ ++ shared_br = NULL; ++ bend = au_sbend(sb); ++ if (do_test) { ++ tgt_sb = br->br_mnt->mnt_sb; ++ for (bindex = 0; bindex <= bend; bindex++) { ++ b = au_sbr(sb, bindex); ++ if (tgt_sb == b->br_mnt->mnt_sb) { ++ shared_br = b; ++ break; ++ } ++ } ++ } ++ ++ if (!shared_br || !shared_br->br_xino.xi_file) { ++ struct au_xino_lock_dir ldir; ++ ++ au_xino_lock_dir(sb, base_file, &ldir); ++ /* mnt_want_write() is unnecessary here */ ++ file = au_xino_create2(base_file, NULL); ++ au_xino_unlock_dir(&ldir); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ br->br_xino.xi_file = file; ++ } else { ++ br->br_xino.xi_file = shared_br->br_xino.xi_file; ++ get_file(br->br_xino.xi_file); ++ } ++ ++ ino = AUFS_ROOT_INO; ++ err = au_xino_do_write(au_sbi(sb)->si_xwrite, br->br_xino.xi_file, ++ h_ino, ino); ++ if (!err) ++ return 0; /* success */ ++ ++ ++ out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* trucate a xino bitmap file */ ++ ++/* todo: slow */ ++static int do_xib_restore(struct super_block *sb, struct file *file, void *page) ++{ ++ int err, bit; ++ ssize_t sz; ++ unsigned long pindex; ++ loff_t pos, pend; ++ struct au_sbinfo *sbinfo; ++ au_readf_t func; ++ ino_t *ino; ++ unsigned long *p; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ p = sbinfo->si_xib_buf; ++ func = sbinfo->si_xread; ++ pend = i_size_read(file->f_dentry->d_inode); ++ pos = 0; ++ while (pos < pend) { ++ sz = xino_fread(func, file, page, PAGE_SIZE, &pos); ++ err = sz; ++ if (unlikely(sz <= 0)) ++ goto out; ++ ++ err = 0; ++ for (ino = page; sz > 0; ino++, sz -= sizeof(ino)) { ++ if (unlikely(*ino < AUFS_FIRST_INO)) ++ continue; ++ ++ xib_calc_bit(*ino, &pindex, &bit); ++ AuDebugOn(page_bits <= bit); ++ err = xib_pindex(sb, pindex); ++ if (!err) ++ set_bit(bit, p); ++ else ++ goto out; ++ } ++ } ++ ++ out: ++ return err; ++} ++ ++static int xib_restore(struct super_block *sb) ++{ ++ int err; ++ aufs_bindex_t bindex, bend; ++ void *page; ++ ++ err = -ENOMEM; ++ page = (void *)__get_free_page(GFP_NOFS); ++ if (unlikely(!page)) ++ goto out; ++ ++ err = 0; ++ bend = au_sbend(sb); ++ for (bindex = 0; !err && bindex <= bend; bindex++) ++ if (!bindex || is_sb_shared(sb, bindex, bindex - 1) < 0) ++ err = do_xib_restore ++ (sb, au_sbr(sb, bindex)->br_xino.xi_file, page); ++ else ++ AuDbg("b%d\n", bindex); ++ free_page((unsigned long)page); ++ ++ out: ++ return err; ++} ++ ++int au_xib_trunc(struct super_block *sb) ++{ ++ int err; ++ ssize_t sz; ++ loff_t pos; ++ struct au_xino_lock_dir ldir; ++ struct au_sbinfo *sbinfo; ++ unsigned long *p; ++ struct file *file; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ if (!au_opt_test(sbinfo->si_mntflags, XINO)) ++ goto out; ++ ++ file = sbinfo->si_xib; ++ if (i_size_read(file->f_dentry->d_inode) <= PAGE_SIZE) ++ goto out; ++ ++ au_xino_lock_dir(sb, file, &ldir); ++ /* mnt_want_write() is unnecessary here */ ++ file = au_xino_create2(sbinfo->si_xib, NULL); ++ au_xino_unlock_dir(&ldir); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = file; ++ ++ p = sbinfo->si_xib_buf; ++ memset(p, 0, PAGE_SIZE); ++ pos = 0; ++ sz = xino_fwrite(sbinfo->si_xwrite, sbinfo->si_xib, p, PAGE_SIZE, &pos); ++ if (unlikely(sz != PAGE_SIZE)) { ++ err = sz; ++ AuIOErr("err %d\n", err); ++ if (sz >= 0) ++ err = -EIO; ++ goto out; ++ } ++ ++ mutex_lock(&sbinfo->si_xib_mtx); ++ /* mnt_want_write() is unnecessary here */ ++ err = xib_restore(sb); ++ mutex_unlock(&sbinfo->si_xib_mtx); ++ ++out: ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * xino mount option handlers ++ */ ++static au_readf_t find_readf(struct file *h_file) ++{ ++ const struct file_operations *fop = h_file->f_op; ++ ++ if (fop) { ++ if (fop->read) ++ return fop->read; ++ if (fop->aio_read) ++ return do_sync_read; ++ } ++ return ERR_PTR(-ENOSYS); ++} ++ ++static au_writef_t find_writef(struct file *h_file) ++{ ++ const struct file_operations *fop = h_file->f_op; ++ ++ if (fop) { ++ if (fop->write) ++ return fop->write; ++ if (fop->aio_write) ++ return do_sync_write; ++ } ++ return ERR_PTR(-ENOSYS); ++} ++ ++/* xino bitmap */ ++static void xino_clear_xib(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ sbinfo = au_sbi(sb); ++ sbinfo->si_xread = NULL; ++ sbinfo->si_xwrite = NULL; ++ if (sbinfo->si_xib) ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = NULL; ++ free_page((unsigned long)sbinfo->si_xib_buf); ++ sbinfo->si_xib_buf = NULL; ++} ++ ++static int au_xino_set_xib(struct super_block *sb, struct file *base) ++{ ++ int err; ++ loff_t pos; ++ struct au_sbinfo *sbinfo; ++ struct file *file; ++ ++ sbinfo = au_sbi(sb); ++ file = au_xino_create2(base, sbinfo->si_xib); ++ err = PTR_ERR(file); ++ if (IS_ERR(file)) ++ goto out; ++ if (sbinfo->si_xib) ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = file; ++ sbinfo->si_xread = find_readf(file); ++ sbinfo->si_xwrite = find_writef(file); ++ ++ err = -ENOMEM; ++ if (!sbinfo->si_xib_buf) ++ sbinfo->si_xib_buf = (void *)get_zeroed_page(GFP_NOFS); ++ if (unlikely(!sbinfo->si_xib_buf)) ++ goto out_unset; ++ ++ sbinfo->si_xib_last_pindex = 0; ++ sbinfo->si_xib_next_bit = 0; ++ if (i_size_read(file->f_dentry->d_inode) < PAGE_SIZE) { ++ pos = 0; ++ err = xino_fwrite(sbinfo->si_xwrite, file, sbinfo->si_xib_buf, ++ PAGE_SIZE, &pos); ++ if (unlikely(err != PAGE_SIZE)) ++ goto out_free; ++ } ++ err = 0; ++ goto out; /* success */ ++ ++ out_free: ++ free_page((unsigned long)sbinfo->si_xib_buf); ++ sbinfo->si_xib_buf = NULL; ++ if (err >= 0) ++ err = -EIO; ++ out_unset: ++ fput(sbinfo->si_xib); ++ sbinfo->si_xib = NULL; ++ sbinfo->si_xread = NULL; ++ sbinfo->si_xwrite = NULL; ++ out: ++ return err; ++} ++ ++/* xino for each branch */ ++static void xino_clear_br(struct super_block *sb) ++{ ++ aufs_bindex_t bindex, bend; ++ struct au_branch *br; ++ ++ bend = au_sbend(sb); ++ for (bindex = 0; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (!br || !br->br_xino.xi_file) ++ continue; ++ ++ fput(br->br_xino.xi_file); ++ br->br_xino.xi_file = NULL; ++ } ++} ++ ++static int au_xino_set_br(struct super_block *sb, struct file *base) ++{ ++ int err; ++ ino_t ino; ++ aufs_bindex_t bindex, bend, bshared; ++ struct { ++ struct file *old, *new; ++ } *fpair, *p; ++ struct au_branch *br; ++ struct inode *inode; ++ au_writef_t writef; ++ ++ err = -ENOMEM; ++ bend = au_sbend(sb); ++ fpair = kcalloc(bend + 1, sizeof(*fpair), GFP_NOFS); ++ if (unlikely(!fpair)) ++ goto out; ++ ++ inode = sb->s_root->d_inode; ++ ino = AUFS_ROOT_INO; ++ writef = au_sbi(sb)->si_xwrite; ++ for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++) { ++ br = au_sbr(sb, bindex); ++ bshared = is_sb_shared(sb, bindex, bindex - 1); ++ if (bshared >= 0) { ++ /* shared xino */ ++ *p = fpair[bshared]; ++ get_file(p->new); ++ } ++ ++ if (!p->new) { ++ /* new xino */ ++ p->old = br->br_xino.xi_file; ++ p->new = au_xino_create2(base, br->br_xino.xi_file); ++ err = PTR_ERR(p->new); ++ if (IS_ERR(p->new)) { ++ p->new = NULL; ++ goto out_pair; ++ } ++ } ++ ++ err = au_xino_do_write(writef, p->new, ++ au_h_iptr(inode, bindex)->i_ino, ino); ++ if (unlikely(err)) ++ goto out_pair; ++ } ++ ++ for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++) { ++ br = au_sbr(sb, bindex); ++ if (br->br_xino.xi_file) ++ fput(br->br_xino.xi_file); ++ get_file(p->new); ++ br->br_xino.xi_file = p->new; ++ } ++ ++ out_pair: ++ for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++) ++ if (p->new) ++ fput(p->new); ++ else ++ break; ++ kfree(fpair); ++ out: ++ return err; ++} ++ ++void au_xino_clr(struct super_block *sb) ++{ ++ struct au_sbinfo *sbinfo; ++ ++ au_xigen_clr(sb); ++ xino_clear_xib(sb); ++ xino_clear_br(sb); ++ sbinfo = au_sbi(sb); ++ /* lvalue, do not call au_mntflags() */ ++ au_opt_clr(sbinfo->si_mntflags, XINO); ++} ++ ++int au_xino_set(struct super_block *sb, struct au_opt_xino *xino, int remount) ++{ ++ int err, skip; ++ struct dentry *parent, *cur_parent; ++ struct qstr *dname, *cur_name; ++ struct file *cur_xino; ++ struct inode *dir; ++ struct au_sbinfo *sbinfo; ++ ++ err = 0; ++ sbinfo = au_sbi(sb); ++ parent = dget_parent(xino->file->f_dentry); ++ if (remount) { ++ skip = 0; ++ dname = &xino->file->f_dentry->d_name; ++ cur_xino = sbinfo->si_xib; ++ if (cur_xino) { ++ cur_parent = dget_parent(cur_xino->f_dentry); ++ cur_name = &cur_xino->f_dentry->d_name; ++ skip = (cur_parent == parent ++ && dname->len == cur_name->len ++ && !memcmp(dname->name, cur_name->name, ++ dname->len)); ++ dput(cur_parent); ++ } ++ if (skip) ++ goto out; ++ } ++ ++ au_opt_set(sbinfo->si_mntflags, XINO); ++ dir = parent->d_inode; ++ mutex_lock_nested(&dir->i_mutex, AuLsc_I_PARENT); ++ /* mnt_want_write() is unnecessary here */ ++ err = au_xino_set_xib(sb, xino->file); ++ if (!err) ++ err = au_xigen_set(sb, xino->file); ++ if (!err) ++ err = au_xino_set_br(sb, xino->file); ++ mutex_unlock(&dir->i_mutex); ++ if (!err) ++ goto out; /* success */ ++ ++ /* reset all */ ++ AuIOErr("failed creating xino(%d).\n", err); ++ ++ out: ++ dput(parent); ++ return err; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ++ * create a xinofile at the default place/path. ++ */ ++struct file *au_xino_def(struct super_block *sb) ++{ ++ struct file *file; ++ char *page, *p; ++ struct au_branch *br; ++ struct super_block *h_sb; ++ struct path path; ++ aufs_bindex_t bend, bindex, bwr; ++ ++ br = NULL; ++ bend = au_sbend(sb); ++ bwr = -1; ++ for (bindex = 0; bindex <= bend; bindex++) { ++ br = au_sbr(sb, bindex); ++ if (au_br_writable(br->br_perm) ++ && !au_test_fs_bad_xino(br->br_mnt->mnt_sb)) { ++ bwr = bindex; ++ break; ++ } ++ } ++ ++ if (bwr >= 0) { ++ file = ERR_PTR(-ENOMEM); ++ page = __getname(); ++ if (unlikely(!page)) ++ goto out; ++ path.mnt = br->br_mnt; ++ path.dentry = au_h_dptr(sb->s_root, bwr); ++ p = d_path(&path, page, PATH_MAX - sizeof(AUFS_XINO_FNAME)); ++ file = (void *)p; ++ if (!IS_ERR(p)) { ++ strcat(p, "/" AUFS_XINO_FNAME); ++ AuDbg("%s\n", p); ++ file = au_xino_create(sb, p, /*silent*/0); ++ if (!IS_ERR(file)) ++ au_xino_brid_set(sb, br->br_id); ++ } ++ __putname(page); ++ } else { ++ file = au_xino_create(sb, AUFS_XINO_DEFPATH, /*silent*/0); ++ if (IS_ERR(file)) ++ goto out; ++ h_sb = file->f_dentry->d_sb; ++ if (unlikely(au_test_fs_bad_xino(h_sb))) { ++ AuErr("xino doesn't support %s(%s)\n", ++ AUFS_XINO_DEFPATH, au_sbtype(h_sb)); ++ fput(file); ++ file = ERR_PTR(-EINVAL); ++ } ++ if (!IS_ERR(file)) ++ au_xino_brid_set(sb, -1); ++ } ++ ++ out: ++ return file; ++} ++ ++/* ---------------------------------------------------------------------- */ ++ ++int au_xino_path(struct seq_file *seq, struct file *file) ++{ ++ int err; ++ ++ err = au_seq_path(seq, &file->f_path); ++ if (unlikely(err < 0)) ++ goto out; ++ ++ err = 0; ++#define Deleted "\\040(deleted)" ++ seq->count -= sizeof(Deleted) - 1; ++ AuDebugOn(memcmp(seq->buf + seq->count, Deleted, ++ sizeof(Deleted) - 1)); ++#undef Deleted ++ ++ out: ++ return err; ++} +diff -Naur a/include/linux/aufs_type.h b/include/linux/aufs_type.h +--- a/include/linux/aufs_type.h 1969-12-31 16:00:00.000000000 -0800 ++++ b/include/linux/aufs_type.h 2009-06-22 23:36:25.000000000 -0700 +@@ -0,0 +1,109 @@ ++/* ++ * Copyright (C) 2005-2009 Junjiro R. Okajima ++ * ++ * This program, aufs is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef __AUFS_TYPE_H__ ++#define __AUFS_TYPE_H__ ++ ++#include <linux/ioctl.h> ++ ++#define AUFS_VERSION "2-standalone.tree-29-20090622" ++ ++/* todo? move this to linux-2.6.19/include/magic.h */ ++#define AUFS_SUPER_MAGIC ('a' << 24 | 'u' << 16 | 'f' << 8 | 's') ++ ++/* ---------------------------------------------------------------------- */ ++ ++#ifdef CONFIG_AUFS_BRANCH_MAX_127 ++/* some environments treat 'char' as 'unsigned char' by default */ ++typedef signed char aufs_bindex_t; ++#define AUFS_BRANCH_MAX 127 ++#else ++typedef short aufs_bindex_t; ++#ifdef CONFIG_AUFS_BRANCH_MAX_511 ++#define AUFS_BRANCH_MAX 511 ++#elif defined(CONFIG_AUFS_BRANCH_MAX_1023) ++#define AUFS_BRANCH_MAX 1023 ++#elif defined(CONFIG_AUFS_BRANCH_MAX_32767) ++#define AUFS_BRANCH_MAX 32767 ++#endif ++#endif ++ ++#ifdef __KERNEL__ ++#ifndef AUFS_BRANCH_MAX ++#error unknown CONFIG_AUFS_BRANCH_MAX value ++#endif ++#endif /* __KERNEL__ */ ++ ++/* ---------------------------------------------------------------------- */ ++ ++#define AUFS_NAME "aufs" ++#define AUFS_FSTYPE AUFS_NAME ++ ++#define AUFS_ROOT_INO 2 ++#define AUFS_FIRST_INO 11 ++ ++#define AUFS_WH_PFX ".wh." ++#define AUFS_WH_PFX_LEN ((int)sizeof(AUFS_WH_PFX) - 1) ++#define AUFS_XINO_FNAME "." AUFS_NAME ".xino" ++#define AUFS_XINO_DEFPATH "/tmp/" AUFS_XINO_FNAME ++#define AUFS_XINO_TRUNC_INIT 64 /* blocks */ ++#define AUFS_XINO_TRUNC_STEP 4 /* blocks */ ++#define AUFS_DIRWH_DEF 3 ++#define AUFS_RDCACHE_DEF 10 /* seconds */ ++#define AUFS_RDBLK_DEF 512 /* bytes */ ++#define AUFS_RDHASH_DEF 32 ++#define AUFS_WKQ_NAME AUFS_NAME "d" ++#define AUFS_NWKQ_DEF 4 ++#define AUFS_MFS_SECOND_DEF 30 /* seconds */ ++#define AUFS_PLINK_WARN 100 /* number of plinks */ ++ ++#define AUFS_DIROPQ_NAME AUFS_WH_PFX ".opq" /* whiteouted doubly */ ++#define AUFS_WH_DIROPQ AUFS_WH_PFX AUFS_DIROPQ_NAME ++ ++#define AUFS_BASE_NAME AUFS_WH_PFX AUFS_NAME ++#define AUFS_PLINKDIR_NAME AUFS_WH_PFX "plnk" ++#define AUFS_ORPHDIR_NAME AUFS_WH_PFX "orph" ++ ++/* doubly whiteouted */ ++#define AUFS_WH_BASE AUFS_WH_PFX AUFS_BASE_NAME ++#define AUFS_WH_PLINKDIR AUFS_WH_PFX AUFS_PLINKDIR_NAME ++#define AUFS_WH_ORPHDIR AUFS_WH_PFX AUFS_ORPHDIR_NAME ++ ++/* branch permission */ ++#define AUFS_BRPERM_RW "rw" ++#define AUFS_BRPERM_RO "ro" ++#define AUFS_BRPERM_RR "rr" ++#define AUFS_BRPERM_WH "wh" ++#define AUFS_BRPERM_NLWH "nolwh" ++#define AUFS_BRPERM_ROWH AUFS_BRPERM_RO "+" AUFS_BRPERM_WH ++#define AUFS_BRPERM_RRWH AUFS_BRPERM_RR "+" AUFS_BRPERM_WH ++#define AUFS_BRPERM_RWNLWH AUFS_BRPERM_RW "+" AUFS_BRPERM_NLWH ++ ++/* ---------------------------------------------------------------------- */ ++ ++/* ioctl */ ++enum { ++ AuCtl_PLINK_MAINT, ++ AuCtl_PLINK_CLEAN ++}; ++ ++#define AuCtlType 'A' ++#define AUFS_CTL_PLINK_MAINT _IO(AuCtlType, AuCtl_PLINK_MAINT) ++#define AUFS_CTL_PLINK_CLEAN _IO(AuCtlType, AuCtl_PLINK_CLEAN) ++ ++#endif /* __AUFS_TYPE_H__ */ diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-squashfs-mount-to-avoid-initramfs.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-squashfs-mount-to-avoid-initramfs.patch new file mode 100644 index 0000000000..9a9b982fef --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/aufs-squashfs-mount-to-avoid-initramfs.patch @@ -0,0 +1,40 @@ +--- linux-omap-2.6/init/do_mounts.c 2008-11-23 01:22:52.000000000 -0800 ++++ linux-omap-2.6/init/do_mounts.c 2008-11-23 02:17:58.000000000 -0800 +@@ -325,6 +325,37 @@ + + void __init mount_root(void) + { ++ int do_special = 0; ++ if (strcmp(root_device_name, "special") == 0) ++ do_special = 1; ++ //do_special = 1; ++ ++ if (do_special) { ++ dev_t ROOT_DEV_RO; ++ dev_t ROOT_DEV_RW; ++ ++ sys_mkdir("/root-ro", 0700); ++ ROOT_DEV_RO = name_to_dev_t("/dev/mtd4"); ++ create_dev("/dev/root-ro", ROOT_DEV_RO); ++ if (sys_mount("/dev/root-ro", "/root-ro", "squashfs", MS_RDONLY | MS_SILENT, NULL) != 0) { ++ ROOT_DEV_RO = name_to_dev_t("/dev/mmcblk0p2"); ++ create_dev("/dev/root-ro2", ROOT_DEV_RO); ++ if (sys_mount("/dev/root-ro2", "/root-ro", "squashfs", MS_RDONLY | MS_SILENT, NULL) != 0) ++ goto no_special; ++ } ++ ++ sys_mkdir("/root-rw", 0700); ++ ROOT_DEV_RW = name_to_dev_t("/dev/mmcblk0p3"); ++ create_dev("/dev/root-rw", ROOT_DEV_RW); ++ if (sys_mount("/dev/root-rw", "/root-rw", "ext3", MS_SILENT, NULL) != 0) ++ goto no_special; ++ sys_mount("none", "/root", "aufs", 0, "br:/root-rw:/root-ro=ro"); ++ sys_chdir("/root"); ++ return; ++ } ++ ++no_special: ++ + #ifdef CONFIG_ROOT_NFS + if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) { + if (mount_nfs_root()) diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-1.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-1.patch new file mode 100644 index 0000000000..035627ac79 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-1.patch @@ -0,0 +1,221 @@ +From 1b3e7e2e095648f244a08b1459ff035bbdc99942 Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Tue, 5 May 2009 23:33:00 -0700 +Subject: [PATCH] TWL BCI: Make charge current controllable and backup battery optional. + +This patch makes the charging current controllable via sysfs and also +makes the backup battery optional. Also, if you don't care about the +temperature readings, you can opt-out from having to supply a +temperature lookup table. + +Signed-off-by: Tim Yamin <plasm@roo.me.uk> +--- + drivers/power/twl4030_bci_battery.c | 91 +++++++++++++++++++++++++++++------ + include/linux/i2c/twl4030.h | 2 + + 2 files changed, 78 insertions(+), 15 deletions(-) + +diff --git a/drivers/power/twl4030_bci_battery.c b/drivers/power/twl4030_bci_battery.c +index ddba62b..eab0933 100644 +--- a/drivers/power/twl4030_bci_battery.c ++++ b/drivers/power/twl4030_bci_battery.c +@@ -125,6 +125,14 @@ + /* BCIEDR3 */ + #define VBATLVL_EDRRISIN 0x02 + ++/* BCIIREF1 */ ++#define REG_BCIIREF1 0x027 ++#define REG_BCIIREF2 0x028 ++ ++/* Key */ ++#define KEY_IIREF 0xE7 ++#define REG_BCIMFKEY 0x011 ++ + /* Step size and prescaler ratio */ + #define TEMP_STEP_SIZE 147 + #define TEMP_PSR_R 100 +@@ -142,9 +150,6 @@ + #define ENABLE 1 + #define DISABLE 1 + +-/* Ptr to thermistor table */ +-int *therm_tbl; +- + struct twl4030_bci_device_info { + struct device *dev; + +@@ -160,6 +165,8 @@ struct twl4030_bci_device_info { + struct power_supply bk_bat; + struct delayed_work twl4030_bci_monitor_work; + struct delayed_work twl4030_bk_bci_monitor_work; ++ ++ struct twl4030_bci_platform_data *pdata; + }; + + static int usb_charger_flag; +@@ -518,11 +525,15 @@ int twl4030charger_usb_en(int enable) + * Return battery temperature + * Or < 0 on failure. + */ +-static int twl4030battery_temperature(void) ++static int twl4030battery_temperature(struct twl4030_bci_device_info *di) + { + u8 val; + int temp, curr, volt, res, ret; + ++ /* Is a temperature table specified? */ ++ if (!di->pdata->tblsize) ++ return 0; ++ + /* Getting and calculating the thermistor voltage */ + ret = read_bci_val(T2_BATTERY_TEMP); + if (ret < 0) +@@ -543,7 +554,7 @@ static int twl4030battery_temperature(void) + + /*calculating temperature*/ + for (temp = 58; temp >= 0; temp--) { +- int actual = therm_tbl[temp]; ++ int actual = di->pdata->battery_tmp_tbl[temp]; + if ((actual - res) >= 0) + break; + } +@@ -772,13 +783,14 @@ static void twl4030_bk_bci_battery_work(struct work_struct *work) + struct twl4030_bci_device_info, + twl4030_bk_bci_monitor_work.work); + +- twl4030_bk_bci_battery_read_status(di); ++ if(!di->pdata->no_backup_battery) ++ twl4030_bk_bci_battery_read_status(di); + schedule_delayed_work(&di->twl4030_bk_bci_monitor_work, 500); + } + + static void twl4030_bci_battery_read_status(struct twl4030_bci_device_info *di) + { +- di->temp_C = twl4030battery_temperature(); ++ di->temp_C = twl4030battery_temperature(di); + di->voltage_uV = twl4030battery_voltage(); + di->current_uA = twl4030battery_current(); + } +@@ -819,6 +831,43 @@ static void twl4030_bci_battery_external_power_changed(struct power_supply *psy) + #define to_twl4030_bk_bci_device_info(x) container_of((x), \ + struct twl4030_bci_device_info, bk_bat); + ++static ssize_t ++show_charge_current(struct device *dev, struct device_attribute *attr, char *buf) ++{ ++ return sprintf(buf, "%d\n", read_bci_val(REG_BCIIREF1)); ++} ++ ++static ssize_t ++set_charge_current(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ++{ ++ unsigned long newCurrent; ++ int ret; ++ ++ ret = strict_strtoul(buf, 10, &newCurrent); ++ if (ret) ++ return -EINVAL; ++ ++ ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, KEY_IIREF, REG_BCIMFKEY); ++ if (ret) ++ return ret; ++ ++ ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, newCurrent & 0xff, REG_BCIIREF1); ++ if (ret) ++ return ret; ++ ++ ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, KEY_IIREF, REG_BCIMFKEY); ++ if (ret) ++ return ret; ++ ++ ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, (newCurrent >> 8) & 0x03, REG_BCIIREF2); ++ if (ret) ++ return ret; ++ ++ return count; ++} ++ ++static DEVICE_ATTR(charge_current, S_IRUGO | S_IWUGO, show_charge_current, set_charge_current); ++ + static int twl4030_bk_bci_battery_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +@@ -912,8 +961,6 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + int irq; + int ret; + +- therm_tbl = pdata->battery_tmp_tbl; +- + di = kzalloc(sizeof(*di), GFP_KERNEL); + if (!di) + return -ENOMEM; +@@ -937,6 +984,7 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + di->bk_bat.num_properties = ARRAY_SIZE(twl4030_bk_bci_battery_props); + di->bk_bat.get_property = twl4030_bk_bci_battery_get_property; + di->bk_bat.external_power_changed = NULL; ++ di->pdata = pdata; + + twl4030charger_ac_en(ENABLE); + twl4030charger_usb_en(ENABLE); +@@ -951,9 +999,12 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + goto temp_setup_fail; + + /* enabling GPCH09 for read back battery voltage */ +- ret = twl4030backupbatt_voltage_setup(); +- if (ret) +- goto voltage_setup_fail; ++ if(!di->pdata->no_backup_battery) ++ { ++ ret = twl4030backupbatt_voltage_setup(); ++ if (ret) ++ goto voltage_setup_fail; ++ } + + /* REVISIT do we need to request both IRQs ?? */ + +@@ -988,9 +1039,18 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + twl4030_bci_battery_work); + schedule_delayed_work(&di->twl4030_bci_monitor_work, 0); + +- ret = power_supply_register(&pdev->dev, &di->bk_bat); ++ if(!pdata->no_backup_battery) ++ { ++ ret = power_supply_register(&pdev->dev, &di->bk_bat); ++ if (ret) { ++ dev_dbg(&pdev->dev, "failed to register backup battery\n"); ++ goto bk_batt_failed; ++ } ++ } ++ ++ ret = device_create_file(di->bat.dev, &dev_attr_charge_current); + if (ret) { +- dev_dbg(&pdev->dev, "failed to register backup battery\n"); ++ dev_err(&pdev->dev, "failed to create sysfs entries\n"); + goto bk_batt_failed; + } + +@@ -1001,7 +1061,8 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + return 0; + + bk_batt_failed: +- power_supply_unregister(&di->bat); ++ if(!pdata->no_backup_battery) ++ power_supply_unregister(&di->bat); + batt_failed: + free_irq(irq, di); + chg_irq_fail: +diff --git a/include/linux/i2c/twl4030.h b/include/linux/i2c/twl4030.h +index 87accda..a188b6c 100644 +--- a/include/linux/i2c/twl4030.h ++++ b/include/linux/i2c/twl4030.h +@@ -299,6 +299,8 @@ int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes); + struct twl4030_bci_platform_data { + int *battery_tmp_tbl; + unsigned int tblsize; ++ ++ bool no_backup_battery; + }; + + /* TWL4030_GPIO_MAX (18) GPIOs, with interrupts */ +-- +1.5.6.3 + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-2.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-2.patch new file mode 100644 index 0000000000..ce5a98f69d --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery1-tps65950-charging-management-2.patch @@ -0,0 +1,246 @@ +diff --git a/drivers/power/twl4030_bci_battery.c b/drivers/power/twl4030_bci_battery.c +index eab0933..d1220d7 100644 +--- a/drivers/power/twl4030_bci_battery.c ++++ b/drivers/power/twl4030_bci_battery.c +@@ -15,6 +15,9 @@ + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + ++/* Boot with automatic charge */ ++#define CHARGE_MODE 1 ++ + #include <linux/init.h> + #include <linux/module.h> + #include <linux/device.h> +@@ -50,6 +53,7 @@ + /* Boot BCI flag bits */ + #define BCIAUTOWEN 0x020 + #define CONFIG_DONE 0x010 ++#define CVENAC 0x004 + #define BCIAUTOUSB 0x002 + #define BCIAUTOAC 0x001 + #define BCIMSTAT_MASK 0x03F +@@ -81,6 +85,11 @@ + #define REG_BB_CFG 0x012 + #define BBCHEN 0x010 + ++/* GPBR */ ++#define REG_GPBR1 0x0c ++#define MADC_HFCLK_EN 0x80 ++#define DEFAULT_MADC_CLK_EN 0x10 ++ + /* Power supply charge interrupt */ + #define REG_PWR_ISR1 0x00 + #define REG_PWR_IMR1 0x01 +@@ -129,8 +138,12 @@ + #define REG_BCIIREF1 0x027 + #define REG_BCIIREF2 0x028 + ++/* BCIMFTH1 */ ++#define REG_BCIMFTH1 0x016 ++ + /* Key */ + #define KEY_IIREF 0xE7 ++#define KEY_FTH1 0xD2 + #define REG_BCIMFKEY 0x011 + + /* Step size and prescaler ratio */ +@@ -432,15 +445,21 @@ static int twl4030battery_hw_presence_en(int enable) + /* + * Enable/Disable AC Charge funtionality. + */ +-static int twl4030charger_ac_en(int enable) ++static int twl4030charger_ac_en(int enable, int automatic) + { + int ret; + + if (enable) { + /* forcing the field BCIAUTOAC (BOOT_BCI[0) to 1 */ +- ret = clear_n_set(TWL4030_MODULE_PM_MASTER, 0, +- (CONFIG_DONE | BCIAUTOWEN | BCIAUTOAC), +- REG_BOOT_BCI); ++ if(!automatic) { ++ ret = clear_n_set(TWL4030_MODULE_PM_MASTER, BCIAUTOAC | CVENAC, ++ (CONFIG_DONE | BCIAUTOWEN), ++ REG_BOOT_BCI); ++ } else { ++ ret = clear_n_set(TWL4030_MODULE_PM_MASTER, 0, ++ (CONFIG_DONE | BCIAUTOWEN | BCIAUTOAC | CVENAC), ++ REG_BOOT_BCI); ++ } + if (ret) + return ret; + } else { +@@ -672,6 +691,9 @@ static int twl4030bci_status(void) + return ret; + } + ++#ifdef DEBUG ++ printk("BCI DEBUG: BCIMSTATEC Charge state is 0x%x\n", status); ++#endif + return (int) (status & BCIMSTAT_MASK); + } + +@@ -720,14 +742,43 @@ static int twl4030backupbatt_voltage_setup(void) + */ + static int twl4030battery_temp_setup(void) + { +- int ret; ++#ifdef DEBUG ++ u8 i; ++#endif ++ u8 ret; + + /* Enabling thermistor current */ +- ret = clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0, ITHEN, ++ ret = clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0, 0x1B, + REG_BCICTL1); + if (ret) + return ret; + ++#ifdef DEBUG ++ twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &ret, REG_BOOT_BCI); ++ printk("BCI DEBUG: BOOT_BCI Value is 0x%x\n", ret); ++ ++ twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &ret, REG_STS_HW_CONDITIONS); ++ printk("BCI DEBUG: STS_HW_CONDITIONS Value is 0x%x\n", ret); ++ ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ret, REG_BCICTL1); ++ printk("BCI DEBUG: BCICTL1 Value is 0x%x\n", ret); ++ ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ret, REG_BCICTL2); ++ printk("BCI DEBUG: BCICTL2 Value is 0x%x\n", ret); ++ ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ret, 0x0); ++ printk("BCI DEBUG: BCIMDEN Value is 0x%x\n", ret); ++ ++ twl4030_i2c_read_u8(TWL4030_MODULE_INTBR, &ret, REG_GPBR1); ++ printk("BCI DEBUG: GPBR1 Value is 0x%x\n", ret); ++ ++ for(i = 0x0; i <= 0x32; i++) ++ { ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ret, i); ++ printk("BCI DEBUG: BCI 0x%x Value is 0x%x\n", i, ret); ++ } ++#endif ++ + return 0; + } + +@@ -743,7 +794,6 @@ static inline int clear_n_set(u8 mod_no, u8 clear, u8 set, u8 reg) + ret = twl4030_i2c_read_u8(mod_no, &val, reg); + if (ret) + return ret; +- + /* Clearing all those bits to clear */ + val &= ~(clear); + +@@ -834,7 +884,19 @@ static void twl4030_bci_battery_external_power_changed(struct power_supply *psy) + static ssize_t + show_charge_current(struct device *dev, struct device_attribute *attr, char *buf) + { +- return sprintf(buf, "%d\n", read_bci_val(REG_BCIIREF1)); ++ u8 ctl; ++ int ret = read_bci_val(REG_BCIIREF1) & 0x1FF; ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ctl, REG_BCICTL1); ++ ++ if (ctl & CGAIN) ++ ret |= 0x200; ++ ++#ifdef DEBUG ++ /* Dump debug */ ++ twl4030battery_temp_setup(); ++#endif ++ ++ return sprintf(buf, "%d\n", ret); + } + + static ssize_t +@@ -859,13 +921,45 @@ set_charge_current(struct device *dev, struct device_attribute *attr, const char + if (ret) + return ret; + +- ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, (newCurrent >> 8) & 0x03, REG_BCIIREF2); ++ ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, (newCurrent >> 8) & 0x1, REG_BCIIREF2); + if (ret) + return ret; + ++ /* Set software-controlled charge */ ++ twl4030charger_ac_en(ENABLE, 0); ++ ++ /* Set CGAIN = 0 or 1 */ ++ if(newCurrent > 511) { ++ u8 tmp; ++ ++ /* Set CGAIN = 1 -- need to wait until automatic charge turns off */ ++ while(!ret) { ++ clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0, CGAIN | 0x1B, REG_BCICTL1); ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &tmp, REG_BCICTL1); ++ ++ ret = tmp & CGAIN; ++ if(!ret) ++ mdelay(50); ++ } ++ } else { ++ u8 tmp; ++ ++ /* Set CGAIN = 0 -- need to wait until automatic charge turns off */ ++ while(!ret) { ++ clear_n_set(TWL4030_MODULE_MAIN_CHARGE, CGAIN, 0x1B, REG_BCICTL1); ++ twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &tmp, REG_BCICTL1); ++ ++ ret = !(tmp & CGAIN); ++ if(!ret) ++ mdelay(50); ++ } ++ } ++ ++ /* Set automatic charge (CGAIN = 0/1 persists) */ ++ twl4030charger_ac_en(ENABLE, 1); ++ + return count; + } +- + static DEVICE_ATTR(charge_current, S_IRUGO | S_IWUGO, show_charge_current, set_charge_current); + + static int twl4030_bk_bci_battery_get_property(struct power_supply *psy, +@@ -986,7 +1080,10 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + di->bk_bat.external_power_changed = NULL; + di->pdata = pdata; + +- twl4030charger_ac_en(ENABLE); ++ /* Set up clocks */ ++ twl4030_i2c_write_u8(TWL4030_MODULE_INTBR, MADC_HFCLK_EN | DEFAULT_MADC_CLK_EN, REG_GPBR1); ++ ++ twl4030charger_ac_en(ENABLE, CHARGE_MODE); + twl4030charger_usb_en(ENABLE); + twl4030battery_hw_level_en(ENABLE); + twl4030battery_hw_presence_en(ENABLE); +@@ -1058,6 +1155,7 @@ static int __init twl4030_bci_battery_probe(struct platform_device *pdev) + twl4030_bk_bci_battery_work); + schedule_delayed_work(&di->twl4030_bk_bci_monitor_work, 500); + ++ set_charge_current (NULL, NULL, "1023", 4); + return 0; + + bk_batt_failed: +@@ -1071,7 +1169,7 @@ chg_irq_fail: + batt_irq_fail: + voltage_setup_fail: + temp_setup_fail: +- twl4030charger_ac_en(DISABLE); ++ twl4030charger_ac_en(DISABLE, CHARGE_MODE); + twl4030charger_usb_en(DISABLE); + twl4030battery_hw_level_en(DISABLE); + twl4030battery_hw_presence_en(DISABLE); +@@ -1085,7 +1183,7 @@ static int __exit twl4030_bci_battery_remove(struct platform_device *pdev) + struct twl4030_bci_device_info *di = platform_get_drvdata(pdev); + int irq; + +- twl4030charger_ac_en(DISABLE); ++ twl4030charger_ac_en(DISABLE, CHARGE_MODE); + twl4030charger_usb_en(DISABLE); + twl4030battery_hw_level_en(DISABLE); + twl4030battery_hw_presence_en(DISABLE); + + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-gpio-charged.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-gpio-charged.patch new file mode 100644 index 0000000000..fd629078ca --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-gpio-charged.patch @@ -0,0 +1,53 @@ +diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c +index bc6ef06..df7aa70 100644 +--- a/drivers/power/bq27x00_battery.c ++++ b/drivers/power/bq27x00_battery.c +@@ -28,6 +28,7 @@ + + #define DRIVER_VERSION "1.0.0" + ++#define BQ27x00_REG_MODE 0x00 + #define BQ27x00_REG_TEMP 0x06 + #define BQ27x00_REG_VOLT 0x08 + #define BQ27x00_REG_RSOC 0x0B /* Relative State-of-Charge */ +@@ -65,6 +66,7 @@ static enum power_supply_property bq27x00_battery_props[] = { + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CAPACITY, + POWER_SUPPLY_PROP_TEMP, ++ POWER_SUPPLY_PROP_ONLINE, + }; + + /* +@@ -83,6 +85,22 @@ static int bq27x00_read(u8 reg, int *rt_value, int b_single, + } + + /* ++ * Return the GPIO status (0 or 1) ++ * Or < 0 if something fails. ++ */ ++static int bq27x00_gpio(struct bq27x00_device_info *di) ++{ ++ int ret; ++ int gpio = 0; ++ ++ ret = bq27x00_read(BQ27x00_REG_MODE, &gpio, 0, di); ++ if (ret) ++ return ret; ++ ++ return (gpio & 0x40) >> 6; ++} ++ ++/* + * Return the battery temperature in Celcius degrees + * Or < 0 if something fails. + */ +@@ -184,6 +202,9 @@ static int bq27x00_battery_get_property(struct power_supply *psy, + case POWER_SUPPLY_PROP_TEMP: + val->intval = bq27x00_battery_temperature(di); + break; ++ case POWER_SUPPLY_PROP_ONLINE: ++ val->intval = bq27x00_gpio(di); ++ break; + default: + return -EINVAL; + } diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-no-error-message.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-no-error-message.patch new file mode 100644 index 0000000000..eb7c8c9699 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/battery2-bq27200-no-error-message.patch @@ -0,0 +1,39 @@ +--- a/drivers/power/bq27x00_battery.c ++++ b/drivers/power/bq27x00_battery.c +@@ -93,7 +93,6 @@ static int bq27x00_battery_temperature(struct bq27x00_device_info *di) + + ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di); + if (ret) { +- dev_err(di->dev, "error reading temperature\n"); + return ret; + } + +@@ -111,7 +110,6 @@ static int bq27x00_battery_voltage(struct bq27x00_device_info *di) + + ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di); + if (ret) { +- dev_err(di->dev, "error reading voltage\n"); + return ret; + } + +@@ -131,12 +129,10 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di) + + ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di); + if (ret) { +- dev_err(di->dev, "error reading current\n"); + return 0; + } + ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di); + if (ret < 0) { +- dev_err(di->dev, "error reading flags\n"); + return 0; + } + if ((flags & (1 << 7)) != 0) { +@@ -157,7 +153,6 @@ static int bq27x00_battery_rsoc(struct bq27x00_device_info *di) + + ret = bq27x00_read(BQ27x00_REG_RSOC, &rsoc, 1, di); + if (ret) { +- dev_err(di->dev, "error reading relative State-of-Charge\n"); + return ret; + } + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/beagle-asoc.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/beagle-asoc.patch new file mode 100644 index 0000000000..b2b920037e --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/beagle-asoc.patch @@ -0,0 +1,35 @@ +diff --git a/sound/soc/omap/Kconfig b/sound/soc/omap/Kconfig +index 4f7f040..ccd8973 100644 +--- a/sound/soc/omap/Kconfig ++++ b/sound/soc/omap/Kconfig +@@ -55,3 +55,13 @@ config SND_OMAP_SOC_OMAP3_PANDORA + select SND_SOC_TWL4030 + help + Say Y if you want to add support for SoC audio on the OMAP3 Pandora. ++ ++config SND_OMAP_SOC_OMAP3_BEAGLE ++ tristate "SoC Audio support for OMAP3 Beagle" ++ depends on TWL4030_CORE && SND_OMAP_SOC && MACH_OMAP3_BEAGLE ++ select SND_OMAP_SOC_MCBSP ++ select SND_SOC_TWL4030 ++ help ++ Say Y if you want to add support for SoC audio on the Beagleboard. ++ ++ +diff --git a/sound/soc/omap/Makefile b/sound/soc/omap/Makefile +index 76fedd9..0c9e4ac 100644 +--- a/sound/soc/omap/Makefile ++++ b/sound/soc/omap/Makefile +@@ -12,6 +12,7 @@ snd-soc-overo-objs := overo.o + snd-soc-omap2evm-objs := omap2evm.o + snd-soc-sdp3430-objs := sdp3430.o + snd-soc-omap3pandora-objs := omap3pandora.o ++snd-soc-omap3beagle-objs := omap3beagle.o + + obj-$(CONFIG_SND_OMAP_SOC_N810) += snd-soc-n810.o + obj-$(CONFIG_SND_OMAP_SOC_OSK5912) += snd-soc-osk5912.o +@@ -19,3 +20,4 @@ obj-$(CONFIG_SND_OMAP_SOC_OVERO) += snd-soc-overo.o + obj-$(CONFIG_MACH_OMAP2EVM) += snd-soc-omap2evm.o + obj-$(CONFIG_SND_OMAP_SOC_SDP3430) += snd-soc-sdp3430.o + obj-$(CONFIG_SND_OMAP_SOC_OMAP3_PANDORA) += snd-soc-omap3pandora.o ++obj-$(CONFIG_SND_OMAP_SOC_OMAP3_BEAGLE) += snd-soc-omap3beagle.o diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/board-omap3beagle.c b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/board-omap3beagle.c new file mode 100644 index 0000000000..c7867bef2f --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/board-omap3beagle.c @@ -0,0 +1,744 @@ +/* + * linux/arch/arm/mach-omap2/board-omap3beagle.c + * + * Copyright (C) 2008 Texas Instruments + * + * Modified from mach-omap2/board-3430sdp.c + * + * Initial code: Syed Mohammed Khasim + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <linux/err.h> +#include <linux/clk.h> +#include <linux/io.h> +#include <linux/leds.h> +#include <linux/gpio.h> +#include <linux/input.h> +#include <linux/gpio_keys.h> + +#include <linux/mtd/mtd.h> +#include <linux/mtd/partitions.h> +#include <linux/mtd/nand.h> + +#include <mach/mcspi.h> +#include <linux/spi/spi.h> +#include <linux/spi/ads7846.h> +#include <linux/mma7455l.h> + +#include <mach/dmtimer.h> +#include <linux/backlight.h> + +#include <linux/regulator/machine.h> +#include <linux/i2c/twl4030.h> +#include <linux/omapfb.h> + +#include <mach/hardware.h> +#include <asm/mach-types.h> +#include <asm/mach/arch.h> +#include <asm/mach/map.h> +#include <asm/mach/flash.h> + +#include <mach/board.h> +#include <mach/usb.h> +#include <mach/common.h> +#include <mach/gpmc.h> +#include <mach/nand.h> +#include <mach/mux.h> +#include <mach/omap-pm.h> +#include <mach/clock.h> +#include <mach/display.h> + +#include "twl4030-generic-scripts.h" +#include "mmc-twl4030.h" +#include "pm.h" +#include "omap3-opp.h" + + +#define GPMC_CS0_BASE 0x60 +#define GPMC_CS_SIZE 0x30 + +#define NAND_BLOCK_SIZE SZ_128K + +#define OMAP3_AC_GPIO 136 //Int1 DRDY +#define OMAP3_TS_GPIO 162 +#define TB_BL_PWM_TIMER 9 +#define TB_KILL_POWER_GPIO 168 + +static struct mtd_partition omap3beagle_nand_partitions[] = { + /* All the partition sizes are listed in terms of NAND block size */ + { + .name = "X-Loader", + .offset = 0, + .size = 4 * NAND_BLOCK_SIZE, + .mask_flags = MTD_WRITEABLE, /* force read-only */ + }, + { + .name = "U-Boot", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */ + .size = 15 * NAND_BLOCK_SIZE, + .mask_flags = MTD_WRITEABLE, /* force read-only */ + }, + { + .name = "U-Boot Env", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */ + .size = 1 * NAND_BLOCK_SIZE, + }, + { + .name = "Kernel", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */ + .size = 32 * NAND_BLOCK_SIZE, + }, + { + .name = "File System", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x680000 */ + .size = MTDPART_SIZ_FULL, + }, +}; + +static struct omap_nand_platform_data omap3beagle_nand_data = { + .options = NAND_BUSWIDTH_16, + .parts = omap3beagle_nand_partitions, + .nr_parts = ARRAY_SIZE(omap3beagle_nand_partitions), + .dma_channel = -1, /* disable DMA in OMAP NAND driver */ + .nand_setup = NULL, + .dev_ready = NULL, +}; + +static struct resource omap3beagle_nand_resource = { + .flags = IORESOURCE_MEM, +}; + +static struct platform_device omap3beagle_nand_device = { + .name = "omap2-nand", + .id = -1, + .dev = { + .platform_data = &omap3beagle_nand_data, + }, + .num_resources = 1, + .resource = &omap3beagle_nand_resource, +}; + +#include "sdram-micron-mt46h32m32lf-6.h" + +static struct omap_uart_config omap3_beagle_uart_config __initdata = { + .enabled_uarts = ((1 << 0) | (1 << 1) | (1 << 2)), +}; + +static struct twl4030_usb_data beagle_usb_data = { + .usb_mode = T2_USB_MODE_ULPI, +}; + +static struct twl4030_hsmmc_info mmc[] = { + { + .mmc = 1, + .wires = 8, + .gpio_wp = 29, + }, + {} /* Terminator */ +}; + +static struct regulator_consumer_supply beagle_vmmc1_supply = { + .supply = "vmmc", +}; + +static struct regulator_consumer_supply beagle_vsim_supply = { + .supply = "vmmc_aux", +}; + +static struct gpio_led gpio_leds[]; + +static int beagle_twl_gpio_setup(struct device *dev, + unsigned gpio, unsigned ngpio) +{ + /* gpio + 0 is "mmc0_cd" (input/IRQ) */ + omap_cfg_reg(AH8_34XX_GPIO29); + mmc[0].gpio_cd = gpio + 0; + twl4030_mmc_init(mmc); + + /* link regulators to MMC adapters */ + beagle_vmmc1_supply.dev = mmc[0].dev; + beagle_vsim_supply.dev = mmc[0].dev; + + /* REVISIT: need ehci-omap hooks for external VBUS + * power switch and overcurrent detect + */ + +#if 0 /* TODO: This needs to be modified to not rely on u-boot */ + gpio_request(gpio + 1, "EHCI_nOC"); + gpio_direction_input(gpio + 1); + + /* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, active low) */ + gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR"); + gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1); + + /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */ + gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1; +#endif + return 0; +} + +static struct twl4030_gpio_platform_data beagle_gpio_data = { + .gpio_base = OMAP_MAX_GPIO_LINES, + .irq_base = TWL4030_GPIO_IRQ_BASE, + .irq_end = TWL4030_GPIO_IRQ_END, + .use_leds = true, + .pullups = BIT(1), + .pulldowns = BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13) + | BIT(15) | BIT(16) | BIT(17), + .setup = beagle_twl_gpio_setup, +}; + +static struct platform_device omap3_beagle_lcd_device = { + .name = "omap3beagle_lcd", + .id = -1, +}; + +static struct regulator_consumer_supply beagle_vdac_supply = { + .supply = "vdac", + .dev = &omap3_beagle_lcd_device.dev, +}; + +static struct regulator_consumer_supply beagle_vdvi_supply = { + .supply = "vdvi", + .dev = &omap3_beagle_lcd_device.dev, +}; + +/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */ +static struct regulator_init_data beagle_vmmc1 = { + .constraints = { + .min_uV = 1850000, + .max_uV = 3150000, + .valid_modes_mask = REGULATOR_MODE_NORMAL + | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE + | REGULATOR_CHANGE_MODE + | REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = 1, + .consumer_supplies = &beagle_vmmc1_supply, +}; + +/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */ +static struct regulator_init_data beagle_vsim = { + .constraints = { + .min_uV = 1800000, + .max_uV = 3000000, + .valid_modes_mask = REGULATOR_MODE_NORMAL + | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE + | REGULATOR_CHANGE_MODE + | REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = 1, + .consumer_supplies = &beagle_vsim_supply, +}; + +/* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */ +static struct regulator_init_data beagle_vdac = { + .constraints = { + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL + | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE + | REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = 1, + .consumer_supplies = &beagle_vdac_supply, +}; + +/* VPLL2 for digital video outputs */ +static struct regulator_init_data beagle_vpll2 = { + .constraints = { + .name = "VDVI", + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL + | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE + | REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = 1, + .consumer_supplies = &beagle_vdvi_supply, +}; + +static const struct twl4030_resconfig beagle_resconfig[] = { + /* disable regulators that u-boot left enabled; the + * devices' drivers should be managing these. + */ + { .resource = RES_VAUX3, }, /* not even connected! */ + { .resource = RES_VMMC1, }, + { .resource = RES_VSIM, }, + { .resource = RES_VPLL2, }, + { .resource = RES_VDAC, }, + { .resource = RES_VUSB_1V5, }, + { .resource = RES_VUSB_1V8, }, + { .resource = RES_VUSB_3V1, }, + { 0, }, +}; + +static struct twl4030_power_data beagle_power_data = { + .resource_config = beagle_resconfig, + /* REVISIT can't use GENERIC3430_T2SCRIPTS_DATA; + * among other things, it makes reboot fail. + */ +}; + +static struct twl4030_bci_platform_data touchbook_bci_data = { + .tblsize = 0, + .no_backup_battery = 1, +}; + +static struct twl4030_platform_data beagle_twldata = { + .irq_base = TWL4030_IRQ_BASE, + .irq_end = TWL4030_IRQ_END, + + /* platform_data for children goes here */ + .usb = &beagle_usb_data, + .gpio = &beagle_gpio_data, + .power = &beagle_power_data, + .vmmc1 = &beagle_vmmc1, + .vsim = &beagle_vsim, + .vdac = &beagle_vdac, + .vpll2 = &beagle_vpll2, + + /* TouchBook BCI */ + .bci = &touchbook_bci_data, +}; + +static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = { + { + I2C_BOARD_INFO("twl4030", 0x48), + .flags = I2C_CLIENT_WAKE, + .irq = INT_34XX_SYS_NIRQ, + .platform_data = &beagle_twldata, + }, +}; + +static struct i2c_board_info __initdata touchBook_i2c_boardinfo[] = { + { + I2C_BOARD_INFO("bq27200", 0x55), + }, +}; + +static int __init omap3_beagle_i2c_init(void) +{ + /* Standard BeagleBoard bus */ + omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo, + ARRAY_SIZE(beagle_i2c_boardinfo)); + + /* TouchBook keyboard bus */ + omap_register_i2c_bus(3, 100, touchBook_i2c_boardinfo, + ARRAY_SIZE(touchBook_i2c_boardinfo)); + + return 0; +} + +static void __init omap3_ads7846_init(void) +{ + if (gpio_request(OMAP3_TS_GPIO, "ads7846_pen_down")) { + printk(KERN_ERR "Failed to request GPIO %d for " + "ads7846 pen down IRQ\n", OMAP3_TS_GPIO); + return; + } + + gpio_direction_input(OMAP3_TS_GPIO); + omap_set_gpio_debounce(OMAP3_TS_GPIO, 1); + omap_set_gpio_debounce_time(OMAP3_TS_GPIO, 0xa); +} + +static struct ads7846_platform_data ads7846_config = { + .x_min = 100, + .y_min = 265, + .x_max = 3950, + .y_max = 3750, + .x_plate_ohms = 40, + .pressure_max = 255, + .debounce_max = 10, + .debounce_tol = 5, + .debounce_rep = 1, + .gpio_pendown = OMAP3_TS_GPIO, + .keep_vref_on = 1, +}; + +static struct omap2_mcspi_device_config ads7846_mcspi_config = { + .turbo_mode = 0, + .single_channel = 1, /* 0: slave, 1: master */ +}; + +static struct spi_board_info omap3_ads7846_spi_board_info[] __initdata = { + { + .modalias = "ads7846", + .bus_num = 4, + .chip_select = 0, + .max_speed_hz = 1500000, + .controller_data = &ads7846_mcspi_config, //(void *) 161, + .irq = OMAP_GPIO_IRQ(OMAP3_TS_GPIO), + .platform_data = &ads7846_config, + } +}; + +static void __init omap3_beagle_init_irq(void) +{ + omap2_init_common_hw(mt46h32m32lf6_sdrc_params, omap3_mpu_rate_table, + omap3_dsp_rate_table, omap3_l3_rate_table); + omap_init_irq(); + omap_gpio_init(); +} + +static struct gpio_led gpio_leds[] = { + { + .name = "beagleboard::usr0", + .default_trigger = "heartbeat", + .gpio = 150, + }, + { + .name = "beagleboard::usr1", + .default_trigger = "mmc0", + .gpio = 149, + }, + { + .name = "beagleboard::pmu_stat", + .gpio = -EINVAL, /* gets replaced */ + .active_low = true, + }, +}; + +static struct gpio_led_platform_data gpio_led_info = { + .leds = gpio_leds, + .num_leds = ARRAY_SIZE(gpio_leds), +}; + +static struct platform_device leds_gpio = { + .name = "leds-gpio", + .id = -1, + .dev = { + .platform_data = &gpio_led_info, + }, +}; + +static struct gpio_keys_button gpio_buttons[] = { + { + .code = BTN_EXTRA, + .gpio = 7, + .desc = "user", + .wakeup = 1, + }, + { + .code = KEY_POWER, + .gpio = 183, + .desc = "power", + .wakeup = 1, + }, +}; + +static struct gpio_keys_platform_data gpio_key_info = { + .buttons = gpio_buttons, + .nbuttons = ARRAY_SIZE(gpio_buttons), +}; + +static struct platform_device keys_gpio = { + .name = "gpio-keys", + .id = -1, + .dev = { + .platform_data = &gpio_key_info, + }, +}; + +/* DSS */ + +static int beagle_enable_dvi(struct omap_display *display) +{ + if (display->hw_config.panel_reset_gpio != -1) + gpio_set_value(display->hw_config.panel_reset_gpio, 1); + + return 0; +} + +static void beagle_disable_dvi(struct omap_display *display) +{ + if (display->hw_config.panel_reset_gpio != -1) + gpio_set_value(display->hw_config.panel_reset_gpio, 0); +} + +static struct omap_dss_display_config beagle_display_data_dvi = { + .type = OMAP_DISPLAY_TYPE_DPI, + .name = "dvi", + .panel_name = "panel-generic", + .u.dpi.data_lines = 24, + .panel_reset_gpio = 176, + .panel_enable = beagle_enable_dvi, + .panel_disable = beagle_disable_dvi, +}; + + +static int beagle_panel_enable_tv(struct omap_display *display) +{ +#define ENABLE_VDAC_DEDICATED 0x03 +#define ENABLE_VDAC_DEV_GRP 0x20 + + twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, + ENABLE_VDAC_DEDICATED, + TWL4030_VDAC_DEDICATED); + twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, + ENABLE_VDAC_DEV_GRP, TWL4030_VDAC_DEV_GRP); + + return 0; +} + +static void beagle_panel_disable_tv(struct omap_display *display) +{ + twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00, + TWL4030_VDAC_DEDICATED); + twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00, + TWL4030_VDAC_DEV_GRP); +} + +static struct omap_dss_display_config beagle_display_data_tv = { + .type = OMAP_DISPLAY_TYPE_VENC, + .name = "tv", + .u.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO, + .panel_enable = beagle_panel_enable_tv, + .panel_disable = beagle_panel_disable_tv, +}; + +static struct omap_dss_board_info beagle_dss_data = { + .num_displays = 2, + .displays = { + &beagle_display_data_dvi, + &beagle_display_data_tv, + } +}; + +static struct platform_device beagle_dss_device = { + .name = "omapdss", + .id = -1, + .dev = { + .platform_data = &beagle_dss_data, + }, +}; + +static void __init beagle_display_init(void) +{ + int r; + + r = gpio_request(beagle_display_data_dvi.panel_reset_gpio, "DVI reset"); + if (r < 0) { + printk(KERN_ERR "Unable to get DVI reset GPIO\n"); + return; + } + + gpio_direction_output(beagle_display_data_dvi.panel_reset_gpio, 0); +} + +static struct omap_board_config_kernel omap3_beagle_config[] __initdata = { + { OMAP_TAG_UART, &omap3_beagle_uart_config }, +}; + +static struct platform_device *omap3_beagle_devices[] __initdata = { + &beagle_dss_device, + &leds_gpio, + &keys_gpio, +}; + +static void __init omap3beagle_flash_init(void) +{ + u8 cs = 0; + u8 nandcs = GPMC_CS_NUM + 1; + + u32 gpmc_base_add = OMAP34XX_GPMC_VIRT; + + /* find out the chip-select on which NAND exists */ + while (cs < GPMC_CS_NUM) { + u32 ret = 0; + ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1); + + if ((ret & 0xC00) == 0x800) { + printk(KERN_INFO "Found NAND on CS%d\n", cs); + if (nandcs > GPMC_CS_NUM) + nandcs = cs; + } + cs++; + } + + if (nandcs > GPMC_CS_NUM) { + printk(KERN_INFO "NAND: Unable to find configuration " + "in GPMC\n "); + return; + } + + if (nandcs < GPMC_CS_NUM) { + omap3beagle_nand_data.cs = nandcs; + omap3beagle_nand_data.gpmc_cs_baseaddr = (void *) + (gpmc_base_add + GPMC_CS0_BASE + nandcs * GPMC_CS_SIZE); + omap3beagle_nand_data.gpmc_baseaddr = (void *) (gpmc_base_add); + + printk(KERN_INFO "Registering NAND on CS%d\n", nandcs); + if (platform_device_register(&omap3beagle_nand_device) < 0) + printk(KERN_ERR "Unable to register NAND device\n"); + } +} + +static void __init omap3_mma7455l_init(void) +{ + int ret; + + ret = gpio_request(OMAP3_AC_GPIO, "mma7455l"); + if (ret < 0) { + printk(KERN_ERR "Failed to request GPIO %d for mma7455l IRQ\n", OMAP3_AC_GPIO); + return; + } + + gpio_direction_input(OMAP3_AC_GPIO); +} + +static struct mma7455l_platform_data mma7455l_config = { + .calibration_x = -4, //26 for Beagleboard + .calibration_y = 28, //44 for Beagleboard + .calibration_z = -28, //26 for Beagleboard +}; + +static struct omap2_mcspi_device_config mma7455l_mcspi_config = { + .turbo_mode = 0, + .single_channel = 1, /* 0: slave, 1: master */ +}; + +static struct spi_board_info omap3_mma7455l_spi_board_info[] __initdata = { + { + .modalias = "mma7455l", + .bus_num = 3, + .chip_select = 0, + .max_speed_hz = 200000, + .irq = OMAP_GPIO_IRQ(OMAP3_AC_GPIO), + .controller_data = &mma7455l_mcspi_config, //(void *) 135, + .platform_data = &mma7455l_config, + } +}; + +static int touchbook_backlight_brightness = 50; +static struct omap_dm_timer *touchbook_backlight_pwm; + +static int touchbook_backlight_read(struct backlight_device *bd) +{ + return touchbook_backlight_brightness; +} + +static int touchbook_backlight_update(struct backlight_device *bd) +{ + int value = bd->props.brightness; + touchbook_backlight_brightness = value; + + /* Frequency calculation: + - For 200Hz PWM, you want to load -164 (=> -32768Hz / 200Hz). + - Minimum duty cycle for the backlight is 15%. + - You have (164*0.85) => ~140 levels of brightness. + */ + + /* Convert from 0-100 range to 0-140 range */ + value = (value * 14) / 10 / 2; + + /* For maximum brightness, just stop the timer... */ + if(value != bd->props.max_brightness) + { + omap_dm_timer_set_load(touchbook_backlight_pwm, 1, -164); + omap_dm_timer_set_match(touchbook_backlight_pwm, 1, -24 - value); + omap_dm_timer_write_counter(touchbook_backlight_pwm, -1); + //omap_dm_timer_stop(touchbook_backlight_pwm); + omap_dm_timer_start(touchbook_backlight_pwm); + } + else + omap_dm_timer_stop(touchbook_backlight_pwm); + + + return 0; +} + +static struct backlight_ops touchbook_backlight_properties = { + .get_brightness = touchbook_backlight_read, + .update_status = touchbook_backlight_update, +}; + +static void __init omap3_touchbook_backlight_init(void) +{ + static struct backlight_device *bd; + bd = backlight_device_register("touchbook", NULL, NULL, &touchbook_backlight_properties); + + if(bd) + { + touchbook_backlight_pwm = omap_dm_timer_request_specific(TB_BL_PWM_TIMER); + omap_dm_timer_enable(touchbook_backlight_pwm); + omap_dm_timer_set_source(touchbook_backlight_pwm, OMAP_TIMER_SRC_32_KHZ); + omap_dm_timer_set_pwm(touchbook_backlight_pwm, 1, 1, OMAP_TIMER_TRIGGER_OVERFLOW_AND_COMPARE); + + bd->props.max_brightness = 100; + bd->props.brightness = touchbook_backlight_brightness; + } + + touchbook_backlight_update(bd); +} + +static void omap3_touchbook_poweroff(void) +{ + int r; + + r = gpio_request(TB_KILL_POWER_GPIO, "DVI reset"); + if (r < 0) { + printk(KERN_ERR "Unable to get kill power GPIO\n"); + return; + } + + gpio_direction_output(TB_KILL_POWER_GPIO, 0); +} + +static void __init omap3_beagle_init(void) +{ + pm_power_off = omap3_touchbook_poweroff; + + omap3_beagle_i2c_init(); + platform_add_devices(omap3_beagle_devices, + ARRAY_SIZE(omap3_beagle_devices)); + omap_board_config = omap3_beagle_config; + omap_board_config_size = ARRAY_SIZE(omap3_beagle_config); + omap_serial_init(); + + omap_cfg_reg(J25_34XX_GPIO170); + + omap3beagle_flash_init(); + beagle_display_init(); + omap3_touchbook_backlight_init(); + + /* Touch Book */ + spi_register_board_info(omap3_ads7846_spi_board_info, ARRAY_SIZE(omap3_ads7846_spi_board_info)); + spi_register_board_info(omap3_mma7455l_spi_board_info, ARRAY_SIZE(omap3_mma7455l_spi_board_info)); + + omap3_ads7846_init(); + omap3_mma7455l_init(); + + usb_musb_init(); + usb_ehci_init(); +} + +static void __init omap3_beagle_map_io(void) +{ + omap2_set_globals_343x(); + omap2_map_common_io(); +} + +MACHINE_START(OMAP3_BEAGLE, "OMAP3 Touch Book") + /* Maintainer: Gregoire Gentil - http://www.alwaysinnovating.com */ + .phys_io = 0x48000000, + .io_pg_offst = ((0xd8000000) >> 18) & 0xfffc, + .boot_params = 0x80000100, + .map_io = omap3_beagle_map_io, + .init_irq = omap3_beagle_init_irq, + .init_machine = omap3_beagle_init, + .timer = &omap_timer, +MACHINE_END diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/boot-no-power-message.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/boot-no-power-message.patch new file mode 100644 index 0000000000..4be59a4212 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/boot-no-power-message.patch @@ -0,0 +1,11 @@ +--- a/arch/arm/mach-omap2/pm34xx.c 2009-07-18 10:13:43.000000000 -0700 ++++ b/arch/arm/mach-omap2/pm34xx.c 2009-07-18 10:13:54.000000000 -0700 +@@ -625,7 +625,7 @@ + struct power_state *pwrst, *tmp; + int ret; + +- printk(KERN_ERR "Power Management for TI OMAP3.\n"); ++// printk(KERN_ERR "Power Management for TI OMAP3.\n"); + + /* XXX prcm_setup_regs needs to be before enabling hw + * supervised mode for powerdomains */ diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig new file mode 100644 index 0000000000..2ff46a4832 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig @@ -0,0 +1,2720 @@ +# +# Automatically generated make config: don't edit +# Linux kernel version: 2.6.29-omap1 +# Fri May 29 14:47:52 2009 +# +CONFIG_ARM=y +CONFIG_SYS_SUPPORTS_APM_EMULATION=y +CONFIG_GENERIC_GPIO=y +CONFIG_GENERIC_TIME=y +CONFIG_GENERIC_CLOCKEVENTS=y +CONFIG_MMU=y +# CONFIG_NO_IOPORT is not set +CONFIG_GENERIC_HARDIRQS=y +CONFIG_STACKTRACE_SUPPORT=y +CONFIG_HAVE_LATENCYTOP_SUPPORT=y +CONFIG_LOCKDEP_SUPPORT=y +CONFIG_TRACE_IRQFLAGS_SUPPORT=y +CONFIG_HARDIRQS_SW_RESEND=y +CONFIG_GENERIC_IRQ_PROBE=y +CONFIG_RWSEM_GENERIC_SPINLOCK=y +# CONFIG_ARCH_HAS_ILOG2_U32 is not set +# CONFIG_ARCH_HAS_ILOG2_U64 is not set +CONFIG_GENERIC_HWEIGHT=y +CONFIG_GENERIC_CALIBRATE_DELAY=y +CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y +CONFIG_OPROFILE_ARMV7=y +CONFIG_VECTORS_BASE=0xffff0000 +CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" + +# +# General setup +# +CONFIG_EXPERIMENTAL=y +CONFIG_BROKEN_ON_SMP=y +CONFIG_INIT_ENV_ARG_LIMIT=32 +CONFIG_LOCALVERSION="" +# CONFIG_LOCALVERSION_AUTO is not set +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +CONFIG_SYSVIPC_SYSCTL=y +# CONFIG_POSIX_MQUEUE is not set +CONFIG_BSD_PROCESS_ACCT=y +# CONFIG_BSD_PROCESS_ACCT_V3 is not set +CONFIG_TASKSTATS=y +CONFIG_TASK_DELAY_ACCT=y +CONFIG_TASK_XACCT=y +CONFIG_TASK_IO_ACCOUNTING=y +# CONFIG_AUDIT is not set + +# +# RCU Subsystem +# +CONFIG_CLASSIC_RCU=y +# CONFIG_TREE_RCU is not set +# CONFIG_PREEMPT_RCU is not set +# CONFIG_TREE_RCU_TRACE is not set +# CONFIG_PREEMPT_RCU_TRACE is not set +CONFIG_IKCONFIG=y +CONFIG_IKCONFIG_PROC=y +CONFIG_LOG_BUF_SHIFT=14 +CONFIG_GROUP_SCHED=y +CONFIG_FAIR_GROUP_SCHED=y +# CONFIG_RT_GROUP_SCHED is not set +CONFIG_USER_SCHED=y +# CONFIG_CGROUP_SCHED is not set +# CONFIG_CGROUPS is not set +# CONFIG_SYSFS_DEPRECATED_V2 is not set +# CONFIG_RELAY is not set +# CONFIG_NAMESPACES is not set +CONFIG_BLK_DEV_INITRD=y +CONFIG_INITRAMFS_SOURCE="" +CONFIG_CC_OPTIMIZE_FOR_SIZE=y +CONFIG_SYSCTL=y +CONFIG_ANON_INODES=y +CONFIG_EMBEDDED=y +CONFIG_UID16=y +# CONFIG_SYSCTL_SYSCALL is not set +CONFIG_KALLSYMS=y +# CONFIG_KALLSYMS_ALL is not set +# CONFIG_KALLSYMS_EXTRA_PASS is not set +CONFIG_HOTPLUG=y +CONFIG_PRINTK=y +CONFIG_BUG=y +# CONFIG_ELF_CORE is not set +CONFIG_BASE_FULL=y +CONFIG_FUTEX=y +CONFIG_EPOLL=y +CONFIG_SIGNALFD=y +CONFIG_TIMERFD=y +CONFIG_EVENTFD=y +CONFIG_SHMEM=y +CONFIG_AIO=y +CONFIG_VM_EVENT_COUNTERS=y +# CONFIG_COMPAT_BRK is not set +CONFIG_SLAB=y +# CONFIG_SLUB is not set +# CONFIG_SLOB is not set +CONFIG_PROFILING=y +CONFIG_TRACEPOINTS=y +# CONFIG_MARKERS is not set +CONFIG_OPROFILE=y +CONFIG_HAVE_OPROFILE=y +# CONFIG_KPROBES is not set +CONFIG_HAVE_KPROBES=y +CONFIG_HAVE_KRETPROBES=y +CONFIG_HAVE_CLK=y +CONFIG_HAVE_GENERIC_DMA_COHERENT=y +CONFIG_SLABINFO=y +CONFIG_RT_MUTEXES=y +CONFIG_BASE_SMALL=0 +CONFIG_MODULES=y +CONFIG_MODULE_FORCE_LOAD=y +CONFIG_MODULE_UNLOAD=y +CONFIG_MODULE_FORCE_UNLOAD=y +CONFIG_MODVERSIONS=y +CONFIG_MODULE_SRCVERSION_ALL=y +CONFIG_BLOCK=y +CONFIG_LBD=y +# CONFIG_BLK_DEV_IO_TRACE is not set +# CONFIG_BLK_DEV_BSG is not set +# CONFIG_BLK_DEV_INTEGRITY is not set + +# +# IO Schedulers +# +CONFIG_IOSCHED_NOOP=y +CONFIG_IOSCHED_AS=y +CONFIG_IOSCHED_DEADLINE=y +CONFIG_IOSCHED_CFQ=y +# CONFIG_DEFAULT_AS is not set +# CONFIG_DEFAULT_DEADLINE is not set +CONFIG_DEFAULT_CFQ=y +# CONFIG_DEFAULT_NOOP is not set +CONFIG_DEFAULT_IOSCHED="cfq" +CONFIG_FREEZER=y + +# +# System Type +# +# CONFIG_ARCH_AAEC2000 is not set +# CONFIG_ARCH_INTEGRATOR is not set +# CONFIG_ARCH_REALVIEW is not set +# CONFIG_ARCH_VERSATILE is not set +# CONFIG_ARCH_AT91 is not set +# CONFIG_ARCH_CLPS711X is not set +# CONFIG_ARCH_EBSA110 is not set +# CONFIG_ARCH_EP93XX is not set +# CONFIG_ARCH_FOOTBRIDGE is not set +# CONFIG_ARCH_NETX is not set +# CONFIG_ARCH_H720X is not set +# CONFIG_ARCH_IMX is not set +# CONFIG_ARCH_IOP13XX is not set +# CONFIG_ARCH_IOP32X is not set +# CONFIG_ARCH_IOP33X is not set +# CONFIG_ARCH_IXP23XX is not set +# CONFIG_ARCH_IXP2000 is not set +# CONFIG_ARCH_IXP4XX is not set +# CONFIG_ARCH_L7200 is not set +# CONFIG_ARCH_KIRKWOOD is not set +# CONFIG_ARCH_KS8695 is not set +# CONFIG_ARCH_NS9XXX is not set +# CONFIG_ARCH_LOKI is not set +# CONFIG_ARCH_MV78XX0 is not set +# CONFIG_ARCH_MXC is not set +# CONFIG_ARCH_ORION5X is not set +# CONFIG_ARCH_PNX4008 is not set +# CONFIG_ARCH_PXA is not set +# CONFIG_ARCH_RPC is not set +# CONFIG_ARCH_SA1100 is not set +# CONFIG_ARCH_S3C2410 is not set +# CONFIG_ARCH_S3C64XX is not set +# CONFIG_ARCH_SHARK is not set +# CONFIG_ARCH_LH7A40X is not set +# CONFIG_ARCH_DAVINCI is not set +CONFIG_ARCH_OMAP=y +# CONFIG_ARCH_MSM is not set +# CONFIG_ARCH_W90X900 is not set + +# +# TI OMAP Implementations +# +CONFIG_ARCH_OMAP_OTG=y +# CONFIG_ARCH_OMAP1 is not set +# CONFIG_ARCH_OMAP2 is not set +CONFIG_ARCH_OMAP3=y + +# +# OMAP Feature Selections +# +# CONFIG_OMAP_DEBUG_POWERDOMAIN is not set +# CONFIG_OMAP_DEBUG_CLOCKDOMAIN is not set +CONFIG_OMAP_SMARTREFLEX=y +# CONFIG_OMAP_SMARTREFLEX_TESTING is not set +CONFIG_OMAP_RESET_CLOCKS=y +CONFIG_OMAP_BOOT_TAG=y +CONFIG_OMAP_BOOT_REASON=y +# CONFIG_OMAP_COMPONENT_VERSION is not set +# CONFIG_OMAP_GPIO_SWITCH is not set +# CONFIG_OMAP_MUX is not set +CONFIG_OMAP_MCBSP=y +# CONFIG_OMAP_MBOX_FWK is not set +# CONFIG_OMAP_IOMMU is not set +# CONFIG_OMAP_MPU_TIMER is not set +CONFIG_OMAP_32K_TIMER=y +CONFIG_OMAP_32K_TIMER_HZ=128 +CONFIG_OMAP_TICK_GPTIMER=12 +CONFIG_OMAP_DM_TIMER=y +# CONFIG_OMAP_LL_DEBUG_UART1 is not set +# CONFIG_OMAP_LL_DEBUG_UART2 is not set +CONFIG_OMAP_LL_DEBUG_UART3=y +CONFIG_ARCH_OMAP34XX=y +CONFIG_ARCH_OMAP3430=y + +# +# OMAP Board Type +# +# CONFIG_MACH_NOKIA_RX51 is not set +# CONFIG_MACH_OMAP_LDP is not set +# CONFIG_MACH_OMAP_3430SDP is not set +# CONFIG_MACH_OMAP3EVM is not set +CONFIG_MACH_OMAP3_BEAGLE=y +# CONFIG_MACH_OVERO is not set +# CONFIG_MACH_OMAP3_PANDORA is not set + +# +# Processor Type +# +CONFIG_CPU_32=y +CONFIG_CPU_32v6K=y +CONFIG_CPU_V7=y +CONFIG_CPU_32v7=y +CONFIG_CPU_ABRT_EV7=y +CONFIG_CPU_PABRT_IFAR=y +CONFIG_CPU_CACHE_V7=y +CONFIG_CPU_CACHE_VIPT=y +CONFIG_CPU_COPY_V6=y +CONFIG_CPU_TLB_V7=y +CONFIG_CPU_HAS_ASID=y +CONFIG_CPU_CP15=y +CONFIG_CPU_CP15_MMU=y + +# +# Processor Features +# +CONFIG_ARM_THUMB=y +CONFIG_ARM_THUMBEE=y +# CONFIG_CPU_ICACHE_DISABLE is not set +# CONFIG_CPU_DCACHE_DISABLE is not set +# CONFIG_CPU_BPREDICT_DISABLE is not set +CONFIG_HAS_TLS_REG=y +# CONFIG_OUTER_CACHE is not set + +# +# Bus support +# +# CONFIG_PCI_SYSCALL is not set +# CONFIG_ARCH_SUPPORTS_MSI is not set +# CONFIG_PCCARD is not set + +# +# Kernel Features +# +CONFIG_TICK_ONESHOT=y +CONFIG_NO_HZ=y +CONFIG_HIGH_RES_TIMERS=y +CONFIG_GENERIC_CLOCKEVENTS_BUILD=y +# CONFIG_VMSPLIT_3G is not set +CONFIG_VMSPLIT_2G=y +# CONFIG_VMSPLIT_1G is not set +CONFIG_PAGE_OFFSET=0x80000000 +# CONFIG_PREEMPT is not set +CONFIG_HZ=128 +CONFIG_AEABI=y +# CONFIG_OABI_COMPAT is not set +CONFIG_ARCH_FLATMEM_HAS_HOLES=y +# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set +# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set +CONFIG_SELECT_MEMORY_MODEL=y +CONFIG_FLATMEM_MANUAL=y +# CONFIG_DISCONTIGMEM_MANUAL is not set +# CONFIG_SPARSEMEM_MANUAL is not set +CONFIG_FLATMEM=y +CONFIG_FLAT_NODE_MEM_MAP=y +CONFIG_PAGEFLAGS_EXTENDED=y +CONFIG_SPLIT_PTLOCK_CPUS=4 +# CONFIG_PHYS_ADDR_T_64BIT is not set +CONFIG_ZONE_DMA_FLAG=0 +CONFIG_VIRT_TO_BUS=y +CONFIG_UNEVICTABLE_LRU=y +CONFIG_LEDS=y +CONFIG_ALIGNMENT_TRAP=y + +# +# Boot options +# +CONFIG_ZBOOT_ROM_TEXT=0x0 +CONFIG_ZBOOT_ROM_BSS=0x0 +CONFIG_CMDLINE=" debug " +# CONFIG_XIP_KERNEL is not set +CONFIG_KEXEC=y +CONFIG_ATAGS_PROC=y + +# +# CPU Power Management +# +# CONFIG_CPU_FREQ is not set +# CONFIG_CPU_IDLE is not set + +# +# Floating point emulation +# + +# +# At least one emulation must be selected +# +CONFIG_VFP=y +CONFIG_VFPv3=y +CONFIG_NEON=y +# CONFIG_ARM_ERRATUM_451034 is not set + +# +# Userspace binary formats +# +CONFIG_BINFMT_ELF=y +CONFIG_HAVE_AOUT=y +CONFIG_BINFMT_AOUT=m +CONFIG_BINFMT_MISC=y + +# +# Power management options +# +CONFIG_PM=y +CONFIG_PM_DEBUG=y +# CONFIG_PM_VERBOSE is not set +CONFIG_CAN_PM_TRACE=y +CONFIG_PM_SLEEP=y +CONFIG_SUSPEND=y +# CONFIG_PM_TEST_SUSPEND is not set +CONFIG_SUSPEND_FREEZER=y +# CONFIG_APM_EMULATION is not set +CONFIG_ARCH_SUSPEND_POSSIBLE=y +CONFIG_NET=y + +# +# Networking options +# +CONFIG_COMPAT_NET_DEV_OPS=y +CONFIG_PACKET=y +CONFIG_PACKET_MMAP=y +CONFIG_UNIX=y +CONFIG_XFRM=y +# CONFIG_XFRM_USER is not set +# CONFIG_XFRM_SUB_POLICY is not set +# CONFIG_XFRM_MIGRATE is not set +# CONFIG_XFRM_STATISTICS is not set +CONFIG_XFRM_IPCOMP=m +CONFIG_NET_KEY=y +# CONFIG_NET_KEY_MIGRATE is not set +CONFIG_INET=y +# CONFIG_IP_MULTICAST is not set +# CONFIG_IP_ADVANCED_ROUTER is not set +CONFIG_IP_FIB_HASH=y +CONFIG_IP_PNP=y +CONFIG_IP_PNP_DHCP=y +CONFIG_IP_PNP_BOOTP=y +CONFIG_IP_PNP_RARP=y +CONFIG_NET_IPIP=m +CONFIG_NET_IPGRE=m +# CONFIG_ARPD is not set +# CONFIG_SYN_COOKIES is not set +CONFIG_INET_AH=m +CONFIG_INET_ESP=m +CONFIG_INET_IPCOMP=m +CONFIG_INET_XFRM_TUNNEL=m +CONFIG_INET_TUNNEL=m +CONFIG_INET_XFRM_MODE_TRANSPORT=y +CONFIG_INET_XFRM_MODE_TUNNEL=y +CONFIG_INET_XFRM_MODE_BEET=y +CONFIG_INET_LRO=m +CONFIG_INET_DIAG=m +CONFIG_INET_TCP_DIAG=m +CONFIG_TCP_CONG_ADVANCED=y +CONFIG_TCP_CONG_BIC=m +CONFIG_TCP_CONG_CUBIC=y +CONFIG_TCP_CONG_WESTWOOD=m +CONFIG_TCP_CONG_HTCP=m +CONFIG_TCP_CONG_HSTCP=m +CONFIG_TCP_CONG_HYBLA=m +CONFIG_TCP_CONG_VEGAS=m +CONFIG_TCP_CONG_SCALABLE=m +CONFIG_TCP_CONG_LP=m +CONFIG_TCP_CONG_VENO=m +CONFIG_TCP_CONG_YEAH=m +CONFIG_TCP_CONG_ILLINOIS=m +# CONFIG_DEFAULT_BIC is not set +CONFIG_DEFAULT_CUBIC=y +# CONFIG_DEFAULT_HTCP is not set +# CONFIG_DEFAULT_VEGAS is not set +# CONFIG_DEFAULT_WESTWOOD is not set +# CONFIG_DEFAULT_RENO is not set +CONFIG_DEFAULT_TCP_CONG="cubic" +# CONFIG_TCP_MD5SIG is not set +CONFIG_IPV6=m +# CONFIG_IPV6_PRIVACY is not set +# CONFIG_IPV6_ROUTER_PREF is not set +# CONFIG_IPV6_OPTIMISTIC_DAD is not set +CONFIG_INET6_AH=m +CONFIG_INET6_ESP=m +CONFIG_INET6_IPCOMP=m +CONFIG_IPV6_MIP6=m +CONFIG_INET6_XFRM_TUNNEL=m +CONFIG_INET6_TUNNEL=m +CONFIG_INET6_XFRM_MODE_TRANSPORT=m +CONFIG_INET6_XFRM_MODE_TUNNEL=m +CONFIG_INET6_XFRM_MODE_BEET=m +CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION=m +CONFIG_IPV6_SIT=m +CONFIG_IPV6_NDISC_NODETYPE=y +CONFIG_IPV6_TUNNEL=m +CONFIG_IPV6_MULTIPLE_TABLES=y +CONFIG_IPV6_SUBTREES=y +CONFIG_IPV6_MROUTE=y +# CONFIG_IPV6_PIMSM_V2 is not set +# CONFIG_NETWORK_SECMARK is not set +CONFIG_NETFILTER=y +# CONFIG_NETFILTER_DEBUG is not set +CONFIG_NETFILTER_ADVANCED=y +CONFIG_BRIDGE_NETFILTER=y + +# +# Core Netfilter Configuration +# +CONFIG_NETFILTER_NETLINK=m +CONFIG_NETFILTER_NETLINK_QUEUE=m +CONFIG_NETFILTER_NETLINK_LOG=m +CONFIG_NF_CONNTRACK=m +CONFIG_NF_CT_ACCT=y +CONFIG_NF_CONNTRACK_MARK=y +CONFIG_NF_CONNTRACK_EVENTS=y +CONFIG_NF_CT_PROTO_DCCP=m +CONFIG_NF_CT_PROTO_GRE=m +CONFIG_NF_CT_PROTO_SCTP=m +CONFIG_NF_CT_PROTO_UDPLITE=m +CONFIG_NF_CONNTRACK_AMANDA=m +CONFIG_NF_CONNTRACK_FTP=m +CONFIG_NF_CONNTRACK_H323=m +CONFIG_NF_CONNTRACK_IRC=m +CONFIG_NF_CONNTRACK_NETBIOS_NS=m +CONFIG_NF_CONNTRACK_PPTP=m +CONFIG_NF_CONNTRACK_SANE=m +CONFIG_NF_CONNTRACK_SIP=m +CONFIG_NF_CONNTRACK_TFTP=m +CONFIG_NF_CT_NETLINK=m +# CONFIG_NETFILTER_TPROXY is not set +CONFIG_NETFILTER_XTABLES=m +CONFIG_NETFILTER_XT_TARGET_CLASSIFY=m +CONFIG_NETFILTER_XT_TARGET_CONNMARK=m +# CONFIG_NETFILTER_XT_TARGET_DSCP is not set +CONFIG_NETFILTER_XT_TARGET_MARK=m +CONFIG_NETFILTER_XT_TARGET_NFLOG=m +CONFIG_NETFILTER_XT_TARGET_NFQUEUE=m +# CONFIG_NETFILTER_XT_TARGET_NOTRACK is not set +CONFIG_NETFILTER_XT_TARGET_RATEEST=m +# CONFIG_NETFILTER_XT_TARGET_TRACE is not set +CONFIG_NETFILTER_XT_TARGET_TCPMSS=m +# CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set +CONFIG_NETFILTER_XT_MATCH_COMMENT=m +CONFIG_NETFILTER_XT_MATCH_CONNBYTES=m +CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=m +CONFIG_NETFILTER_XT_MATCH_CONNMARK=m +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m +CONFIG_NETFILTER_XT_MATCH_DCCP=m +CONFIG_NETFILTER_XT_MATCH_DSCP=m +CONFIG_NETFILTER_XT_MATCH_ESP=m +CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=m +CONFIG_NETFILTER_XT_MATCH_HELPER=m +CONFIG_NETFILTER_XT_MATCH_IPRANGE=m +CONFIG_NETFILTER_XT_MATCH_LENGTH=m +CONFIG_NETFILTER_XT_MATCH_LIMIT=m +CONFIG_NETFILTER_XT_MATCH_MAC=m +CONFIG_NETFILTER_XT_MATCH_MARK=m +CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m +CONFIG_NETFILTER_XT_MATCH_OWNER=m +CONFIG_NETFILTER_XT_MATCH_POLICY=m +# CONFIG_NETFILTER_XT_MATCH_PHYSDEV is not set +CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m +CONFIG_NETFILTER_XT_MATCH_QUOTA=m +CONFIG_NETFILTER_XT_MATCH_RATEEST=m +CONFIG_NETFILTER_XT_MATCH_REALM=m +CONFIG_NETFILTER_XT_MATCH_RECENT=m +# CONFIG_NETFILTER_XT_MATCH_RECENT_PROC_COMPAT is not set +CONFIG_NETFILTER_XT_MATCH_SCTP=m +CONFIG_NETFILTER_XT_MATCH_STATE=m +CONFIG_NETFILTER_XT_MATCH_STATISTIC=m +CONFIG_NETFILTER_XT_MATCH_STRING=m +CONFIG_NETFILTER_XT_MATCH_TCPMSS=m +CONFIG_NETFILTER_XT_MATCH_TIME=m +CONFIG_NETFILTER_XT_MATCH_U32=m +CONFIG_IP_VS=m +CONFIG_IP_VS_IPV6=y +CONFIG_IP_VS_DEBUG=y +CONFIG_IP_VS_TAB_BITS=12 + +# +# IPVS transport protocol load balancing support +# +CONFIG_IP_VS_PROTO_TCP=y +CONFIG_IP_VS_PROTO_UDP=y +CONFIG_IP_VS_PROTO_AH_ESP=y +CONFIG_IP_VS_PROTO_ESP=y +CONFIG_IP_VS_PROTO_AH=y + +# +# IPVS scheduler +# +CONFIG_IP_VS_RR=m +CONFIG_IP_VS_WRR=m +CONFIG_IP_VS_LC=m +CONFIG_IP_VS_WLC=m +CONFIG_IP_VS_LBLC=m +CONFIG_IP_VS_LBLCR=m +CONFIG_IP_VS_DH=m +CONFIG_IP_VS_SH=m +CONFIG_IP_VS_SED=m +CONFIG_IP_VS_NQ=m + +# +# IPVS application helper +# +CONFIG_IP_VS_FTP=m + +# +# IP: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV4=m +CONFIG_NF_CONNTRACK_IPV4=m +CONFIG_NF_CONNTRACK_PROC_COMPAT=y +CONFIG_IP_NF_QUEUE=m +CONFIG_IP_NF_IPTABLES=m +CONFIG_IP_NF_MATCH_ADDRTYPE=m +CONFIG_IP_NF_MATCH_AH=m +CONFIG_IP_NF_MATCH_ECN=m +CONFIG_IP_NF_MATCH_TTL=m +CONFIG_IP_NF_FILTER=m +CONFIG_IP_NF_TARGET_REJECT=m +CONFIG_IP_NF_TARGET_LOG=m +CONFIG_IP_NF_TARGET_ULOG=m +CONFIG_NF_NAT=m +CONFIG_NF_NAT_NEEDED=y +CONFIG_IP_NF_TARGET_MASQUERADE=m +CONFIG_IP_NF_TARGET_NETMAP=m +CONFIG_IP_NF_TARGET_REDIRECT=m +CONFIG_IP_NF_TARGET_IDLETIMER=m +CONFIG_NF_NAT_SNMP_BASIC=m +CONFIG_NF_NAT_PROTO_DCCP=m +CONFIG_NF_NAT_PROTO_GRE=m +CONFIG_NF_NAT_PROTO_UDPLITE=m +CONFIG_NF_NAT_PROTO_SCTP=m +CONFIG_NF_NAT_FTP=m +CONFIG_NF_NAT_IRC=m +CONFIG_NF_NAT_TFTP=m +CONFIG_NF_NAT_AMANDA=m +CONFIG_NF_NAT_PPTP=m +CONFIG_NF_NAT_H323=m +CONFIG_NF_NAT_SIP=m +CONFIG_IP_NF_MANGLE=m +CONFIG_IP_NF_TARGET_CLUSTERIP=m +CONFIG_IP_NF_TARGET_ECN=m +CONFIG_IP_NF_TARGET_TTL=m +CONFIG_IP_NF_RAW=m +CONFIG_IP_NF_ARPTABLES=m +CONFIG_IP_NF_ARPFILTER=m +CONFIG_IP_NF_ARP_MANGLE=m + +# +# IPv6: Netfilter Configuration +# +CONFIG_NF_CONNTRACK_IPV6=m +CONFIG_IP6_NF_QUEUE=m +CONFIG_IP6_NF_IPTABLES=m +CONFIG_IP6_NF_MATCH_AH=m +CONFIG_IP6_NF_MATCH_EUI64=m +CONFIG_IP6_NF_MATCH_FRAG=m +CONFIG_IP6_NF_MATCH_OPTS=m +CONFIG_IP6_NF_MATCH_HL=m +CONFIG_IP6_NF_MATCH_IPV6HEADER=m +CONFIG_IP6_NF_MATCH_MH=m +CONFIG_IP6_NF_MATCH_RT=m +CONFIG_IP6_NF_TARGET_LOG=m +CONFIG_IP6_NF_FILTER=m +CONFIG_IP6_NF_TARGET_REJECT=m +CONFIG_IP6_NF_MANGLE=m +CONFIG_IP6_NF_TARGET_HL=m +CONFIG_IP6_NF_RAW=m +# CONFIG_BRIDGE_NF_EBTABLES is not set +CONFIG_IP_DCCP=m +CONFIG_INET_DCCP_DIAG=m + +# +# DCCP CCIDs Configuration (EXPERIMENTAL) +# +# CONFIG_IP_DCCP_CCID2_DEBUG is not set +CONFIG_IP_DCCP_CCID3=y +# CONFIG_IP_DCCP_CCID3_DEBUG is not set +CONFIG_IP_DCCP_CCID3_RTO=100 +CONFIG_IP_DCCP_TFRC_LIB=y + +# +# DCCP Kernel Hacking +# +# CONFIG_IP_DCCP_DEBUG is not set +CONFIG_IP_SCTP=m +# CONFIG_SCTP_DBG_MSG is not set +# CONFIG_SCTP_DBG_OBJCNT is not set +# CONFIG_SCTP_HMAC_NONE is not set +# CONFIG_SCTP_HMAC_SHA1 is not set +CONFIG_SCTP_HMAC_MD5=y +CONFIG_TIPC=m +# CONFIG_TIPC_ADVANCED is not set +# CONFIG_TIPC_DEBUG is not set +CONFIG_ATM=m +CONFIG_ATM_CLIP=m +# CONFIG_ATM_CLIP_NO_ICMP is not set +CONFIG_ATM_LANE=m +CONFIG_ATM_MPOA=m +CONFIG_ATM_BR2684=m +# CONFIG_ATM_BR2684_IPFILTER is not set +CONFIG_STP=m +CONFIG_GARP=m +CONFIG_BRIDGE=m +# CONFIG_NET_DSA is not set +CONFIG_VLAN_8021Q=m +CONFIG_VLAN_8021Q_GVRP=y +# CONFIG_DECNET is not set +CONFIG_LLC=m +# CONFIG_LLC2 is not set +# CONFIG_IPX is not set +# CONFIG_ATALK is not set +# CONFIG_X25 is not set +# CONFIG_LAPB is not set +# CONFIG_ECONET is not set +CONFIG_WAN_ROUTER=m +CONFIG_NET_SCHED=y + +# +# Queueing/Scheduling +# +CONFIG_NET_SCH_CBQ=m +CONFIG_NET_SCH_HTB=m +CONFIG_NET_SCH_HFSC=m +CONFIG_NET_SCH_ATM=m +CONFIG_NET_SCH_PRIO=m +CONFIG_NET_SCH_MULTIQ=m +CONFIG_NET_SCH_RED=m +CONFIG_NET_SCH_SFQ=m +CONFIG_NET_SCH_TEQL=m +CONFIG_NET_SCH_TBF=m +CONFIG_NET_SCH_GRED=m +CONFIG_NET_SCH_DSMARK=m +CONFIG_NET_SCH_NETEM=m +CONFIG_NET_SCH_DRR=m + +# +# Classification +# +CONFIG_NET_CLS=y +CONFIG_NET_CLS_BASIC=m +CONFIG_NET_CLS_TCINDEX=m +CONFIG_NET_CLS_ROUTE4=m +CONFIG_NET_CLS_ROUTE=y +CONFIG_NET_CLS_FW=m +CONFIG_NET_CLS_U32=m +CONFIG_CLS_U32_PERF=y +CONFIG_CLS_U32_MARK=y +CONFIG_NET_CLS_RSVP=m +CONFIG_NET_CLS_RSVP6=m +CONFIG_NET_CLS_FLOW=m +# CONFIG_NET_EMATCH is not set +# CONFIG_NET_CLS_ACT is not set +CONFIG_NET_CLS_IND=y +CONFIG_NET_SCH_FIFO=y +# CONFIG_DCB is not set + +# +# Network testing +# +# CONFIG_NET_PKTGEN is not set +# CONFIG_HAMRADIO is not set +CONFIG_CAN=m +CONFIG_CAN_RAW=m +CONFIG_CAN_BCM=m + +# +# CAN Device Drivers +# +CONFIG_CAN_VCAN=m +# CONFIG_CAN_DEBUG_DEVICES is not set +CONFIG_IRDA=m + +# +# IrDA protocols +# +CONFIG_IRLAN=m +CONFIG_IRNET=m +CONFIG_IRCOMM=m +CONFIG_IRDA_ULTRA=y + +# +# IrDA options +# +CONFIG_IRDA_CACHE_LAST_LSAP=y +CONFIG_IRDA_FAST_RR=y +CONFIG_IRDA_DEBUG=y + +# +# Infrared-port device drivers +# + +# +# SIR device drivers +# +CONFIG_IRTTY_SIR=m + +# +# Dongle support +# +CONFIG_DONGLE=y +CONFIG_ESI_DONGLE=m +CONFIG_ACTISYS_DONGLE=m +CONFIG_TEKRAM_DONGLE=m +CONFIG_TOIM3232_DONGLE=m +CONFIG_LITELINK_DONGLE=m +CONFIG_MA600_DONGLE=m +CONFIG_GIRBIL_DONGLE=m +CONFIG_MCP2120_DONGLE=m +CONFIG_OLD_BELKIN_DONGLE=m +# CONFIG_ACT200L_DONGLE is not set +CONFIG_KINGSUN_DONGLE=m +CONFIG_KSDAZZLE_DONGLE=m +CONFIG_KS959_DONGLE=m + +# +# FIR device drivers +# +CONFIG_USB_IRDA=m +CONFIG_SIGMATEL_FIR=m +CONFIG_MCS_FIR=m +# CONFIG_OMAP_IR is not set +CONFIG_BT=y +CONFIG_BT_L2CAP=y +CONFIG_BT_SCO=y +CONFIG_BT_RFCOMM=y +CONFIG_BT_RFCOMM_TTY=y +CONFIG_BT_BNEP=y +CONFIG_BT_BNEP_MC_FILTER=y +CONFIG_BT_BNEP_PROTO_FILTER=y +CONFIG_BT_HIDP=y + +# +# Bluetooth device drivers +# +CONFIG_BT_HCIBTUSB=y +CONFIG_BT_HCIBTSDIO=y +CONFIG_BT_HCIUART=y +CONFIG_BT_HCIUART_H4=y +CONFIG_BT_HCIUART_BCSP=y +CONFIG_BT_HCIUART_LL=y +CONFIG_BT_HCIBCM203X=y +CONFIG_BT_HCIBPA10X=y +CONFIG_BT_HCIBFUSB=y +# CONFIG_BT_HCIBRF6150 is not set +# CONFIG_BT_HCIH4P is not set +# CONFIG_BT_HCIVHCI is not set +CONFIG_AF_RXRPC=m +# CONFIG_AF_RXRPC_DEBUG is not set +# CONFIG_RXKAD is not set +# CONFIG_PHONET is not set +CONFIG_FIB_RULES=y +CONFIG_WIRELESS=y +CONFIG_CFG80211=y +# CONFIG_CFG80211_REG_DEBUG is not set +CONFIG_NL80211=y +CONFIG_WIRELESS_OLD_REGULATORY=y +CONFIG_WIRELESS_EXT=y +CONFIG_WIRELESS_EXT_SYSFS=y +CONFIG_LIB80211=y +CONFIG_LIB80211_CRYPT_WEP=y +CONFIG_LIB80211_CRYPT_CCMP=y +CONFIG_LIB80211_CRYPT_TKIP=y +# CONFIG_LIB80211_DEBUG is not set +CONFIG_MAC80211=y + +# +# Rate control algorithm selection +# +CONFIG_MAC80211_RC_PID=y +# CONFIG_MAC80211_RC_MINSTREL is not set +CONFIG_MAC80211_RC_DEFAULT_PID=y +# CONFIG_MAC80211_RC_DEFAULT_MINSTREL is not set +CONFIG_MAC80211_RC_DEFAULT="pid" +# CONFIG_MAC80211_MESH is not set +CONFIG_MAC80211_LEDS=y +# CONFIG_MAC80211_DEBUGFS is not set +# CONFIG_MAC80211_DEBUG_MENU is not set +CONFIG_WIMAX=m +CONFIG_WIMAX_DEBUG_LEVEL=8 +# CONFIG_RFKILL is not set +CONFIG_NET_9P=m +# CONFIG_NET_9P_DEBUG is not set + +# +# Device Drivers +# + +# +# Generic Driver Options +# +CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug" +CONFIG_STANDALONE=y +CONFIG_PREVENT_FIRMWARE_BUILD=y +CONFIG_FW_LOADER=y +CONFIG_FIRMWARE_IN_KERNEL=y +CONFIG_EXTRA_FIRMWARE="" +# CONFIG_DEBUG_DRIVER is not set +# CONFIG_DEBUG_DEVRES is not set +# CONFIG_SYS_HYPERVISOR is not set +# CONFIG_CONNECTOR is not set +CONFIG_MTD=y +# CONFIG_MTD_DEBUG is not set +CONFIG_MTD_CONCAT=y +CONFIG_MTD_PARTITIONS=y +# CONFIG_MTD_TESTS is not set +# CONFIG_MTD_REDBOOT_PARTS is not set +# CONFIG_MTD_CMDLINE_PARTS is not set +# CONFIG_MTD_AFS_PARTS is not set +# CONFIG_MTD_AR7_PARTS is not set + +# +# User Modules And Translation Layers +# +CONFIG_MTD_CHAR=y +CONFIG_MTD_BLKDEVS=y +CONFIG_MTD_BLOCK=y +# CONFIG_FTL is not set +# CONFIG_NFTL is not set +# CONFIG_INFTL is not set +# CONFIG_RFD_FTL is not set +# CONFIG_SSFDC is not set +# CONFIG_MTD_OOPS is not set + +# +# RAM/ROM/Flash chip drivers +# +# CONFIG_MTD_CFI is not set +# CONFIG_MTD_JEDECPROBE is not set +CONFIG_MTD_MAP_BANK_WIDTH_1=y +CONFIG_MTD_MAP_BANK_WIDTH_2=y +CONFIG_MTD_MAP_BANK_WIDTH_4=y +# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set +# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set +# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set +CONFIG_MTD_CFI_I1=y +CONFIG_MTD_CFI_I2=y +# CONFIG_MTD_CFI_I4 is not set +# CONFIG_MTD_CFI_I8 is not set +# CONFIG_MTD_RAM is not set +# CONFIG_MTD_ROM is not set +# CONFIG_MTD_ABSENT is not set + +# +# Mapping drivers for chip access +# +# CONFIG_MTD_COMPLEX_MAPPINGS is not set +# CONFIG_MTD_PLATRAM is not set + +# +# Self-contained MTD device drivers +# +# CONFIG_MTD_DATAFLASH is not set +# CONFIG_MTD_M25P80 is not set +# CONFIG_MTD_SLRAM is not set +# CONFIG_MTD_PHRAM is not set +# CONFIG_MTD_MTDRAM is not set +# CONFIG_MTD_BLOCK2MTD is not set + +# +# Disk-On-Chip Device Drivers +# +# CONFIG_MTD_DOC2000 is not set +# CONFIG_MTD_DOC2001 is not set +# CONFIG_MTD_DOC2001PLUS is not set +CONFIG_MTD_NAND=y +# CONFIG_MTD_NAND_VERIFY_WRITE is not set +# CONFIG_MTD_NAND_ECC_SMC is not set +# CONFIG_MTD_NAND_MUSEUM_IDS is not set +# CONFIG_MTD_NAND_GPIO is not set +CONFIG_MTD_NAND_OMAP2=y +CONFIG_MTD_NAND_IDS=y +# CONFIG_MTD_NAND_DISKONCHIP is not set +# CONFIG_MTD_NAND_NANDSIM is not set +CONFIG_MTD_NAND_PLATFORM=y +# CONFIG_MTD_ALAUDA is not set +# CONFIG_MTD_ONENAND is not set + +# +# LPDDR flash memory drivers +# +# CONFIG_MTD_LPDDR is not set + +# +# UBI - Unsorted block images +# +CONFIG_MTD_UBI=y +CONFIG_MTD_UBI_WL_THRESHOLD=4096 +CONFIG_MTD_UBI_BEB_RESERVE=1 +# CONFIG_MTD_UBI_GLUEBI is not set + +# +# UBI debugging options +# +# CONFIG_MTD_UBI_DEBUG is not set +# CONFIG_PARPORT is not set +CONFIG_BLK_DEV=y +# CONFIG_BLK_DEV_COW_COMMON is not set +CONFIG_BLK_DEV_LOOP=y +CONFIG_BLK_DEV_CRYPTOLOOP=m +# CONFIG_BLK_DEV_NBD is not set +# CONFIG_BLK_DEV_UB is not set +CONFIG_BLK_DEV_RAM=y +CONFIG_BLK_DEV_RAM_COUNT=16 +CONFIG_BLK_DEV_RAM_SIZE=16384 +# CONFIG_BLK_DEV_XIP is not set +CONFIG_CDROM_PKTCDVD=m +CONFIG_CDROM_PKTCDVD_BUFFERS=8 +# CONFIG_CDROM_PKTCDVD_WCACHE is not set +# CONFIG_ATA_OVER_ETH is not set +CONFIG_MISC_DEVICES=y +# CONFIG_ICS932S401 is not set +# CONFIG_OMAP_STI is not set +# CONFIG_ENCLOSURE_SERVICES is not set +# CONFIG_C2PORT is not set + +# +# EEPROM support +# +# CONFIG_EEPROM_AT24 is not set +# CONFIG_EEPROM_AT25 is not set +# CONFIG_EEPROM_LEGACY is not set +CONFIG_EEPROM_93CX6=y +CONFIG_HAVE_IDE=y +# CONFIG_IDE is not set + +# +# SCSI device support +# +CONFIG_RAID_ATTRS=m +CONFIG_SCSI=y +CONFIG_SCSI_DMA=y +# CONFIG_SCSI_TGT is not set +# CONFIG_SCSI_NETLINK is not set +CONFIG_SCSI_PROC_FS=y + +# +# SCSI support type (disk, tape, CD-ROM) +# +CONFIG_BLK_DEV_SD=y +# CONFIG_CHR_DEV_ST is not set +# CONFIG_CHR_DEV_OSST is not set +CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR_VENDOR=y +CONFIG_CHR_DEV_SG=y +CONFIG_CHR_DEV_SCH=m + +# +# Some SCSI devices (e.g. CD jukebox) support multiple LUNs +# +CONFIG_SCSI_MULTI_LUN=y +# CONFIG_SCSI_CONSTANTS is not set +# CONFIG_SCSI_LOGGING is not set +# CONFIG_SCSI_SCAN_ASYNC is not set +CONFIG_SCSI_WAIT_SCAN=m + +# +# SCSI Transports +# +# CONFIG_SCSI_SPI_ATTRS is not set +# CONFIG_SCSI_FC_ATTRS is not set +CONFIG_SCSI_ISCSI_ATTRS=m +# CONFIG_SCSI_SAS_LIBSAS is not set +# CONFIG_SCSI_SRP_ATTRS is not set +CONFIG_SCSI_LOWLEVEL=y +CONFIG_ISCSI_TCP=m +# CONFIG_LIBFC is not set +# CONFIG_SCSI_DEBUG is not set +# CONFIG_SCSI_DH is not set +# CONFIG_ATA is not set +CONFIG_MD=y +CONFIG_BLK_DEV_MD=m +CONFIG_MD_LINEAR=m +CONFIG_MD_RAID0=m +CONFIG_MD_RAID1=m +CONFIG_MD_RAID10=m +CONFIG_MD_RAID456=m +CONFIG_MD_RAID5_RESHAPE=y +CONFIG_MD_MULTIPATH=m +CONFIG_MD_FAULTY=m +CONFIG_BLK_DEV_DM=m +# CONFIG_DM_DEBUG is not set +CONFIG_DM_CRYPT=m +CONFIG_DM_SNAPSHOT=m +CONFIG_DM_MIRROR=m +CONFIG_DM_ZERO=m +CONFIG_DM_MULTIPATH=m +CONFIG_DM_DELAY=m +# CONFIG_DM_UEVENT is not set +CONFIG_NETDEVICES=y +CONFIG_DUMMY=m +CONFIG_BONDING=m +CONFIG_MACVLAN=m +CONFIG_EQUALIZER=m +CONFIG_TUN=m +CONFIG_VETH=m +# CONFIG_NET_ETHERNET is not set +CONFIG_MII=y +# CONFIG_NETDEV_1000 is not set +# CONFIG_NETDEV_10000 is not set + +# +# Wireless LAN +# +# CONFIG_WLAN_PRE80211 is not set +CONFIG_WLAN_80211=y +CONFIG_LIBERTAS=y +CONFIG_LIBERTAS_USB=y +# CONFIG_LIBERTAS_SDIO is not set +# CONFIG_LIBERTAS_DEBUG is not set +# CONFIG_LIBERTAS_THINFIRM is not set +CONFIG_USB_ZD1201=y +CONFIG_USB_NET_RNDIS_WLAN=y +CONFIG_RTL8187=y +# CONFIG_MAC80211_HWSIM is not set +CONFIG_P54_COMMON=y +CONFIG_P54_USB=y +# CONFIG_IWLWIFI_LEDS is not set +CONFIG_HOSTAP=y +CONFIG_HOSTAP_FIRMWARE=y +CONFIG_HOSTAP_FIRMWARE_NVRAM=y +CONFIG_B43=y +CONFIG_B43_LEDS=y +# CONFIG_B43_DEBUG is not set +# CONFIG_B43LEGACY is not set +CONFIG_ZD1211RW=y +# CONFIG_ZD1211RW_DEBUG is not set +CONFIG_RT2X00=y +CONFIG_RT2500USB=y +CONFIG_RT73USB=y +CONFIG_RT2X00_LIB_USB=y +CONFIG_RT2X00_LIB=y +CONFIG_RT2X00_LIB_FIRMWARE=y +CONFIG_RT2X00_LIB_CRYPTO=y +CONFIG_RT2X00_LIB_LEDS=y +# CONFIG_RT2X00_DEBUG is not set + +# +# WiMAX Wireless Broadband devices +# +# CONFIG_WIMAX_I2400M_USB is not set +# CONFIG_WIMAX_I2400M_SDIO is not set + +# +# USB Network Adapters +# +CONFIG_USB_CATC=y +CONFIG_USB_KAWETH=y +CONFIG_USB_PEGASUS=y +CONFIG_USB_RTL8150=y +CONFIG_USB_USBNET=y +CONFIG_USB_NET_AX8817X=y +CONFIG_USB_NET_CDCETHER=y +CONFIG_USB_NET_DM9601=y +CONFIG_USB_NET_SMSC95XX=y +CONFIG_USB_NET_GL620A=y +CONFIG_USB_NET_NET1080=y +CONFIG_USB_NET_PLUSB=y +CONFIG_USB_NET_MCS7830=y +CONFIG_USB_NET_RNDIS_HOST=y +CONFIG_USB_NET_CDC_SUBSET=y +CONFIG_USB_ALI_M5632=y +CONFIG_USB_AN2720=y +CONFIG_USB_BELKIN=y +CONFIG_USB_ARMLINUX=y +CONFIG_USB_EPSON2888=y +CONFIG_USB_KC2190=y +CONFIG_USB_NET_ZAURUS=y +# CONFIG_WAN is not set +CONFIG_ATM_DRIVERS=y +# CONFIG_ATM_DUMMY is not set +# CONFIG_ATM_TCP is not set +CONFIG_PPP=m +CONFIG_PPP_MULTILINK=y +CONFIG_PPP_FILTER=y +CONFIG_PPP_ASYNC=m +CONFIG_PPP_SYNC_TTY=m +CONFIG_PPP_DEFLATE=m +CONFIG_PPP_BSDCOMP=m +CONFIG_PPP_MPPE=m +CONFIG_PPPOE=m +# CONFIG_PPPOATM is not set +CONFIG_PPPOL2TP=m +# CONFIG_SLIP is not set +CONFIG_SLHC=m +CONFIG_NETCONSOLE=m +CONFIG_NETCONSOLE_DYNAMIC=y +CONFIG_NETPOLL=y +CONFIG_NETPOLL_TRAP=y +CONFIG_NET_POLL_CONTROLLER=y +# CONFIG_ISDN is not set + +# +# Input device support +# +CONFIG_INPUT=y +CONFIG_INPUT_FF_MEMLESS=y +# CONFIG_INPUT_POLLDEV is not set + +# +# Userland interfaces +# +CONFIG_INPUT_MOUSEDEV=y +CONFIG_INPUT_MOUSEDEV_PSAUX=y +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 +# CONFIG_INPUT_JOYDEV is not set +CONFIG_INPUT_EVDEV=y +# CONFIG_INPUT_EVBUG is not set + +# +# Input Device Drivers +# +CONFIG_INPUT_KEYBOARD=y +# CONFIG_KEYBOARD_ATKBD is not set +# CONFIG_KEYBOARD_SUNKBD is not set +# CONFIG_KEYBOARD_LKKBD is not set +# CONFIG_KEYBOARD_XTKBD is not set +# CONFIG_KEYBOARD_NEWTON is not set +# CONFIG_KEYBOARD_STOWAWAY is not set +# CONFIG_KEYBOARD_TWL4030 is not set +# CONFIG_KEYBOARD_LM8323 is not set +CONFIG_KEYBOARD_GPIO=y +CONFIG_INPUT_MOUSE=y +CONFIG_MOUSE_PS2=y +CONFIG_MOUSE_PS2_ALPS=y +CONFIG_MOUSE_PS2_LOGIPS2PP=y +CONFIG_MOUSE_PS2_SYNAPTICS=y +CONFIG_MOUSE_PS2_TRACKPOINT=y +# CONFIG_MOUSE_PS2_ELANTECH is not set +# CONFIG_MOUSE_PS2_TOUCHKIT is not set +# CONFIG_MOUSE_SERIAL is not set +# CONFIG_MOUSE_APPLETOUCH is not set +# CONFIG_MOUSE_BCM5974 is not set +# CONFIG_MOUSE_VSXXXAA is not set +# CONFIG_MOUSE_GPIO is not set +# CONFIG_INPUT_JOYSTICK is not set +# CONFIG_INPUT_TABLET is not set +CONFIG_INPUT_TOUCHSCREEN=y +CONFIG_TOUCHSCREEN_ADS7846=y +# CONFIG_TOUCHSCREEN_FUJITSU is not set +# CONFIG_TOUCHSCREEN_GUNZE is not set +# CONFIG_TOUCHSCREEN_ELO is not set +# CONFIG_TOUCHSCREEN_WACOM_W8001 is not set +# CONFIG_TOUCHSCREEN_MTOUCH is not set +# CONFIG_TOUCHSCREEN_INEXIO is not set +# CONFIG_TOUCHSCREEN_MK712 is not set +# CONFIG_TOUCHSCREEN_PENMOUNT is not set +# CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set +# CONFIG_TOUCHSCREEN_TOUCHWIN is not set +# CONFIG_TOUCHSCREEN_TSC2005 is not set +# CONFIG_TOUCHSCREEN_TSC210X is not set +# CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set +# CONFIG_TOUCHSCREEN_TOUCHIT213 is not set +# CONFIG_TOUCHSCREEN_TSC2007 is not set +CONFIG_INPUT_MISC=y +# CONFIG_INPUT_ATI_REMOTE is not set +# CONFIG_INPUT_ATI_REMOTE2 is not set +# CONFIG_INPUT_KEYSPAN_REMOTE is not set +# CONFIG_INPUT_POWERMATE is not set +# CONFIG_INPUT_YEALINK is not set +# CONFIG_INPUT_CM109 is not set +CONFIG_INPUT_TWL4030_PWRBUTTON=y +CONFIG_INPUT_UINPUT=y +CONFIG_INPUT_MMA7455L=y + +# +# Hardware I/O ports +# +CONFIG_SERIO=y +CONFIG_SERIO_SERPORT=y +CONFIG_SERIO_LIBPS2=y +# CONFIG_SERIO_RAW is not set +# CONFIG_GAMEPORT is not set + +# +# Character devices +# +CONFIG_VT=y +CONFIG_CONSOLE_TRANSLATIONS=y +CONFIG_VT_CONSOLE=y +CONFIG_HW_CONSOLE=y +CONFIG_VT_HW_CONSOLE_BINDING=y +CONFIG_DEVKMEM=y +# CONFIG_SERIAL_NONSTANDARD is not set + +# +# Serial drivers +# +CONFIG_SERIAL_8250=y +CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_NR_UARTS=32 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4 +CONFIG_SERIAL_8250_EXTENDED=y +CONFIG_SERIAL_8250_MANY_PORTS=y +CONFIG_SERIAL_8250_SHARE_IRQ=y +CONFIG_SERIAL_8250_DETECT_IRQ=y +CONFIG_SERIAL_8250_RSA=y + +# +# Non-8250 serial port support +# +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +CONFIG_UNIX98_PTYS=y +# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set +# CONFIG_LEGACY_PTYS is not set +# CONFIG_IPMI_HANDLER is not set +CONFIG_HW_RANDOM=y +# CONFIG_R3964 is not set +# CONFIG_RAW_DRIVER is not set +# CONFIG_TCG_TPM is not set +CONFIG_I2C=y +CONFIG_I2C_BOARDINFO=y +CONFIG_I2C_CHARDEV=y +CONFIG_I2C_HELPER_AUTO=y + +# +# I2C Hardware Bus support +# + +# +# I2C system bus drivers (mostly embedded / system-on-chip) +# +# CONFIG_I2C_GPIO is not set +# CONFIG_I2C_OCORES is not set +CONFIG_I2C_OMAP=y +# CONFIG_I2C_SIMTEC is not set + +# +# External I2C/SMBus adapter drivers +# +# CONFIG_I2C_PARPORT_LIGHT is not set +# CONFIG_I2C_TAOS_EVM is not set +# CONFIG_I2C_TINY_USB is not set + +# +# Other I2C/SMBus bus drivers +# +# CONFIG_I2C_PCA_PLATFORM is not set +# CONFIG_I2C_STUB is not set + +# +# Miscellaneous I2C Chip support +# +# CONFIG_DS1682 is not set +# CONFIG_SENSORS_PCF8574 is not set +# CONFIG_PCF8575 is not set +# CONFIG_SENSORS_PCA9539 is not set +# CONFIG_SENSORS_PCF8591 is not set +CONFIG_TWL4030_MADC=y +CONFIG_TWL4030_POWEROFF=y +# CONFIG_SENSORS_MAX6875 is not set +# CONFIG_SENSORS_TSL2550 is not set +# CONFIG_SENSORS_TSL2563 is not set +# CONFIG_I2C_DEBUG_CORE is not set +# CONFIG_I2C_DEBUG_ALGO is not set +# CONFIG_I2C_DEBUG_BUS is not set +# CONFIG_I2C_DEBUG_CHIP is not set +CONFIG_SPI=y +# CONFIG_SPI_DEBUG is not set +CONFIG_SPI_MASTER=y + +# +# SPI Master Controller Drivers +# +# CONFIG_SPI_BITBANG is not set +# CONFIG_SPI_GPIO is not set +CONFIG_SPI_OMAP24XX=y + +# +# SPI Protocol Masters +# +# CONFIG_SPI_TSC210X is not set +# CONFIG_SPI_TSC2301 is not set +# CONFIG_SPI_SPIDEV is not set +# CONFIG_SPI_TLE62X0 is not set +CONFIG_ARCH_REQUIRE_GPIOLIB=y +CONFIG_GPIOLIB=y +# CONFIG_DEBUG_GPIO is not set +CONFIG_GPIO_SYSFS=y + +# +# Memory mapped GPIO expanders: +# + +# +# I2C GPIO expanders: +# +# CONFIG_GPIO_MAX732X is not set +# CONFIG_GPIO_PCA953X is not set +# CONFIG_GPIO_PCF857X is not set +CONFIG_GPIO_TWL4030=y + +# +# PCI GPIO expanders: +# + +# +# SPI GPIO expanders: +# +# CONFIG_GPIO_MAX7301 is not set +# CONFIG_GPIO_MCP23S08 is not set +# CONFIG_W1 is not set +CONFIG_POWER_SUPPLY=y +# CONFIG_POWER_SUPPLY_DEBUG is not set +# CONFIG_PDA_POWER is not set +# CONFIG_BATTERY_DS2760 is not set +CONFIG_TWL4030_BCI_BATTERY=y +CONFIG_BATTERY_BQ27x00=y +CONFIG_HWMON=y +# CONFIG_HWMON_VID is not set +# CONFIG_SENSORS_AD7414 is not set +# CONFIG_SENSORS_AD7418 is not set +# CONFIG_SENSORS_ADCXX is not set +# CONFIG_SENSORS_ADM1021 is not set +# CONFIG_SENSORS_ADM1025 is not set +# CONFIG_SENSORS_ADM1026 is not set +# CONFIG_SENSORS_ADM1029 is not set +# CONFIG_SENSORS_ADM1031 is not set +# CONFIG_SENSORS_ADM9240 is not set +# CONFIG_SENSORS_ADT7462 is not set +# CONFIG_SENSORS_ADT7470 is not set +# CONFIG_SENSORS_ADT7473 is not set +# CONFIG_SENSORS_ADT7475 is not set +# CONFIG_SENSORS_ATXP1 is not set +# CONFIG_SENSORS_DS1621 is not set +# CONFIG_SENSORS_F71805F is not set +# CONFIG_SENSORS_F71882FG is not set +# CONFIG_SENSORS_F75375S is not set +# CONFIG_SENSORS_GL518SM is not set +# CONFIG_SENSORS_GL520SM is not set +# CONFIG_SENSORS_IT87 is not set +# CONFIG_SENSORS_LM63 is not set +# CONFIG_SENSORS_LM70 is not set +# CONFIG_SENSORS_LM75 is not set +# CONFIG_SENSORS_LM77 is not set +# CONFIG_SENSORS_LM78 is not set +# CONFIG_SENSORS_LM80 is not set +# CONFIG_SENSORS_LM83 is not set +# CONFIG_SENSORS_LM85 is not set +# CONFIG_SENSORS_LM87 is not set +# CONFIG_SENSORS_LM90 is not set +# CONFIG_SENSORS_LM92 is not set +# CONFIG_SENSORS_LM93 is not set +# CONFIG_SENSORS_LTC4245 is not set +# CONFIG_SENSORS_MAX1111 is not set +# CONFIG_SENSORS_MAX1619 is not set +# CONFIG_SENSORS_MAX6650 is not set +# CONFIG_SENSORS_PC87360 is not set +# CONFIG_SENSORS_PC87427 is not set +# CONFIG_SENSORS_DME1737 is not set +# CONFIG_SENSORS_SMSC47M1 is not set +# CONFIG_SENSORS_SMSC47M192 is not set +# CONFIG_SENSORS_SMSC47B397 is not set +# CONFIG_SENSORS_ADS7828 is not set +# CONFIG_SENSORS_THMC50 is not set +# CONFIG_SENSORS_VT1211 is not set +# CONFIG_SENSORS_W83781D is not set +# CONFIG_SENSORS_W83791D is not set +# CONFIG_SENSORS_W83792D is not set +# CONFIG_SENSORS_W83793 is not set +# CONFIG_SENSORS_W83L785TS is not set +# CONFIG_SENSORS_W83L786NG is not set +# CONFIG_SENSORS_W83627HF is not set +# CONFIG_SENSORS_W83627EHF is not set +# CONFIG_SENSORS_TSC210X is not set +CONFIG_SENSORS_OMAP34XX=y +# CONFIG_HWMON_DEBUG_CHIP is not set +CONFIG_THERMAL=y +CONFIG_THERMAL_HWMON=y +CONFIG_WATCHDOG=y +CONFIG_WATCHDOG_NOWAYOUT=y + +# +# Watchdog Device Drivers +# +# CONFIG_SOFT_WATCHDOG is not set +CONFIG_OMAP_WATCHDOG=y + +# +# USB-based Watchdog Cards +# +# CONFIG_USBPCWATCHDOG is not set +CONFIG_SSB_POSSIBLE=y + +# +# Sonics Silicon Backplane +# +CONFIG_SSB=y +# CONFIG_SSB_SILENT is not set +# CONFIG_SSB_DEBUG is not set + +# +# Multifunction device drivers +# +# CONFIG_MFD_CORE is not set +# CONFIG_MFD_SM501 is not set +# CONFIG_MFD_ASIC3 is not set +# CONFIG_HTC_EGPIO is not set +# CONFIG_HTC_PASIC3 is not set +# CONFIG_TPS65010 is not set +CONFIG_TWL4030_CORE=y +# CONFIG_TWL4030_POWER is not set +# CONFIG_MFD_TMIO is not set +# CONFIG_MFD_T7L66XB is not set +# CONFIG_MFD_TC6387XB is not set +# CONFIG_MFD_TC6393XB is not set +# CONFIG_PMIC_DA903X is not set +# CONFIG_MFD_WM8400 is not set +# CONFIG_MFD_WM8350_I2C is not set +# CONFIG_MFD_PCF50633 is not set + +# +# Multimedia devices +# + +# +# Multimedia core support +# +CONFIG_VIDEO_DEV=m +CONFIG_VIDEO_V4L2_COMMON=m +CONFIG_VIDEO_ALLOW_V4L1=y +CONFIG_VIDEO_V4L1_COMPAT=y +CONFIG_DVB_CORE=m +CONFIG_VIDEO_MEDIA=m + +# +# Multimedia drivers +# +CONFIG_MEDIA_ATTACH=y +CONFIG_MEDIA_TUNER=m +# CONFIG_MEDIA_TUNER_CUSTOMIZE is not set +CONFIG_MEDIA_TUNER_SIMPLE=m +CONFIG_MEDIA_TUNER_TDA8290=m +CONFIG_MEDIA_TUNER_TDA827X=m +CONFIG_MEDIA_TUNER_TDA18271=m +CONFIG_MEDIA_TUNER_TDA9887=m +CONFIG_MEDIA_TUNER_TEA5761=m +CONFIG_MEDIA_TUNER_TEA5767=m +CONFIG_MEDIA_TUNER_MT20XX=m +CONFIG_MEDIA_TUNER_MT2060=m +CONFIG_MEDIA_TUNER_MT2266=m +CONFIG_MEDIA_TUNER_QT1010=m +CONFIG_MEDIA_TUNER_XC2028=m +CONFIG_MEDIA_TUNER_XC5000=m +CONFIG_MEDIA_TUNER_MXL5005S=m +CONFIG_VIDEO_V4L2=m +CONFIG_VIDEO_V4L1=m +CONFIG_VIDEOBUF_GEN=m +CONFIG_VIDEOBUF_VMALLOC=m +CONFIG_VIDEOBUF_DVB=m +CONFIG_VIDEO_IR=m +CONFIG_VIDEO_TVEEPROM=m +CONFIG_VIDEO_TUNER=m +CONFIG_VIDEO_CAPTURE_DRIVERS=y +# CONFIG_VIDEO_ADV_DEBUG is not set +# CONFIG_VIDEO_FIXED_MINOR_RANGES is not set +CONFIG_VIDEO_HELPER_CHIPS_AUTO=y +CONFIG_VIDEO_IR_I2C=m +CONFIG_VIDEO_MSP3400=m +CONFIG_VIDEO_CS53L32A=m +CONFIG_VIDEO_WM8775=m +CONFIG_VIDEO_SAA711X=m +CONFIG_VIDEO_TVP5150=m +CONFIG_VIDEO_CX25840=m +CONFIG_VIDEO_CX2341X=m +CONFIG_VIDEO_VIVI=m +# CONFIG_VIDEO_CPIA is not set +# CONFIG_VIDEO_CPIA2 is not set +# CONFIG_VIDEO_SAA5246A is not set +# CONFIG_VIDEO_SAA5249 is not set +# CONFIG_VIDEO_AU0828 is not set +# CONFIG_VIDEO_OMAP3 is not set +# CONFIG_SOC_CAMERA is not set +CONFIG_V4L_USB_DRIVERS=y +CONFIG_USB_VIDEO_CLASS=m +CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y +CONFIG_USB_GSPCA=m +CONFIG_USB_M5602=m +CONFIG_USB_STV06XX=m +CONFIG_USB_GSPCA_CONEX=m +CONFIG_USB_GSPCA_ETOMS=m +CONFIG_USB_GSPCA_FINEPIX=m +CONFIG_USB_GSPCA_MARS=m +CONFIG_USB_GSPCA_OV519=m +CONFIG_USB_GSPCA_OV534=m +CONFIG_USB_GSPCA_PAC207=m +CONFIG_USB_GSPCA_PAC7311=m +CONFIG_USB_GSPCA_SONIXB=m +CONFIG_USB_GSPCA_SONIXJ=m +CONFIG_USB_GSPCA_SPCA500=m +CONFIG_USB_GSPCA_SPCA501=m +CONFIG_USB_GSPCA_SPCA505=m +CONFIG_USB_GSPCA_SPCA506=m +CONFIG_USB_GSPCA_SPCA508=m +CONFIG_USB_GSPCA_SPCA561=m +CONFIG_USB_GSPCA_STK014=m +CONFIG_USB_GSPCA_SUNPLUS=m +CONFIG_USB_GSPCA_T613=m +CONFIG_USB_GSPCA_TV8532=m +CONFIG_USB_GSPCA_VC032X=m +CONFIG_USB_GSPCA_ZC3XX=m +CONFIG_VIDEO_PVRUSB2=m +CONFIG_VIDEO_PVRUSB2_SYSFS=y +CONFIG_VIDEO_PVRUSB2_DVB=y +# CONFIG_VIDEO_PVRUSB2_DEBUGIFC is not set +CONFIG_VIDEO_EM28XX=m +CONFIG_VIDEO_EM28XX_ALSA=m +CONFIG_VIDEO_EM28XX_DVB=m +CONFIG_VIDEO_USBVISION=m +CONFIG_VIDEO_USBVIDEO=m +CONFIG_USB_VICAM=m +CONFIG_USB_IBMCAM=m +CONFIG_USB_KONICAWC=m +CONFIG_USB_QUICKCAM_MESSENGER=m +CONFIG_USB_ET61X251=m +CONFIG_VIDEO_OVCAMCHIP=m +CONFIG_USB_W9968CF=m +CONFIG_USB_OV511=m +CONFIG_USB_SE401=m +CONFIG_USB_SN9C102=m +CONFIG_USB_STV680=m +CONFIG_USB_ZC0301=m +CONFIG_USB_PWC=m +# CONFIG_USB_PWC_DEBUG is not set +CONFIG_USB_ZR364XX=m +CONFIG_USB_STKWEBCAM=m +CONFIG_USB_S2255=m +CONFIG_RADIO_ADAPTERS=y +# CONFIG_USB_DSBR is not set +# CONFIG_USB_SI470X is not set +# CONFIG_USB_MR800 is not set +# CONFIG_RADIO_TEA5764 is not set +CONFIG_DVB_DYNAMIC_MINORS=y +CONFIG_DVB_CAPTURE_DRIVERS=y +# CONFIG_TTPCI_EEPROM is not set + +# +# Supported USB Adapters +# +CONFIG_DVB_USB=m +# CONFIG_DVB_USB_DEBUG is not set +CONFIG_DVB_USB_A800=m +CONFIG_DVB_USB_DIBUSB_MB=m +# CONFIG_DVB_USB_DIBUSB_MB_FAULTY is not set +CONFIG_DVB_USB_DIBUSB_MC=m +CONFIG_DVB_USB_DIB0700=m +CONFIG_DVB_USB_UMT_010=m +CONFIG_DVB_USB_CXUSB=m +CONFIG_DVB_USB_M920X=m +CONFIG_DVB_USB_GL861=m +CONFIG_DVB_USB_AU6610=m +CONFIG_DVB_USB_DIGITV=m +CONFIG_DVB_USB_VP7045=m +CONFIG_DVB_USB_VP702X=m +CONFIG_DVB_USB_GP8PSK=m +CONFIG_DVB_USB_NOVA_T_USB2=m +CONFIG_DVB_USB_TTUSB2=m +CONFIG_DVB_USB_DTT200U=m +CONFIG_DVB_USB_OPERA1=m +CONFIG_DVB_USB_AF9005=m +CONFIG_DVB_USB_AF9005_REMOTE=m +CONFIG_DVB_USB_DW2102=m +CONFIG_DVB_USB_CINERGY_T2=m +CONFIG_DVB_USB_ANYSEE=m +CONFIG_DVB_USB_DTV5100=m +CONFIG_DVB_USB_AF9015=m +CONFIG_DVB_SIANO_SMS1XXX=m +CONFIG_DVB_SIANO_SMS1XXX_SMS_IDS=y + +# +# Supported FlexCopII (B2C2) Adapters +# +CONFIG_DVB_B2C2_FLEXCOP=m +CONFIG_DVB_B2C2_FLEXCOP_USB=m +# CONFIG_DVB_B2C2_FLEXCOP_DEBUG is not set + +# +# Supported DVB Frontends +# + +# +# Customise DVB Frontends +# +# CONFIG_DVB_FE_CUSTOMISE is not set + +# +# Multistandard (satellite) frontends +# +CONFIG_DVB_STB0899=m +CONFIG_DVB_STB6100=m + +# +# DVB-S (satellite) frontends +# +CONFIG_DVB_CX24110=m +CONFIG_DVB_CX24123=m +CONFIG_DVB_MT312=m +CONFIG_DVB_S5H1420=m +CONFIG_DVB_STV0288=m +CONFIG_DVB_STB6000=m +CONFIG_DVB_STV0299=m +CONFIG_DVB_TDA8083=m +CONFIG_DVB_TDA10086=m +CONFIG_DVB_TDA8261=m +CONFIG_DVB_VES1X93=m +CONFIG_DVB_TUNER_ITD1000=m +CONFIG_DVB_TUNER_CX24113=m +CONFIG_DVB_TDA826X=m +CONFIG_DVB_TUA6100=m +CONFIG_DVB_CX24116=m +CONFIG_DVB_SI21XX=m + +# +# DVB-T (terrestrial) frontends +# +CONFIG_DVB_SP8870=m +CONFIG_DVB_SP887X=m +CONFIG_DVB_CX22700=m +CONFIG_DVB_CX22702=m +CONFIG_DVB_DRX397XD=m +CONFIG_DVB_L64781=m +CONFIG_DVB_TDA1004X=m +CONFIG_DVB_NXT6000=m +CONFIG_DVB_MT352=m +CONFIG_DVB_ZL10353=m +CONFIG_DVB_DIB3000MB=m +CONFIG_DVB_DIB3000MC=m +CONFIG_DVB_DIB7000M=m +CONFIG_DVB_DIB7000P=m +CONFIG_DVB_TDA10048=m + +# +# DVB-C (cable) frontends +# +CONFIG_DVB_VES1820=m +CONFIG_DVB_TDA10021=m +CONFIG_DVB_TDA10023=m +CONFIG_DVB_STV0297=m + +# +# ATSC (North American/Korean Terrestrial/Cable DTV) frontends +# +CONFIG_DVB_NXT200X=m +CONFIG_DVB_OR51211=m +CONFIG_DVB_OR51132=m +CONFIG_DVB_BCM3510=m +CONFIG_DVB_LGDT330X=m +CONFIG_DVB_LGDT3304=m +CONFIG_DVB_S5H1409=m +CONFIG_DVB_AU8522=m +CONFIG_DVB_S5H1411=m + +# +# ISDB-T (terrestrial) frontends +# +CONFIG_DVB_S921=m + +# +# Digital terrestrial only tuners/PLL +# +CONFIG_DVB_PLL=m +CONFIG_DVB_TUNER_DIB0070=m + +# +# SEC control devices for DVB-S +# +CONFIG_DVB_LNBP21=m +# CONFIG_DVB_ISL6405 is not set +CONFIG_DVB_ISL6421=m +CONFIG_DVB_LGS8GL5=m + +# +# Tools to develop new frontends +# +# CONFIG_DVB_DUMMY_FE is not set +CONFIG_DVB_AF9013=m +# CONFIG_DAB is not set + +# +# Graphics support +# +# CONFIG_VGASTATE is not set +# CONFIG_VIDEO_OUTPUT_CONTROL is not set +CONFIG_FB=y +# CONFIG_FIRMWARE_EDID is not set +# CONFIG_FB_DDC is not set +# CONFIG_FB_BOOT_VESA_SUPPORT is not set +CONFIG_FB_CFB_FILLRECT=y +CONFIG_FB_CFB_COPYAREA=y +CONFIG_FB_CFB_IMAGEBLIT=y +# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set +# CONFIG_FB_SYS_FILLRECT is not set +# CONFIG_FB_SYS_COPYAREA is not set +# CONFIG_FB_SYS_IMAGEBLIT is not set +# CONFIG_FB_FOREIGN_ENDIAN is not set +# CONFIG_FB_SYS_FOPS is not set +# CONFIG_FB_SVGALIB is not set +# CONFIG_FB_MACMODES is not set +# CONFIG_FB_BACKLIGHT is not set +# CONFIG_FB_MODE_HELPERS is not set +# CONFIG_FB_TILEBLITTING is not set + +# +# Frame buffer hardware drivers +# +# CONFIG_FB_S1D13XXX is not set +# CONFIG_FB_VIRTUAL is not set +# CONFIG_FB_METRONOME is not set +# CONFIG_FB_MB862XX is not set +# CONFIG_FB_OMAP_BOOTLOADER_INIT is not set +CONFIG_OMAP2_DSS=y +CONFIG_OMAP2_DSS_VRAM_SIZE=14 +CONFIG_OMAP2_DSS_DEBUG_SUPPORT=y +# CONFIG_OMAP2_DSS_RFBI is not set +CONFIG_OMAP2_DSS_VENC=y +# CONFIG_OMAP2_DSS_SDI is not set +CONFIG_OMAP2_DSS_DSI=y +CONFIG_OMAP2_DSS_USE_DSI_PLL=y +# CONFIG_OMAP2_DSS_FAKE_VSYNC is not set +CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK=1 + +# +# OMAP2/3 Display Device Drivers +# +CONFIG_PANEL_GENERIC=y +CONFIG_PANEL_SAMSUNG_LTE430WQ_F0C=m +# CONFIG_PANEL_SHARP_LS037V7DW01 is not set +# CONFIG_PANEL_N800 is not set +# CONFIG_CTRL_BLIZZARD is not set +CONFIG_FB_OMAP2=y +CONFIG_FB_OMAP2_DEBUG_SUPPORT=y +# CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE is not set +CONFIG_FB_OMAP2_NUM_FBS=3 +# CONFIG_BACKLIGHT_LCD_SUPPORT is not set +CONFIG_BACKLIGHT_CLASS_DEVICE=y +CONFIG_BACKLIGHT_GENERIC=y + +# +# Display device support +# +CONFIG_DISPLAY_SUPPORT=y + +# +# Display hardware drivers +# + +# +# Console display driver support +# +# CONFIG_VGA_CONSOLE is not set +CONFIG_DUMMY_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE=y +# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set +CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y +# CONFIG_FONTS is not set +CONFIG_FONT_8x8=y +CONFIG_FONT_8x16=y +CONFIG_LOGO=y +CONFIG_LOGO_LINUX_MONO=y +CONFIG_LOGO_LINUX_VGA16=y +CONFIG_LOGO_LINUX_CLUT224=y +CONFIG_SOUND=y +CONFIG_SOUND_OSS_CORE=y +CONFIG_SND=y +CONFIG_SND_TIMER=y +CONFIG_SND_PCM=y +CONFIG_SND_HWDEP=y +CONFIG_SND_RAWMIDI=y +CONFIG_SND_SEQUENCER=m +# CONFIG_SND_SEQ_DUMMY is not set +CONFIG_SND_OSSEMUL=y +CONFIG_SND_MIXER_OSS=y +CONFIG_SND_PCM_OSS=y +CONFIG_SND_PCM_OSS_PLUGINS=y +CONFIG_SND_SEQUENCER_OSS=y +CONFIG_SND_HRTIMER=m +CONFIG_SND_SEQ_HRTIMER_DEFAULT=y +# CONFIG_SND_DYNAMIC_MINORS is not set +CONFIG_SND_SUPPORT_OLD_API=y +CONFIG_SND_VERBOSE_PROCFS=y +# CONFIG_SND_VERBOSE_PRINTK is not set +# CONFIG_SND_DEBUG is not set +CONFIG_SND_DRIVERS=y +# CONFIG_SND_DUMMY is not set +# CONFIG_SND_VIRMIDI is not set +# CONFIG_SND_MTPAV is not set +# CONFIG_SND_SERIAL_U16550 is not set +# CONFIG_SND_MPU401 is not set +# CONFIG_SND_ARM is not set +CONFIG_SND_SPI=y +CONFIG_SND_USB=y +CONFIG_SND_USB_AUDIO=y +CONFIG_SND_USB_CAIAQ=m +CONFIG_SND_USB_CAIAQ_INPUT=y +CONFIG_SND_SOC=y +CONFIG_SND_OMAP_SOC=y +CONFIG_SND_OMAP_SOC_MCBSP=y +CONFIG_SND_OMAP_SOC_OMAP3_BEAGLE=y +CONFIG_SND_SOC_I2C_AND_SPI=y +# CONFIG_SND_SOC_ALL_CODECS is not set +CONFIG_SND_SOC_TWL4030=y +# CONFIG_SOUND_PRIME is not set +CONFIG_HID_SUPPORT=y +CONFIG_HID=y +CONFIG_HID_DEBUG=y +# CONFIG_HIDRAW is not set + +# +# USB Input Devices +# +CONFIG_USB_HID=y +# CONFIG_HID_PID is not set +# CONFIG_USB_HIDDEV is not set + +# +# Special HID drivers +# +CONFIG_HID_COMPAT=y +CONFIG_HID_A4TECH=y +CONFIG_HID_APPLE=y +CONFIG_HID_BELKIN=y +CONFIG_HID_CHERRY=y +CONFIG_HID_CHICONY=y +CONFIG_HID_CYPRESS=y +CONFIG_HID_EZKEY=y +CONFIG_HID_GYRATION=y +CONFIG_HID_LOGITECH=y +# CONFIG_LOGITECH_FF is not set +# CONFIG_LOGIRUMBLEPAD2_FF is not set +CONFIG_HID_MICROSOFT=y +CONFIG_HID_MONTEREY=y +CONFIG_HID_NTRIG=y +CONFIG_HID_PANTHERLORD=y +# CONFIG_PANTHERLORD_FF is not set +CONFIG_HID_PETALYNX=y +CONFIG_HID_SAMSUNG=y +CONFIG_HID_SONY=y +CONFIG_HID_SUNPLUS=y +CONFIG_GREENASIA_FF=y +CONFIG_HID_TOPSEED=y +# CONFIG_THRUSTMASTER_FF is not set +# CONFIG_ZEROPLUS_FF is not set +CONFIG_USB_SUPPORT=y +CONFIG_USB_ARCH_HAS_HCD=y +CONFIG_USB_ARCH_HAS_OHCI=y +CONFIG_USB_ARCH_HAS_EHCI=y +CONFIG_USB=y +# CONFIG_USB_DEBUG is not set +# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set + +# +# Miscellaneous USB options +# +CONFIG_USB_DEVICEFS=y +CONFIG_USB_DEVICE_CLASS=y +# CONFIG_USB_DYNAMIC_MINORS is not set +CONFIG_USB_SUSPEND=y +CONFIG_USB_OTG=y +# CONFIG_USB_OTG_WHITELIST is not set +# CONFIG_USB_OTG_BLACKLIST_HUB is not set +CONFIG_USB_MON=y +# CONFIG_USB_WUSB is not set +# CONFIG_USB_WUSB_CBAF is not set + +# +# USB Host Controller Drivers +# +# CONFIG_USB_C67X00_HCD is not set +CONFIG_USB_EHCI_HCD=y +CONFIG_OMAP_EHCI_PHY_MODE=y +# CONFIG_OMAP_EHCI_TLL_MODE is not set +CONFIG_USB_EHCI_ROOT_HUB_TT=y +CONFIG_USB_EHCI_TT_NEWSCHED=y +CONFIG_USB_OXU210HP_HCD=y +# CONFIG_USB_ISP116X_HCD is not set +# CONFIG_USB_OHCI_HCD is not set +# CONFIG_USB_U132_HCD is not set +# CONFIG_USB_SL811_HCD is not set +# CONFIG_USB_R8A66597_HCD is not set +# CONFIG_USB_HWA_HCD is not set +CONFIG_USB_MUSB_HDRC=y +CONFIG_USB_MUSB_SOC=y + +# +# OMAP 343x high speed USB support +# +# CONFIG_USB_MUSB_HOST is not set +# CONFIG_USB_MUSB_PERIPHERAL is not set +CONFIG_USB_MUSB_OTG=y +CONFIG_USB_GADGET_MUSB_HDRC=y +CONFIG_USB_MUSB_HDRC_HCD=y +# CONFIG_MUSB_PIO_ONLY is not set +CONFIG_USB_INVENTRA_DMA=y +# CONFIG_USB_TI_CPPI_DMA is not set +# CONFIG_USB_MUSB_DEBUG is not set + +# +# USB Device Class drivers +# +CONFIG_USB_ACM=m +CONFIG_USB_PRINTER=m +CONFIG_USB_WDM=m +CONFIG_USB_TMC=m + +# +# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed; +# + +# +# see USB_STORAGE Help for more information +# +CONFIG_USB_STORAGE=y +# CONFIG_USB_STORAGE_DEBUG is not set +# CONFIG_USB_STORAGE_DATAFAB is not set +# CONFIG_USB_STORAGE_FREECOM is not set +# CONFIG_USB_STORAGE_ISD200 is not set +# CONFIG_USB_STORAGE_USBAT is not set +# CONFIG_USB_STORAGE_SDDR09 is not set +# CONFIG_USB_STORAGE_SDDR55 is not set +# CONFIG_USB_STORAGE_JUMPSHOT is not set +# CONFIG_USB_STORAGE_ALAUDA is not set +# CONFIG_USB_STORAGE_ONETOUCH is not set +# CONFIG_USB_STORAGE_KARMA is not set +# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set +# CONFIG_USB_LIBUSUAL is not set + +# +# USB Imaging devices +# +# CONFIG_USB_MDC800 is not set +# CONFIG_USB_MICROTEK is not set + +# +# USB port drivers +# +CONFIG_USB_SERIAL=m +CONFIG_USB_EZUSB=y +CONFIG_USB_SERIAL_GENERIC=y +CONFIG_USB_SERIAL_AIRCABLE=m +CONFIG_USB_SERIAL_ARK3116=m +CONFIG_USB_SERIAL_BELKIN=m +CONFIG_USB_SERIAL_CH341=m +CONFIG_USB_SERIAL_WHITEHEAT=m +CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m +CONFIG_USB_SERIAL_CP2101=m +CONFIG_USB_SERIAL_CYPRESS_M8=m +CONFIG_USB_SERIAL_EMPEG=m +CONFIG_USB_SERIAL_FTDI_SIO=m +CONFIG_USB_SERIAL_FUNSOFT=m +CONFIG_USB_SERIAL_VISOR=m +CONFIG_USB_SERIAL_IPAQ=m +CONFIG_USB_SERIAL_IR=m +CONFIG_USB_SERIAL_EDGEPORT=m +CONFIG_USB_SERIAL_EDGEPORT_TI=m +CONFIG_USB_SERIAL_GARMIN=m +CONFIG_USB_SERIAL_IPW=m +CONFIG_USB_SERIAL_IUU=m +CONFIG_USB_SERIAL_KEYSPAN_PDA=m +CONFIG_USB_SERIAL_KEYSPAN=m +CONFIG_USB_SERIAL_KEYSPAN_MPR=y +CONFIG_USB_SERIAL_KEYSPAN_USA28=y +CONFIG_USB_SERIAL_KEYSPAN_USA28X=y +CONFIG_USB_SERIAL_KEYSPAN_USA28XA=y +CONFIG_USB_SERIAL_KEYSPAN_USA28XB=y +CONFIG_USB_SERIAL_KEYSPAN_USA19=y +CONFIG_USB_SERIAL_KEYSPAN_USA18X=y +CONFIG_USB_SERIAL_KEYSPAN_USA19W=y +CONFIG_USB_SERIAL_KEYSPAN_USA19QW=y +CONFIG_USB_SERIAL_KEYSPAN_USA19QI=y +CONFIG_USB_SERIAL_KEYSPAN_USA49W=y +CONFIG_USB_SERIAL_KEYSPAN_USA49WLC=y +CONFIG_USB_SERIAL_KLSI=m +CONFIG_USB_SERIAL_KOBIL_SCT=m +CONFIG_USB_SERIAL_MCT_U232=m +CONFIG_USB_SERIAL_MOS7720=m +CONFIG_USB_SERIAL_MOS7840=m +CONFIG_USB_SERIAL_MOTOROLA=m +CONFIG_USB_SERIAL_NAVMAN=m +CONFIG_USB_SERIAL_PL2303=m +CONFIG_USB_SERIAL_OTI6858=m +CONFIG_USB_SERIAL_SPCP8X5=m +CONFIG_USB_SERIAL_HP4X=m +CONFIG_USB_SERIAL_SAFE=m +# CONFIG_USB_SERIAL_SAFE_PADDED is not set +CONFIG_USB_SERIAL_SIEMENS_MPI=m +CONFIG_USB_SERIAL_SIERRAWIRELESS=m +CONFIG_USB_SERIAL_TI=m +CONFIG_USB_SERIAL_CYBERJACK=m +CONFIG_USB_SERIAL_XIRCOM=m +CONFIG_USB_SERIAL_OPTION=m +CONFIG_USB_SERIAL_OMNINET=m +CONFIG_USB_SERIAL_OPTICON=m +CONFIG_USB_SERIAL_DEBUG=m + +# +# USB Miscellaneous drivers +# +CONFIG_USB_EMI62=m +CONFIG_USB_EMI26=m +# CONFIG_USB_ADUTUX is not set +# CONFIG_USB_SEVSEG is not set +# CONFIG_USB_RIO500 is not set +CONFIG_USB_LEGOTOWER=m +CONFIG_USB_LCD=m +CONFIG_USB_BERRY_CHARGE=m +CONFIG_USB_LED=m +CONFIG_USB_CYPRESS_CY7C63=m +CONFIG_USB_CYTHERM=m +CONFIG_USB_PHIDGET=m +CONFIG_USB_PHIDGETKIT=m +CONFIG_USB_PHIDGETMOTORCONTROL=m +CONFIG_USB_PHIDGETSERVO=m +CONFIG_USB_IDMOUSE=m +CONFIG_USB_FTDI_ELAN=m +# CONFIG_USB_APPLEDISPLAY is not set +CONFIG_USB_SISUSBVGA=m +CONFIG_USB_SISUSBVGA_CON=y +CONFIG_USB_LD=m +CONFIG_USB_TRANCEVIBRATOR=m +# CONFIG_USB_IOWARRIOR is not set +CONFIG_USB_TEST=m +# CONFIG_USB_ISIGHTFW is not set +CONFIG_USB_VST=m +CONFIG_USB_ATM=m +CONFIG_USB_SPEEDTOUCH=m +CONFIG_USB_CXACRU=m +CONFIG_USB_UEAGLEATM=m +CONFIG_USB_XUSBATM=m +CONFIG_USB_GADGET=m +# CONFIG_USB_GADGET_DEBUG is not set +# CONFIG_USB_GADGET_DEBUG_FILES is not set +CONFIG_USB_GADGET_DEBUG_FS=y +CONFIG_USB_GADGET_VBUS_DRAW=2 +CONFIG_USB_GADGET_SELECTED=y +# CONFIG_USB_GADGET_AT91 is not set +# CONFIG_USB_GADGET_ATMEL_USBA is not set +# CONFIG_USB_GADGET_FSL_USB2 is not set +# CONFIG_USB_GADGET_LH7A40X is not set +# CONFIG_USB_GADGET_OMAP is not set +# CONFIG_USB_GADGET_PXA25X is not set +# CONFIG_USB_GADGET_PXA27X is not set +# CONFIG_USB_GADGET_S3C2410 is not set +# CONFIG_USB_GADGET_IMX is not set +# CONFIG_USB_GADGET_M66592 is not set +# CONFIG_USB_GADGET_AMD5536UDC is not set +# CONFIG_USB_GADGET_FSL_QE is not set +# CONFIG_USB_GADGET_CI13XXX is not set +# CONFIG_USB_GADGET_NET2280 is not set +# CONFIG_USB_GADGET_GOKU is not set +# CONFIG_USB_GADGET_DUMMY_HCD is not set +CONFIG_USB_GADGET_DUALSPEED=y +CONFIG_USB_ZERO=m +CONFIG_USB_ZERO_HNPTEST=y +CONFIG_USB_ETH=m +CONFIG_USB_ETH_RNDIS=y +CONFIG_USB_GADGETFS=m +CONFIG_USB_FILE_STORAGE=m +# CONFIG_USB_FILE_STORAGE_TEST is not set +CONFIG_USB_G_SERIAL=m +CONFIG_USB_MIDI_GADGET=m +CONFIG_USB_G_PRINTER=m +CONFIG_USB_CDC_COMPOSITE=m + +# +# OTG and related infrastructure +# +CONFIG_USB_OTG_UTILS=y +CONFIG_USB_GPIO_VBUS=y +# CONFIG_ISP1301_OMAP is not set +CONFIG_TWL4030_USB=y +# CONFIG_NOP_USB_XCEIV is not set +CONFIG_MMC=y +# CONFIG_MMC_DEBUG is not set +CONFIG_MMC_UNSAFE_RESUME=y + +# +# MMC/SD/SDIO Card Drivers +# +CONFIG_MMC_BLOCK=y +CONFIG_MMC_BLOCK_BOUNCE=y +CONFIG_SDIO_UART=y +# CONFIG_MMC_TEST is not set + +# +# MMC/SD/SDIO Host Controller Drivers +# +# CONFIG_MMC_SDHCI is not set +CONFIG_MMC_OMAP_HS=y +CONFIG_MMC_SPI=m +# CONFIG_MEMSTICK is not set +# CONFIG_ACCESSIBILITY is not set +CONFIG_NEW_LEDS=y +CONFIG_LEDS_CLASS=y + +# +# LED drivers +# +# CONFIG_LEDS_OMAP_DEBUG is not set +CONFIG_LEDS_OMAP=y +# CONFIG_LEDS_OMAP_PWM is not set +# CONFIG_LEDS_PCA9532 is not set +CONFIG_LEDS_GPIO=y +# CONFIG_LEDS_LP5521 is not set +# CONFIG_LEDS_PCA955X is not set + +# +# LED Triggers +# +CONFIG_LEDS_TRIGGERS=y +CONFIG_LEDS_TRIGGER_TIMER=m +CONFIG_LEDS_TRIGGER_HEARTBEAT=y +CONFIG_LEDS_TRIGGER_BACKLIGHT=m +CONFIG_LEDS_TRIGGER_DEFAULT_ON=m +CONFIG_RTC_LIB=y +CONFIG_RTC_CLASS=y +CONFIG_RTC_HCTOSYS=y +CONFIG_RTC_HCTOSYS_DEVICE="rtc0" +# CONFIG_RTC_DEBUG is not set + +# +# RTC interfaces +# +CONFIG_RTC_INTF_SYSFS=y +CONFIG_RTC_INTF_PROC=y +CONFIG_RTC_INTF_DEV=y +# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set +# CONFIG_RTC_DRV_TEST is not set + +# +# I2C RTC drivers +# +# CONFIG_RTC_DRV_DS1307 is not set +# CONFIG_RTC_DRV_DS1374 is not set +# CONFIG_RTC_DRV_DS1672 is not set +# CONFIG_RTC_DRV_MAX6900 is not set +# CONFIG_RTC_DRV_RS5C372 is not set +# CONFIG_RTC_DRV_ISL1208 is not set +# CONFIG_RTC_DRV_X1205 is not set +# CONFIG_RTC_DRV_PCF8563 is not set +# CONFIG_RTC_DRV_PCF8583 is not set +# CONFIG_RTC_DRV_M41T80 is not set +CONFIG_RTC_DRV_TWL4030=y +# CONFIG_RTC_DRV_S35390A is not set +# CONFIG_RTC_DRV_FM3130 is not set +# CONFIG_RTC_DRV_RX8581 is not set + +# +# SPI RTC drivers +# +# CONFIG_RTC_DRV_M41T94 is not set +# CONFIG_RTC_DRV_DS1305 is not set +# CONFIG_RTC_DRV_DS1390 is not set +# CONFIG_RTC_DRV_MAX6902 is not set +# CONFIG_RTC_DRV_R9701 is not set +# CONFIG_RTC_DRV_RS5C348 is not set +# CONFIG_RTC_DRV_DS3234 is not set + +# +# Platform RTC drivers +# +# CONFIG_RTC_DRV_CMOS is not set +# CONFIG_RTC_DRV_DS1286 is not set +# CONFIG_RTC_DRV_DS1511 is not set +# CONFIG_RTC_DRV_DS1553 is not set +# CONFIG_RTC_DRV_DS1742 is not set +# CONFIG_RTC_DRV_STK17TA8 is not set +# CONFIG_RTC_DRV_M48T86 is not set +# CONFIG_RTC_DRV_M48T35 is not set +# CONFIG_RTC_DRV_M48T59 is not set +# CONFIG_RTC_DRV_BQ4802 is not set +# CONFIG_RTC_DRV_V3020 is not set + +# +# on-CPU RTC drivers +# +# CONFIG_DMADEVICES is not set +CONFIG_REGULATOR=y +# CONFIG_REGULATOR_DEBUG is not set +# CONFIG_REGULATOR_FIXED_VOLTAGE is not set +# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set +# CONFIG_REGULATOR_BQ24022 is not set +CONFIG_REGULATOR_TWL4030=y +CONFIG_UIO=m +CONFIG_UIO_PDRV=m +CONFIG_UIO_PDRV_GENIRQ=m +# CONFIG_UIO_SMX is not set +# CONFIG_UIO_SERCOS3 is not set +CONFIG_STAGING=y +# CONFIG_STAGING_EXCLUDE_BUILD is not set +# CONFIG_MEILHAUS is not set +# CONFIG_USB_IP_COMMON is not set +CONFIG_W35UND=m +CONFIG_PRISM2_USB=m +# CONFIG_ECHO is not set +CONFIG_USB_ATMEL=m +# CONFIG_AGNX is not set +CONFIG_OTUS=m +# CONFIG_COMEDI is not set +# CONFIG_ASUS_OLED is not set +# CONFIG_INPUT_MIMIO is not set +# CONFIG_TRANZPORT is not set + +# +# Android +# +CONFIG_ANDROID=y +CONFIG_ANDROID_BINDER_IPC=y +CONFIG_ANDROID_LOGGER=m +CONFIG_ANDROID_RAM_CONSOLE=y +CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE=y +# CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION is not set +# CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT is not set +CONFIG_ANDROID_TIMED_GPIO=m +CONFIG_ANDROID_LOW_MEMORY_KILLER=y + +# +# CBUS support +# +# CONFIG_CBUS is not set +CONFIG_MPU_BRIDGE=m +CONFIG_BRIDGE_MEMPOOL_SIZE=0x600000 +# CONFIG_BRIDGE_DEBUG is not set + +# +# File systems +# +CONFIG_EXT2_FS=y +# CONFIG_EXT2_FS_XATTR is not set +# CONFIG_EXT2_FS_XIP is not set +CONFIG_EXT3_FS=y +# CONFIG_EXT3_FS_XATTR is not set +CONFIG_EXT4_FS=m +# CONFIG_EXT4DEV_COMPAT is not set +CONFIG_EXT4_FS_XATTR=y +# CONFIG_EXT4_FS_POSIX_ACL is not set +# CONFIG_EXT4_FS_SECURITY is not set +CONFIG_JBD=y +# CONFIG_JBD_DEBUG is not set +CONFIG_JBD2=m +# CONFIG_JBD2_DEBUG is not set +CONFIG_FS_MBCACHE=m +CONFIG_REISERFS_FS=m +# CONFIG_REISERFS_CHECK is not set +CONFIG_REISERFS_PROC_INFO=y +CONFIG_REISERFS_FS_XATTR=y +# CONFIG_REISERFS_FS_POSIX_ACL is not set +# CONFIG_REISERFS_FS_SECURITY is not set +CONFIG_JFS_FS=m +# CONFIG_JFS_POSIX_ACL is not set +# CONFIG_JFS_SECURITY is not set +# CONFIG_JFS_DEBUG is not set +# CONFIG_JFS_STATISTICS is not set +CONFIG_FS_POSIX_ACL=y +CONFIG_FILE_LOCKING=y +CONFIG_XFS_FS=m +# CONFIG_XFS_QUOTA is not set +# CONFIG_XFS_POSIX_ACL is not set +# CONFIG_XFS_RT is not set +# CONFIG_XFS_DEBUG is not set +CONFIG_GFS2_FS=m +CONFIG_GFS2_FS_LOCKING_DLM=m +CONFIG_OCFS2_FS=m +CONFIG_OCFS2_FS_O2CB=m +CONFIG_OCFS2_FS_USERSPACE_CLUSTER=m +CONFIG_OCFS2_FS_STATS=y +CONFIG_OCFS2_DEBUG_MASKLOG=y +# CONFIG_OCFS2_DEBUG_FS is not set +# CONFIG_OCFS2_FS_POSIX_ACL is not set +CONFIG_BTRFS_FS=m +# CONFIG_BTRFS_FS_POSIX_ACL is not set +CONFIG_DNOTIFY=y +CONFIG_INOTIFY=y +CONFIG_INOTIFY_USER=y +CONFIG_QUOTA=y +# CONFIG_QUOTA_NETLINK_INTERFACE is not set +CONFIG_PRINT_QUOTA_WARNING=y +CONFIG_QUOTA_TREE=y +# CONFIG_QFMT_V1 is not set +CONFIG_QFMT_V2=y +CONFIG_QUOTACTL=y +# CONFIG_AUTOFS_FS is not set +CONFIG_AUTOFS4_FS=m +CONFIG_FUSE_FS=y + +# +# CD-ROM/DVD Filesystems +# +CONFIG_ISO9660_FS=m +CONFIG_JOLIET=y +CONFIG_ZISOFS=y +CONFIG_UDF_FS=m +CONFIG_UDF_NLS=y + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +CONFIG_FAT_DEFAULT_CODEPAGE=437 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" +CONFIG_NTFS_FS=m +# CONFIG_NTFS_DEBUG is not set +CONFIG_NTFS_RW=y + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +CONFIG_PROC_SYSCTL=y +CONFIG_PROC_PAGE_MONITOR=y +CONFIG_SYSFS=y +CONFIG_TMPFS=y +# CONFIG_TMPFS_POSIX_ACL is not set +# CONFIG_HUGETLB_PAGE is not set +CONFIG_CONFIGFS_FS=m +CONFIG_MISC_FILESYSTEMS=y +CONFIG_ADFS_FS=m +# CONFIG_ADFS_FS_RW is not set +CONFIG_AFFS_FS=m +# CONFIG_ECRYPT_FS is not set +CONFIG_HFS_FS=m +CONFIG_HFSPLUS_FS=m +CONFIG_BEFS_FS=m +# CONFIG_BEFS_DEBUG is not set +CONFIG_BFS_FS=m +CONFIG_EFS_FS=m +CONFIG_JFFS2_FS=y +CONFIG_JFFS2_FS_DEBUG=0 +CONFIG_JFFS2_FS_WRITEBUFFER=y +# CONFIG_JFFS2_FS_WBUF_VERIFY is not set +CONFIG_JFFS2_SUMMARY=y +CONFIG_JFFS2_FS_XATTR=y +CONFIG_JFFS2_FS_POSIX_ACL=y +CONFIG_JFFS2_FS_SECURITY=y +CONFIG_JFFS2_COMPRESSION_OPTIONS=y +CONFIG_JFFS2_ZLIB=y +CONFIG_JFFS2_LZO=y +CONFIG_JFFS2_RTIME=y +CONFIG_JFFS2_RUBIN=y +# CONFIG_JFFS2_CMODE_NONE is not set +# CONFIG_JFFS2_CMODE_PRIORITY is not set +# CONFIG_JFFS2_CMODE_SIZE is not set +CONFIG_JFFS2_CMODE_FAVOURLZO=y +CONFIG_UBIFS_FS=y +CONFIG_UBIFS_FS_XATTR=y +CONFIG_UBIFS_FS_ADVANCED_COMPR=y +CONFIG_UBIFS_FS_LZO=y +CONFIG_UBIFS_FS_ZLIB=y +# CONFIG_UBIFS_FS_DEBUG is not set +CONFIG_CRAMFS=m +CONFIG_SQUASHFS=y +# CONFIG_SQUASHFS_EMBEDDED is not set +CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3 +CONFIG_VXFS_FS=m +CONFIG_MINIX_FS=m +CONFIG_OMFS_FS=m +CONFIG_HPFS_FS=m +CONFIG_QNX4FS_FS=m +CONFIG_ROMFS_FS=m +CONFIG_SYSV_FS=m +CONFIG_UFS_FS=m +# CONFIG_UFS_FS_WRITE is not set +# CONFIG_UFS_DEBUG is not set +CONFIG_AUFS_FS=y +CONFIG_AUFS_BRANCH_MAX_127=y +# CONFIG_AUFS_BRANCH_MAX_511 is not set +# CONFIG_AUFS_BRANCH_MAX_1023 is not set +# CONFIG_AUFS_BRANCH_MAX_32767 is not set +# CONFIG_AUFS_HINOTIFY is not set +# CONFIG_AUFS_SHWH is not set +# CONFIG_AUFS_BR_RAMFS is not set +CONFIG_AUFS_DEBUG=y +CONFIG_AUFS_MAGIC_SYSRQ=y +CONFIG_AUFS_BDEV_LOOP=y +CONFIG_NETWORK_FILESYSTEMS=y +CONFIG_NFS_FS=y +CONFIG_NFS_V3=y +# CONFIG_NFS_V3_ACL is not set +CONFIG_NFS_V4=y +CONFIG_ROOT_NFS=y +CONFIG_NFSD=m +CONFIG_NFSD_V2_ACL=y +CONFIG_NFSD_V3=y +CONFIG_NFSD_V3_ACL=y +CONFIG_NFSD_V4=y +CONFIG_LOCKD=y +CONFIG_LOCKD_V4=y +CONFIG_EXPORTFS=m +CONFIG_NFS_ACL_SUPPORT=m +CONFIG_NFS_COMMON=y +CONFIG_SUNRPC=y +CONFIG_SUNRPC_GSS=y +# CONFIG_SUNRPC_REGISTER_V4 is not set +CONFIG_RPCSEC_GSS_KRB5=y +# CONFIG_RPCSEC_GSS_SPKM3 is not set +CONFIG_SMB_FS=m +# CONFIG_SMB_NLS_DEFAULT is not set +CONFIG_CIFS=m +CONFIG_CIFS_STATS=y +CONFIG_CIFS_STATS2=y +# CONFIG_CIFS_WEAK_PW_HASH is not set +# CONFIG_CIFS_UPCALL is not set +# CONFIG_CIFS_XATTR is not set +# CONFIG_CIFS_DEBUG2 is not set +CONFIG_CIFS_EXPERIMENTAL=y +# CONFIG_CIFS_DFS_UPCALL is not set +CONFIG_NCP_FS=m +# CONFIG_NCPFS_PACKET_SIGNING is not set +# CONFIG_NCPFS_IOCTL_LOCKING is not set +# CONFIG_NCPFS_STRONG is not set +# CONFIG_NCPFS_NFS_NS is not set +# CONFIG_NCPFS_OS2_NS is not set +# CONFIG_NCPFS_SMALLDOS is not set +# CONFIG_NCPFS_NLS is not set +# CONFIG_NCPFS_EXTRAS is not set +CONFIG_CODA_FS=m +CONFIG_AFS_FS=m +# CONFIG_AFS_DEBUG is not set +CONFIG_9P_FS=m + +# +# Partition Types +# +CONFIG_PARTITION_ADVANCED=y +# CONFIG_ACORN_PARTITION is not set +# CONFIG_OSF_PARTITION is not set +# CONFIG_AMIGA_PARTITION is not set +# CONFIG_ATARI_PARTITION is not set +CONFIG_MAC_PARTITION=y +CONFIG_MSDOS_PARTITION=y +CONFIG_BSD_DISKLABEL=y +CONFIG_MINIX_SUBPARTITION=y +CONFIG_SOLARIS_X86_PARTITION=y +CONFIG_UNIXWARE_DISKLABEL=y +CONFIG_LDM_PARTITION=y +CONFIG_LDM_DEBUG=y +# CONFIG_SGI_PARTITION is not set +# CONFIG_ULTRIX_PARTITION is not set +# CONFIG_SUN_PARTITION is not set +# CONFIG_KARMA_PARTITION is not set +CONFIG_EFI_PARTITION=y +# CONFIG_SYSV68_PARTITION is not set +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="iso8859-1" +CONFIG_NLS_CODEPAGE_437=y +CONFIG_NLS_CODEPAGE_737=m +CONFIG_NLS_CODEPAGE_775=m +CONFIG_NLS_CODEPAGE_850=m +CONFIG_NLS_CODEPAGE_852=m +CONFIG_NLS_CODEPAGE_855=m +CONFIG_NLS_CODEPAGE_857=m +CONFIG_NLS_CODEPAGE_860=m +CONFIG_NLS_CODEPAGE_861=m +CONFIG_NLS_CODEPAGE_862=m +CONFIG_NLS_CODEPAGE_863=m +CONFIG_NLS_CODEPAGE_864=m +CONFIG_NLS_CODEPAGE_865=m +CONFIG_NLS_CODEPAGE_866=m +CONFIG_NLS_CODEPAGE_869=m +CONFIG_NLS_CODEPAGE_936=m +CONFIG_NLS_CODEPAGE_950=m +CONFIG_NLS_CODEPAGE_932=m +CONFIG_NLS_CODEPAGE_949=m +CONFIG_NLS_CODEPAGE_874=m +CONFIG_NLS_ISO8859_8=m +CONFIG_NLS_CODEPAGE_1250=m +CONFIG_NLS_CODEPAGE_1251=m +CONFIG_NLS_ASCII=m +CONFIG_NLS_ISO8859_1=m +CONFIG_NLS_ISO8859_2=m +CONFIG_NLS_ISO8859_3=m +CONFIG_NLS_ISO8859_4=m +CONFIG_NLS_ISO8859_5=m +CONFIG_NLS_ISO8859_6=m +CONFIG_NLS_ISO8859_7=m +CONFIG_NLS_ISO8859_9=m +CONFIG_NLS_ISO8859_13=m +CONFIG_NLS_ISO8859_14=m +CONFIG_NLS_ISO8859_15=m +CONFIG_NLS_KOI8_R=m +CONFIG_NLS_KOI8_U=m +CONFIG_NLS_UTF8=y +CONFIG_DLM=m +# CONFIG_DLM_DEBUG is not set + +# +# Kernel hacking +# +CONFIG_PRINTK_TIME=y +CONFIG_ENABLE_WARN_DEPRECATED=y +CONFIG_ENABLE_MUST_CHECK=y +CONFIG_FRAME_WARN=1024 +CONFIG_MAGIC_SYSRQ=y +# CONFIG_UNUSED_SYMBOLS is not set +CONFIG_DEBUG_FS=y +# CONFIG_HEADERS_CHECK is not set +CONFIG_DEBUG_KERNEL=y +# CONFIG_DEBUG_SHIRQ is not set +CONFIG_DETECT_SOFTLOCKUP=y +# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0 +CONFIG_SCHED_DEBUG=y +CONFIG_SCHEDSTATS=y +CONFIG_TIMER_STATS=y +# CONFIG_DEBUG_OBJECTS is not set +# CONFIG_DEBUG_SLAB is not set +# CONFIG_DEBUG_RT_MUTEXES is not set +# CONFIG_RT_MUTEX_TESTER is not set +# CONFIG_DEBUG_SPINLOCK is not set +CONFIG_DEBUG_MUTEXES=y +# CONFIG_DEBUG_LOCK_ALLOC is not set +# CONFIG_PROVE_LOCKING is not set +# CONFIG_LOCK_STAT is not set +# CONFIG_DEBUG_SPINLOCK_SLEEP is not set +# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set +CONFIG_STACKTRACE=y +# CONFIG_DEBUG_KOBJECT is not set +# CONFIG_DEBUG_BUGVERBOSE is not set +# CONFIG_DEBUG_INFO is not set +# CONFIG_DEBUG_VM is not set +# CONFIG_DEBUG_WRITECOUNT is not set +# CONFIG_DEBUG_MEMORY_INIT is not set +# CONFIG_DEBUG_LIST is not set +# CONFIG_DEBUG_SG is not set +# CONFIG_DEBUG_NOTIFIERS is not set +CONFIG_FRAME_POINTER=y +# CONFIG_BOOT_PRINTK_DELAY is not set +# CONFIG_RCU_TORTURE_TEST is not set +# CONFIG_RCU_CPU_STALL_DETECTOR is not set +# CONFIG_BACKTRACE_SELF_TEST is not set +# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set +# CONFIG_FAULT_INJECTION is not set +# CONFIG_LATENCYTOP is not set +CONFIG_NOP_TRACER=y +CONFIG_HAVE_FUNCTION_TRACER=y +CONFIG_RING_BUFFER=y +CONFIG_TRACING=y + +# +# Tracers +# +# CONFIG_FUNCTION_TRACER is not set +# CONFIG_IRQSOFF_TRACER is not set +# CONFIG_SCHED_TRACER is not set +# CONFIG_CONTEXT_SWITCH_TRACER is not set +# CONFIG_BOOT_TRACER is not set +# CONFIG_TRACE_BRANCH_PROFILING is not set +# CONFIG_STACK_TRACER is not set +# CONFIG_FTRACE_STARTUP_TEST is not set +# CONFIG_DYNAMIC_PRINTK_DEBUG is not set +# CONFIG_SAMPLES is not set +CONFIG_HAVE_ARCH_KGDB=y +# CONFIG_KGDB is not set +# CONFIG_DEBUG_USER is not set +# CONFIG_DEBUG_ERRORS is not set +# CONFIG_DEBUG_STACK_USAGE is not set +# CONFIG_DEBUG_LL is not set + +# +# Security options +# +CONFIG_KEYS=y +# CONFIG_KEYS_DEBUG_PROC_KEYS is not set +# CONFIG_SECURITY is not set +# CONFIG_SECURITYFS is not set +# CONFIG_SECURITY_FILE_CAPABILITIES is not set +CONFIG_XOR_BLOCKS=m +CONFIG_ASYNC_CORE=m +CONFIG_ASYNC_MEMCPY=m +CONFIG_ASYNC_XOR=m +CONFIG_CRYPTO=y + +# +# Crypto core or helper +# +CONFIG_CRYPTO_FIPS=y +CONFIG_CRYPTO_ALGAPI=y +CONFIG_CRYPTO_ALGAPI2=y +CONFIG_CRYPTO_AEAD=m +CONFIG_CRYPTO_AEAD2=y +CONFIG_CRYPTO_BLKCIPHER=y +CONFIG_CRYPTO_BLKCIPHER2=y +CONFIG_CRYPTO_HASH=y +CONFIG_CRYPTO_HASH2=y +CONFIG_CRYPTO_RNG=m +CONFIG_CRYPTO_RNG2=y +CONFIG_CRYPTO_MANAGER=y +CONFIG_CRYPTO_MANAGER2=y +CONFIG_CRYPTO_GF128MUL=m +CONFIG_CRYPTO_NULL=m +CONFIG_CRYPTO_CRYPTD=m +CONFIG_CRYPTO_AUTHENC=m +CONFIG_CRYPTO_TEST=m + +# +# Authenticated Encryption with Associated Data +# +CONFIG_CRYPTO_CCM=m +CONFIG_CRYPTO_GCM=m +CONFIG_CRYPTO_SEQIV=m + +# +# Block modes +# +CONFIG_CRYPTO_CBC=y +CONFIG_CRYPTO_CTR=m +CONFIG_CRYPTO_CTS=m +CONFIG_CRYPTO_ECB=y +CONFIG_CRYPTO_LRW=m +CONFIG_CRYPTO_PCBC=m +CONFIG_CRYPTO_XTS=m + +# +# Hash modes +# +CONFIG_CRYPTO_HMAC=m +CONFIG_CRYPTO_XCBC=m + +# +# Digest +# +CONFIG_CRYPTO_CRC32C=y +CONFIG_CRYPTO_MD4=m +CONFIG_CRYPTO_MD5=y +CONFIG_CRYPTO_MICHAEL_MIC=y +CONFIG_CRYPTO_RMD128=m +CONFIG_CRYPTO_RMD160=m +CONFIG_CRYPTO_RMD256=m +CONFIG_CRYPTO_RMD320=m +CONFIG_CRYPTO_SHA1=m +CONFIG_CRYPTO_SHA256=m +CONFIG_CRYPTO_SHA512=m +CONFIG_CRYPTO_TGR192=m +CONFIG_CRYPTO_WP512=m + +# +# Ciphers +# +CONFIG_CRYPTO_AES=y +CONFIG_CRYPTO_ANUBIS=m +CONFIG_CRYPTO_ARC4=y +CONFIG_CRYPTO_BLOWFISH=m +CONFIG_CRYPTO_CAMELLIA=m +CONFIG_CRYPTO_CAST5=m +CONFIG_CRYPTO_CAST6=m +CONFIG_CRYPTO_DES=y +CONFIG_CRYPTO_FCRYPT=m +CONFIG_CRYPTO_KHAZAD=m +CONFIG_CRYPTO_SALSA20=m +CONFIG_CRYPTO_SEED=m +CONFIG_CRYPTO_SERPENT=m +CONFIG_CRYPTO_TEA=m +CONFIG_CRYPTO_TWOFISH=m +CONFIG_CRYPTO_TWOFISH_COMMON=m + +# +# Compression +# +CONFIG_CRYPTO_DEFLATE=y +CONFIG_CRYPTO_LZO=y + +# +# Random Number Generation +# +CONFIG_CRYPTO_ANSI_CPRNG=m +CONFIG_CRYPTO_HW=y + +# +# Library routines +# +CONFIG_BITREVERSE=y +CONFIG_GENERIC_FIND_LAST_BIT=y +CONFIG_CRC_CCITT=y +CONFIG_CRC16=y +CONFIG_CRC_T10DIF=y +CONFIG_CRC_ITU_T=y +CONFIG_CRC32=y +CONFIG_CRC7=y +CONFIG_LIBCRC32C=y +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y +CONFIG_LZO_COMPRESS=y +CONFIG_LZO_DECOMPRESS=y +CONFIG_TEXTSEARCH=y +CONFIG_TEXTSEARCH_KMP=m +CONFIG_TEXTSEARCH_BM=m +CONFIG_TEXTSEARCH_FSM=m +CONFIG_PLIST=y +CONFIG_HAS_IOMEM=y +CONFIG_HAS_IOPORT=y +CONFIG_HAS_DMA=y diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig.orig b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig.orig new file mode 100644 index 0000000000..1aa7cf57ac --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/defconfig.orig @@ -0,0 +1,2701 @@ +# +# Automatically generated make config: don't edit +# Linux kernel version: 2.6.29-omap1 +# Fri May 29 14:47:52 2009 +# +CONFIG_ARM=y +CONFIG_SYS_SUPPORTS_APM_EMULATION=y +CONFIG_GENERIC_GPIO=y +CONFIG_GENERIC_TIME=y +CONFIG_GENERIC_CLOCKEVENTS=y +CONFIG_MMU=y +# CONFIG_NO_IOPORT is not set +CONFIG_GENERIC_HARDIRQS=y +CONFIG_STACKTRACE_SUPPORT=y +CONFIG_HAVE_LATENCYTOP_SUPPORT=y +CONFIG_LOCKDEP_SUPPORT=y +CONFIG_TRACE_IRQFLAGS_SUPPORT=y +CONFIG_HARDIRQS_SW_RESEND=y +CONFIG_GENERIC_IRQ_PROBE=y +CONFIG_RWSEM_GENERIC_SPINLOCK=y +# CONFIG_ARCH_HAS_ILOG2_U32 is not set +# CONFIG_ARCH_HAS_ILOG2_U64 is not set +CONFIG_GENERIC_HWEIGHT=y +CONFIG_GENERIC_CALIBRATE_DELAY=y +CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y +CONFIG_OPROFILE_ARMV7=y +CONFIG_VECTORS_BASE=0xffff0000 +CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" + +# +# General setup +# +CONFIG_EXPERIMENTAL=y +CONFIG_BROKEN_ON_SMP=y +CONFIG_INIT_ENV_ARG_LIMIT=32 +CONFIG_LOCALVERSION="" +# CONFIG_LOCALVERSION_AUTO is not set +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +CONFIG_SYSVIPC_SYSCTL=y +# CONFIG_POSIX_MQUEUE is not set +CONFIG_BSD_PROCESS_ACCT=y +# CONFIG_BSD_PROCESS_ACCT_V3 is not set +CONFIG_TASKSTATS=y +CONFIG_TASK_DELAY_ACCT=y +CONFIG_TASK_XACCT=y +CONFIG_TASK_IO_ACCOUNTING=y +# CONFIG_AUDIT is not set + +# +# RCU Subsystem +# +CONFIG_CLASSIC_RCU=y +# CONFIG_TREE_RCU is not set +# CONFIG_PREEMPT_RCU is not set +# CONFIG_TREE_RCU_TRACE is not set +# CONFIG_PREEMPT_RCU_TRACE is not set +CONFIG_IKCONFIG=y +CONFIG_IKCONFIG_PROC=y +CONFIG_LOG_BUF_SHIFT=14 +CONFIG_GROUP_SCHED=y +CONFIG_FAIR_GROUP_SCHED=y +# CONFIG_RT_GROUP_SCHED is not set +CONFIG_USER_SCHED=y +# CONFIG_CGROUP_SCHED is not set +# CONFIG_CGROUPS is not set +# CONFIG_SYSFS_DEPRECATED_V2 is not set +# CONFIG_RELAY is not set +# CONFIG_NAMESPACES is not set +CONFIG_BLK_DEV_INITRD=y +CONFIG_INITRAMFS_SOURCE="" +CONFIG_CC_OPTIMIZE_FOR_SIZE=y +CONFIG_SYSCTL=y +CONFIG_ANON_INODES=y +CONFIG_EMBEDDED=y +CONFIG_UID16=y +# CONFIG_SYSCTL_SYSCALL is not set +CONFIG_KALLSYMS=y +# CONFIG_KALLSYMS_ALL is not set +# CONFIG_KALLSYMS_EXTRA_PASS is not set +CONFIG_HOTPLUG=y +CONFIG_PRINTK=y +CONFIG_BUG=y +# CONFIG_ELF_CORE is not set +CONFIG_BASE_FULL=y +CONFIG_FUTEX=y +CONFIG_EPOLL=y +CONFIG_SIGNALFD=y +CONFIG_TIMERFD=y +CONFIG_EVENTFD=y +CONFIG_SHMEM=y +CONFIG_AIO=y +CONFIG_VM_EVENT_COUNTERS=y +# CONFIG_COMPAT_BRK is not set +CONFIG_SLAB=y +# CONFIG_SLUB is not set +# CONFIG_SLOB is not set +CONFIG_PROFILING=y +CONFIG_TRACEPOINTS=y +# CONFIG_MARKERS is not set +CONFIG_OPROFILE=y +CONFIG_HAVE_OPROFILE=y +# CONFIG_KPROBES is not set +CONFIG_HAVE_KPROBES=y +CONFIG_HAVE_KRETPROBES=y +CONFIG_HAVE_CLK=y +CONFIG_HAVE_GENERIC_DMA_COHERENT=y +CONFIG_SLABINFO=y +CONFIG_RT_MUTEXES=y +CONFIG_BASE_SMALL=0 +CONFIG_MODULES=y +CONFIG_MODULE_FORCE_LOAD=y +CONFIG_MODULE_UNLOAD=y +CONFIG_MODULE_FORCE_UNLOAD=y +CONFIG_MODVERSIONS=y +CONFIG_MODULE_SRCVERSION_ALL=y +CONFIG_BLOCK=y +CONFIG_LBD=y +# CONFIG_BLK_DEV_IO_TRACE is not set +# CONFIG_BLK_DEV_BSG is not set +# CONFIG_BLK_DEV_INTEGRITY is not set + +# +# IO Schedulers +# +CONFIG_IOSCHED_NOOP=y +CONFIG_IOSCHED_AS=y +CONFIG_IOSCHED_DEADLINE=y +CONFIG_IOSCHED_CFQ=y +# CONFIG_DEFAULT_AS is not set +# CONFIG_DEFAULT_DEADLINE is not set +CONFIG_DEFAULT_CFQ=y +# CONFIG_DEFAULT_NOOP is not set +CONFIG_DEFAULT_IOSCHED="cfq" +CONFIG_FREEZER=y + +# +# System Type +# +# CONFIG_ARCH_AAEC2000 is not set +# CONFIG_ARCH_INTEGRATOR is not set +# CONFIG_ARCH_REALVIEW is not set +# CONFIG_ARCH_VERSATILE is not set +# CONFIG_ARCH_AT91 is not set +# CONFIG_ARCH_CLPS711X is not set +# CONFIG_ARCH_EBSA110 is not set +# CONFIG_ARCH_EP93XX is not set +# CONFIG_ARCH_FOOTBRIDGE is not set +# CONFIG_ARCH_NETX is not set +# CONFIG_ARCH_H720X is not set +# CONFIG_ARCH_IMX is not set +# CONFIG_ARCH_IOP13XX is not set +# CONFIG_ARCH_IOP32X is not set +# CONFIG_ARCH_IOP33X is not set +# CONFIG_ARCH_IXP23XX is not set +# CONFIG_ARCH_IXP2000 is not set +# CONFIG_ARCH_IXP4XX is not set +# CONFIG_ARCH_L7200 is not set +# CONFIG_ARCH_KIRKWOOD is not set +# CONFIG_ARCH_KS8695 is not set +# CONFIG_ARCH_NS9XXX is not set +# CONFIG_ARCH_LOKI is not set +# CONFIG_ARCH_MV78XX0 is not set +# CONFIG_ARCH_MXC is not set +# CONFIG_ARCH_ORION5X is not set +# CONFIG_ARCH_PNX4008 is not set +# CONFIG_ARCH_PXA is not set +# CONFIG_ARCH_RPC is not set +# CONFIG_ARCH_SA1100 is not set +# CONFIG_ARCH_S3C2410 is not set +# CONFIG_ARCH_S3C64XX is not set +# CONFIG_ARCH_SHARK is not set +# CONFIG_ARCH_LH7A40X is not set +# CONFIG_ARCH_DAVINCI is not set +CONFIG_ARCH_OMAP=y +# CONFIG_ARCH_MSM is not set +# CONFIG_ARCH_W90X900 is not set + +# +# TI OMAP Implementations +# +CONFIG_ARCH_OMAP_OTG=y +# CONFIG_ARCH_OMAP1 is not set +# CONFIG_ARCH_OMAP2 is not set +CONFIG_ARCH_OMAP3=y + +# +# OMAP Feature Selections +# +# CONFIG_OMAP_DEBUG_POWERDOMAIN is not set +# CONFIG_OMAP_DEBUG_CLOCKDOMAIN is not set +CONFIG_OMAP_SMARTREFLEX=y +# CONFIG_OMAP_SMARTREFLEX_TESTING is not set +CONFIG_OMAP_RESET_CLOCKS=y +CONFIG_OMAP_BOOT_TAG=y +CONFIG_OMAP_BOOT_REASON=y +# CONFIG_OMAP_COMPONENT_VERSION is not set +# CONFIG_OMAP_GPIO_SWITCH is not set +# CONFIG_OMAP_MUX is not set +CONFIG_OMAP_MCBSP=y +# CONFIG_OMAP_MBOX_FWK is not set +# CONFIG_OMAP_IOMMU is not set +# CONFIG_OMAP_MPU_TIMER is not set +CONFIG_OMAP_32K_TIMER=y +CONFIG_OMAP_32K_TIMER_HZ=128 +CONFIG_OMAP_TICK_GPTIMER=12 +CONFIG_OMAP_DM_TIMER=y +# CONFIG_OMAP_LL_DEBUG_UART1 is not set +# CONFIG_OMAP_LL_DEBUG_UART2 is not set +CONFIG_OMAP_LL_DEBUG_UART3=y +CONFIG_ARCH_OMAP34XX=y +CONFIG_ARCH_OMAP3430=y + +# +# OMAP Board Type +# +# CONFIG_MACH_NOKIA_RX51 is not set +# CONFIG_MACH_OMAP_LDP is not set +# CONFIG_MACH_OMAP_3430SDP is not set +# CONFIG_MACH_OMAP3EVM is not set +CONFIG_MACH_OMAP3_BEAGLE=y +# CONFIG_MACH_OVERO is not set +# CONFIG_MACH_OMAP3_PANDORA is not set + +# +# Processor Type +# +CONFIG_CPU_32=y +CONFIG_CPU_32v6K=y +CONFIG_CPU_V7=y +CONFIG_CPU_32v7=y +CONFIG_CPU_ABRT_EV7=y +CONFIG_CPU_PABRT_IFAR=y +CONFIG_CPU_CACHE_V7=y +CONFIG_CPU_CACHE_VIPT=y +CONFIG_CPU_COPY_V6=y +CONFIG_CPU_TLB_V7=y +CONFIG_CPU_HAS_ASID=y +CONFIG_CPU_CP15=y +CONFIG_CPU_CP15_MMU=y + +# +# Processor Features +# +CONFIG_ARM_THUMB=y +CONFIG_ARM_THUMBEE=y +# CONFIG_CPU_ICACHE_DISABLE is not set +# CONFIG_CPU_DCACHE_DISABLE is not set +# CONFIG_CPU_BPREDICT_DISABLE is not set +CONFIG_HAS_TLS_REG=y +# CONFIG_OUTER_CACHE is not set + +# +# Bus support +# +# CONFIG_PCI_SYSCALL is not set +# CONFIG_ARCH_SUPPORTS_MSI is not set +# CONFIG_PCCARD is not set + +# +# Kernel Features +# +CONFIG_TICK_ONESHOT=y +CONFIG_NO_HZ=y +CONFIG_HIGH_RES_TIMERS=y +CONFIG_GENERIC_CLOCKEVENTS_BUILD=y +CONFIG_VMSPLIT_3G=y +# CONFIG_VMSPLIT_2G is not set +# CONFIG_VMSPLIT_1G is not set +CONFIG_PAGE_OFFSET=0xC0000000 +# CONFIG_PREEMPT is not set +CONFIG_HZ=128 +CONFIG_AEABI=y +# CONFIG_OABI_COMPAT is not set +CONFIG_ARCH_FLATMEM_HAS_HOLES=y +# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set +# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set +CONFIG_SELECT_MEMORY_MODEL=y +CONFIG_FLATMEM_MANUAL=y +# CONFIG_DISCONTIGMEM_MANUAL is not set +# CONFIG_SPARSEMEM_MANUAL is not set +CONFIG_FLATMEM=y +CONFIG_FLAT_NODE_MEM_MAP=y +CONFIG_PAGEFLAGS_EXTENDED=y +CONFIG_SPLIT_PTLOCK_CPUS=4 +# CONFIG_PHYS_ADDR_T_64BIT is not set +CONFIG_ZONE_DMA_FLAG=0 +CONFIG_VIRT_TO_BUS=y +CONFIG_UNEVICTABLE_LRU=y +CONFIG_LEDS=y +CONFIG_ALIGNMENT_TRAP=y + +# +# Boot options +# +CONFIG_ZBOOT_ROM_TEXT=0x0 +CONFIG_ZBOOT_ROM_BSS=0x0 +CONFIG_CMDLINE=" debug " +# CONFIG_XIP_KERNEL is not set +CONFIG_KEXEC=y +CONFIG_ATAGS_PROC=y + +# +# CPU Power Management +# +CONFIG_CPU_FREQ=y +CONFIG_CPU_FREQ_TABLE=y +CONFIG_CPU_FREQ_DEBUG=y +CONFIG_CPU_FREQ_STAT=y +CONFIG_CPU_FREQ_STAT_DETAILS=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set +CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y +CONFIG_CPU_FREQ_GOV_POWERSAVE=y +CONFIG_CPU_FREQ_GOV_USERSPACE=y +CONFIG_CPU_FREQ_GOV_ONDEMAND=y +CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y +# CONFIG_CPU_IDLE is not set + +# +# Floating point emulation +# + +# +# At least one emulation must be selected +# +CONFIG_VFP=y +CONFIG_VFPv3=y +CONFIG_NEON=y +# CONFIG_ARM_ERRATUM_451034 is not set + +# +# Userspace binary formats +# +CONFIG_BINFMT_ELF=y +CONFIG_HAVE_AOUT=y +CONFIG_BINFMT_AOUT=m +CONFIG_BINFMT_MISC=y + +# +# Power management options +# +CONFIG_PM=y +CONFIG_PM_DEBUG=y +# CONFIG_PM_VERBOSE is not set +CONFIG_CAN_PM_TRACE=y +CONFIG_PM_SLEEP=y +CONFIG_SUSPEND=y +# CONFIG_PM_TEST_SUSPEND is not set +CONFIG_SUSPEND_FREEZER=y +# CONFIG_APM_EMULATION is not set +CONFIG_ARCH_SUSPEND_POSSIBLE=y +CONFIG_NET=y + +# +# Networking options +# +CONFIG_COMPAT_NET_DEV_OPS=y +CONFIG_PACKET=y +CONFIG_PACKET_MMAP=y +CONFIG_UNIX=y +CONFIG_XFRM=y +# CONFIG_XFRM_USER is not set +# CONFIG_XFRM_SUB_POLICY is not set +# CONFIG_XFRM_MIGRATE is not set +# CONFIG_XFRM_STATISTICS is not set +CONFIG_XFRM_IPCOMP=m +CONFIG_NET_KEY=y +# CONFIG_NET_KEY_MIGRATE is not set +CONFIG_INET=y +# CONFIG_IP_MULTICAST is not set +# CONFIG_IP_ADVANCED_ROUTER is not set +CONFIG_IP_FIB_HASH=y +CONFIG_IP_PNP=y +CONFIG_IP_PNP_DHCP=y +CONFIG_IP_PNP_BOOTP=y +CONFIG_IP_PNP_RARP=y +CONFIG_NET_IPIP=m +CONFIG_NET_IPGRE=m +# CONFIG_ARPD is not set +# CONFIG_SYN_COOKIES is not set +CONFIG_INET_AH=m +CONFIG_INET_ESP=m +CONFIG_INET_IPCOMP=m +CONFIG_INET_XFRM_TUNNEL=m +CONFIG_INET_TUNNEL=m +CONFIG_INET_XFRM_MODE_TRANSPORT=y +CONFIG_INET_XFRM_MODE_TUNNEL=y +CONFIG_INET_XFRM_MODE_BEET=y +CONFIG_INET_LRO=m +CONFIG_INET_DIAG=m +CONFIG_INET_TCP_DIAG=m +CONFIG_TCP_CONG_ADVANCED=y +CONFIG_TCP_CONG_BIC=m +CONFIG_TCP_CONG_CUBIC=y +CONFIG_TCP_CONG_WESTWOOD=m +CONFIG_TCP_CONG_HTCP=m +CONFIG_TCP_CONG_HSTCP=m +CONFIG_TCP_CONG_HYBLA=m +CONFIG_TCP_CONG_VEGAS=m +CONFIG_TCP_CONG_SCALABLE=m +CONFIG_TCP_CONG_LP=m +CONFIG_TCP_CONG_VENO=m +CONFIG_TCP_CONG_YEAH=m +CONFIG_TCP_CONG_ILLINOIS=m +# CONFIG_DEFAULT_BIC is not set +CONFIG_DEFAULT_CUBIC=y +# CONFIG_DEFAULT_HTCP is not set +# CONFIG_DEFAULT_VEGAS is not set +# CONFIG_DEFAULT_WESTWOOD is not set +# CONFIG_DEFAULT_RENO is not set +CONFIG_DEFAULT_TCP_CONG="cubic" +# CONFIG_TCP_MD5SIG is not set +CONFIG_IPV6=m +# CONFIG_IPV6_PRIVACY is not set +# CONFIG_IPV6_ROUTER_PREF is not set +# CONFIG_IPV6_OPTIMISTIC_DAD is not set +CONFIG_INET6_AH=m +CONFIG_INET6_ESP=m +CONFIG_INET6_IPCOMP=m +CONFIG_IPV6_MIP6=m +CONFIG_INET6_XFRM_TUNNEL=m +CONFIG_INET6_TUNNEL=m +CONFIG_INET6_XFRM_MODE_TRANSPORT=m +CONFIG_INET6_XFRM_MODE_TUNNEL=m +CONFIG_INET6_XFRM_MODE_BEET=m +CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION=m +CONFIG_IPV6_SIT=m +CONFIG_IPV6_NDISC_NODETYPE=y +CONFIG_IPV6_TUNNEL=m +CONFIG_IPV6_MULTIPLE_TABLES=y +CONFIG_IPV6_SUBTREES=y +CONFIG_IPV6_MROUTE=y +# CONFIG_IPV6_PIMSM_V2 is not set +# CONFIG_NETWORK_SECMARK is not set +CONFIG_NETFILTER=y +# CONFIG_NETFILTER_DEBUG is not set +CONFIG_NETFILTER_ADVANCED=y +CONFIG_BRIDGE_NETFILTER=y + +# +# Core Netfilter Configuration +# +CONFIG_NETFILTER_NETLINK=m +CONFIG_NETFILTER_NETLINK_QUEUE=m +CONFIG_NETFILTER_NETLINK_LOG=m +CONFIG_NF_CONNTRACK=m +CONFIG_NF_CT_ACCT=y +CONFIG_NF_CONNTRACK_MARK=y +CONFIG_NF_CONNTRACK_EVENTS=y +CONFIG_NF_CT_PROTO_DCCP=m +CONFIG_NF_CT_PROTO_GRE=m +CONFIG_NF_CT_PROTO_SCTP=m +CONFIG_NF_CT_PROTO_UDPLITE=m +CONFIG_NF_CONNTRACK_AMANDA=m +CONFIG_NF_CONNTRACK_FTP=m +CONFIG_NF_CONNTRACK_H323=m +CONFIG_NF_CONNTRACK_IRC=m +CONFIG_NF_CONNTRACK_NETBIOS_NS=m +CONFIG_NF_CONNTRACK_PPTP=m +CONFIG_NF_CONNTRACK_SANE=m +CONFIG_NF_CONNTRACK_SIP=m +CONFIG_NF_CONNTRACK_TFTP=m +CONFIG_NF_CT_NETLINK=m +# CONFIG_NETFILTER_TPROXY is not set +CONFIG_NETFILTER_XTABLES=m +CONFIG_NETFILTER_XT_TARGET_CLASSIFY=m +CONFIG_NETFILTER_XT_TARGET_CONNMARK=m +# CONFIG_NETFILTER_XT_TARGET_DSCP is not set +CONFIG_NETFILTER_XT_TARGET_MARK=m +CONFIG_NETFILTER_XT_TARGET_NFLOG=m +CONFIG_NETFILTER_XT_TARGET_NFQUEUE=m +# CONFIG_NETFILTER_XT_TARGET_NOTRACK is not set +CONFIG_NETFILTER_XT_TARGET_RATEEST=m +# CONFIG_NETFILTER_XT_TARGET_TRACE is not set +CONFIG_NETFILTER_XT_TARGET_TCPMSS=m +# CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set +CONFIG_NETFILTER_XT_MATCH_COMMENT=m +CONFIG_NETFILTER_XT_MATCH_CONNBYTES=m +CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=m +CONFIG_NETFILTER_XT_MATCH_CONNMARK=m +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m +CONFIG_NETFILTER_XT_MATCH_DCCP=m +CONFIG_NETFILTER_XT_MATCH_DSCP=m +CONFIG_NETFILTER_XT_MATCH_ESP=m +CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=m +CONFIG_NETFILTER_XT_MATCH_HELPER=m +CONFIG_NETFILTER_XT_MATCH_IPRANGE=m +CONFIG_NETFILTER_XT_MATCH_LENGTH=m +CONFIG_NETFILTER_XT_MATCH_LIMIT=m +CONFIG_NETFILTER_XT_MATCH_MAC=m +CONFIG_NETFILTER_XT_MATCH_MARK=m +CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m +CONFIG_NETFILTER_XT_MATCH_OWNER=m +CONFIG_NETFILTER_XT_MATCH_POLICY=m +# CONFIG_NETFILTER_XT_MATCH_PHYSDEV is not set +CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m +CONFIG_NETFILTER_XT_MATCH_QUOTA=m +CONFIG_NETFILTER_XT_MATCH_RATEEST=m +CONFIG_NETFILTER_XT_MATCH_REALM=m +CONFIG_NETFILTER_XT_MATCH_RECENT=m +# CONFIG_NETFILTER_XT_MATCH_RECENT_PROC_COMPAT is not set +CONFIG_NETFILTER_XT_MATCH_SCTP=m +CONFIG_NETFILTER_XT_MATCH_STATE=m +CONFIG_NETFILTER_XT_MATCH_STATISTIC=m +CONFIG_NETFILTER_XT_MATCH_STRING=m +CONFIG_NETFILTER_XT_MATCH_TCPMSS=m +CONFIG_NETFILTER_XT_MATCH_TIME=m +CONFIG_NETFILTER_XT_MATCH_U32=m +CONFIG_IP_VS=m +CONFIG_IP_VS_IPV6=y +CONFIG_IP_VS_DEBUG=y +CONFIG_IP_VS_TAB_BITS=12 + +# +# IPVS transport protocol load balancing support +# +CONFIG_IP_VS_PROTO_TCP=y +CONFIG_IP_VS_PROTO_UDP=y +CONFIG_IP_VS_PROTO_AH_ESP=y +CONFIG_IP_VS_PROTO_ESP=y +CONFIG_IP_VS_PROTO_AH=y + +# +# IPVS scheduler +# +CONFIG_IP_VS_RR=m +CONFIG_IP_VS_WRR=m +CONFIG_IP_VS_LC=m +CONFIG_IP_VS_WLC=m +CONFIG_IP_VS_LBLC=m +CONFIG_IP_VS_LBLCR=m +CONFIG_IP_VS_DH=m +CONFIG_IP_VS_SH=m +CONFIG_IP_VS_SED=m +CONFIG_IP_VS_NQ=m + +# +# IPVS application helper +# +CONFIG_IP_VS_FTP=m + +# +# IP: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV4=m +CONFIG_NF_CONNTRACK_IPV4=m +CONFIG_NF_CONNTRACK_PROC_COMPAT=y +CONFIG_IP_NF_QUEUE=m +CONFIG_IP_NF_IPTABLES=m +CONFIG_IP_NF_MATCH_ADDRTYPE=m +CONFIG_IP_NF_MATCH_AH=m +CONFIG_IP_NF_MATCH_ECN=m +CONFIG_IP_NF_MATCH_TTL=m +CONFIG_IP_NF_FILTER=m +CONFIG_IP_NF_TARGET_REJECT=m +CONFIG_IP_NF_TARGET_LOG=m +CONFIG_IP_NF_TARGET_ULOG=m +CONFIG_NF_NAT=m +CONFIG_NF_NAT_NEEDED=y +CONFIG_IP_NF_TARGET_MASQUERADE=m +CONFIG_IP_NF_TARGET_NETMAP=m +CONFIG_IP_NF_TARGET_REDIRECT=m +CONFIG_IP_NF_TARGET_IDLETIMER=m +CONFIG_NF_NAT_SNMP_BASIC=m +CONFIG_NF_NAT_PROTO_DCCP=m +CONFIG_NF_NAT_PROTO_GRE=m +CONFIG_NF_NAT_PROTO_UDPLITE=m +CONFIG_NF_NAT_PROTO_SCTP=m +CONFIG_NF_NAT_FTP=m +CONFIG_NF_NAT_IRC=m +CONFIG_NF_NAT_TFTP=m +CONFIG_NF_NAT_AMANDA=m +CONFIG_NF_NAT_PPTP=m +CONFIG_NF_NAT_H323=m +CONFIG_NF_NAT_SIP=m +CONFIG_IP_NF_MANGLE=m +CONFIG_IP_NF_TARGET_CLUSTERIP=m +CONFIG_IP_NF_TARGET_ECN=m +CONFIG_IP_NF_TARGET_TTL=m +CONFIG_IP_NF_RAW=m +CONFIG_IP_NF_ARPTABLES=m +CONFIG_IP_NF_ARPFILTER=m +CONFIG_IP_NF_ARP_MANGLE=m + +# +# IPv6: Netfilter Configuration +# +CONFIG_NF_CONNTRACK_IPV6=m +CONFIG_IP6_NF_QUEUE=m +CONFIG_IP6_NF_IPTABLES=m +CONFIG_IP6_NF_MATCH_AH=m +CONFIG_IP6_NF_MATCH_EUI64=m +CONFIG_IP6_NF_MATCH_FRAG=m +CONFIG_IP6_NF_MATCH_OPTS=m +CONFIG_IP6_NF_MATCH_HL=m +CONFIG_IP6_NF_MATCH_IPV6HEADER=m +CONFIG_IP6_NF_MATCH_MH=m +CONFIG_IP6_NF_MATCH_RT=m +CONFIG_IP6_NF_TARGET_LOG=m +CONFIG_IP6_NF_FILTER=m +CONFIG_IP6_NF_TARGET_REJECT=m +CONFIG_IP6_NF_MANGLE=m +CONFIG_IP6_NF_TARGET_HL=m +CONFIG_IP6_NF_RAW=m +# CONFIG_BRIDGE_NF_EBTABLES is not set +CONFIG_IP_DCCP=m +CONFIG_INET_DCCP_DIAG=m + +# +# DCCP CCIDs Configuration (EXPERIMENTAL) +# +# CONFIG_IP_DCCP_CCID2_DEBUG is not set +CONFIG_IP_DCCP_CCID3=y +# CONFIG_IP_DCCP_CCID3_DEBUG is not set +CONFIG_IP_DCCP_CCID3_RTO=100 +CONFIG_IP_DCCP_TFRC_LIB=y + +# +# DCCP Kernel Hacking +# +# CONFIG_IP_DCCP_DEBUG is not set +CONFIG_IP_SCTP=m +# CONFIG_SCTP_DBG_MSG is not set +# CONFIG_SCTP_DBG_OBJCNT is not set +# CONFIG_SCTP_HMAC_NONE is not set +# CONFIG_SCTP_HMAC_SHA1 is not set +CONFIG_SCTP_HMAC_MD5=y +CONFIG_TIPC=m +# CONFIG_TIPC_ADVANCED is not set +# CONFIG_TIPC_DEBUG is not set +CONFIG_ATM=m +CONFIG_ATM_CLIP=m +# CONFIG_ATM_CLIP_NO_ICMP is not set +CONFIG_ATM_LANE=m +CONFIG_ATM_MPOA=m +CONFIG_ATM_BR2684=m +# CONFIG_ATM_BR2684_IPFILTER is not set +CONFIG_STP=m +CONFIG_GARP=m +CONFIG_BRIDGE=m +# CONFIG_NET_DSA is not set +CONFIG_VLAN_8021Q=m +CONFIG_VLAN_8021Q_GVRP=y +# CONFIG_DECNET is not set +CONFIG_LLC=m +# CONFIG_LLC2 is not set +# CONFIG_IPX is not set +# CONFIG_ATALK is not set +# CONFIG_X25 is not set +# CONFIG_LAPB is not set +# CONFIG_ECONET is not set +CONFIG_WAN_ROUTER=m +CONFIG_NET_SCHED=y + +# +# Queueing/Scheduling +# +CONFIG_NET_SCH_CBQ=m +CONFIG_NET_SCH_HTB=m +CONFIG_NET_SCH_HFSC=m +CONFIG_NET_SCH_ATM=m +CONFIG_NET_SCH_PRIO=m +CONFIG_NET_SCH_MULTIQ=m +CONFIG_NET_SCH_RED=m +CONFIG_NET_SCH_SFQ=m +CONFIG_NET_SCH_TEQL=m +CONFIG_NET_SCH_TBF=m +CONFIG_NET_SCH_GRED=m +CONFIG_NET_SCH_DSMARK=m +CONFIG_NET_SCH_NETEM=m +CONFIG_NET_SCH_DRR=m + +# +# Classification +# +CONFIG_NET_CLS=y +CONFIG_NET_CLS_BASIC=m +CONFIG_NET_CLS_TCINDEX=m +CONFIG_NET_CLS_ROUTE4=m +CONFIG_NET_CLS_ROUTE=y +CONFIG_NET_CLS_FW=m +CONFIG_NET_CLS_U32=m +CONFIG_CLS_U32_PERF=y +CONFIG_CLS_U32_MARK=y +CONFIG_NET_CLS_RSVP=m +CONFIG_NET_CLS_RSVP6=m +CONFIG_NET_CLS_FLOW=m +# CONFIG_NET_EMATCH is not set +# CONFIG_NET_CLS_ACT is not set +CONFIG_NET_CLS_IND=y +CONFIG_NET_SCH_FIFO=y +# CONFIG_DCB is not set + +# +# Network testing +# +# CONFIG_NET_PKTGEN is not set +# CONFIG_HAMRADIO is not set +CONFIG_CAN=m +CONFIG_CAN_RAW=m +CONFIG_CAN_BCM=m + +# +# CAN Device Drivers +# +CONFIG_CAN_VCAN=m +# CONFIG_CAN_DEBUG_DEVICES is not set +CONFIG_IRDA=m + +# +# IrDA protocols +# +CONFIG_IRLAN=m +CONFIG_IRNET=m +CONFIG_IRCOMM=m +CONFIG_IRDA_ULTRA=y + +# +# IrDA options +# +CONFIG_IRDA_CACHE_LAST_LSAP=y +CONFIG_IRDA_FAST_RR=y +CONFIG_IRDA_DEBUG=y + +# +# Infrared-port device drivers +# + +# +# SIR device drivers +# +CONFIG_IRTTY_SIR=m + +# +# Dongle support +# +CONFIG_DONGLE=y +CONFIG_ESI_DONGLE=m +CONFIG_ACTISYS_DONGLE=m +CONFIG_TEKRAM_DONGLE=m +CONFIG_TOIM3232_DONGLE=m +CONFIG_LITELINK_DONGLE=m +CONFIG_MA600_DONGLE=m +CONFIG_GIRBIL_DONGLE=m +CONFIG_MCP2120_DONGLE=m +CONFIG_OLD_BELKIN_DONGLE=m +# CONFIG_ACT200L_DONGLE is not set +CONFIG_KINGSUN_DONGLE=m +CONFIG_KSDAZZLE_DONGLE=m +CONFIG_KS959_DONGLE=m + +# +# FIR device drivers +# +CONFIG_USB_IRDA=m +CONFIG_SIGMATEL_FIR=m +CONFIG_MCS_FIR=m +# CONFIG_OMAP_IR is not set +CONFIG_BT=y +CONFIG_BT_L2CAP=y +CONFIG_BT_SCO=y +CONFIG_BT_RFCOMM=y +CONFIG_BT_RFCOMM_TTY=y +CONFIG_BT_BNEP=y +CONFIG_BT_BNEP_MC_FILTER=y +CONFIG_BT_BNEP_PROTO_FILTER=y +CONFIG_BT_HIDP=y + +# +# Bluetooth device drivers +# +CONFIG_BT_HCIBTUSB=y +CONFIG_BT_HCIBTSDIO=y +CONFIG_BT_HCIUART=y +CONFIG_BT_HCIUART_H4=y +CONFIG_BT_HCIUART_BCSP=y +CONFIG_BT_HCIUART_LL=y +CONFIG_BT_HCIBCM203X=y +CONFIG_BT_HCIBPA10X=y +CONFIG_BT_HCIBFUSB=y +# CONFIG_BT_HCIBRF6150 is not set +# CONFIG_BT_HCIH4P is not set +# CONFIG_BT_HCIVHCI is not set +CONFIG_AF_RXRPC=m +# CONFIG_AF_RXRPC_DEBUG is not set +# CONFIG_RXKAD is not set +# CONFIG_PHONET is not set +CONFIG_FIB_RULES=y +CONFIG_WIRELESS=y +CONFIG_CFG80211=y +# CONFIG_CFG80211_REG_DEBUG is not set +CONFIG_NL80211=y +CONFIG_WIRELESS_OLD_REGULATORY=y +CONFIG_WIRELESS_EXT=y +CONFIG_WIRELESS_EXT_SYSFS=y +CONFIG_LIB80211=y +CONFIG_LIB80211_CRYPT_WEP=y +CONFIG_LIB80211_CRYPT_CCMP=y +CONFIG_LIB80211_CRYPT_TKIP=y +# CONFIG_LIB80211_DEBUG is not set +CONFIG_MAC80211=y + +# +# Rate control algorithm selection +# +CONFIG_MAC80211_RC_PID=y +# CONFIG_MAC80211_RC_MINSTREL is not set +CONFIG_MAC80211_RC_DEFAULT_PID=y +# CONFIG_MAC80211_RC_DEFAULT_MINSTREL is not set +CONFIG_MAC80211_RC_DEFAULT="pid" +# CONFIG_MAC80211_MESH is not set +CONFIG_MAC80211_LEDS=y +# CONFIG_MAC80211_DEBUGFS is not set +# CONFIG_MAC80211_DEBUG_MENU is not set +CONFIG_WIMAX=m +CONFIG_WIMAX_DEBUG_LEVEL=8 +# CONFIG_RFKILL is not set +CONFIG_NET_9P=m +# CONFIG_NET_9P_DEBUG is not set + +# +# Device Drivers +# + +# +# Generic Driver Options +# +CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug" +CONFIG_STANDALONE=y +CONFIG_PREVENT_FIRMWARE_BUILD=y +CONFIG_FW_LOADER=y +CONFIG_FIRMWARE_IN_KERNEL=y +CONFIG_EXTRA_FIRMWARE="" +# CONFIG_DEBUG_DRIVER is not set +# CONFIG_DEBUG_DEVRES is not set +# CONFIG_SYS_HYPERVISOR is not set +# CONFIG_CONNECTOR is not set +CONFIG_MTD=y +# CONFIG_MTD_DEBUG is not set +CONFIG_MTD_CONCAT=y +CONFIG_MTD_PARTITIONS=y +# CONFIG_MTD_TESTS is not set +# CONFIG_MTD_REDBOOT_PARTS is not set +# CONFIG_MTD_CMDLINE_PARTS is not set +# CONFIG_MTD_AFS_PARTS is not set +# CONFIG_MTD_AR7_PARTS is not set + +# +# User Modules And Translation Layers +# +CONFIG_MTD_CHAR=y +CONFIG_MTD_BLKDEVS=y +CONFIG_MTD_BLOCK=y +# CONFIG_FTL is not set +# CONFIG_NFTL is not set +# CONFIG_INFTL is not set +# CONFIG_RFD_FTL is not set +# CONFIG_SSFDC is not set +# CONFIG_MTD_OOPS is not set + +# +# RAM/ROM/Flash chip drivers +# +# CONFIG_MTD_CFI is not set +# CONFIG_MTD_JEDECPROBE is not set +CONFIG_MTD_MAP_BANK_WIDTH_1=y +CONFIG_MTD_MAP_BANK_WIDTH_2=y +CONFIG_MTD_MAP_BANK_WIDTH_4=y +# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set +# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set +# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set +CONFIG_MTD_CFI_I1=y +CONFIG_MTD_CFI_I2=y +# CONFIG_MTD_CFI_I4 is not set +# CONFIG_MTD_CFI_I8 is not set +# CONFIG_MTD_RAM is not set +# CONFIG_MTD_ROM is not set +# CONFIG_MTD_ABSENT is not set + +# +# Mapping drivers for chip access +# +# CONFIG_MTD_COMPLEX_MAPPINGS is not set +# CONFIG_MTD_PLATRAM is not set + +# +# Self-contained MTD device drivers +# +# CONFIG_MTD_DATAFLASH is not set +# CONFIG_MTD_M25P80 is not set +# CONFIG_MTD_SLRAM is not set +# CONFIG_MTD_PHRAM is not set +# CONFIG_MTD_MTDRAM is not set +# CONFIG_MTD_BLOCK2MTD is not set + +# +# Disk-On-Chip Device Drivers +# +# CONFIG_MTD_DOC2000 is not set +# CONFIG_MTD_DOC2001 is not set +# CONFIG_MTD_DOC2001PLUS is not set +CONFIG_MTD_NAND=y +# CONFIG_MTD_NAND_VERIFY_WRITE is not set +# CONFIG_MTD_NAND_ECC_SMC is not set +# CONFIG_MTD_NAND_MUSEUM_IDS is not set +# CONFIG_MTD_NAND_GPIO is not set +CONFIG_MTD_NAND_OMAP2=y +CONFIG_MTD_NAND_IDS=y +# CONFIG_MTD_NAND_DISKONCHIP is not set +# CONFIG_MTD_NAND_NANDSIM is not set +CONFIG_MTD_NAND_PLATFORM=y +# CONFIG_MTD_ALAUDA is not set +# CONFIG_MTD_ONENAND is not set + +# +# LPDDR flash memory drivers +# +# CONFIG_MTD_LPDDR is not set + +# +# UBI - Unsorted block images +# +CONFIG_MTD_UBI=y +CONFIG_MTD_UBI_WL_THRESHOLD=4096 +CONFIG_MTD_UBI_BEB_RESERVE=1 +# CONFIG_MTD_UBI_GLUEBI is not set + +# +# UBI debugging options +# +# CONFIG_MTD_UBI_DEBUG is not set +# CONFIG_PARPORT is not set +CONFIG_BLK_DEV=y +# CONFIG_BLK_DEV_COW_COMMON is not set +CONFIG_BLK_DEV_LOOP=y +CONFIG_BLK_DEV_CRYPTOLOOP=m +# CONFIG_BLK_DEV_NBD is not set +# CONFIG_BLK_DEV_UB is not set +CONFIG_BLK_DEV_RAM=y +CONFIG_BLK_DEV_RAM_COUNT=16 +CONFIG_BLK_DEV_RAM_SIZE=16384 +# CONFIG_BLK_DEV_XIP is not set +CONFIG_CDROM_PKTCDVD=m +CONFIG_CDROM_PKTCDVD_BUFFERS=8 +# CONFIG_CDROM_PKTCDVD_WCACHE is not set +# CONFIG_ATA_OVER_ETH is not set +CONFIG_MISC_DEVICES=y +# CONFIG_ICS932S401 is not set +# CONFIG_OMAP_STI is not set +# CONFIG_ENCLOSURE_SERVICES is not set +# CONFIG_C2PORT is not set + +# +# EEPROM support +# +# CONFIG_EEPROM_AT24 is not set +# CONFIG_EEPROM_AT25 is not set +# CONFIG_EEPROM_LEGACY is not set +CONFIG_EEPROM_93CX6=y +CONFIG_HAVE_IDE=y +# CONFIG_IDE is not set + +# +# SCSI device support +# +CONFIG_RAID_ATTRS=m +CONFIG_SCSI=y +CONFIG_SCSI_DMA=y +# CONFIG_SCSI_TGT is not set +# CONFIG_SCSI_NETLINK is not set +CONFIG_SCSI_PROC_FS=y + +# +# SCSI support type (disk, tape, CD-ROM) +# +CONFIG_BLK_DEV_SD=y +# CONFIG_CHR_DEV_ST is not set +# CONFIG_CHR_DEV_OSST is not set +CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR_VENDOR=y +CONFIG_CHR_DEV_SG=y +CONFIG_CHR_DEV_SCH=m + +# +# Some SCSI devices (e.g. CD jukebox) support multiple LUNs +# +CONFIG_SCSI_MULTI_LUN=y +# CONFIG_SCSI_CONSTANTS is not set +# CONFIG_SCSI_LOGGING is not set +# CONFIG_SCSI_SCAN_ASYNC is not set +CONFIG_SCSI_WAIT_SCAN=m + +# +# SCSI Transports +# +# CONFIG_SCSI_SPI_ATTRS is not set +# CONFIG_SCSI_FC_ATTRS is not set +CONFIG_SCSI_ISCSI_ATTRS=m +# CONFIG_SCSI_SAS_LIBSAS is not set +# CONFIG_SCSI_SRP_ATTRS is not set +CONFIG_SCSI_LOWLEVEL=y +CONFIG_ISCSI_TCP=m +# CONFIG_LIBFC is not set +# CONFIG_SCSI_DEBUG is not set +# CONFIG_SCSI_DH is not set +# CONFIG_ATA is not set +CONFIG_MD=y +CONFIG_BLK_DEV_MD=m +CONFIG_MD_LINEAR=m +CONFIG_MD_RAID0=m +CONFIG_MD_RAID1=m +CONFIG_MD_RAID10=m +CONFIG_MD_RAID456=m +CONFIG_MD_RAID5_RESHAPE=y +CONFIG_MD_MULTIPATH=m +CONFIG_MD_FAULTY=m +CONFIG_BLK_DEV_DM=m +# CONFIG_DM_DEBUG is not set +CONFIG_DM_CRYPT=m +CONFIG_DM_SNAPSHOT=m +CONFIG_DM_MIRROR=m +CONFIG_DM_ZERO=m +CONFIG_DM_MULTIPATH=m +CONFIG_DM_DELAY=m +# CONFIG_DM_UEVENT is not set +CONFIG_NETDEVICES=y +CONFIG_DUMMY=m +CONFIG_BONDING=m +CONFIG_MACVLAN=m +CONFIG_EQUALIZER=m +CONFIG_TUN=m +CONFIG_VETH=m +# CONFIG_NET_ETHERNET is not set +CONFIG_MII=y +# CONFIG_NETDEV_1000 is not set +# CONFIG_NETDEV_10000 is not set + +# +# Wireless LAN +# +# CONFIG_WLAN_PRE80211 is not set +CONFIG_WLAN_80211=y +CONFIG_LIBERTAS=y +CONFIG_LIBERTAS_USB=y +# CONFIG_LIBERTAS_SDIO is not set +# CONFIG_LIBERTAS_DEBUG is not set +# CONFIG_LIBERTAS_THINFIRM is not set +CONFIG_USB_ZD1201=y +CONFIG_USB_NET_RNDIS_WLAN=y +CONFIG_RTL8187=y +# CONFIG_MAC80211_HWSIM is not set +CONFIG_P54_COMMON=y +CONFIG_P54_USB=y +# CONFIG_IWLWIFI_LEDS is not set +CONFIG_HOSTAP=y +CONFIG_HOSTAP_FIRMWARE=y +CONFIG_HOSTAP_FIRMWARE_NVRAM=y +CONFIG_B43=y +CONFIG_B43_LEDS=y +# CONFIG_B43_DEBUG is not set +# CONFIG_B43LEGACY is not set +CONFIG_ZD1211RW=y +# CONFIG_ZD1211RW_DEBUG is not set +CONFIG_RT2X00=y +CONFIG_RT2500USB=y +CONFIG_RT73USB=y +CONFIG_RT2X00_LIB_USB=y +CONFIG_RT2X00_LIB=y +CONFIG_RT2X00_LIB_FIRMWARE=y +CONFIG_RT2X00_LIB_CRYPTO=y +CONFIG_RT2X00_LIB_LEDS=y +# CONFIG_RT2X00_DEBUG is not set + +# +# WiMAX Wireless Broadband devices +# +# CONFIG_WIMAX_I2400M_USB is not set +# CONFIG_WIMAX_I2400M_SDIO is not set + +# +# USB Network Adapters +# +CONFIG_USB_CATC=y +CONFIG_USB_KAWETH=y +CONFIG_USB_PEGASUS=y +CONFIG_USB_RTL8150=y +CONFIG_USB_USBNET=y +CONFIG_USB_NET_AX8817X=y +CONFIG_USB_NET_CDCETHER=y +CONFIG_USB_NET_DM9601=y +CONFIG_USB_NET_SMSC95XX=y +CONFIG_USB_NET_GL620A=y +CONFIG_USB_NET_NET1080=y +CONFIG_USB_NET_PLUSB=y +CONFIG_USB_NET_MCS7830=y +CONFIG_USB_NET_RNDIS_HOST=y +CONFIG_USB_NET_CDC_SUBSET=y +CONFIG_USB_ALI_M5632=y +CONFIG_USB_AN2720=y +CONFIG_USB_BELKIN=y +CONFIG_USB_ARMLINUX=y +CONFIG_USB_EPSON2888=y +CONFIG_USB_KC2190=y +CONFIG_USB_NET_ZAURUS=y +# CONFIG_WAN is not set +CONFIG_ATM_DRIVERS=y +# CONFIG_ATM_DUMMY is not set +# CONFIG_ATM_TCP is not set +CONFIG_PPP=m +CONFIG_PPP_MULTILINK=y +CONFIG_PPP_FILTER=y +CONFIG_PPP_ASYNC=m +CONFIG_PPP_SYNC_TTY=m +CONFIG_PPP_DEFLATE=m +CONFIG_PPP_BSDCOMP=m +CONFIG_PPP_MPPE=m +CONFIG_PPPOE=m +# CONFIG_PPPOATM is not set +CONFIG_PPPOL2TP=m +# CONFIG_SLIP is not set +CONFIG_SLHC=m +CONFIG_NETCONSOLE=m +CONFIG_NETCONSOLE_DYNAMIC=y +CONFIG_NETPOLL=y +CONFIG_NETPOLL_TRAP=y +CONFIG_NET_POLL_CONTROLLER=y +# CONFIG_ISDN is not set + +# +# Input device support +# +CONFIG_INPUT=y +CONFIG_INPUT_FF_MEMLESS=y +# CONFIG_INPUT_POLLDEV is not set + +# +# Userland interfaces +# +CONFIG_INPUT_MOUSEDEV=y +CONFIG_INPUT_MOUSEDEV_PSAUX=y +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 +# CONFIG_INPUT_JOYDEV is not set +CONFIG_INPUT_EVDEV=y +# CONFIG_INPUT_EVBUG is not set + +# +# Input Device Drivers +# +CONFIG_INPUT_KEYBOARD=y +# CONFIG_KEYBOARD_ATKBD is not set +# CONFIG_KEYBOARD_SUNKBD is not set +# CONFIG_KEYBOARD_LKKBD is not set +# CONFIG_KEYBOARD_XTKBD is not set +# CONFIG_KEYBOARD_NEWTON is not set +# CONFIG_KEYBOARD_STOWAWAY is not set +# CONFIG_KEYBOARD_TWL4030 is not set +# CONFIG_KEYBOARD_LM8323 is not set +CONFIG_KEYBOARD_GPIO=y +CONFIG_INPUT_MOUSE=y +CONFIG_MOUSE_PS2=y +CONFIG_MOUSE_PS2_ALPS=y +CONFIG_MOUSE_PS2_LOGIPS2PP=y +CONFIG_MOUSE_PS2_SYNAPTICS=y +CONFIG_MOUSE_PS2_TRACKPOINT=y +# CONFIG_MOUSE_PS2_ELANTECH is not set +# CONFIG_MOUSE_PS2_TOUCHKIT is not set +# CONFIG_MOUSE_SERIAL is not set +# CONFIG_MOUSE_APPLETOUCH is not set +# CONFIG_MOUSE_BCM5974 is not set +# CONFIG_MOUSE_VSXXXAA is not set +# CONFIG_MOUSE_GPIO is not set +# CONFIG_INPUT_JOYSTICK is not set +# CONFIG_INPUT_TABLET is not set +# CONFIG_INPUT_TOUCHSCREEN is not set +CONFIG_INPUT_MISC=y +# CONFIG_INPUT_ATI_REMOTE is not set +# CONFIG_INPUT_ATI_REMOTE2 is not set +# CONFIG_INPUT_KEYSPAN_REMOTE is not set +# CONFIG_INPUT_POWERMATE is not set +# CONFIG_INPUT_YEALINK is not set +# CONFIG_INPUT_CM109 is not set +CONFIG_INPUT_TWL4030_PWRBUTTON=y +CONFIG_INPUT_UINPUT=y + +# +# Hardware I/O ports +# +CONFIG_SERIO=y +CONFIG_SERIO_SERPORT=y +CONFIG_SERIO_LIBPS2=y +# CONFIG_SERIO_RAW is not set +# CONFIG_GAMEPORT is not set + +# +# Character devices +# +CONFIG_VT=y +CONFIG_CONSOLE_TRANSLATIONS=y +CONFIG_VT_CONSOLE=y +CONFIG_HW_CONSOLE=y +CONFIG_VT_HW_CONSOLE_BINDING=y +CONFIG_DEVKMEM=y +# CONFIG_SERIAL_NONSTANDARD is not set + +# +# Serial drivers +# +CONFIG_SERIAL_8250=y +CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_NR_UARTS=32 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4 +CONFIG_SERIAL_8250_EXTENDED=y +CONFIG_SERIAL_8250_MANY_PORTS=y +CONFIG_SERIAL_8250_SHARE_IRQ=y +CONFIG_SERIAL_8250_DETECT_IRQ=y +CONFIG_SERIAL_8250_RSA=y + +# +# Non-8250 serial port support +# +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +CONFIG_UNIX98_PTYS=y +# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set +# CONFIG_LEGACY_PTYS is not set +# CONFIG_IPMI_HANDLER is not set +CONFIG_HW_RANDOM=y +# CONFIG_R3964 is not set +# CONFIG_RAW_DRIVER is not set +# CONFIG_TCG_TPM is not set +CONFIG_I2C=y +CONFIG_I2C_BOARDINFO=y +CONFIG_I2C_CHARDEV=y +CONFIG_I2C_HELPER_AUTO=y + +# +# I2C Hardware Bus support +# + +# +# I2C system bus drivers (mostly embedded / system-on-chip) +# +# CONFIG_I2C_GPIO is not set +# CONFIG_I2C_OCORES is not set +CONFIG_I2C_OMAP=y +# CONFIG_I2C_SIMTEC is not set + +# +# External I2C/SMBus adapter drivers +# +# CONFIG_I2C_PARPORT_LIGHT is not set +# CONFIG_I2C_TAOS_EVM is not set +# CONFIG_I2C_TINY_USB is not set + +# +# Other I2C/SMBus bus drivers +# +# CONFIG_I2C_PCA_PLATFORM is not set +# CONFIG_I2C_STUB is not set + +# +# Miscellaneous I2C Chip support +# +# CONFIG_DS1682 is not set +# CONFIG_SENSORS_PCF8574 is not set +# CONFIG_PCF8575 is not set +# CONFIG_SENSORS_PCA9539 is not set +# CONFIG_SENSORS_PCF8591 is not set +CONFIG_TWL4030_MADC=m +CONFIG_TWL4030_POWEROFF=y +# CONFIG_SENSORS_MAX6875 is not set +# CONFIG_SENSORS_TSL2550 is not set +# CONFIG_SENSORS_TSL2563 is not set +# CONFIG_I2C_DEBUG_CORE is not set +# CONFIG_I2C_DEBUG_ALGO is not set +# CONFIG_I2C_DEBUG_BUS is not set +# CONFIG_I2C_DEBUG_CHIP is not set +CONFIG_SPI=y +# CONFIG_SPI_DEBUG is not set +CONFIG_SPI_MASTER=y + +# +# SPI Master Controller Drivers +# +# CONFIG_SPI_BITBANG is not set +# CONFIG_SPI_GPIO is not set +# CONFIG_SPI_OMAP24XX is not set + +# +# SPI Protocol Masters +# +# CONFIG_SPI_TSC210X is not set +# CONFIG_SPI_TSC2301 is not set +# CONFIG_SPI_SPIDEV is not set +# CONFIG_SPI_TLE62X0 is not set +CONFIG_ARCH_REQUIRE_GPIOLIB=y +CONFIG_GPIOLIB=y +# CONFIG_DEBUG_GPIO is not set +CONFIG_GPIO_SYSFS=y + +# +# Memory mapped GPIO expanders: +# + +# +# I2C GPIO expanders: +# +# CONFIG_GPIO_MAX732X is not set +# CONFIG_GPIO_PCA953X is not set +# CONFIG_GPIO_PCF857X is not set +CONFIG_GPIO_TWL4030=y + +# +# PCI GPIO expanders: +# + +# +# SPI GPIO expanders: +# +# CONFIG_GPIO_MAX7301 is not set +# CONFIG_GPIO_MCP23S08 is not set +# CONFIG_W1 is not set +CONFIG_POWER_SUPPLY=m +# CONFIG_POWER_SUPPLY_DEBUG is not set +# CONFIG_PDA_POWER is not set +# CONFIG_BATTERY_DS2760 is not set +# CONFIG_TWL4030_BCI_BATTERY is not set +# CONFIG_BATTERY_BQ27x00 is not set +CONFIG_HWMON=y +# CONFIG_HWMON_VID is not set +# CONFIG_SENSORS_AD7414 is not set +# CONFIG_SENSORS_AD7418 is not set +# CONFIG_SENSORS_ADCXX is not set +# CONFIG_SENSORS_ADM1021 is not set +# CONFIG_SENSORS_ADM1025 is not set +# CONFIG_SENSORS_ADM1026 is not set +# CONFIG_SENSORS_ADM1029 is not set +# CONFIG_SENSORS_ADM1031 is not set +# CONFIG_SENSORS_ADM9240 is not set +# CONFIG_SENSORS_ADT7462 is not set +# CONFIG_SENSORS_ADT7470 is not set +# CONFIG_SENSORS_ADT7473 is not set +# CONFIG_SENSORS_ADT7475 is not set +# CONFIG_SENSORS_ATXP1 is not set +# CONFIG_SENSORS_DS1621 is not set +# CONFIG_SENSORS_F71805F is not set +# CONFIG_SENSORS_F71882FG is not set +# CONFIG_SENSORS_F75375S is not set +# CONFIG_SENSORS_GL518SM is not set +# CONFIG_SENSORS_GL520SM is not set +# CONFIG_SENSORS_IT87 is not set +# CONFIG_SENSORS_LM63 is not set +# CONFIG_SENSORS_LM70 is not set +# CONFIG_SENSORS_LM75 is not set +# CONFIG_SENSORS_LM77 is not set +# CONFIG_SENSORS_LM78 is not set +# CONFIG_SENSORS_LM80 is not set +# CONFIG_SENSORS_LM83 is not set +# CONFIG_SENSORS_LM85 is not set +# CONFIG_SENSORS_LM87 is not set +# CONFIG_SENSORS_LM90 is not set +# CONFIG_SENSORS_LM92 is not set +# CONFIG_SENSORS_LM93 is not set +# CONFIG_SENSORS_LTC4245 is not set +# CONFIG_SENSORS_MAX1111 is not set +# CONFIG_SENSORS_MAX1619 is not set +# CONFIG_SENSORS_MAX6650 is not set +# CONFIG_SENSORS_PC87360 is not set +# CONFIG_SENSORS_PC87427 is not set +# CONFIG_SENSORS_DME1737 is not set +# CONFIG_SENSORS_SMSC47M1 is not set +# CONFIG_SENSORS_SMSC47M192 is not set +# CONFIG_SENSORS_SMSC47B397 is not set +# CONFIG_SENSORS_ADS7828 is not set +# CONFIG_SENSORS_THMC50 is not set +# CONFIG_SENSORS_VT1211 is not set +# CONFIG_SENSORS_W83781D is not set +# CONFIG_SENSORS_W83791D is not set +# CONFIG_SENSORS_W83792D is not set +# CONFIG_SENSORS_W83793 is not set +# CONFIG_SENSORS_W83L785TS is not set +# CONFIG_SENSORS_W83L786NG is not set +# CONFIG_SENSORS_W83627HF is not set +# CONFIG_SENSORS_W83627EHF is not set +# CONFIG_SENSORS_TSC210X is not set +CONFIG_SENSORS_OMAP34XX=y +# CONFIG_HWMON_DEBUG_CHIP is not set +CONFIG_THERMAL=y +CONFIG_THERMAL_HWMON=y +CONFIG_WATCHDOG=y +CONFIG_WATCHDOG_NOWAYOUT=y + +# +# Watchdog Device Drivers +# +# CONFIG_SOFT_WATCHDOG is not set +CONFIG_OMAP_WATCHDOG=y + +# +# USB-based Watchdog Cards +# +# CONFIG_USBPCWATCHDOG is not set +CONFIG_SSB_POSSIBLE=y + +# +# Sonics Silicon Backplane +# +CONFIG_SSB=y +# CONFIG_SSB_SILENT is not set +# CONFIG_SSB_DEBUG is not set + +# +# Multifunction device drivers +# +# CONFIG_MFD_CORE is not set +# CONFIG_MFD_SM501 is not set +# CONFIG_MFD_ASIC3 is not set +# CONFIG_HTC_EGPIO is not set +# CONFIG_HTC_PASIC3 is not set +# CONFIG_TPS65010 is not set +CONFIG_TWL4030_CORE=y +# CONFIG_TWL4030_POWER is not set +# CONFIG_MFD_TMIO is not set +# CONFIG_MFD_T7L66XB is not set +# CONFIG_MFD_TC6387XB is not set +# CONFIG_MFD_TC6393XB is not set +# CONFIG_PMIC_DA903X is not set +# CONFIG_MFD_WM8400 is not set +# CONFIG_MFD_WM8350_I2C is not set +# CONFIG_MFD_PCF50633 is not set + +# +# Multimedia devices +# + +# +# Multimedia core support +# +CONFIG_VIDEO_DEV=m +CONFIG_VIDEO_V4L2_COMMON=m +CONFIG_VIDEO_ALLOW_V4L1=y +CONFIG_VIDEO_V4L1_COMPAT=y +CONFIG_DVB_CORE=m +CONFIG_VIDEO_MEDIA=m + +# +# Multimedia drivers +# +CONFIG_MEDIA_ATTACH=y +CONFIG_MEDIA_TUNER=m +# CONFIG_MEDIA_TUNER_CUSTOMIZE is not set +CONFIG_MEDIA_TUNER_SIMPLE=m +CONFIG_MEDIA_TUNER_TDA8290=m +CONFIG_MEDIA_TUNER_TDA827X=m +CONFIG_MEDIA_TUNER_TDA18271=m +CONFIG_MEDIA_TUNER_TDA9887=m +CONFIG_MEDIA_TUNER_TEA5761=m +CONFIG_MEDIA_TUNER_TEA5767=m +CONFIG_MEDIA_TUNER_MT20XX=m +CONFIG_MEDIA_TUNER_MT2060=m +CONFIG_MEDIA_TUNER_MT2266=m +CONFIG_MEDIA_TUNER_QT1010=m +CONFIG_MEDIA_TUNER_XC2028=m +CONFIG_MEDIA_TUNER_XC5000=m +CONFIG_MEDIA_TUNER_MXL5005S=m +CONFIG_VIDEO_V4L2=m +CONFIG_VIDEO_V4L1=m +CONFIG_VIDEOBUF_GEN=m +CONFIG_VIDEOBUF_VMALLOC=m +CONFIG_VIDEOBUF_DVB=m +CONFIG_VIDEO_IR=m +CONFIG_VIDEO_TVEEPROM=m +CONFIG_VIDEO_TUNER=m +CONFIG_VIDEO_CAPTURE_DRIVERS=y +# CONFIG_VIDEO_ADV_DEBUG is not set +# CONFIG_VIDEO_FIXED_MINOR_RANGES is not set +CONFIG_VIDEO_HELPER_CHIPS_AUTO=y +CONFIG_VIDEO_IR_I2C=m +CONFIG_VIDEO_MSP3400=m +CONFIG_VIDEO_CS53L32A=m +CONFIG_VIDEO_WM8775=m +CONFIG_VIDEO_SAA711X=m +CONFIG_VIDEO_TVP5150=m +CONFIG_VIDEO_CX25840=m +CONFIG_VIDEO_CX2341X=m +CONFIG_VIDEO_VIVI=m +# CONFIG_VIDEO_CPIA is not set +# CONFIG_VIDEO_CPIA2 is not set +# CONFIG_VIDEO_SAA5246A is not set +# CONFIG_VIDEO_SAA5249 is not set +# CONFIG_VIDEO_AU0828 is not set +# CONFIG_VIDEO_OMAP3 is not set +# CONFIG_SOC_CAMERA is not set +CONFIG_V4L_USB_DRIVERS=y +CONFIG_USB_VIDEO_CLASS=m +CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y +CONFIG_USB_GSPCA=m +CONFIG_USB_M5602=m +CONFIG_USB_STV06XX=m +CONFIG_USB_GSPCA_CONEX=m +CONFIG_USB_GSPCA_ETOMS=m +CONFIG_USB_GSPCA_FINEPIX=m +CONFIG_USB_GSPCA_MARS=m +CONFIG_USB_GSPCA_OV519=m +CONFIG_USB_GSPCA_OV534=m +CONFIG_USB_GSPCA_PAC207=m +CONFIG_USB_GSPCA_PAC7311=m +CONFIG_USB_GSPCA_SONIXB=m +CONFIG_USB_GSPCA_SONIXJ=m +CONFIG_USB_GSPCA_SPCA500=m +CONFIG_USB_GSPCA_SPCA501=m +CONFIG_USB_GSPCA_SPCA505=m +CONFIG_USB_GSPCA_SPCA506=m +CONFIG_USB_GSPCA_SPCA508=m +CONFIG_USB_GSPCA_SPCA561=m +CONFIG_USB_GSPCA_STK014=m +CONFIG_USB_GSPCA_SUNPLUS=m +CONFIG_USB_GSPCA_T613=m +CONFIG_USB_GSPCA_TV8532=m +CONFIG_USB_GSPCA_VC032X=m +CONFIG_USB_GSPCA_ZC3XX=m +CONFIG_VIDEO_PVRUSB2=m +CONFIG_VIDEO_PVRUSB2_SYSFS=y +CONFIG_VIDEO_PVRUSB2_DVB=y +# CONFIG_VIDEO_PVRUSB2_DEBUGIFC is not set +CONFIG_VIDEO_EM28XX=m +CONFIG_VIDEO_EM28XX_ALSA=m +CONFIG_VIDEO_EM28XX_DVB=m +CONFIG_VIDEO_USBVISION=m +CONFIG_VIDEO_USBVIDEO=m +CONFIG_USB_VICAM=m +CONFIG_USB_IBMCAM=m +CONFIG_USB_KONICAWC=m +CONFIG_USB_QUICKCAM_MESSENGER=m +CONFIG_USB_ET61X251=m +CONFIG_VIDEO_OVCAMCHIP=m +CONFIG_USB_W9968CF=m +CONFIG_USB_OV511=m +CONFIG_USB_SE401=m +CONFIG_USB_SN9C102=m +CONFIG_USB_STV680=m +CONFIG_USB_ZC0301=m +CONFIG_USB_PWC=m +# CONFIG_USB_PWC_DEBUG is not set +CONFIG_USB_ZR364XX=m +CONFIG_USB_STKWEBCAM=m +CONFIG_USB_S2255=m +CONFIG_RADIO_ADAPTERS=y +# CONFIG_USB_DSBR is not set +# CONFIG_USB_SI470X is not set +# CONFIG_USB_MR800 is not set +# CONFIG_RADIO_TEA5764 is not set +CONFIG_DVB_DYNAMIC_MINORS=y +CONFIG_DVB_CAPTURE_DRIVERS=y +# CONFIG_TTPCI_EEPROM is not set + +# +# Supported USB Adapters +# +CONFIG_DVB_USB=m +# CONFIG_DVB_USB_DEBUG is not set +CONFIG_DVB_USB_A800=m +CONFIG_DVB_USB_DIBUSB_MB=m +# CONFIG_DVB_USB_DIBUSB_MB_FAULTY is not set +CONFIG_DVB_USB_DIBUSB_MC=m +CONFIG_DVB_USB_DIB0700=m +CONFIG_DVB_USB_UMT_010=m +CONFIG_DVB_USB_CXUSB=m +CONFIG_DVB_USB_M920X=m +CONFIG_DVB_USB_GL861=m +CONFIG_DVB_USB_AU6610=m +CONFIG_DVB_USB_DIGITV=m +CONFIG_DVB_USB_VP7045=m +CONFIG_DVB_USB_VP702X=m +CONFIG_DVB_USB_GP8PSK=m +CONFIG_DVB_USB_NOVA_T_USB2=m +CONFIG_DVB_USB_TTUSB2=m +CONFIG_DVB_USB_DTT200U=m +CONFIG_DVB_USB_OPERA1=m +CONFIG_DVB_USB_AF9005=m +CONFIG_DVB_USB_AF9005_REMOTE=m +CONFIG_DVB_USB_DW2102=m +CONFIG_DVB_USB_CINERGY_T2=m +CONFIG_DVB_USB_ANYSEE=m +CONFIG_DVB_USB_DTV5100=m +CONFIG_DVB_USB_AF9015=m +CONFIG_DVB_SIANO_SMS1XXX=m +CONFIG_DVB_SIANO_SMS1XXX_SMS_IDS=y + +# +# Supported FlexCopII (B2C2) Adapters +# +CONFIG_DVB_B2C2_FLEXCOP=m +CONFIG_DVB_B2C2_FLEXCOP_USB=m +# CONFIG_DVB_B2C2_FLEXCOP_DEBUG is not set + +# +# Supported DVB Frontends +# + +# +# Customise DVB Frontends +# +# CONFIG_DVB_FE_CUSTOMISE is not set + +# +# Multistandard (satellite) frontends +# +CONFIG_DVB_STB0899=m +CONFIG_DVB_STB6100=m + +# +# DVB-S (satellite) frontends +# +CONFIG_DVB_CX24110=m +CONFIG_DVB_CX24123=m +CONFIG_DVB_MT312=m +CONFIG_DVB_S5H1420=m +CONFIG_DVB_STV0288=m +CONFIG_DVB_STB6000=m +CONFIG_DVB_STV0299=m +CONFIG_DVB_TDA8083=m +CONFIG_DVB_TDA10086=m +CONFIG_DVB_TDA8261=m +CONFIG_DVB_VES1X93=m +CONFIG_DVB_TUNER_ITD1000=m +CONFIG_DVB_TUNER_CX24113=m +CONFIG_DVB_TDA826X=m +CONFIG_DVB_TUA6100=m +CONFIG_DVB_CX24116=m +CONFIG_DVB_SI21XX=m + +# +# DVB-T (terrestrial) frontends +# +CONFIG_DVB_SP8870=m +CONFIG_DVB_SP887X=m +CONFIG_DVB_CX22700=m +CONFIG_DVB_CX22702=m +CONFIG_DVB_DRX397XD=m +CONFIG_DVB_L64781=m +CONFIG_DVB_TDA1004X=m +CONFIG_DVB_NXT6000=m +CONFIG_DVB_MT352=m +CONFIG_DVB_ZL10353=m +CONFIG_DVB_DIB3000MB=m +CONFIG_DVB_DIB3000MC=m +CONFIG_DVB_DIB7000M=m +CONFIG_DVB_DIB7000P=m +CONFIG_DVB_TDA10048=m + +# +# DVB-C (cable) frontends +# +CONFIG_DVB_VES1820=m +CONFIG_DVB_TDA10021=m +CONFIG_DVB_TDA10023=m +CONFIG_DVB_STV0297=m + +# +# ATSC (North American/Korean Terrestrial/Cable DTV) frontends +# +CONFIG_DVB_NXT200X=m +CONFIG_DVB_OR51211=m +CONFIG_DVB_OR51132=m +CONFIG_DVB_BCM3510=m +CONFIG_DVB_LGDT330X=m +CONFIG_DVB_LGDT3304=m +CONFIG_DVB_S5H1409=m +CONFIG_DVB_AU8522=m +CONFIG_DVB_S5H1411=m + +# +# ISDB-T (terrestrial) frontends +# +CONFIG_DVB_S921=m + +# +# Digital terrestrial only tuners/PLL +# +CONFIG_DVB_PLL=m +CONFIG_DVB_TUNER_DIB0070=m + +# +# SEC control devices for DVB-S +# +CONFIG_DVB_LNBP21=m +# CONFIG_DVB_ISL6405 is not set +CONFIG_DVB_ISL6421=m +CONFIG_DVB_LGS8GL5=m + +# +# Tools to develop new frontends +# +# CONFIG_DVB_DUMMY_FE is not set +CONFIG_DVB_AF9013=m +# CONFIG_DAB is not set + +# +# Graphics support +# +# CONFIG_VGASTATE is not set +# CONFIG_VIDEO_OUTPUT_CONTROL is not set +CONFIG_FB=y +# CONFIG_FIRMWARE_EDID is not set +# CONFIG_FB_DDC is not set +# CONFIG_FB_BOOT_VESA_SUPPORT is not set +CONFIG_FB_CFB_FILLRECT=y +CONFIG_FB_CFB_COPYAREA=y +CONFIG_FB_CFB_IMAGEBLIT=y +# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set +# CONFIG_FB_SYS_FILLRECT is not set +# CONFIG_FB_SYS_COPYAREA is not set +# CONFIG_FB_SYS_IMAGEBLIT is not set +# CONFIG_FB_FOREIGN_ENDIAN is not set +# CONFIG_FB_SYS_FOPS is not set +# CONFIG_FB_SVGALIB is not set +# CONFIG_FB_MACMODES is not set +# CONFIG_FB_BACKLIGHT is not set +# CONFIG_FB_MODE_HELPERS is not set +# CONFIG_FB_TILEBLITTING is not set + +# +# Frame buffer hardware drivers +# +# CONFIG_FB_S1D13XXX is not set +# CONFIG_FB_VIRTUAL is not set +# CONFIG_FB_METRONOME is not set +# CONFIG_FB_MB862XX is not set +# CONFIG_FB_OMAP_BOOTLOADER_INIT is not set +CONFIG_OMAP2_DSS=y +CONFIG_OMAP2_DSS_VRAM_SIZE=14 +CONFIG_OMAP2_DSS_DEBUG_SUPPORT=y +# CONFIG_OMAP2_DSS_RFBI is not set +CONFIG_OMAP2_DSS_VENC=y +# CONFIG_OMAP2_DSS_SDI is not set +CONFIG_OMAP2_DSS_DSI=y +CONFIG_OMAP2_DSS_USE_DSI_PLL=y +# CONFIG_OMAP2_DSS_FAKE_VSYNC is not set +CONFIG_OMAP2_DSS_MIN_FCK_PER_PCK=1 + +# +# OMAP2/3 Display Device Drivers +# +CONFIG_PANEL_GENERIC=y +CONFIG_PANEL_SAMSUNG_LTE430WQ_F0C=m +# CONFIG_PANEL_SHARP_LS037V7DW01 is not set +# CONFIG_PANEL_N800 is not set +# CONFIG_CTRL_BLIZZARD is not set +CONFIG_FB_OMAP2=y +CONFIG_FB_OMAP2_DEBUG_SUPPORT=y +# CONFIG_FB_OMAP2_FORCE_AUTO_UPDATE is not set +CONFIG_FB_OMAP2_NUM_FBS=3 +# CONFIG_BACKLIGHT_LCD_SUPPORT is not set + +# +# Display device support +# +CONFIG_DISPLAY_SUPPORT=y + +# +# Display hardware drivers +# + +# +# Console display driver support +# +# CONFIG_VGA_CONSOLE is not set +CONFIG_DUMMY_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE=y +# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set +CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y +# CONFIG_FONTS is not set +CONFIG_FONT_8x8=y +CONFIG_FONT_8x16=y +CONFIG_LOGO=y +CONFIG_LOGO_LINUX_MONO=y +CONFIG_LOGO_LINUX_VGA16=y +CONFIG_LOGO_LINUX_CLUT224=y +CONFIG_SOUND=y +CONFIG_SOUND_OSS_CORE=y +CONFIG_SND=y +CONFIG_SND_TIMER=y +CONFIG_SND_PCM=y +CONFIG_SND_HWDEP=y +CONFIG_SND_RAWMIDI=y +CONFIG_SND_SEQUENCER=m +# CONFIG_SND_SEQ_DUMMY is not set +CONFIG_SND_OSSEMUL=y +CONFIG_SND_MIXER_OSS=y +CONFIG_SND_PCM_OSS=y +CONFIG_SND_PCM_OSS_PLUGINS=y +CONFIG_SND_SEQUENCER_OSS=y +CONFIG_SND_HRTIMER=m +CONFIG_SND_SEQ_HRTIMER_DEFAULT=y +# CONFIG_SND_DYNAMIC_MINORS is not set +CONFIG_SND_SUPPORT_OLD_API=y +CONFIG_SND_VERBOSE_PROCFS=y +# CONFIG_SND_VERBOSE_PRINTK is not set +# CONFIG_SND_DEBUG is not set +CONFIG_SND_DRIVERS=y +# CONFIG_SND_DUMMY is not set +# CONFIG_SND_VIRMIDI is not set +# CONFIG_SND_MTPAV is not set +# CONFIG_SND_SERIAL_U16550 is not set +# CONFIG_SND_MPU401 is not set +# CONFIG_SND_ARM is not set +CONFIG_SND_SPI=y +CONFIG_SND_USB=y +CONFIG_SND_USB_AUDIO=y +CONFIG_SND_USB_CAIAQ=m +CONFIG_SND_USB_CAIAQ_INPUT=y +CONFIG_SND_SOC=y +CONFIG_SND_OMAP_SOC=y +CONFIG_SND_OMAP_SOC_MCBSP=y +CONFIG_SND_OMAP_SOC_OMAP3_BEAGLE=y +CONFIG_SND_SOC_I2C_AND_SPI=y +# CONFIG_SND_SOC_ALL_CODECS is not set +CONFIG_SND_SOC_TWL4030=y +# CONFIG_SOUND_PRIME is not set +CONFIG_HID_SUPPORT=y +CONFIG_HID=y +CONFIG_HID_DEBUG=y +# CONFIG_HIDRAW is not set + +# +# USB Input Devices +# +CONFIG_USB_HID=y +# CONFIG_HID_PID is not set +# CONFIG_USB_HIDDEV is not set + +# +# Special HID drivers +# +CONFIG_HID_COMPAT=y +CONFIG_HID_A4TECH=y +CONFIG_HID_APPLE=y +CONFIG_HID_BELKIN=y +CONFIG_HID_CHERRY=y +CONFIG_HID_CHICONY=y +CONFIG_HID_CYPRESS=y +CONFIG_HID_EZKEY=y +CONFIG_HID_GYRATION=y +CONFIG_HID_LOGITECH=y +# CONFIG_LOGITECH_FF is not set +# CONFIG_LOGIRUMBLEPAD2_FF is not set +CONFIG_HID_MICROSOFT=y +CONFIG_HID_MONTEREY=y +CONFIG_HID_NTRIG=y +CONFIG_HID_PANTHERLORD=y +# CONFIG_PANTHERLORD_FF is not set +CONFIG_HID_PETALYNX=y +CONFIG_HID_SAMSUNG=y +CONFIG_HID_SONY=y +CONFIG_HID_SUNPLUS=y +CONFIG_GREENASIA_FF=y +CONFIG_HID_TOPSEED=y +# CONFIG_THRUSTMASTER_FF is not set +# CONFIG_ZEROPLUS_FF is not set +CONFIG_USB_SUPPORT=y +CONFIG_USB_ARCH_HAS_HCD=y +CONFIG_USB_ARCH_HAS_OHCI=y +CONFIG_USB_ARCH_HAS_EHCI=y +CONFIG_USB=y +# CONFIG_USB_DEBUG is not set +# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set + +# +# Miscellaneous USB options +# +CONFIG_USB_DEVICEFS=y +CONFIG_USB_DEVICE_CLASS=y +# CONFIG_USB_DYNAMIC_MINORS is not set +CONFIG_USB_SUSPEND=y +CONFIG_USB_OTG=y +# CONFIG_USB_OTG_WHITELIST is not set +# CONFIG_USB_OTG_BLACKLIST_HUB is not set +CONFIG_USB_MON=y +# CONFIG_USB_WUSB is not set +# CONFIG_USB_WUSB_CBAF is not set + +# +# USB Host Controller Drivers +# +# CONFIG_USB_C67X00_HCD is not set +CONFIG_USB_EHCI_HCD=y +CONFIG_OMAP_EHCI_PHY_MODE=y +# CONFIG_OMAP_EHCI_TLL_MODE is not set +CONFIG_USB_EHCI_ROOT_HUB_TT=y +CONFIG_USB_EHCI_TT_NEWSCHED=y +CONFIG_USB_OXU210HP_HCD=y +# CONFIG_USB_ISP116X_HCD is not set +# CONFIG_USB_OHCI_HCD is not set +# CONFIG_USB_U132_HCD is not set +# CONFIG_USB_SL811_HCD is not set +# CONFIG_USB_R8A66597_HCD is not set +# CONFIG_USB_HWA_HCD is not set +CONFIG_USB_MUSB_HDRC=y +CONFIG_USB_MUSB_SOC=y + +# +# OMAP 343x high speed USB support +# +# CONFIG_USB_MUSB_HOST is not set +# CONFIG_USB_MUSB_PERIPHERAL is not set +CONFIG_USB_MUSB_OTG=y +CONFIG_USB_GADGET_MUSB_HDRC=y +CONFIG_USB_MUSB_HDRC_HCD=y +# CONFIG_MUSB_PIO_ONLY is not set +CONFIG_USB_INVENTRA_DMA=y +# CONFIG_USB_TI_CPPI_DMA is not set +# CONFIG_USB_MUSB_DEBUG is not set + +# +# USB Device Class drivers +# +CONFIG_USB_ACM=m +CONFIG_USB_PRINTER=m +CONFIG_USB_WDM=m +CONFIG_USB_TMC=m + +# +# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed; +# + +# +# see USB_STORAGE Help for more information +# +CONFIG_USB_STORAGE=y +# CONFIG_USB_STORAGE_DEBUG is not set +# CONFIG_USB_STORAGE_DATAFAB is not set +# CONFIG_USB_STORAGE_FREECOM is not set +# CONFIG_USB_STORAGE_ISD200 is not set +# CONFIG_USB_STORAGE_USBAT is not set +# CONFIG_USB_STORAGE_SDDR09 is not set +# CONFIG_USB_STORAGE_SDDR55 is not set +# CONFIG_USB_STORAGE_JUMPSHOT is not set +# CONFIG_USB_STORAGE_ALAUDA is not set +# CONFIG_USB_STORAGE_ONETOUCH is not set +# CONFIG_USB_STORAGE_KARMA is not set +# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set +# CONFIG_USB_LIBUSUAL is not set + +# +# USB Imaging devices +# +# CONFIG_USB_MDC800 is not set +# CONFIG_USB_MICROTEK is not set + +# +# USB port drivers +# +CONFIG_USB_SERIAL=m +CONFIG_USB_EZUSB=y +CONFIG_USB_SERIAL_GENERIC=y +CONFIG_USB_SERIAL_AIRCABLE=m +CONFIG_USB_SERIAL_ARK3116=m +CONFIG_USB_SERIAL_BELKIN=m +CONFIG_USB_SERIAL_CH341=m +CONFIG_USB_SERIAL_WHITEHEAT=m +CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m +CONFIG_USB_SERIAL_CP2101=m +CONFIG_USB_SERIAL_CYPRESS_M8=m +CONFIG_USB_SERIAL_EMPEG=m +CONFIG_USB_SERIAL_FTDI_SIO=m +CONFIG_USB_SERIAL_FUNSOFT=m +CONFIG_USB_SERIAL_VISOR=m +CONFIG_USB_SERIAL_IPAQ=m +CONFIG_USB_SERIAL_IR=m +CONFIG_USB_SERIAL_EDGEPORT=m +CONFIG_USB_SERIAL_EDGEPORT_TI=m +CONFIG_USB_SERIAL_GARMIN=m +CONFIG_USB_SERIAL_IPW=m +CONFIG_USB_SERIAL_IUU=m +CONFIG_USB_SERIAL_KEYSPAN_PDA=m +CONFIG_USB_SERIAL_KEYSPAN=m +CONFIG_USB_SERIAL_KEYSPAN_MPR=y +CONFIG_USB_SERIAL_KEYSPAN_USA28=y +CONFIG_USB_SERIAL_KEYSPAN_USA28X=y +CONFIG_USB_SERIAL_KEYSPAN_USA28XA=y +CONFIG_USB_SERIAL_KEYSPAN_USA28XB=y +CONFIG_USB_SERIAL_KEYSPAN_USA19=y +CONFIG_USB_SERIAL_KEYSPAN_USA18X=y +CONFIG_USB_SERIAL_KEYSPAN_USA19W=y +CONFIG_USB_SERIAL_KEYSPAN_USA19QW=y +CONFIG_USB_SERIAL_KEYSPAN_USA19QI=y +CONFIG_USB_SERIAL_KEYSPAN_USA49W=y +CONFIG_USB_SERIAL_KEYSPAN_USA49WLC=y +CONFIG_USB_SERIAL_KLSI=m +CONFIG_USB_SERIAL_KOBIL_SCT=m +CONFIG_USB_SERIAL_MCT_U232=m +CONFIG_USB_SERIAL_MOS7720=m +CONFIG_USB_SERIAL_MOS7840=m +CONFIG_USB_SERIAL_MOTOROLA=m +CONFIG_USB_SERIAL_NAVMAN=m +CONFIG_USB_SERIAL_PL2303=m +CONFIG_USB_SERIAL_OTI6858=m +CONFIG_USB_SERIAL_SPCP8X5=m +CONFIG_USB_SERIAL_HP4X=m +CONFIG_USB_SERIAL_SAFE=m +# CONFIG_USB_SERIAL_SAFE_PADDED is not set +CONFIG_USB_SERIAL_SIEMENS_MPI=m +CONFIG_USB_SERIAL_SIERRAWIRELESS=m +CONFIG_USB_SERIAL_TI=m +CONFIG_USB_SERIAL_CYBERJACK=m +CONFIG_USB_SERIAL_XIRCOM=m +CONFIG_USB_SERIAL_OPTION=m +CONFIG_USB_SERIAL_OMNINET=m +CONFIG_USB_SERIAL_OPTICON=m +CONFIG_USB_SERIAL_DEBUG=m + +# +# USB Miscellaneous drivers +# +CONFIG_USB_EMI62=m +CONFIG_USB_EMI26=m +# CONFIG_USB_ADUTUX is not set +# CONFIG_USB_SEVSEG is not set +# CONFIG_USB_RIO500 is not set +CONFIG_USB_LEGOTOWER=m +CONFIG_USB_LCD=m +CONFIG_USB_BERRY_CHARGE=m +CONFIG_USB_LED=m +CONFIG_USB_CYPRESS_CY7C63=m +CONFIG_USB_CYTHERM=m +CONFIG_USB_PHIDGET=m +CONFIG_USB_PHIDGETKIT=m +CONFIG_USB_PHIDGETMOTORCONTROL=m +CONFIG_USB_PHIDGETSERVO=m +CONFIG_USB_IDMOUSE=m +CONFIG_USB_FTDI_ELAN=m +# CONFIG_USB_APPLEDISPLAY is not set +CONFIG_USB_SISUSBVGA=m +CONFIG_USB_SISUSBVGA_CON=y +CONFIG_USB_LD=m +CONFIG_USB_TRANCEVIBRATOR=m +# CONFIG_USB_IOWARRIOR is not set +CONFIG_USB_TEST=m +# CONFIG_USB_ISIGHTFW is not set +CONFIG_USB_VST=m +CONFIG_USB_ATM=m +CONFIG_USB_SPEEDTOUCH=m +CONFIG_USB_CXACRU=m +CONFIG_USB_UEAGLEATM=m +CONFIG_USB_XUSBATM=m +CONFIG_USB_GADGET=y +# CONFIG_USB_GADGET_DEBUG is not set +# CONFIG_USB_GADGET_DEBUG_FILES is not set +CONFIG_USB_GADGET_DEBUG_FS=y +CONFIG_USB_GADGET_VBUS_DRAW=2 +CONFIG_USB_GADGET_SELECTED=y +# CONFIG_USB_GADGET_AT91 is not set +# CONFIG_USB_GADGET_ATMEL_USBA is not set +# CONFIG_USB_GADGET_FSL_USB2 is not set +# CONFIG_USB_GADGET_LH7A40X is not set +# CONFIG_USB_GADGET_OMAP is not set +# CONFIG_USB_GADGET_PXA25X is not set +# CONFIG_USB_GADGET_PXA27X is not set +# CONFIG_USB_GADGET_S3C2410 is not set +# CONFIG_USB_GADGET_IMX is not set +# CONFIG_USB_GADGET_M66592 is not set +# CONFIG_USB_GADGET_AMD5536UDC is not set +# CONFIG_USB_GADGET_FSL_QE is not set +# CONFIG_USB_GADGET_CI13XXX is not set +# CONFIG_USB_GADGET_NET2280 is not set +# CONFIG_USB_GADGET_GOKU is not set +# CONFIG_USB_GADGET_DUMMY_HCD is not set +CONFIG_USB_GADGET_DUALSPEED=y +CONFIG_USB_ZERO=m +CONFIG_USB_ZERO_HNPTEST=y +CONFIG_USB_ETH=m +CONFIG_USB_ETH_RNDIS=y +CONFIG_USB_GADGETFS=m +CONFIG_USB_FILE_STORAGE=m +# CONFIG_USB_FILE_STORAGE_TEST is not set +CONFIG_USB_G_SERIAL=m +CONFIG_USB_MIDI_GADGET=m +CONFIG_USB_G_PRINTER=m +CONFIG_USB_CDC_COMPOSITE=m + +# +# OTG and related infrastructure +# +CONFIG_USB_OTG_UTILS=y +CONFIG_USB_GPIO_VBUS=y +# CONFIG_ISP1301_OMAP is not set +CONFIG_TWL4030_USB=y +# CONFIG_NOP_USB_XCEIV is not set +CONFIG_MMC=y +# CONFIG_MMC_DEBUG is not set +CONFIG_MMC_UNSAFE_RESUME=y + +# +# MMC/SD/SDIO Card Drivers +# +CONFIG_MMC_BLOCK=y +CONFIG_MMC_BLOCK_BOUNCE=y +CONFIG_SDIO_UART=y +# CONFIG_MMC_TEST is not set + +# +# MMC/SD/SDIO Host Controller Drivers +# +# CONFIG_MMC_SDHCI is not set +CONFIG_MMC_OMAP_HS=y +CONFIG_MMC_SPI=m +# CONFIG_MEMSTICK is not set +# CONFIG_ACCESSIBILITY is not set +CONFIG_NEW_LEDS=y +CONFIG_LEDS_CLASS=y + +# +# LED drivers +# +# CONFIG_LEDS_OMAP_DEBUG is not set +CONFIG_LEDS_OMAP=y +# CONFIG_LEDS_OMAP_PWM is not set +# CONFIG_LEDS_PCA9532 is not set +CONFIG_LEDS_GPIO=y +# CONFIG_LEDS_LP5521 is not set +# CONFIG_LEDS_PCA955X is not set + +# +# LED Triggers +# +CONFIG_LEDS_TRIGGERS=y +CONFIG_LEDS_TRIGGER_TIMER=m +CONFIG_LEDS_TRIGGER_HEARTBEAT=y +CONFIG_LEDS_TRIGGER_BACKLIGHT=m +CONFIG_LEDS_TRIGGER_DEFAULT_ON=m +CONFIG_RTC_LIB=y +CONFIG_RTC_CLASS=y +CONFIG_RTC_HCTOSYS=y +CONFIG_RTC_HCTOSYS_DEVICE="rtc0" +# CONFIG_RTC_DEBUG is not set + +# +# RTC interfaces +# +CONFIG_RTC_INTF_SYSFS=y +CONFIG_RTC_INTF_PROC=y +CONFIG_RTC_INTF_DEV=y +# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set +# CONFIG_RTC_DRV_TEST is not set + +# +# I2C RTC drivers +# +# CONFIG_RTC_DRV_DS1307 is not set +# CONFIG_RTC_DRV_DS1374 is not set +# CONFIG_RTC_DRV_DS1672 is not set +# CONFIG_RTC_DRV_MAX6900 is not set +# CONFIG_RTC_DRV_RS5C372 is not set +# CONFIG_RTC_DRV_ISL1208 is not set +# CONFIG_RTC_DRV_X1205 is not set +# CONFIG_RTC_DRV_PCF8563 is not set +# CONFIG_RTC_DRV_PCF8583 is not set +# CONFIG_RTC_DRV_M41T80 is not set +CONFIG_RTC_DRV_TWL4030=y +# CONFIG_RTC_DRV_S35390A is not set +# CONFIG_RTC_DRV_FM3130 is not set +# CONFIG_RTC_DRV_RX8581 is not set + +# +# SPI RTC drivers +# +# CONFIG_RTC_DRV_M41T94 is not set +# CONFIG_RTC_DRV_DS1305 is not set +# CONFIG_RTC_DRV_DS1390 is not set +# CONFIG_RTC_DRV_MAX6902 is not set +# CONFIG_RTC_DRV_R9701 is not set +# CONFIG_RTC_DRV_RS5C348 is not set +# CONFIG_RTC_DRV_DS3234 is not set + +# +# Platform RTC drivers +# +# CONFIG_RTC_DRV_CMOS is not set +# CONFIG_RTC_DRV_DS1286 is not set +# CONFIG_RTC_DRV_DS1511 is not set +# CONFIG_RTC_DRV_DS1553 is not set +# CONFIG_RTC_DRV_DS1742 is not set +# CONFIG_RTC_DRV_STK17TA8 is not set +# CONFIG_RTC_DRV_M48T86 is not set +# CONFIG_RTC_DRV_M48T35 is not set +# CONFIG_RTC_DRV_M48T59 is not set +# CONFIG_RTC_DRV_BQ4802 is not set +# CONFIG_RTC_DRV_V3020 is not set + +# +# on-CPU RTC drivers +# +# CONFIG_DMADEVICES is not set +CONFIG_REGULATOR=y +# CONFIG_REGULATOR_DEBUG is not set +# CONFIG_REGULATOR_FIXED_VOLTAGE is not set +# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set +# CONFIG_REGULATOR_BQ24022 is not set +CONFIG_REGULATOR_TWL4030=y +CONFIG_UIO=m +CONFIG_UIO_PDRV=m +CONFIG_UIO_PDRV_GENIRQ=m +# CONFIG_UIO_SMX is not set +# CONFIG_UIO_SERCOS3 is not set +CONFIG_STAGING=y +# CONFIG_STAGING_EXCLUDE_BUILD is not set +# CONFIG_MEILHAUS is not set +# CONFIG_USB_IP_COMMON is not set +CONFIG_W35UND=m +CONFIG_PRISM2_USB=m +# CONFIG_ECHO is not set +CONFIG_USB_ATMEL=m +# CONFIG_AGNX is not set +CONFIG_OTUS=m +# CONFIG_COMEDI is not set +# CONFIG_ASUS_OLED is not set +# CONFIG_INPUT_MIMIO is not set +# CONFIG_TRANZPORT is not set + +# +# Android +# +CONFIG_ANDROID=y +CONFIG_ANDROID_BINDER_IPC=y +CONFIG_ANDROID_LOGGER=m +CONFIG_ANDROID_RAM_CONSOLE=y +CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE=y +# CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION is not set +# CONFIG_ANDROID_RAM_CONSOLE_EARLY_INIT is not set +CONFIG_ANDROID_TIMED_GPIO=m +CONFIG_ANDROID_LOW_MEMORY_KILLER=y + +# +# CBUS support +# +# CONFIG_CBUS is not set + +# +# File systems +# +CONFIG_EXT2_FS=y +# CONFIG_EXT2_FS_XATTR is not set +# CONFIG_EXT2_FS_XIP is not set +CONFIG_EXT3_FS=y +# CONFIG_EXT3_FS_XATTR is not set +CONFIG_EXT4_FS=m +# CONFIG_EXT4DEV_COMPAT is not set +CONFIG_EXT4_FS_XATTR=y +# CONFIG_EXT4_FS_POSIX_ACL is not set +# CONFIG_EXT4_FS_SECURITY is not set +CONFIG_JBD=y +# CONFIG_JBD_DEBUG is not set +CONFIG_JBD2=m +# CONFIG_JBD2_DEBUG is not set +CONFIG_FS_MBCACHE=m +CONFIG_REISERFS_FS=m +# CONFIG_REISERFS_CHECK is not set +CONFIG_REISERFS_PROC_INFO=y +CONFIG_REISERFS_FS_XATTR=y +# CONFIG_REISERFS_FS_POSIX_ACL is not set +# CONFIG_REISERFS_FS_SECURITY is not set +CONFIG_JFS_FS=m +# CONFIG_JFS_POSIX_ACL is not set +# CONFIG_JFS_SECURITY is not set +# CONFIG_JFS_DEBUG is not set +# CONFIG_JFS_STATISTICS is not set +CONFIG_FS_POSIX_ACL=y +CONFIG_FILE_LOCKING=y +CONFIG_XFS_FS=m +# CONFIG_XFS_QUOTA is not set +# CONFIG_XFS_POSIX_ACL is not set +# CONFIG_XFS_RT is not set +# CONFIG_XFS_DEBUG is not set +CONFIG_GFS2_FS=m +CONFIG_GFS2_FS_LOCKING_DLM=m +CONFIG_OCFS2_FS=m +CONFIG_OCFS2_FS_O2CB=m +CONFIG_OCFS2_FS_USERSPACE_CLUSTER=m +CONFIG_OCFS2_FS_STATS=y +CONFIG_OCFS2_DEBUG_MASKLOG=y +# CONFIG_OCFS2_DEBUG_FS is not set +# CONFIG_OCFS2_FS_POSIX_ACL is not set +CONFIG_BTRFS_FS=m +# CONFIG_BTRFS_FS_POSIX_ACL is not set +CONFIG_DNOTIFY=y +CONFIG_INOTIFY=y +CONFIG_INOTIFY_USER=y +CONFIG_QUOTA=y +# CONFIG_QUOTA_NETLINK_INTERFACE is not set +CONFIG_PRINT_QUOTA_WARNING=y +CONFIG_QUOTA_TREE=y +# CONFIG_QFMT_V1 is not set +CONFIG_QFMT_V2=y +CONFIG_QUOTACTL=y +# CONFIG_AUTOFS_FS is not set +CONFIG_AUTOFS4_FS=m +CONFIG_FUSE_FS=m + +# +# CD-ROM/DVD Filesystems +# +CONFIG_ISO9660_FS=m +CONFIG_JOLIET=y +CONFIG_ZISOFS=y +CONFIG_UDF_FS=m +CONFIG_UDF_NLS=y + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +CONFIG_FAT_DEFAULT_CODEPAGE=437 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" +CONFIG_NTFS_FS=m +# CONFIG_NTFS_DEBUG is not set +CONFIG_NTFS_RW=y + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +CONFIG_PROC_SYSCTL=y +CONFIG_PROC_PAGE_MONITOR=y +CONFIG_SYSFS=y +CONFIG_TMPFS=y +# CONFIG_TMPFS_POSIX_ACL is not set +# CONFIG_HUGETLB_PAGE is not set +CONFIG_CONFIGFS_FS=m +CONFIG_MISC_FILESYSTEMS=y +CONFIG_ADFS_FS=m +# CONFIG_ADFS_FS_RW is not set +CONFIG_AFFS_FS=m +# CONFIG_ECRYPT_FS is not set +CONFIG_HFS_FS=m +CONFIG_HFSPLUS_FS=m +CONFIG_BEFS_FS=m +# CONFIG_BEFS_DEBUG is not set +CONFIG_BFS_FS=m +CONFIG_EFS_FS=m +CONFIG_JFFS2_FS=y +CONFIG_JFFS2_FS_DEBUG=0 +CONFIG_JFFS2_FS_WRITEBUFFER=y +# CONFIG_JFFS2_FS_WBUF_VERIFY is not set +CONFIG_JFFS2_SUMMARY=y +CONFIG_JFFS2_FS_XATTR=y +CONFIG_JFFS2_FS_POSIX_ACL=y +CONFIG_JFFS2_FS_SECURITY=y +CONFIG_JFFS2_COMPRESSION_OPTIONS=y +CONFIG_JFFS2_ZLIB=y +CONFIG_JFFS2_LZO=y +CONFIG_JFFS2_RTIME=y +CONFIG_JFFS2_RUBIN=y +# CONFIG_JFFS2_CMODE_NONE is not set +# CONFIG_JFFS2_CMODE_PRIORITY is not set +# CONFIG_JFFS2_CMODE_SIZE is not set +CONFIG_JFFS2_CMODE_FAVOURLZO=y +CONFIG_UBIFS_FS=y +CONFIG_UBIFS_FS_XATTR=y +CONFIG_UBIFS_FS_ADVANCED_COMPR=y +CONFIG_UBIFS_FS_LZO=y +CONFIG_UBIFS_FS_ZLIB=y +# CONFIG_UBIFS_FS_DEBUG is not set +CONFIG_CRAMFS=m +CONFIG_SQUASHFS=y +# CONFIG_SQUASHFS_EMBEDDED is not set +CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3 +CONFIG_VXFS_FS=m +CONFIG_MINIX_FS=m +CONFIG_OMFS_FS=m +CONFIG_HPFS_FS=m +CONFIG_QNX4FS_FS=m +CONFIG_ROMFS_FS=m +CONFIG_SYSV_FS=m +CONFIG_UFS_FS=m +# CONFIG_UFS_FS_WRITE is not set +# CONFIG_UFS_DEBUG is not set +CONFIG_NETWORK_FILESYSTEMS=y +CONFIG_NFS_FS=y +CONFIG_NFS_V3=y +# CONFIG_NFS_V3_ACL is not set +CONFIG_NFS_V4=y +CONFIG_ROOT_NFS=y +CONFIG_NFSD=m +CONFIG_NFSD_V2_ACL=y +CONFIG_NFSD_V3=y +CONFIG_NFSD_V3_ACL=y +CONFIG_NFSD_V4=y +CONFIG_LOCKD=y +CONFIG_LOCKD_V4=y +CONFIG_EXPORTFS=m +CONFIG_NFS_ACL_SUPPORT=m +CONFIG_NFS_COMMON=y +CONFIG_SUNRPC=y +CONFIG_SUNRPC_GSS=y +# CONFIG_SUNRPC_REGISTER_V4 is not set +CONFIG_RPCSEC_GSS_KRB5=y +# CONFIG_RPCSEC_GSS_SPKM3 is not set +CONFIG_SMB_FS=m +# CONFIG_SMB_NLS_DEFAULT is not set +CONFIG_CIFS=m +CONFIG_CIFS_STATS=y +CONFIG_CIFS_STATS2=y +# CONFIG_CIFS_WEAK_PW_HASH is not set +# CONFIG_CIFS_UPCALL is not set +# CONFIG_CIFS_XATTR is not set +# CONFIG_CIFS_DEBUG2 is not set +CONFIG_CIFS_EXPERIMENTAL=y +# CONFIG_CIFS_DFS_UPCALL is not set +CONFIG_NCP_FS=m +# CONFIG_NCPFS_PACKET_SIGNING is not set +# CONFIG_NCPFS_IOCTL_LOCKING is not set +# CONFIG_NCPFS_STRONG is not set +# CONFIG_NCPFS_NFS_NS is not set +# CONFIG_NCPFS_OS2_NS is not set +# CONFIG_NCPFS_SMALLDOS is not set +# CONFIG_NCPFS_NLS is not set +# CONFIG_NCPFS_EXTRAS is not set +CONFIG_CODA_FS=m +CONFIG_AFS_FS=m +# CONFIG_AFS_DEBUG is not set +CONFIG_9P_FS=m + +# +# Partition Types +# +CONFIG_PARTITION_ADVANCED=y +# CONFIG_ACORN_PARTITION is not set +# CONFIG_OSF_PARTITION is not set +# CONFIG_AMIGA_PARTITION is not set +# CONFIG_ATARI_PARTITION is not set +CONFIG_MAC_PARTITION=y +CONFIG_MSDOS_PARTITION=y +CONFIG_BSD_DISKLABEL=y +CONFIG_MINIX_SUBPARTITION=y +CONFIG_SOLARIS_X86_PARTITION=y +CONFIG_UNIXWARE_DISKLABEL=y +CONFIG_LDM_PARTITION=y +CONFIG_LDM_DEBUG=y +# CONFIG_SGI_PARTITION is not set +# CONFIG_ULTRIX_PARTITION is not set +# CONFIG_SUN_PARTITION is not set +# CONFIG_KARMA_PARTITION is not set +CONFIG_EFI_PARTITION=y +# CONFIG_SYSV68_PARTITION is not set +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="iso8859-1" +CONFIG_NLS_CODEPAGE_437=y +CONFIG_NLS_CODEPAGE_737=m +CONFIG_NLS_CODEPAGE_775=m +CONFIG_NLS_CODEPAGE_850=m +CONFIG_NLS_CODEPAGE_852=m +CONFIG_NLS_CODEPAGE_855=m +CONFIG_NLS_CODEPAGE_857=m +CONFIG_NLS_CODEPAGE_860=m +CONFIG_NLS_CODEPAGE_861=m +CONFIG_NLS_CODEPAGE_862=m +CONFIG_NLS_CODEPAGE_863=m +CONFIG_NLS_CODEPAGE_864=m +CONFIG_NLS_CODEPAGE_865=m +CONFIG_NLS_CODEPAGE_866=m +CONFIG_NLS_CODEPAGE_869=m +CONFIG_NLS_CODEPAGE_936=m +CONFIG_NLS_CODEPAGE_950=m +CONFIG_NLS_CODEPAGE_932=m +CONFIG_NLS_CODEPAGE_949=m +CONFIG_NLS_CODEPAGE_874=m +CONFIG_NLS_ISO8859_8=m +CONFIG_NLS_CODEPAGE_1250=m +CONFIG_NLS_CODEPAGE_1251=m +CONFIG_NLS_ASCII=m +CONFIG_NLS_ISO8859_1=m +CONFIG_NLS_ISO8859_2=m +CONFIG_NLS_ISO8859_3=m +CONFIG_NLS_ISO8859_4=m +CONFIG_NLS_ISO8859_5=m +CONFIG_NLS_ISO8859_6=m +CONFIG_NLS_ISO8859_7=m +CONFIG_NLS_ISO8859_9=m +CONFIG_NLS_ISO8859_13=m +CONFIG_NLS_ISO8859_14=m +CONFIG_NLS_ISO8859_15=m +CONFIG_NLS_KOI8_R=m +CONFIG_NLS_KOI8_U=m +CONFIG_NLS_UTF8=y +CONFIG_DLM=m +# CONFIG_DLM_DEBUG is not set + +# +# Kernel hacking +# +CONFIG_PRINTK_TIME=y +CONFIG_ENABLE_WARN_DEPRECATED=y +CONFIG_ENABLE_MUST_CHECK=y +CONFIG_FRAME_WARN=1024 +CONFIG_MAGIC_SYSRQ=y +# CONFIG_UNUSED_SYMBOLS is not set +CONFIG_DEBUG_FS=y +# CONFIG_HEADERS_CHECK is not set +CONFIG_DEBUG_KERNEL=y +# CONFIG_DEBUG_SHIRQ is not set +CONFIG_DETECT_SOFTLOCKUP=y +# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0 +CONFIG_SCHED_DEBUG=y +CONFIG_SCHEDSTATS=y +CONFIG_TIMER_STATS=y +# CONFIG_DEBUG_OBJECTS is not set +# CONFIG_DEBUG_SLAB is not set +# CONFIG_DEBUG_RT_MUTEXES is not set +# CONFIG_RT_MUTEX_TESTER is not set +# CONFIG_DEBUG_SPINLOCK is not set +CONFIG_DEBUG_MUTEXES=y +# CONFIG_DEBUG_LOCK_ALLOC is not set +# CONFIG_PROVE_LOCKING is not set +# CONFIG_LOCK_STAT is not set +# CONFIG_DEBUG_SPINLOCK_SLEEP is not set +# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set +CONFIG_STACKTRACE=y +# CONFIG_DEBUG_KOBJECT is not set +# CONFIG_DEBUG_BUGVERBOSE is not set +# CONFIG_DEBUG_INFO is not set +# CONFIG_DEBUG_VM is not set +# CONFIG_DEBUG_WRITECOUNT is not set +# CONFIG_DEBUG_MEMORY_INIT is not set +# CONFIG_DEBUG_LIST is not set +# CONFIG_DEBUG_SG is not set +# CONFIG_DEBUG_NOTIFIERS is not set +CONFIG_FRAME_POINTER=y +# CONFIG_BOOT_PRINTK_DELAY is not set +# CONFIG_RCU_TORTURE_TEST is not set +# CONFIG_RCU_CPU_STALL_DETECTOR is not set +# CONFIG_BACKTRACE_SELF_TEST is not set +# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set +# CONFIG_FAULT_INJECTION is not set +# CONFIG_LATENCYTOP is not set +CONFIG_NOP_TRACER=y +CONFIG_HAVE_FUNCTION_TRACER=y +CONFIG_RING_BUFFER=y +CONFIG_TRACING=y + +# +# Tracers +# +# CONFIG_FUNCTION_TRACER is not set +# CONFIG_IRQSOFF_TRACER is not set +# CONFIG_SCHED_TRACER is not set +# CONFIG_CONTEXT_SWITCH_TRACER is not set +# CONFIG_BOOT_TRACER is not set +# CONFIG_TRACE_BRANCH_PROFILING is not set +# CONFIG_STACK_TRACER is not set +# CONFIG_FTRACE_STARTUP_TEST is not set +# CONFIG_DYNAMIC_PRINTK_DEBUG is not set +# CONFIG_SAMPLES is not set +CONFIG_HAVE_ARCH_KGDB=y +# CONFIG_KGDB is not set +# CONFIG_DEBUG_USER is not set +# CONFIG_DEBUG_ERRORS is not set +# CONFIG_DEBUG_STACK_USAGE is not set +# CONFIG_DEBUG_LL is not set + +# +# Security options +# +CONFIG_KEYS=y +# CONFIG_KEYS_DEBUG_PROC_KEYS is not set +# CONFIG_SECURITY is not set +# CONFIG_SECURITYFS is not set +# CONFIG_SECURITY_FILE_CAPABILITIES is not set +CONFIG_XOR_BLOCKS=m +CONFIG_ASYNC_CORE=m +CONFIG_ASYNC_MEMCPY=m +CONFIG_ASYNC_XOR=m +CONFIG_CRYPTO=y + +# +# Crypto core or helper +# +CONFIG_CRYPTO_FIPS=y +CONFIG_CRYPTO_ALGAPI=y +CONFIG_CRYPTO_ALGAPI2=y +CONFIG_CRYPTO_AEAD=m +CONFIG_CRYPTO_AEAD2=y +CONFIG_CRYPTO_BLKCIPHER=y +CONFIG_CRYPTO_BLKCIPHER2=y +CONFIG_CRYPTO_HASH=y +CONFIG_CRYPTO_HASH2=y +CONFIG_CRYPTO_RNG=m +CONFIG_CRYPTO_RNG2=y +CONFIG_CRYPTO_MANAGER=y +CONFIG_CRYPTO_MANAGER2=y +CONFIG_CRYPTO_GF128MUL=m +CONFIG_CRYPTO_NULL=m +CONFIG_CRYPTO_CRYPTD=m +CONFIG_CRYPTO_AUTHENC=m +CONFIG_CRYPTO_TEST=m + +# +# Authenticated Encryption with Associated Data +# +CONFIG_CRYPTO_CCM=m +CONFIG_CRYPTO_GCM=m +CONFIG_CRYPTO_SEQIV=m + +# +# Block modes +# +CONFIG_CRYPTO_CBC=y +CONFIG_CRYPTO_CTR=m +CONFIG_CRYPTO_CTS=m +CONFIG_CRYPTO_ECB=y +CONFIG_CRYPTO_LRW=m +CONFIG_CRYPTO_PCBC=m +CONFIG_CRYPTO_XTS=m + +# +# Hash modes +# +CONFIG_CRYPTO_HMAC=m +CONFIG_CRYPTO_XCBC=m + +# +# Digest +# +CONFIG_CRYPTO_CRC32C=y +CONFIG_CRYPTO_MD4=m +CONFIG_CRYPTO_MD5=y +CONFIG_CRYPTO_MICHAEL_MIC=y +CONFIG_CRYPTO_RMD128=m +CONFIG_CRYPTO_RMD160=m +CONFIG_CRYPTO_RMD256=m +CONFIG_CRYPTO_RMD320=m +CONFIG_CRYPTO_SHA1=m +CONFIG_CRYPTO_SHA256=m +CONFIG_CRYPTO_SHA512=m +CONFIG_CRYPTO_TGR192=m +CONFIG_CRYPTO_WP512=m + +# +# Ciphers +# +CONFIG_CRYPTO_AES=y +CONFIG_CRYPTO_ANUBIS=m +CONFIG_CRYPTO_ARC4=y +CONFIG_CRYPTO_BLOWFISH=m +CONFIG_CRYPTO_CAMELLIA=m +CONFIG_CRYPTO_CAST5=m +CONFIG_CRYPTO_CAST6=m +CONFIG_CRYPTO_DES=y +CONFIG_CRYPTO_FCRYPT=m +CONFIG_CRYPTO_KHAZAD=m +CONFIG_CRYPTO_SALSA20=m +CONFIG_CRYPTO_SEED=m +CONFIG_CRYPTO_SERPENT=m +CONFIG_CRYPTO_TEA=m +CONFIG_CRYPTO_TWOFISH=m +CONFIG_CRYPTO_TWOFISH_COMMON=m + +# +# Compression +# +CONFIG_CRYPTO_DEFLATE=y +CONFIG_CRYPTO_LZO=y + +# +# Random Number Generation +# +CONFIG_CRYPTO_ANSI_CPRNG=m +CONFIG_CRYPTO_HW=y + +# +# Library routines +# +CONFIG_BITREVERSE=y +CONFIG_GENERIC_FIND_LAST_BIT=y +CONFIG_CRC_CCITT=y +CONFIG_CRC16=y +CONFIG_CRC_T10DIF=y +CONFIG_CRC_ITU_T=y +CONFIG_CRC32=y +CONFIG_CRC7=y +CONFIG_LIBCRC32C=y +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y +CONFIG_LZO_COMPRESS=y +CONFIG_LZO_DECOMPRESS=y +CONFIG_TEXTSEARCH=y +CONFIG_TEXTSEARCH_KMP=m +CONFIG_TEXTSEARCH_BM=m +CONFIG_TEXTSEARCH_FSM=m +CONFIG_PLIST=y +CONFIG_HAS_IOMEM=y +CONFIG_HAS_IOPORT=y +CONFIG_HAS_DMA=y diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dspbridge.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dspbridge.patch new file mode 100644 index 0000000000..621ae93d3b --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dspbridge.patch @@ -0,0 +1,66715 @@ +From ea83ad971e877ef8e9b1304f2678469c2fc74c67 Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Sun, 26 Apr 2009 18:58:30 -0700 +Subject: [PATCH] Merge in tidspbridge from git://gitorious.org/tidspbridge/mainline.git + revisions fe30e75..20f5ca. + +Made a few changes so this compiles clean against a 2.6.29 non-PM +tree. + +Signed-off-by: Tim Yamin <plasm@roo.me.uk> +--- + Documentation/tidspbridge/README | 70 + + arch/arm/Kconfig | 2 + + arch/arm/mach-omap2/Makefile | 2 + + arch/arm/mach-omap2/dspbridge.c | 74 + + arch/arm/mach-omap2/io.c | 3 + + arch/arm/plat-omap/devices.c | 28 + + arch/arm/plat-omap/include/dspbridge/_chnl_sm.h | 212 ++ + arch/arm/plat-omap/include/dspbridge/_dcd.h | 187 + + arch/arm/plat-omap/include/dspbridge/brddefs.h | 54 + + arch/arm/plat-omap/include/dspbridge/cfg.h | 339 ++ + arch/arm/plat-omap/include/dspbridge/cfgdefs.h | 126 + + arch/arm/plat-omap/include/dspbridge/chnl.h | 170 + + arch/arm/plat-omap/include/dspbridge/chnl_sm.h | 168 + + arch/arm/plat-omap/include/dspbridge/chnldefs.h | 92 + + arch/arm/plat-omap/include/dspbridge/chnlpriv.h | 136 + + arch/arm/plat-omap/include/dspbridge/clk.h | 155 + + arch/arm/plat-omap/include/dspbridge/cmm.h | 420 +++ + arch/arm/plat-omap/include/dspbridge/cmmdefs.h | 135 + + arch/arm/plat-omap/include/dspbridge/cod.h | 433 +++ + arch/arm/plat-omap/include/dspbridge/csl.h | 135 + + arch/arm/plat-omap/include/dspbridge/dbc.h | 66 + + arch/arm/plat-omap/include/dspbridge/dbdcd.h | 388 +++ + arch/arm/plat-omap/include/dspbridge/dbdcddef.h | 94 + + arch/arm/plat-omap/include/dspbridge/dbdefs.h | 580 ++++ + arch/arm/plat-omap/include/dspbridge/dbg.h | 110 + + arch/arm/plat-omap/include/dspbridge/dbl.h | 354 ++ + arch/arm/plat-omap/include/dspbridge/dbldefs.h | 155 + + arch/arm/plat-omap/include/dspbridge/dbll.h | 70 + + arch/arm/plat-omap/include/dspbridge/dblldefs.h | 509 +++ + arch/arm/plat-omap/include/dspbridge/dbof.h | 117 + + arch/arm/plat-omap/include/dspbridge/dbreg.h | 113 + + arch/arm/plat-omap/include/dspbridge/dbtype.h | 103 + + arch/arm/plat-omap/include/dspbridge/dehdefs.h | 42 + + arch/arm/plat-omap/include/dspbridge/dev.h | 785 +++++ + arch/arm/plat-omap/include/dspbridge/devdefs.h | 35 + + arch/arm/plat-omap/include/dspbridge/disp.h | 236 ++ + arch/arm/plat-omap/include/dspbridge/dispdefs.h | 45 + + arch/arm/plat-omap/include/dspbridge/dmm.h | 85 + + arch/arm/plat-omap/include/dspbridge/dpc.h | 167 + + arch/arm/plat-omap/include/dspbridge/drv.h | 449 +++ + arch/arm/plat-omap/include/dspbridge/drvdefs.h | 34 + + arch/arm/plat-omap/include/dspbridge/dspdrv.h | 106 + + .../plat-omap/include/dspbridge/dynamic_loader.h | 505 +++ + arch/arm/plat-omap/include/dspbridge/errbase.h | 509 +++ + arch/arm/plat-omap/include/dspbridge/gb.h | 85 + + arch/arm/plat-omap/include/dspbridge/getsection.h | 118 + + arch/arm/plat-omap/include/dspbridge/gh.h | 37 + + arch/arm/plat-omap/include/dspbridge/gs.h | 64 + + arch/arm/plat-omap/include/dspbridge/gt.h | 315 ++ + arch/arm/plat-omap/include/dspbridge/host_os.h | 96 + + arch/arm/plat-omap/include/dspbridge/io.h | 132 + + arch/arm/plat-omap/include/dspbridge/io_sm.h | 335 ++ + arch/arm/plat-omap/include/dspbridge/iodefs.h | 45 + + arch/arm/plat-omap/include/dspbridge/kfile.h | 216 ++ + arch/arm/plat-omap/include/dspbridge/ldr.h | 51 + + arch/arm/plat-omap/include/dspbridge/list.h | 296 ++ + arch/arm/plat-omap/include/dspbridge/mbx_sh.h | 213 ++ + arch/arm/plat-omap/include/dspbridge/mem.h | 340 ++ + arch/arm/plat-omap/include/dspbridge/memdefs.h | 52 + + arch/arm/plat-omap/include/dspbridge/mgr.h | 234 ++ + arch/arm/plat-omap/include/dspbridge/mgrpriv.h | 55 + + arch/arm/plat-omap/include/dspbridge/msg.h | 106 + + arch/arm/plat-omap/include/dspbridge/msgdefs.h | 43 + + arch/arm/plat-omap/include/dspbridge/nldr.h | 81 + + arch/arm/plat-omap/include/dspbridge/nldrdefs.h | 307 ++ + arch/arm/plat-omap/include/dspbridge/node.h | 619 ++++ + arch/arm/plat-omap/include/dspbridge/nodedefs.h | 40 + + arch/arm/plat-omap/include/dspbridge/nodepriv.h | 202 ++ + arch/arm/plat-omap/include/dspbridge/ntfy.h | 146 + + arch/arm/plat-omap/include/dspbridge/proc.h | 648 ++++ + arch/arm/plat-omap/include/dspbridge/procpriv.h | 35 + + arch/arm/plat-omap/include/dspbridge/pwr.h | 129 + + arch/arm/plat-omap/include/dspbridge/pwr_sh.h | 41 + + arch/arm/plat-omap/include/dspbridge/reg.h | 257 ++ + .../plat-omap/include/dspbridge/resourcecleanup.h | 88 + + arch/arm/plat-omap/include/dspbridge/rmm.h | 199 ++ + arch/arm/plat-omap/include/dspbridge/rms_sh.h | 125 + + arch/arm/plat-omap/include/dspbridge/rmstypes.h | 40 + + arch/arm/plat-omap/include/dspbridge/services.h | 63 + + arch/arm/plat-omap/include/dspbridge/std.h | 143 + + arch/arm/plat-omap/include/dspbridge/strm.h | 441 +++ + arch/arm/plat-omap/include/dspbridge/strmdefs.h | 57 + + arch/arm/plat-omap/include/dspbridge/sync.h | 340 ++ + arch/arm/plat-omap/include/dspbridge/util.h | 122 + + arch/arm/plat-omap/include/dspbridge/utildefs.h | 51 + + arch/arm/plat-omap/include/dspbridge/uuidutil.h | 74 + + arch/arm/plat-omap/include/dspbridge/wcd.h | 61 + + arch/arm/plat-omap/include/dspbridge/wcdioctl.h | 519 +++ + arch/arm/plat-omap/include/dspbridge/wmd.h | 1193 +++++++ + arch/arm/plat-omap/include/dspbridge/wmdchnl.h | 90 + + arch/arm/plat-omap/include/dspbridge/wmddeh.h | 64 + + arch/arm/plat-omap/include/dspbridge/wmdio.h | 53 + + arch/arm/plat-omap/include/dspbridge/wmdioctl.h | 91 + + arch/arm/plat-omap/include/dspbridge/wmdmsg.h | 70 + + drivers/Makefile | 1 + + drivers/dsp/bridge/Kbuild | 39 + + drivers/dsp/bridge/Kconfig | 36 + + drivers/dsp/bridge/dynload/cload.c | 1854 ++++++++++ + drivers/dsp/bridge/dynload/dlclasses_hdr.h | 41 + + drivers/dsp/bridge/dynload/dload_internal.h | 237 ++ + drivers/dsp/bridge/dynload/doff.h | 347 ++ + drivers/dsp/bridge/dynload/getsection.c | 412 +++ + drivers/dsp/bridge/dynload/header.h | 59 + + drivers/dsp/bridge/dynload/module_list.h | 161 + + drivers/dsp/bridge/dynload/params.h | 231 ++ + drivers/dsp/bridge/dynload/reloc.c | 425 +++ + drivers/dsp/bridge/dynload/reloc_table.h | 102 + + drivers/dsp/bridge/dynload/reloc_table_c6000.c | 258 ++ + drivers/dsp/bridge/gen/_gt_para.c | 107 + + drivers/dsp/bridge/gen/gb.c | 182 + + drivers/dsp/bridge/gen/gh.c | 191 ++ + drivers/dsp/bridge/gen/gs.c | 108 + + drivers/dsp/bridge/gen/gt.c | 348 ++ + drivers/dsp/bridge/gen/uuidutil.c | 238 ++ + drivers/dsp/bridge/hw/EasiGlobal.h | 42 + + drivers/dsp/bridge/hw/GlobalTypes.h | 325 ++ + drivers/dsp/bridge/hw/IPIAccInt.h | 41 + + drivers/dsp/bridge/hw/IVA2RegAcM.h | 28 + + drivers/dsp/bridge/hw/MLBAccInt.h | 132 + + drivers/dsp/bridge/hw/MLBRegAcM.h | 200 ++ + drivers/dsp/bridge/hw/MMUAccInt.h | 76 + + drivers/dsp/bridge/hw/MMURegAcM.h | 253 ++ + drivers/dsp/bridge/hw/PRCMAccInt.h | 300 ++ + drivers/dsp/bridge/hw/PRCMRegAcM.h | 669 ++++ + drivers/dsp/bridge/hw/hw_defs.h | 73 + + drivers/dsp/bridge/hw/hw_dspssC64P.c | 55 + + drivers/dsp/bridge/hw/hw_dspssC64P.h | 48 + + drivers/dsp/bridge/hw/hw_mbox.c | 244 ++ + drivers/dsp/bridge/hw/hw_mbox.h | 323 ++ + drivers/dsp/bridge/hw/hw_mmu.c | 598 ++++ + drivers/dsp/bridge/hw/hw_mmu.h | 177 + + drivers/dsp/bridge/hw/hw_prcm.c | 167 + + drivers/dsp/bridge/hw/hw_prcm.h | 168 + + drivers/dsp/bridge/pmgr/chnl.c | 260 ++ + drivers/dsp/bridge/pmgr/chnlobj.h | 71 + + drivers/dsp/bridge/pmgr/cmm.c | 1291 +++++++ + drivers/dsp/bridge/pmgr/cod.c | 683 ++++ + drivers/dsp/bridge/pmgr/dbl.c | 1385 ++++++++ + drivers/dsp/bridge/pmgr/dbll.c | 1564 +++++++++ + drivers/dsp/bridge/pmgr/dev.c | 1476 ++++++++ + drivers/dsp/bridge/pmgr/dmm.c | 692 ++++ + drivers/dsp/bridge/pmgr/io.c | 205 ++ + drivers/dsp/bridge/pmgr/ioobj.h | 52 + + drivers/dsp/bridge/pmgr/msg.c | 173 + + drivers/dsp/bridge/pmgr/msgobj.h | 52 + + drivers/dsp/bridge/pmgr/wcd.c | 1647 +++++++++ + drivers/dsp/bridge/rmgr/dbdcd.c | 1573 +++++++++ + drivers/dsp/bridge/rmgr/disp.c | 916 +++++ + drivers/dsp/bridge/rmgr/drv.c | 1893 +++++++++++ + drivers/dsp/bridge/rmgr/drv_interface.c | 777 +++++ + drivers/dsp/bridge/rmgr/drv_interface.h | 40 + + drivers/dsp/bridge/rmgr/dspdrv.c | 276 ++ + drivers/dsp/bridge/rmgr/mgr.c | 491 +++ + drivers/dsp/bridge/rmgr/nldr.c | 1967 +++++++++++ + drivers/dsp/bridge/rmgr/node.c | 3544 ++++++++++++++++++++ + drivers/dsp/bridge/rmgr/proc.c | 1985 +++++++++++ + drivers/dsp/bridge/rmgr/pwr.c | 184 + + drivers/dsp/bridge/rmgr/rmm.c | 604 ++++ + drivers/dsp/bridge/rmgr/strm.c | 1066 ++++++ + drivers/dsp/bridge/services/cfg.c | 483 +++ + drivers/dsp/bridge/services/clk.c | 375 +++ + drivers/dsp/bridge/services/csl.c | 173 + + drivers/dsp/bridge/services/dbg.c | 119 + + drivers/dsp/bridge/services/dpc.c | 274 ++ + drivers/dsp/bridge/services/kfile.c | 338 ++ + drivers/dsp/bridge/services/list.c | 285 ++ + drivers/dsp/bridge/services/mem.c | 599 ++++ + drivers/dsp/bridge/services/ntfy.c | 329 ++ + drivers/dsp/bridge/services/reg.c | 196 ++ + drivers/dsp/bridge/services/regsup.c | 368 ++ + drivers/dsp/bridge/services/regsup.h | 58 + + drivers/dsp/bridge/services/services.c | 193 ++ + drivers/dsp/bridge/services/sync.c | 602 ++++ + drivers/dsp/bridge/wmd/_cmm.h | 59 + + drivers/dsp/bridge/wmd/_deh.h | 46 + + drivers/dsp/bridge/wmd/_msg_sm.h | 158 + + drivers/dsp/bridge/wmd/_tiomap.h | 384 +++ + drivers/dsp/bridge/wmd/_tiomap_mmu.h | 53 + + drivers/dsp/bridge/wmd/_tiomap_pwr.h | 102 + + drivers/dsp/bridge/wmd/_tiomap_util.h | 46 + + drivers/dsp/bridge/wmd/chnl_sm.c | 1100 ++++++ + drivers/dsp/bridge/wmd/io_sm.c | 2011 +++++++++++ + drivers/dsp/bridge/wmd/mmu_fault.c | 172 + + drivers/dsp/bridge/wmd/mmu_fault.h | 45 + + drivers/dsp/bridge/wmd/msg_sm.c | 643 ++++ + drivers/dsp/bridge/wmd/tiomap3430.c | 2149 ++++++++++++ + drivers/dsp/bridge/wmd/tiomap3430_pwr.c | 731 ++++ + drivers/dsp/bridge/wmd/tiomap_io.c | 427 +++ + drivers/dsp/bridge/wmd/tiomap_io.h | 112 + + drivers/dsp/bridge/wmd/tiomap_sm.c | 195 ++ + drivers/dsp/bridge/wmd/ue_deh.c | 329 ++ + 191 files changed, 65137 insertions(+), 0 deletions(-) + create mode 100644 Documentation/tidspbridge/README + create mode 100644 arch/arm/mach-omap2/dspbridge.c + create mode 100644 arch/arm/plat-omap/include/dspbridge/_chnl_sm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/_dcd.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/brddefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/cfg.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/cfgdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/chnl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/chnl_sm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/chnldefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/chnlpriv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/clk.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/cmm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/cmmdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/cod.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/csl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbc.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbdcd.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbdcddef.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbg.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbldefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbll.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dblldefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbof.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbreg.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dbtype.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dehdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dev.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/devdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/disp.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dispdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dmm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dpc.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/drv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/drvdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dspdrv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/dynamic_loader.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/errbase.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/gb.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/getsection.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/gh.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/gs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/gt.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/host_os.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/io.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/io_sm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/iodefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/kfile.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/ldr.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/list.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/mbx_sh.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/mem.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/memdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/mgr.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/mgrpriv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/msg.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/msgdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/nldr.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/nldrdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/node.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/nodedefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/nodepriv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/ntfy.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/proc.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/procpriv.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/pwr.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/pwr_sh.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/reg.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/resourcecleanup.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/rmm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/rms_sh.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/rmstypes.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/services.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/std.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/strm.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/strmdefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/sync.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/util.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/utildefs.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/uuidutil.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wcd.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wcdioctl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmd.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmdchnl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmddeh.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmdio.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmdioctl.h + create mode 100644 arch/arm/plat-omap/include/dspbridge/wmdmsg.h + create mode 100644 drivers/dsp/bridge/Kbuild + create mode 100644 drivers/dsp/bridge/Kconfig + create mode 100644 drivers/dsp/bridge/dynload/cload.c + create mode 100644 drivers/dsp/bridge/dynload/dlclasses_hdr.h + create mode 100644 drivers/dsp/bridge/dynload/dload_internal.h + create mode 100644 drivers/dsp/bridge/dynload/doff.h + create mode 100644 drivers/dsp/bridge/dynload/getsection.c + create mode 100644 drivers/dsp/bridge/dynload/header.h + create mode 100644 drivers/dsp/bridge/dynload/module_list.h + create mode 100644 drivers/dsp/bridge/dynload/params.h + create mode 100644 drivers/dsp/bridge/dynload/reloc.c + create mode 100644 drivers/dsp/bridge/dynload/reloc_table.h + create mode 100644 drivers/dsp/bridge/dynload/reloc_table_c6000.c + create mode 100644 drivers/dsp/bridge/gen/_gt_para.c + create mode 100644 drivers/dsp/bridge/gen/gb.c + create mode 100644 drivers/dsp/bridge/gen/gh.c + create mode 100644 drivers/dsp/bridge/gen/gs.c + create mode 100644 drivers/dsp/bridge/gen/gt.c + create mode 100644 drivers/dsp/bridge/gen/uuidutil.c + create mode 100644 drivers/dsp/bridge/hw/EasiGlobal.h + create mode 100644 drivers/dsp/bridge/hw/GlobalTypes.h + create mode 100644 drivers/dsp/bridge/hw/IPIAccInt.h + create mode 100644 drivers/dsp/bridge/hw/IVA2RegAcM.h + create mode 100644 drivers/dsp/bridge/hw/MLBAccInt.h + create mode 100644 drivers/dsp/bridge/hw/MLBRegAcM.h + create mode 100644 drivers/dsp/bridge/hw/MMUAccInt.h + create mode 100644 drivers/dsp/bridge/hw/MMURegAcM.h + create mode 100644 drivers/dsp/bridge/hw/PRCMAccInt.h + create mode 100644 drivers/dsp/bridge/hw/PRCMRegAcM.h + create mode 100644 drivers/dsp/bridge/hw/hw_defs.h + create mode 100644 drivers/dsp/bridge/hw/hw_dspssC64P.c + create mode 100644 drivers/dsp/bridge/hw/hw_dspssC64P.h + create mode 100644 drivers/dsp/bridge/hw/hw_mbox.c + create mode 100644 drivers/dsp/bridge/hw/hw_mbox.h + create mode 100644 drivers/dsp/bridge/hw/hw_mmu.c + create mode 100644 drivers/dsp/bridge/hw/hw_mmu.h + create mode 100644 drivers/dsp/bridge/hw/hw_prcm.c + create mode 100644 drivers/dsp/bridge/hw/hw_prcm.h + create mode 100644 drivers/dsp/bridge/pmgr/chnl.c + create mode 100644 drivers/dsp/bridge/pmgr/chnlobj.h + create mode 100644 drivers/dsp/bridge/pmgr/cmm.c + create mode 100644 drivers/dsp/bridge/pmgr/cod.c + create mode 100644 drivers/dsp/bridge/pmgr/dbl.c + create mode 100644 drivers/dsp/bridge/pmgr/dbll.c + create mode 100644 drivers/dsp/bridge/pmgr/dev.c + create mode 100644 drivers/dsp/bridge/pmgr/dmm.c + create mode 100644 drivers/dsp/bridge/pmgr/io.c + create mode 100644 drivers/dsp/bridge/pmgr/ioobj.h + create mode 100644 drivers/dsp/bridge/pmgr/msg.c + create mode 100644 drivers/dsp/bridge/pmgr/msgobj.h + create mode 100644 drivers/dsp/bridge/pmgr/wcd.c + create mode 100644 drivers/dsp/bridge/rmgr/dbdcd.c + create mode 100644 drivers/dsp/bridge/rmgr/disp.c + create mode 100644 drivers/dsp/bridge/rmgr/drv.c + create mode 100644 drivers/dsp/bridge/rmgr/drv_interface.c + create mode 100644 drivers/dsp/bridge/rmgr/drv_interface.h + create mode 100644 drivers/dsp/bridge/rmgr/dspdrv.c + create mode 100644 drivers/dsp/bridge/rmgr/mgr.c + create mode 100644 drivers/dsp/bridge/rmgr/nldr.c + create mode 100644 drivers/dsp/bridge/rmgr/node.c + create mode 100644 drivers/dsp/bridge/rmgr/proc.c + create mode 100644 drivers/dsp/bridge/rmgr/pwr.c + create mode 100644 drivers/dsp/bridge/rmgr/rmm.c + create mode 100644 drivers/dsp/bridge/rmgr/strm.c + create mode 100644 drivers/dsp/bridge/services/cfg.c + create mode 100644 drivers/dsp/bridge/services/clk.c + create mode 100644 drivers/dsp/bridge/services/csl.c + create mode 100644 drivers/dsp/bridge/services/dbg.c + create mode 100644 drivers/dsp/bridge/services/dpc.c + create mode 100644 drivers/dsp/bridge/services/kfile.c + create mode 100644 drivers/dsp/bridge/services/list.c + create mode 100644 drivers/dsp/bridge/services/mem.c + create mode 100644 drivers/dsp/bridge/services/ntfy.c + create mode 100644 drivers/dsp/bridge/services/reg.c + create mode 100644 drivers/dsp/bridge/services/regsup.c + create mode 100644 drivers/dsp/bridge/services/regsup.h + create mode 100644 drivers/dsp/bridge/services/services.c + create mode 100644 drivers/dsp/bridge/services/sync.c + create mode 100644 drivers/dsp/bridge/wmd/_cmm.h + create mode 100644 drivers/dsp/bridge/wmd/_deh.h + create mode 100644 drivers/dsp/bridge/wmd/_msg_sm.h + create mode 100644 drivers/dsp/bridge/wmd/_tiomap.h + create mode 100644 drivers/dsp/bridge/wmd/_tiomap_mmu.h + create mode 100644 drivers/dsp/bridge/wmd/_tiomap_pwr.h + create mode 100644 drivers/dsp/bridge/wmd/_tiomap_util.h + create mode 100644 drivers/dsp/bridge/wmd/chnl_sm.c + create mode 100644 drivers/dsp/bridge/wmd/io_sm.c + create mode 100644 drivers/dsp/bridge/wmd/mmu_fault.c + create mode 100644 drivers/dsp/bridge/wmd/mmu_fault.h + create mode 100644 drivers/dsp/bridge/wmd/msg_sm.c + create mode 100644 drivers/dsp/bridge/wmd/tiomap3430.c + create mode 100644 drivers/dsp/bridge/wmd/tiomap3430_pwr.c + create mode 100644 drivers/dsp/bridge/wmd/tiomap_io.c + create mode 100644 drivers/dsp/bridge/wmd/tiomap_io.h + create mode 100644 drivers/dsp/bridge/wmd/tiomap_sm.c + create mode 100644 drivers/dsp/bridge/wmd/ue_deh.c + +diff --git a/Documentation/tidspbridge/README b/Documentation/tidspbridge/README +new file mode 100644 +index 0000000..df6d371 +--- /dev/null ++++ b/Documentation/tidspbridge/README +@@ -0,0 +1,70 @@ ++ Linux DSP/BIOS Bridge release ++ ++DSP/BIOS Bridge overview ++======================== ++ ++DSP/BIOS Bridge is designed for platforms that contain a GPP and one or more ++attached DSPs. The GPP is considered the master or "host" processor, and the ++attached DSPs are processing resources that can be utilized by applications ++and drivers running on the GPP. ++ ++The abstraction that DSP/BIOS Bridge supplies, is a direct link between a GPP ++program and a DSP task. This communication link is partitioned into two ++types of sub-links: messaging (short, fixed-length packets) and data ++streaming (multiple, large buffers). Each sub-link operates independently, ++and features in-order delivery of data, meaning that messages are delivered ++in the order they were submitted to the message link, and stream buffers are ++delivered in the order they were submitted to the stream link. ++ ++In addition, a GPP client can specify what inputs and outputs a DSP task ++uses. DSP tasks typically use message objects for passing control and status ++information and stream objects for efficient streaming of real-time data. ++ ++GPP Software Architecture ++========================= ++ ++A GPP application communicates with its associated DSP task running on the ++DSP subsystem using the DSP/BIOS Bridge API. For example, a GPP audio ++application can use the API to pass messages to a DSP task that is managing ++data flowing from analog-to-digital converters (ADCs) to digital-to-analog ++converters (DACs). ++ ++From the perspective of the GPP OS, the DSP is treated as just another ++peripheral device. Most high level GPP OS typically support a device driver ++model, whereby applications can safely access and share a hardware peripheral ++through standard driver interfaces. Therefore, to allow multiple GPP ++applications to share access to the DSP, the GPP side of DSP/BIOS Bridge ++implements a device driver for the DSP. ++ ++Since driver interfaces are not always standard across GPP OS, and to provide ++some level of interoperability of application code using DSP/BIOS Bridge ++between GPP OS, DSP/BIOS Bridge provides a standard library of APIs which ++wrap calls into the device driver. So, rather than calling GPP OS specific ++driver interfaces, applications (and even other device drivers) can use the ++standard API library directly. ++ ++DSP Software Architecture ++========================= ++ ++For DSP/BIOS, DSP/BIOS Bridge adds a device-independent streaming I/O (STRM) ++interface, a messaging interface (NODE), and a Resource Manager (RM) Server. ++The RM Server runs as a task of DSP/BIOS and is subservient to commands ++and queries from the GPP. It executes commands to start and stop DSP signal ++processing nodes in response to GPP programs making requests through the ++(GPP-side) API. ++ ++DSP tasks started by the RM Server are similar to any other DSP task with two ++important differences: they must follow a specific task model consisting of ++three C-callable functions (node create, execute, and delete), with specific ++sets of arguments, and they have a pre-defined task environment established ++by the RM Server. ++ ++Tasks started by the RM Server communicate using the STRM and NODE interfaces ++and act as servers for their corresponding GPP clients, performing signal ++processing functions as requested by messages sent by their GPP client. ++Typically, a DSP task moves data from source devices to sink devices using ++device independent I/O streams, performing application-specific processing ++and transformations on the data while it is moved. For example, an audio ++task might perform audio decompression (ADPCM, MPEG, CELP) on data received ++from a GPP audio driver and then send the decompressed linear samples to a ++digital-to-analog converter. +diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig +index e7fb201..2060772 100644 +--- a/arch/arm/Kconfig ++++ b/arch/arm/Kconfig +@@ -1331,6 +1331,8 @@ if ARCH_OMAP + source "drivers/cbus/Kconfig" + endif + ++source "drivers/dsp/bridge/Kconfig" ++ + endmenu + + source "fs/Kconfig" +diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile +index 9b270d8..e52e01e 100644 +--- a/arch/arm/mach-omap2/Makefile ++++ b/arch/arm/mach-omap2/Makefile +@@ -34,6 +34,8 @@ obj-$(CONFIG_OMAP_SMARTREFLEX) += smartreflex.o + obj-$(CONFIG_ARCH_OMAP2) += clock24xx.o + obj-$(CONFIG_ARCH_OMAP3) += clock34xx.o + ++obj-$(CONFIG_MPU_BRIDGE) += dspbridge.o ++ + # DSP + obj-$(CONFIG_OMAP_MBOX_FWK) += mailbox_mach.o + mailbox_mach-objs := mailbox.o +diff --git a/arch/arm/mach-omap2/dspbridge.c b/arch/arm/mach-omap2/dspbridge.c +new file mode 100644 +index 0000000..221e8ff +--- /dev/null ++++ b/arch/arm/mach-omap2/dspbridge.c +@@ -0,0 +1,74 @@ ++/* ++ * TI's dspbridge platform device registration ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * Copyright (C) 2009 Nokia Corporation ++ * ++ * Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++ ++#include <linux/platform_device.h> ++#include <dspbridge/host_os.h> ++ ++static struct platform_device *dspbridge_pdev; ++ ++#ifdef CONFIG_BRIDGE_DVFS ++#include <mach/omap-pm.h> ++static struct dspbridge_platform_data dspbridge_pdata __initdata = { ++ .dsp_set_min_opp = omap_pm_dsp_set_min_opp, ++ .dsp_get_opp = omap_pm_dsp_get_opp, ++ .cpu_set_freq = omap_pm_cpu_set_freq, ++ .cpu_get_freq = omap_pm_cpu_get_freq, ++}; ++#else ++static struct dspbridge_platform_data dspbridge_pdata; ++#endif ++ ++static int __init dspbridge_init(void) ++{ ++ struct platform_device *pdev; ++ int err = -ENOMEM; ++ struct dspbridge_platform_data *pdata = &dspbridge_pdata; ++ ++ pdata->phys_mempool_base = dspbridge_get_mempool_base(); ++ ++ if (pdata->phys_mempool_base) { ++ pdata->phys_mempool_size = CONFIG_BRIDGE_MEMPOOL_SIZE; ++ pr_info("%s: %x bytes @ %x\n", __func__, ++ pdata->phys_mempool_size, pdata->phys_mempool_base); ++ } ++ ++ pdev = platform_device_alloc("C6410", -1); ++ if (!pdev) ++ goto err_out; ++ ++ err = platform_device_add_data(pdev, pdata, sizeof(*pdata)); ++ if (err) ++ goto err_out; ++ ++ err = platform_device_add(pdev); ++ if (err) ++ goto err_out; ++ ++ dspbridge_pdev = pdev; ++ return 0; ++ ++err_out: ++ platform_device_put(pdev); ++ return err; ++} ++module_init(dspbridge_init); ++ ++static void __exit dspbridge_exit(void) ++{ ++ platform_device_unregister(dspbridge_pdev); ++} ++module_exit(dspbridge_exit); ++ ++MODULE_AUTHOR("Hiroshi DOYU"); ++MODULE_DESCRIPTION("TI's dspbridge platform device registration"); ++MODULE_LICENSE("GPL v2"); +diff --git a/arch/arm/mach-omap2/io.c b/arch/arm/mach-omap2/io.c +index a04e3ee..40488ae 100644 +--- a/arch/arm/mach-omap2/io.c ++++ b/arch/arm/mach-omap2/io.c +@@ -38,6 +38,8 @@ + #include <mach/clockdomain.h> + #include "clockdomains.h" + ++#include <dspbridge/host_os.h> ++ + /* + * The machine specific code may provide the extra mapping besides the + * default mapping provided here. +@@ -192,6 +194,7 @@ void __init omap2_map_common_io(void) + omap2_check_revision(); + omap_sram_init(); + omapfb_reserve_sdram(); ++ dspbridge_reserve_sdram(); + } + + void __init omap2_init_common_hw(struct omap_sdrc_params *sp) +diff --git a/arch/arm/plat-omap/devices.c b/arch/arm/plat-omap/devices.c +index 6b742a8..e66dd8a 100644 +--- a/arch/arm/plat-omap/devices.c ++++ b/arch/arm/plat-omap/devices.c +@@ -15,6 +15,7 @@ + #include <linux/platform_device.h> + #include <linux/io.h> + #include <linux/i2c/menelaus.h> ++#include <linux/bootmem.h> + + #include <mach/hardware.h> + #include <asm/mach-types.h> +@@ -89,6 +90,33 @@ EXPORT_SYMBOL(dsp_kfunc_device_register); + static inline void omap_init_dsp(void) { } + #endif /* CONFIG_OMAP_DSP */ + ++#if defined(CONFIG_MPU_BRIDGE) || defined(CONFIG_MPU_BRIDGE_MODULE) ++ ++static unsigned long dspbridge_phys_mempool_base; ++ ++void dspbridge_reserve_sdram(void) ++{ ++ void *va; ++ unsigned long size = CONFIG_BRIDGE_MEMPOOL_SIZE; ++ ++ if (!size) ++ return; ++ ++ va = __alloc_bootmem_nopanic(size, SZ_1M, 0); ++ if (!va) { ++ pr_err("%s: Failed to bootmem allocation(%lu bytes)\n", ++ __func__, size); ++ return; ++ } ++ dspbridge_phys_mempool_base = virt_to_phys(va); ++} ++ ++unsigned long dspbridge_get_mempool_base(void) ++{ ++ return dspbridge_phys_mempool_base; ++} ++EXPORT_SYMBOL(dspbridge_get_mempool_base); ++#endif + /*-------------------------------------------------------------------------*/ + #if defined(CONFIG_KEYBOARD_OMAP) || defined(CONFIG_KEYBOARD_OMAP_MODULE) + +diff --git a/arch/arm/plat-omap/include/dspbridge/_chnl_sm.h b/arch/arm/plat-omap/include/dspbridge/_chnl_sm.h +new file mode 100644 +index 0000000..28af799 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/_chnl_sm.h +@@ -0,0 +1,212 @@ ++/* ++ * _chnl_sm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _chnl_sm.h ======== ++ * Description: ++ * Private header file defining channel manager and channel objects for ++ * a shared memory channel driver. ++ * ++ * Public Functions: ++ * None. ++ * ++ * Notes: ++ * Shared between the modules implementing the shared memory channel class ++ * library. ++ * ++ *! Revision History: ++ *! ================ ++ *! 15-Oct-2002 kc Removed legacy PERF code. ++ *! 12-Jan-2002 ag Removed unused gppReqIO & ddmaChnlId DDMA fields. ++ *! Added zero-copy chnl descriptor array: zchnldesc. ++ *! 21-Dec-2001 ag Moved descPaGpp to private chnl obj from chnl descriptor. ++ *! 20-May-2001 ag/jeh Removed fShmSyms field from CHNL_MGR. ++ *! 04-Feb-2001 ag DSP-DMA support added. ++ *! 26-Oct-2000 jeh Added arg and resvd to SHM control structure. Added dwArg ++ *! to CHNL_IRP. ++ *! 16-Oct-2000 jeh Removed #ifdef DEBUG from around channel object's cIOCs ++ *! field, added cIOReqs. ++ *! 20-Jan-2000 ag: Incorporated code review comments. ++ *! 05-Jan-2000 ag: Text format cleanup. ++ *! 03-Nov-1999 ag: Added szEventName[] to CHNL object for name event support. ++ *! 02-Nov-1999 ag: _SHM_BEG & _END Syms from COFF now used for IO and SM CLASS. ++ *! 27-Oct-1999 jeh Define SHM structure to work for 16-bit targets. ++ *! 25-May-1999 jg: Added target side symbol names for share memory buffer ++ *! 03-Jan-1997 gp: Added fSharedIRQ field. ++ *! 22-Oct-1996 gp: Made dwProcessID a handle. ++ *! 09-Sep-1996 gp: Added dwProcessID field to CHNL_OBJECT. ++ *! 13-Aug-1996 gp: Created. ++ */ ++ ++#ifndef _CHNL_SM_ ++#define _CHNL_SM_ ++ ++#include <dspbridge/wcd.h> ++#include <dspbridge/wmd.h> ++#include <dspbridge/dpc.h> ++ ++#include <dspbridge/list.h> ++#include <dspbridge/ntfy.h> ++ ++/* ++ * These target side symbols define the beginning and ending addresses ++ * of shared memory buffer. They are defined in the *cfg.cmd file by ++ * cdb code. ++ */ ++#define CHNL_SHARED_BUFFER_BASE_SYM "_SHM_BEG" ++#define CHNL_SHARED_BUFFER_LIMIT_SYM "_SHM_END" ++#define BRIDGEINIT_BIOSGPTIMER "_BRIDGEINIT_BIOSGPTIMER" ++#define BRIDGEINIT_LOADMON_GPTIMER "_BRIDGEINIT_LOADMON_GPTIMER" ++ ++#ifndef _CHNL_WORDSIZE ++#define _CHNL_WORDSIZE 4 /* default _CHNL_WORDSIZE is 2 bytes/word */ ++#endif ++ ++#define MAXOPPS 16 ++ ++struct oppTableEntry { ++ u32 voltage; ++ u32 frequency; ++ u32 minFreq; ++ u32 maxFreq; ++} ; ++ ++struct oppStruct { ++ u32 currOppPt; ++ u32 numOppPts; ++ struct oppTableEntry oppPoint[MAXOPPS]; ++} ; ++ ++/* Request to MPU */ ++struct oppRqstStruct { ++ u32 rqstDspFreq; ++ u32 rqstOppPt; ++}; ++ ++/* Info to MPU */ ++struct loadMonStruct { ++ u32 currDspLoad; ++ u32 currDspFreq; ++ u32 predDspLoad; ++ u32 predDspFreq; ++}; ++ ++ enum SHM_DESCTYPE { ++ SHM_CURROPP = 0, ++ SHM_OPPINFO = 1, ++ SHM_GETOPP = 2, /* Get DSP requested OPP info */ ++ } ; ++ ++/* Structure in shared between DSP and PC for communication.*/ ++ struct SHM { ++ u32 dspFreeMask; /* Written by DSP, read by PC. */ ++ u32 hostFreeMask; /* Written by PC, read by DSP */ ++ ++ u32 inputFull; /* Input channel has unread data. */ ++ u32 inputId; /* Channel for which input is available. */ ++ u32 inputSize; /* Size of data block (in DSP words). */ ++ ++ u32 outputFull; /* Output channel has unread data. */ ++ u32 outputId; /* Channel for which output is available. */ ++ u32 outputSize; /* Size of data block (in DSP words). */ ++ ++ u32 arg; /* Arg for Issue/Reclaim (23 bits for 55x). */ ++ u32 resvd; /* Keep structure size even for 32-bit DSPs */ ++ ++ /* Operating Point structure */ ++ struct oppStruct oppTableStruct; ++ /* Operating Point Request structure */ ++ struct oppRqstStruct oppRequest; ++ /* load monitor information structure*/ ++ struct loadMonStruct loadMonInfo; ++ char dummy[184]; /* padding to 256 byte boundary */ ++ u32 shm_dbg_var[64]; /* shared memory debug variables */ ++ } ; ++ ++ /* Channel Manager: only one created per board: */ ++ struct CHNL_MGR { ++ u32 dwSignature; /* Used for object validation */ ++ /* Function interface to WMD */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct IO_MGR *hIOMgr; /* IO manager */ ++ /* Device this board represents */ ++ struct DEV_OBJECT *hDevObject; ++ ++ /* These fields initialized in WMD_CHNL_Create(): */ ++ u32 dwOutputMask; /* Host output channels w/ full buffers */ ++ u32 dwLastOutput; /* Last output channel fired from DPC */ ++ /* Critical section object handle */ ++ struct SYNC_CSOBJECT *hCSObj; ++ u32 uWordSize; /* Size in bytes of DSP word */ ++ u32 cChannels; /* Total number of channels */ ++ u32 cOpenChannels; /* Total number of open channels */ ++ struct CHNL_OBJECT **apChannel; /* Array of channels */ ++ u32 dwType; /* Type of channel class library */ ++ /* If no SHM syms, return for CHNL_Open */ ++ DSP_STATUS chnlOpenStatus; ++ } ; ++ ++/* ++ * Channel: up to CHNL_MAXCHANNELS per board or if DSP-DMA supported then ++ * up to CHNL_MAXCHANNELS + CHNL_MAXDDMACHNLS per board. ++ */ ++ struct CHNL_OBJECT { ++ u32 dwSignature; /* Used for object validation */ ++ /* Pointer back to channel manager */ ++ struct CHNL_MGR *pChnlMgr; ++ u32 uId; /* Channel id */ ++ u32 dwState; /* Current channel state */ ++ u32 uMode; /* Chnl mode and attributes */ ++ /* Chnl I/O completion event (user mode) */ ++ HANDLE hUserEvent; ++ /* Abstract syncronization object */ ++ struct SYNC_OBJECT *hSyncEvent; ++ /* Name of Sync event */ ++ char szEventName[SYNC_MAXNAMELENGTH + 1]; ++ u32 hProcess; /* Process which created this channel */ ++ u32 pCBArg; /* Argument to use with callback */ ++ struct LST_LIST *pIORequests; /* List of IOR's to driver */ ++ s32 cIOCs; /* Number of IOC's in queue */ ++ s32 cIOReqs; /* Number of IORequests in queue */ ++ s32 cChirps; /* Initial number of free Irps */ ++ /* List of IOC's from driver */ ++ struct LST_LIST *pIOCompletions; ++ struct LST_LIST *pFreeList; /* List of free Irps */ ++ struct NTFY_OBJECT *hNtfy; ++ u32 cBytesMoved; /* Total number of bytes transfered */ ++ ++ /* For DSP-DMA */ ++ ++ /* Type of chnl transport:CHNL_[PCPY][DDMA] */ ++ u32 uChnlType; ++ } ; ++ ++/* I/O Request/completion packet: */ ++ struct CHNL_IRP { ++ struct LST_ELEM link; /* Link to next CHIRP in queue. */ ++ /* Buffer to be filled/emptied. (User) */ ++ u8 *pHostUserBuf; ++ /* Buffer to be filled/emptied. (System) */ ++ u8 *pHostSysBuf; ++ u32 dwArg; /* Issue/Reclaim argument. */ ++ u32 uDspAddr; /* Transfer address on DSP side. */ ++ u32 cBytes; /* Bytes transferred. */ ++ u32 cBufSize; /* Actual buffer size when allocated. */ ++ u32 status; /* Status of IO completion. */ ++ } ; ++ ++#endif /* _CHNL_SM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/_dcd.h b/arch/arm/plat-omap/include/dspbridge/_dcd.h +new file mode 100644 +index 0000000..b6a8d9e +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/_dcd.h +@@ -0,0 +1,187 @@ ++/* ++ * _dcd.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _dcd.h ======== ++ * Description: ++ * Includes the wrapper functions called directly by the ++ * DeviceIOControl interface. ++ * ++ * Public Functions: ++ * WCD_CallDevIOCtl ++ * WCD_Init ++ * WCD_InitComplete2 ++ * WCD_Exit ++ * <MOD>WRAP_* ++ * ++ * Notes: ++ * Compiled with CDECL calling convention. ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping feature ++ *! 30-Jan-2002 ag Renamed CMMWRAP_AllocBuf to CMMWRAP_CallocBuf. ++ *! 22-Nov-2000 kc: Added MGRWRAP_GetPerf_Data to acquire PERF stats. ++ *! 27-Oct-2000 jeh Added NODEWRAP_AllocMsgBuf, NODEWRAP_FreeMsgBuf. Removed ++ *! NODEWRAP_GetMessageStream. ++ *! 10-Oct-2000 ag: Added user CMM wrappers. ++ *! 04-Aug-2000 rr: MEMWRAP and UTIL_Wrap added. ++ *! 27-Jul-2000 rr: NODEWRAP, STRMWRAP added. ++ *! 27-Jun-2000 rr: MGRWRAP fxns added.IFDEF to build for PM or DSP/BIOS Bridge ++ *! 03-Dec-1999 rr: WCD_InitComplete2 enabled for BRD_AutoStart. ++ *! 09-Nov-1999 kc: Added MEMRY. ++ *! 02-Nov-1999 ag: Added CHNL. ++ *! 08-Oct-1999 rr: Utilwrap_Testdll fxn added ++ *! 24-Sep-1999 rr: header changed from _wcd.h to _dcd.h ++ *! 09-Sep-1997 gp: Created. ++ */ ++ ++#ifndef _WCD_ ++#define _WCD_ ++ ++#include <dspbridge/wcdioctl.h> ++ ++/* ++ * ======== WCD_CallDevIOCtl ======== ++ * Purpose: ++ * Call the (wrapper) function for the corresponding WCD IOCTL. ++ * Parameters: ++ * cmd: IOCTL id, base 0. ++ * args: Argument structure. ++ * pResult: ++ * Returns: ++ * DSP_SOK if command called; DSP_EINVALIDARG if command not in IOCTL ++ * table. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS WCD_CallDevIOCtl(unsigned int cmd, ++ union Trapped_Args *args, ++ u32 *pResult); ++ ++/* ++ * ======== WCD_Init ======== ++ * Purpose: ++ * Initialize WCD modules, and export WCD services to WMD's. ++ * This procedure is called when the class driver is loaded. ++ * Parameters: ++ * Returns: ++ * TRUE if success; FALSE otherwise. ++ * Requires: ++ * Ensures: ++ */ ++ extern bool WCD_Init(void); ++ ++/* ++ * ======== WCD_InitComplete2 ======== ++ * Purpose: ++ * Perform any required WCD, and WMD initialization which ++ * cannot not be performed in WCD_Init(void) or DEV_StartDevice() due ++ * to the fact that some services are not yet ++ * completely initialized. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Allow this device to load ++ * DSP_EFAIL: Failure. ++ * Requires: ++ * WCD initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS WCD_InitComplete2(void); ++ ++/* ++ * ======== WCD_Exit ======== ++ * Purpose: ++ * Exit all modules initialized in WCD_Init(void). ++ * This procedure is called when the class driver is unloaded. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * WCD_Init(void) was previously called. ++ * Ensures: ++ * Resources acquired in WCD_Init(void) are freed. ++ */ ++ extern void WCD_Exit(void); ++ ++/* MGR wrapper functions */ ++ extern u32 MGRWRAP_EnumNode_Info(union Trapped_Args *args); ++ extern u32 MGRWRAP_EnumProc_Info(union Trapped_Args *args); ++ extern u32 MGRWRAP_RegisterObject(union Trapped_Args *args); ++ extern u32 MGRWRAP_UnregisterObject(union Trapped_Args *args); ++ extern u32 MGRWRAP_WaitForBridgeEvents(union Trapped_Args *args); ++ ++#ifndef RES_CLEANUP_DISABLE ++ extern u32 MGRWRAP_GetProcessResourcesInfo(union Trapped_Args *args); ++#endif ++ ++ ++/* CPRC (Processor) wrapper Functions */ ++ extern u32 PROCWRAP_Attach(union Trapped_Args *args); ++ extern u32 PROCWRAP_Ctrl(union Trapped_Args *args); ++ extern u32 PROCWRAP_Detach(union Trapped_Args *args); ++ extern u32 PROCWRAP_EnumNode_Info(union Trapped_Args *args); ++ extern u32 PROCWRAP_EnumResources(union Trapped_Args *args); ++ extern u32 PROCWRAP_GetState(union Trapped_Args *args); ++ extern u32 PROCWRAP_GetTrace(union Trapped_Args *args); ++ extern u32 PROCWRAP_Load(union Trapped_Args *args); ++ extern u32 PROCWRAP_RegisterNotify(union Trapped_Args *args); ++ extern u32 PROCWRAP_Start(union Trapped_Args *args); ++ extern u32 PROCWRAP_ReserveMemory(union Trapped_Args *args); ++ extern u32 PROCWRAP_UnReserveMemory(union Trapped_Args *args); ++ extern u32 PROCWRAP_Map(union Trapped_Args *args); ++ extern u32 PROCWRAP_UnMap(union Trapped_Args *args); ++ extern u32 PROCWRAP_FlushMemory(union Trapped_Args *args); ++ extern u32 PROCWRAP_Stop(union Trapped_Args *args); ++ extern u32 PROCWRAP_InvalidateMemory(union Trapped_Args *args); ++ ++/* NODE wrapper functions */ ++ extern u32 NODEWRAP_Allocate(union Trapped_Args *args); ++ extern u32 NODEWRAP_AllocMsgBuf(union Trapped_Args *args); ++ extern u32 NODEWRAP_ChangePriority(union Trapped_Args *args); ++ extern u32 NODEWRAP_Connect(union Trapped_Args *args); ++ extern u32 NODEWRAP_Create(union Trapped_Args *args); ++ extern u32 NODEWRAP_Delete(union Trapped_Args *args); ++ extern u32 NODEWRAP_FreeMsgBuf(union Trapped_Args *args); ++ extern u32 NODEWRAP_GetAttr(union Trapped_Args *args); ++ extern u32 NODEWRAP_GetMessage(union Trapped_Args *args); ++ extern u32 NODEWRAP_Pause(union Trapped_Args *args); ++ extern u32 NODEWRAP_PutMessage(union Trapped_Args *args); ++ extern u32 NODEWRAP_RegisterNotify(union Trapped_Args *args); ++ extern u32 NODEWRAP_Run(union Trapped_Args *args); ++ extern u32 NODEWRAP_Terminate(union Trapped_Args *args); ++ extern u32 NODEWRAP_GetUUIDProps(union Trapped_Args *args); ++ ++/* STRM wrapper functions */ ++ extern u32 STRMWRAP_AllocateBuffer(union Trapped_Args *args); ++ extern u32 STRMWRAP_Close(union Trapped_Args *args); ++ extern u32 STRMWRAP_FreeBuffer(union Trapped_Args *args); ++ extern u32 STRMWRAP_GetEventHandle(union Trapped_Args *args); ++ extern u32 STRMWRAP_GetInfo(union Trapped_Args *args); ++ extern u32 STRMWRAP_Idle(union Trapped_Args *args); ++ extern u32 STRMWRAP_Issue(union Trapped_Args *args); ++ extern u32 STRMWRAP_Open(union Trapped_Args *args); ++ extern u32 STRMWRAP_Reclaim(union Trapped_Args *args); ++ extern u32 STRMWRAP_RegisterNotify(union Trapped_Args *args); ++ extern u32 STRMWRAP_Select(union Trapped_Args *args); ++ ++ extern u32 CMMWRAP_CallocBuf(union Trapped_Args *args); ++ extern u32 CMMWRAP_FreeBuf(union Trapped_Args *args); ++ extern u32 CMMWRAP_GetHandle(union Trapped_Args *args); ++ extern u32 CMMWRAP_GetInfo(union Trapped_Args *args); ++ ++#endif /* _WCD_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/brddefs.h b/arch/arm/plat-omap/include/dspbridge/brddefs.h +new file mode 100644 +index 0000000..c62388c +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/brddefs.h +@@ -0,0 +1,54 @@ ++/* ++ * brddefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== brddefs.h ======== ++ * Description: ++ * Global BRD constants and types, shared between WSX, WCD, and WMD. ++ * ++ *! Revision History: ++ *! ================ ++ *! 31-Jan-2000 rr: Comment Exec changed to Monitor ++ *! 22-Jul-1999 jeh Added BRD_LOADED state. ++ *! 26-Mar-1997 gp: Added BRD_SYNCINIT state. ++ *! 11-Dec-1996 cr: Added BRD_LASTSTATE definition. ++ *! 11-Jul-1996 gp: Added missing u32 callback argument to BRD_CALLBACK. ++ *! 10-Jun-1996 gp: Created from board.h and brd.h. ++ */ ++ ++#ifndef BRDDEFS_ ++#define BRDDEFS_ ++ ++/* platform status values */ ++#define BRD_STOPPED 0x0 /* No Monitor Loaded, Not running. */ ++#define BRD_IDLE 0x1 /* Monitor Loaded, but suspended. */ ++#define BRD_RUNNING 0x2 /* Monitor loaded, and executing. */ ++#define BRD_UNKNOWN 0x3 /* Board state is indeterminate. */ ++#define BRD_SYNCINIT 0x4 ++#define BRD_LOADED 0x5 ++#define BRD_LASTSTATE BRD_LOADED /* Set to highest legal board state. */ ++#define BRD_SLEEP_TRANSITION 0x6 /* Sleep transition in progress */ ++#define BRD_HIBERNATION 0x7 /* MPU initiated hibernation */ ++#define BRD_RETENTION 0x8 /* Retention mode */ ++#define BRD_DSP_HIBERNATION 0x9 /* DSP initiated hibernation */ ++#define BRD_ERROR 0xA /* Board state is Error */ ++ typedef u32 BRD_STATUS; ++ ++/* BRD Object */ ++ struct BRD_OBJECT; ++ ++#endif /* BRDDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/cfg.h b/arch/arm/plat-omap/include/dspbridge/cfg.h +new file mode 100644 +index 0000000..68db842 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/cfg.h +@@ -0,0 +1,339 @@ ++/* ++ * cfg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cfg.h ======== ++ * Purpose: ++ * PM Configuration module. ++ * ++ * Private Functions: ++ * CFG_Exit ++ * CFG_GetAutoStart ++ * CFG_GetCDVersion ++ * CFG_GetDevObject ++ * CFG_GetDSPResources ++ * CFG_GetExecFile ++ * CFG_GetHostResources ++ * CFG_GetObject ++ * CFG_GetPerfValue ++ * CFG_GetWMDFileName ++ * CFG_GetZLFile ++ * CFG_Init ++ * CFG_SetDevObject ++ * CFG_SetObject ++ * ++ *! Revision History: ++ *! ================= ++ *! 26-Feb-2003 kc Removed unused CFG fxns. ++ *! 28-Aug-2001 jeh Added CFG_GetLoaderName. ++ *! 26-Jul-2000 rr: Added CFG_GetDCDName to retrieve the DCD Dll name. ++ *! 13-Jul-2000 rr: Added CFG_GetObject & CFG_SetObject. ++ *! 13-Jan-2000 rr: CFG_Get/SetPrivateDword renamed to CFG_Get/SetDevObject. ++ *! CFG_GetWinBRIDGEDir/Directory,CFG_GetSearchPath removed. ++ *! 15-Jan-1998 cr: Code review cleanup. ++ *! 16-Aug-1997 cr: Added explicit cdecl identifiers. ++ *! 12-Dec-1996 gp: Moved CFG_FindInSearchPath to CSP module. ++ *! 13-Sep-1996 gp: Added CFG_GetBoardName(). ++ *! 22-Jul-1996 gp: Added CFG_GetTraceStr, to retrieve an initial GT trace. ++ *! 26-Jun-1996 cr: Added CFG_FindInSearchPath. ++ *! 25-Jun-1996 cr: Added CFG_GetWinSPOXDir. ++ *! 17-Jun-1996 cr: Added CFG_GetDevNode. ++ *! 11-Jun-1996 cr: Cleaned up for code review. ++ *! 07-Jun-1996 cr: Added CFG_GetExecFile and CFG_GetZLFileName functions. ++ *! 04-Jun-1996 gp: Added AutoStart regkey and accessor function. Placed ++ *! OUT parameters in accessor function param. lists at end. ++ *! 29-May-1996 gp: Moved DEV_HDEVNODE to here and renamed CFG_HDEVNODE. ++ *! 22-May-1996 cr: Added GetHostResources, GetDSPResources, and ++ *! GetWMDFileName services. ++ *! 18-May-1996 gp: Created. ++ */ ++ ++#ifndef CFG_ ++#define CFG_ ++#include <dspbridge/host_os.h> ++#include <dspbridge/cfgdefs.h> ++ ++/* ++ * ======== CFG_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CFG module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * CFG_Init(void) was previously called. ++ * Ensures: ++ * Resources acquired in CFG_Init(void) are freed. ++ */ ++ extern void CFG_Exit(void); ++ ++/* ++ * ======== CFG_GetAutoStart ======== ++ * Purpose: ++ * Retreive the autostart mask, if any, for this board. ++ * Parameters: ++ * hDevNode: Handle to the DevNode who's WMD we are querying. ++ * pdwAutoStart: Ptr to location for 32 bit autostart mask. ++ * Returns: ++ * DSP_SOK: Success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_RESOURCENOTAVAIL: Unable to retreive resource. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: *pdwAutoStart contains autostart mask for this devnode. ++ */ ++ extern DSP_STATUS CFG_GetAutoStart(IN struct CFG_DEVNODE *hDevNode, ++ OUT u32 *pdwAutoStart); ++ ++/* ++ * ======== CFG_GetCDVersion ======== ++ * Purpose: ++ * Retrieves the version of the PM Class Driver. ++ * Parameters: ++ * pdwVersion: Ptr to u32 to contain version number upon return. ++ * Returns: ++ * DSP_SOK: Success. pdwVersion contains Class Driver version in ++ * the form: 0xAABBCCDD where AABB is Major version and ++ * CCDD is Minor. ++ * DSP_EFAIL: Failure. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: Success. ++ * else: *pdwVersion is NULL. ++ */ ++ extern DSP_STATUS CFG_GetCDVersion(OUT u32 *pdwVersion); ++ ++/* ++ * ======== CFG_GetDevObject ======== ++ * Purpose: ++ * Retrieve the Device Object handle for a given devnode. ++ * Parameters: ++ * hDevNode: Platform's DevNode handle from which to retrieve value. ++ * pdwValue: Ptr to location to store the value. ++ * Returns: ++ * DSP_SOK: Success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_INVALIDPOINTER: phDevObject is invalid. ++ * CFG_E_RESOURCENOTAVAIL: The resource is not available. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: *pdwValue is set to the retrieved u32. ++ * else: *pdwValue is set to 0L. ++ */ ++ extern DSP_STATUS CFG_GetDevObject(IN struct CFG_DEVNODE *hDevNode, ++ OUT u32 *pdwValue); ++ ++/* ++ * ======== CFG_GetDSPResources ======== ++ * Purpose: ++ * Get the DSP resources available to a given device. ++ * Parameters: ++ * hDevNode: Handle to the DEVNODE who's resources we are querying. ++ * pDSPResTable: Ptr to a location to store the DSP resource table. ++ * Returns: ++ * DSP_SOK: On success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_RESOURCENOTAVAIL: The DSP Resource information is not ++ * available ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: pDSPResTable points to a filled table of resources allocated ++ * for the specified WMD. ++ */ ++ extern DSP_STATUS CFG_GetDSPResources(IN struct CFG_DEVNODE *hDevNode, ++ OUT struct CFG_DSPRES *pDSPResTable); ++ ++ ++/* ++ * ======== CFG_GetExecFile ======== ++ * Purpose: ++ * Retreive the default executable, if any, for this board. ++ * Parameters: ++ * hDevNode: Handle to the DevNode who's WMD we are querying. ++ * cBufSize: Size of buffer. ++ * pstrExecFile: Ptr to character buf to hold ExecFile. ++ * Returns: ++ * DSP_SOK: Success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_INVALIDPOINTER: pstrExecFile is invalid. ++ * CFG_E_RESOURCENOTAVAIL: The resource is not available. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: Not more than cBufSize bytes were copied into pstrExecFile, ++ * and *pstrExecFile contains default executable for this ++ * devnode. ++ */ ++ extern DSP_STATUS CFG_GetExecFile(IN struct CFG_DEVNODE *hDevNode, ++ IN u32 cBufSize, ++ OUT char *pstrExecFile); ++ ++/* ++ * ======== CFG_GetHostResources ======== ++ * Purpose: ++ * Get the Host PC allocated resources assigned to a given device. ++ * Parameters: ++ * hDevNode: Handle to the DEVNODE who's resources we are querying. ++ * pHostResTable: Ptr to a location to store the host resource table. ++ * Returns: ++ * DSP_SOK: On success. ++ * CFG_E_INVALIDPOINTER: pHostResTable is invalid. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_RESOURCENOTAVAIL: The resource is not available. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: pHostResTable points to a filled table of resources ++ * allocated for the specified WMD. ++ * ++ */ ++ extern DSP_STATUS CFG_GetHostResources(IN struct CFG_DEVNODE *hDevNode, ++ OUT struct CFG_HOSTRES *pHostResTable); ++ ++/* ++ * ======== CFG_GetObject ======== ++ * Purpose: ++ * Retrieve the Driver Object handle From the Registry ++ * Parameters: ++ * pdwValue: Ptr to location to store the value. ++ * dwType Type of Object to Get ++ * Returns: ++ * DSP_SOK: Success. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: *pdwValue is set to the retrieved u32(non-Zero). ++ * else: *pdwValue is set to 0L. ++ */ ++ extern DSP_STATUS CFG_GetObject(OUT u32 *pdwValue, u32 dwType); ++ ++/* ++ * ======== CFG_GetPerfValue ======== ++ * Purpose: ++ * Retrieve a flag indicating whether PERF should log statistics for the ++ * PM class driver. ++ * Parameters: ++ * pfEnablePerf: Location to store flag. 0 indicates the key was ++ * not found, or had a zero value. A nonzero value ++ * means the key was found and had a nonzero value. ++ * Returns: ++ * Requires: ++ * pfEnablePerf != NULL; ++ * Ensures: ++ */ ++ extern void CFG_GetPerfValue(OUT bool *pfEnablePerf); ++ ++/* ++ * ======== CFG_GetWMDFileName ======== ++ * Purpose: ++ * Get the mini-driver file name for a given device. ++ * Parameters: ++ * hDevNode: Handle to the DevNode who's WMD we are querying. ++ * cBufSize: Size of buffer. ++ * pWMDFileName: Ptr to a character buffer to hold the WMD filename. ++ * Returns: ++ * DSP_SOK: On success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_RESOURCENOTAVAIL: The filename is not available. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: Not more than cBufSize bytes were copied ++ * into pWMDFileName. ++ * ++ */ ++ extern DSP_STATUS CFG_GetWMDFileName(IN struct CFG_DEVNODE *hDevNode, ++ IN u32 cBufSize, ++ OUT char *pWMDFileName); ++ ++/* ++ * ======== CFG_GetZLFile ======== ++ * Purpose: ++ * Retreive the ZLFile, if any, for this board. ++ * Parameters: ++ * hDevNode: Handle to the DevNode who's WMD we are querying. ++ * cBufSize: Size of buffer. ++ * pstrZLFileName: Ptr to character buf to hold ZLFileName. ++ * Returns: ++ * DSP_SOK: Success. ++ * CFG_E_INVALIDPOINTER: pstrZLFileName is invalid. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * CFG_E_RESOURCENOTAVAIL: couldn't find the ZLFileName. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: Not more than cBufSize bytes were copied into ++ * pstrZLFileName, and *pstrZLFileName contains ZLFileName ++ * for this devnode. ++ */ ++ extern DSP_STATUS CFG_GetZLFile(IN struct CFG_DEVNODE *hDevNode, ++ IN u32 cBufSize, ++ OUT char *pstrZLFileName); ++ ++/* ++ * ======== CFG_Init ======== ++ * Purpose: ++ * Initialize the CFG module's private state. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public CFG functions. ++ */ ++ extern bool CFG_Init(void); ++ ++/* ++ * ======== CFG_SetDevObject ======== ++ * Purpose: ++ * Store the Device Object handle for a given devnode. ++ * Parameters: ++ * hDevNode: Platform's DevNode handle we are storing value with. ++ * dwValue: Arbitrary value to store. ++ * Returns: ++ * DSP_SOK: Success. ++ * CFG_E_INVALIDHDEVNODE: hDevNode is invalid. ++ * DSP_EFAIL: Internal Error. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: The Private u32 was successfully set. ++ */ ++ extern DSP_STATUS CFG_SetDevObject(IN struct CFG_DEVNODE *hDevNode, ++ IN u32 dwValue); ++ ++/* ++ * ======== CFG_SetDrvObject ======== ++ * Purpose: ++ * Store the Driver Object handle. ++ * Parameters: ++ * dwValue: Arbitrary value to store. ++ * dwType Type of Object to Store ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Internal Error. ++ * Requires: ++ * CFG initialized. ++ * Ensures: ++ * DSP_SOK: The Private u32 was successfully set. ++ */ ++ extern DSP_STATUS CFG_SetObject(IN u32 dwValue, IN u32 dwType); ++ ++#endif /* CFG_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/cfgdefs.h b/arch/arm/plat-omap/include/dspbridge/cfgdefs.h +new file mode 100644 +index 0000000..4f78d82 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/cfgdefs.h +@@ -0,0 +1,126 @@ ++/* ++ * cfgdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== cfgdefs.h ======== ++ * Purpose: ++ * Global CFG constants and types, shared between class and mini driver. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 kc Removed wIOPort* in CFG_HOSTRES. ++ *! 06-Sep-2000 jeh Added channel info to CFG_HOSTRES. ++ *! 09-May-2000 rr: CFG_HOSTRES now support multiple windows for PCI support. ++ *! 31-Jan-2000 rr: Comments changed after code review. ++ *! 06-Jan-2000 rr: Bus Type included in CFG_HOSTRES. ++ *! 12-Nov-1999 rr: CFG_HOSTRES member names changed. ++ *! 25-Oct-1999 rr: Modified the CFG_HOSTRES Structure ++ *! PCMCIA ISR Register/Unregister fxn removed.. ++ *! New flag PCCARD introduced during compile time. ++ *! 10-Sep-1999 ww: Added PCMCIA ISR Register/Unregister fxn. ++ *! 01-Sep-1999 ag: Removed NT/95 specific fields in CFG_HOSTRES ++ *! 27-Oct-1997 cr: Updated CFG_HOSTRES struct to support 1+ IRQs per board. ++ *! 17-Sep-1997 gp: Tacked some NT config info to end of CFG_HOSTRES structure. ++ *! 12-Dec-1996 cr: Cleaned up after code review. ++ *! 14-Nov-1996 gp: Renamed from wsxcfg.h ++ *! 19-Jun-1996 cr: Created. ++ */ ++ ++#ifndef CFGDEFS_ ++#define CFGDEFS_ ++ ++/* Maximum length of module search path. */ ++#define CFG_MAXSEARCHPATHLEN 255 ++ ++/* Maximum length of general paths. */ ++#define CFG_MAXPATH 255 ++ ++/* Host Resources: */ ++#define CFG_MAXMEMREGISTERS 9 ++#define CFG_MAXIOPORTS 20 ++#define CFG_MAXIRQS 7 ++#define CFG_MAXDMACHANNELS 7 ++ ++/* IRQ flag */ ++#define CFG_IRQSHARED 0x01 /* IRQ can be shared */ ++ ++/* DSP Resources: */ ++#define CFG_DSPMAXMEMTYPES 10 ++#define CFG_DEFAULT_NUM_WINDOWS 1 /* We support only one window. */ ++ ++/* A platform-related device handle: */ ++ struct CFG_DEVNODE; ++ ++/* ++ * Host resource structure. ++ */ ++ struct CFG_HOSTRES { ++ u32 wNumMemWindows; /* Set to default */ ++ /* This is the base.memory */ ++ u32 dwMemBase[CFG_MAXMEMREGISTERS]; /* SHM virtual address */ ++ u32 dwMemLength[CFG_MAXMEMREGISTERS]; /* Length of the Base */ ++ u32 dwMemPhys[CFG_MAXMEMREGISTERS]; /* SHM Physical address */ ++ u8 bIRQRegisters; /* IRQ Number */ ++ u8 bIRQAttrib; /* IRQ Attribute */ ++ u32 dwOffsetForMonitor; /* The Shared memory starts from ++ * dwMemBase + this offset */ ++ u32 dwBusType; /* Bus type for this device */ ++ u32 dwProgBase; /* DSP ProgBase */ ++ u32 dwProgLength; /* DSP ProgBase Length */ ++ u32 dwRegBase; /* DSP memory mapped register base */ ++ u32 dwRegLength; /* DSP Register Base Length */ ++ u32 ClientHandle; /* Client Handle */ ++ u32 SocketHandle; /* Socket and Function Pair */ ++ u32 CardInfo; /* This will be used as a context data in ++ * in the CardRequestIRQ */ ++ /* ++ * Info needed by NODE for allocating channels to communicate with RMS: ++ * dwChnlOffset: Offset of RMS channels. Lower channels are ++ * reserved. ++ * dwChnlBufSize: Size of channel buffer to send to RMS ++ * dwNumChnls: Total number of channels (including reserved). ++ */ ++ u32 dwChnlOffset; ++ u32 dwChnlBufSize; ++ u32 dwNumChnls; ++ u32 dwPrmBase; ++ u32 dwCmBase; ++ u32 dwPerBase; ++ u32 dwPerPmBase; ++ u32 dwCorePmBase; ++ u32 dwWdTimerDspBase; ++ u32 dwMboxBase; ++ u32 dwDmmuBase; ++ u32 dwDipiBase; ++ u32 dwSysCtrlBase; ++ } ; ++ ++ struct CFG_DSPMEMDESC { ++ u32 uMemType; /* Type of memory. */ ++ u32 ulMin; /* Minimum amount of memory of this type. */ ++ u32 ulMax; /* Maximum amount of memory of this type. */ ++ } ; ++ ++ struct CFG_DSPRES { ++ u32 uChipType; /* DSP chip type. */ ++ u32 uWordSize; /* Number of bytes in a word */ ++ u32 cChips; /* Number of chips. */ ++ u32 cMemTypes; /* Types of memory. */ ++ struct CFG_DSPMEMDESC aMemDesc[CFG_DSPMAXMEMTYPES]; ++ /* DSP Memory types */ ++ } ; ++ ++#endif /* CFGDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/chnl.h b/arch/arm/plat-omap/include/dspbridge/chnl.h +new file mode 100644 +index 0000000..f39e3f4 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/chnl.h +@@ -0,0 +1,170 @@ ++/* ++ * chnl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnl.h ======== ++ * Description: ++ * WCD channel interface: multiplexes data streams through the single ++ * physical link managed by a mini-driver. ++ * ++ * Public Functions: ++ * CHNL_AddIOReq ++ * CHNL_AllocBuffer ++ * CHNL_CancelIO ++ * CHNL_Close ++ * CHNL_CloseOrphans ++ * CHNL_Create ++ * CHNL_Destroy ++ * CHNL_Exit ++ * CHNL_FlushIO ++ * CHNL_FreeBuffer ++ * CHNL_GetEventHandle ++ * CHNL_GetHandle ++ * CHNL_GetIOCompletion ++ * CHNL_GetId ++ * CHNL_GetMgr ++ * CHNL_GetMode ++ * CHNL_GetPosition ++ * CHNL_GetProcessHandle ++ * CHNL_Init ++ * CHNL_Open ++ * ++ * Notes: ++ * See DSP API chnl.h for more details. ++ * ++ *! Revision History: ++ *! ================ ++ *! 14-Jan-1997 gp: Updated based on code review feedback. ++ *! 24-Oct-1996 gp: Move CloseOrphans into here from dspsys. ++ *! 09-Sep-1996 gp: Added CHNL_GetProcessID() and CHNL_GetHandle(). ++ *! 10-Jul-1996 gp: Created. ++ */ ++ ++#ifndef CHNL_ ++#define CHNL_ ++ ++#include <dspbridge/chnlpriv.h> ++ ++/* ++ * ======== CHNL_Close ======== ++ * Purpose: ++ * Ensures all pending I/O on this channel is cancelled, discards all ++ * queued I/O completion notifications, then frees the resources allocated ++ * for this channel, and makes the corresponding logical channel id ++ * available for subsequent use. ++ * Parameters: ++ * hChnl: Channel object handle. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * Requires: ++ * CHNL_Init(void) called. ++ * No thread must be blocked on this channel's I/O completion event. ++ * Ensures: ++ * DSP_SOK: The I/O completion event for this channel is freed. ++ * hChnl is no longer valid. ++ */ ++ extern DSP_STATUS CHNL_Close(struct CHNL_OBJECT *hChnl); ++ ++ ++/* ++ * ======== CHNL_Create ======== ++ * Purpose: ++ * Create a channel manager object, responsible for opening new channels ++ * and closing old ones for a given board. ++ * Parameters: ++ * phChnlMgr: Location to store a channel manager object on output. ++ * hDevObject: Handle to a device object. ++ * pMgrAttrs: Channel manager attributes. ++ * pMgrAttrs->cChannels: Max channels ++ * pMgrAttrs->bIRQ: Channel's I/O IRQ number. ++ * pMgrAttrs->fShared: TRUE if the IRQ is shareable. ++ * pMgrAttrs->uWordSize: DSP Word size in equivalent PC bytes.. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: hDevObject is invalid. ++ * DSP_EINVALIDARG: cChannels is 0. ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * CHNL_E_ISR: Unable to plug channel ISR for configured IRQ. ++ * CHNL_E_MAXCHANNELS: This manager cannot handle this many channels. ++ * CHNL_E_INVALIDIRQ: Invalid IRQ number. Must be 0 <= bIRQ <= 15. ++ * CHNL_E_INVALIDWORDSIZE: Invalid DSP word size. Must be > 0. ++ * CHNL_E_INVALIDMEMBASE: Invalid base address for DSP communications. ++ * CHNL_E_MGREXISTS: Channel manager already exists for this device. ++ * Requires: ++ * CHNL_Init(void) called. ++ * phChnlMgr != NULL. ++ * pMgrAttrs != NULL. ++ * Ensures: ++ * DSP_SOK: Subsequent calls to CHNL_Create() for the same ++ * board without an intervening call to ++ * CHNL_Destroy() will fail. ++ */ ++ extern DSP_STATUS CHNL_Create(OUT struct CHNL_MGR **phChnlMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CHNL_MGRATTRS *pMgrAttrs); ++ ++/* ++ * ======== CHNL_Destroy ======== ++ * Purpose: ++ * Close all open channels, and destroy the channel manager. ++ * Parameters: ++ * hChnlMgr: Channel manager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: hChnlMgr was invalid. ++ * Requires: ++ * CHNL_Init(void) called. ++ * Ensures: ++ * DSP_SOK: Cancels I/O on each open channel. ++ * Closes each open channel. ++ * CHNL_Create may subsequently be called for the ++ * same board. ++ */ ++ extern DSP_STATUS CHNL_Destroy(struct CHNL_MGR *hChnlMgr); ++ ++/* ++ * ======== CHNL_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CHNL module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * CHNL_Init(void) previously called. ++ * Ensures: ++ * Resources, if any acquired in CHNL_Init(void), are freed when the last ++ * client of CHNL calls CHNL_Exit(void). ++ */ ++ extern void CHNL_Exit(void); ++ ++ ++/* ++ * ======== CHNL_Init ======== ++ * Purpose: ++ * Initialize the CHNL module's private state. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occurred. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public CHNL functions. ++ */ ++ extern bool CHNL_Init(void); ++ ++ ++ ++#endif /* CHNL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/chnl_sm.h b/arch/arm/plat-omap/include/dspbridge/chnl_sm.h +new file mode 100644 +index 0000000..789b9bd +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/chnl_sm.h +@@ -0,0 +1,168 @@ ++/* ++ * chnl_sm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnl_sm.h ======== ++ * Description: ++ * Prototypes for channel lower edge functions for a WinBRIDGE mini driver ++ * implementing data transfer via shared memory. ++ * ++ * Public Functions: ++ * CHNLSM_DisableInterrupt; ++ * CHNLSM_EnableInterrupt; ++ * CHNLSM_ISR; ++ * CHNLSM_Read; ++ * CHNLSM_UpdateSHMLength; ++ * CHNLSM_Write; ++ * ++ * Notes: ++ * These lower edge functions must be implemented by the WMD writer. ++ * Currently, CHNLSM_Read() and CHNLSM_Write() are not called, but must ++ * be defined to link. ++ * ++ */ ++ ++#ifndef CHNLSM_ ++#define CHNLSM_ ++ ++#include <dspbridge/wmd.h> ++ ++/* ++ * ======== CHNLSM_DisableInterrupt ======== ++ * Purpose: ++ * Disable interrupts from the DSP board to the PC. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * Returns: ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CHNLSM_DisableInterrupt(struct WMD_DEV_CONTEXT* ++ hDevContext); ++ ++/* ++ * ======== CHNLSM_EnableInterrupt ======== ++ * Purpose: ++ * Enable interrupts from the DSP board to the PC. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * Returns: ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CHNLSM_EnableInterrupt(struct WMD_DEV_CONTEXT* ++ hDevContext); ++ ++/* ++ * ======== CHNLSM_InterruptDSP2 ======== ++ * Purpose: ++ * Set interrupt value & send an interrupt to the DSP processor(s). ++ * This is typicaly used when mailbox interrupt mechanisms allow data ++ * to be associated with interrupt such as for OMAP's CMD/DATA regs. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * wMbVal: Value associated with interrupt(e.g. mailbox value). ++ * Returns: ++ * DSP_SOK: Interrupt sent; ++ * else: Unable to send interrupt. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CHNLSM_InterruptDSP2(struct WMD_DEV_CONTEXT* ++ hDevContext, u16 wMbVal); ++ ++/* ++ * ======== CHNLSM_ISR ======== ++ * Purpose: ++ * Mini-driver's ISR, called by WCD when the board interrupts the host. ++ * Parameters: ++ * hDevContext: Handle to the mini-driver defined device info. ++ * pfSchedDPC: Set to TRUE to schedule a deferred procedure call ++ * to advance the channel protocol. The channel class ++ * library will call the WMD's CHNLSM_DPC routine during ++ * its own DPC, before dispatching I/O. ++ * The channel class library should ignore *pfSchedDPC when ++ * CHNLSM_ISR returns FALSE. ++ * pwMBRegVal: Value of mailbox register. ++ * Returns: ++ * TRUE if this interrupt is was generated by the DSP board. ++ * FALSE otherwise. ++ * Requires: ++ * Interrupts to the host processor are disabled on entry. ++ * Must only call functions which are in page locked memory. ++ * Must only call asynchronous OS services. ++ * The EOI for this interrupt has already been sent to the PIC. ++ * Ensures: ++ * If the interrupt is *not* shared, this routine must return TRUE. ++ */ ++ extern bool CHNLSM_ISR(struct WMD_DEV_CONTEXT *hDevContext, ++ OUT bool *pfSchedDPC, ++ OUT u16 *pwIntrVal); ++ ++/* ++ * ======== CHNLSM_Read ======== ++ * Purpose: ++ * Read data from DSP board memory into a Host buffer. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * pHostBuf: Pointer to host buffer (Destination). ++ * dwDSPAddr: Address on DSP board (Source). ++ * ulNumBytes: Number of bytes to transfer. ++ * Returns: ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CHNLSM_Read(struct WMD_DEV_CONTEXT *hDevContext, ++ OUT u8 *pHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes); ++ ++/* ++ * ======== CHNLSM_UpdateSHMLength ======== ++ * Purpose: ++ * Allow the minidriver a chance to override the SHM length as reported ++ * to the mini driver (chnl_sm.lib) by Windows Plug and Play. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * pSHMLength: Pointer to size of SHM window (in DSP words). ++ * Returns: ++ * TRUE if pSHMLength updated; FALSE otherwise. ++ * Requires: ++ * pSHMLength != NULL. ++ * Ensures: ++ * No more than sizeof(u32) bytes written to *pSHMLength ++ */ ++ extern bool CHNLSM_UpdateSHMLength(struct WMD_DEV_CONTEXT *hDevContext, ++ IN OUT u32 *pSHMLength); ++ ++/* ++ * ======== CHNLSM_Write ======== ++ * Purpose: ++ * Write data from a Host buffer to DSP board memory. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * pHostBuf: Pointer to host buffer (Source). ++ * dwDSPAddr: Address on DSP board (Destination). ++ * ulNumBytes: Number of bytes to transfer. ++ * Returns: ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CHNLSM_Write(struct WMD_DEV_CONTEXT *hDevContext, ++ IN u8 *pHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes); ++ ++#endif /* CHNLSM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/chnldefs.h b/arch/arm/plat-omap/include/dspbridge/chnldefs.h +new file mode 100644 +index 0000000..9f59229 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/chnldefs.h +@@ -0,0 +1,92 @@ ++/* ++ * chnldefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnldefs.h ======== ++ * Purpose: ++ * System-wide channel objects and constants. ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Jan-2002 ag Added cBufSize to IOC. ++ *! 05-Jan-2000 ag: Text format cleanup. ++ *! 02-Dec-1999 ag: Added new chnl attribute pstrEventName. ++ *! 12-Nov-1999 kc: Enabled hEvent attribute for tests. ++ *! 01-Nov-1999 ag: hEvent attribute not supported(yet). ++ *! 16-Jan-1997 gp: Moved private stuff into chnlpriv.h ++ *! 14-Jan-1997 gp: Updated based on code review feedback: ++ *! Removed CHNL_MODENOWAIT, CHNL_MODEDIRECT, ++ *! 03-Jan-1997 gp: Added channel class library types. ++ *! 14-Dec-1996 gp: Moved uChnlId field from CHNL_ATTRS to CHNL_Open(). ++ *! 10-Dec-1996 gp: Added CHNL_IsTimedOut() macro. ++ *! 14-Nov-1996 gp: Renamed from wsxchnl.h. ++ *! 09-Sep-1996 gp: Added hReserved2 field to CHNL_ATTRS. Updated CHNL_INFO. ++ *! 10-Jul-1996 gp: Created from channel.h. ++ */ ++ ++#ifndef CHNLDEFS_ ++#define CHNLDEFS_ ++ ++/* Channel id option. */ ++#define CHNL_PICKFREE (~0UL) /* Let manager pick a free channel. */ ++ ++/* Channel manager limits: */ ++#define CHNL_INITIOREQS 4 /* Default # of I/O requests. */ ++ ++/* Channel modes */ ++#define CHNL_MODETODSP 0x0000 /* Data streaming to the DSP. */ ++#define CHNL_MODEFROMDSP 0x0001 /* Data streaming from the DSP. */ ++ ++/* GetIOCompletion flags */ ++#define CHNL_IOCINFINITE 0xffffffff /* Wait forever for IO completion. */ ++#define CHNL_IOCNOWAIT 0x0 /* Dequeue an IOC, if available. */ ++ ++/* IO Completion Record status: */ ++#define CHNL_IOCSTATCOMPLETE 0x0000 /* IO Completed. */ ++#define CHNL_IOCSTATCANCEL 0x0002 /* IO was cancelled */ ++#define CHNL_IOCSTATTIMEOUT 0x0008 /* Wait for IOC timed out. */ ++#define CHNL_IOCSTATEOS 0x8000 /* End Of Stream reached. */ ++ ++/* Macros for checking I/O Completion status: */ ++#define CHNL_IsEOS(ioc) (ioc.status & CHNL_IOCSTATEOS) ++#define CHNL_IsIOComplete(ioc) (!(ioc.status & ~CHNL_IOCSTATEOS)) ++#define CHNL_IsIOCancelled(ioc) (ioc.status & CHNL_IOCSTATCANCEL) ++#define CHNL_IsTimedOut(ioc) (ioc.status & CHNL_IOCSTATTIMEOUT) ++ ++/* CHNL types: */ ++ typedef u32 CHNL_MODE; /* Channel transfer mode. */ ++ ++/* Channel attributes: */ ++ struct CHNL_ATTRS { ++ u32 uIOReqs; /* Max # of preallocated I/O requests. */ ++ HANDLE hEvent; /* User supplied auto-reset event object. */ ++ char *pstrEventName; /* Ptr to name of user event object. */ ++ HANDLE hReserved1; /* Reserved for future use. */ ++ u32 hReserved2; /* Reserved for future use. */ ++ ++ }; ++ ++/* I/O completion record: */ ++ struct CHNL_IOC { ++ void *pBuf; /* Buffer to be filled/emptied. */ ++ u32 cBytes; /* Bytes transferred. */ ++ u32 cBufSize; /* Actual buffer size in bytes */ ++ u32 status; /* Status of IO completion. */ ++ u32 dwArg; /* User argument associated with pBuf. */ ++ } ; ++ ++#endif /* CHNLDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/chnlpriv.h b/arch/arm/plat-omap/include/dspbridge/chnlpriv.h +new file mode 100644 +index 0000000..fdcda24 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/chnlpriv.h +@@ -0,0 +1,136 @@ ++/* ++ * chnlpriv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnlpriv.h ======== ++ * Description: ++ * Private channel header shared between DSPSYS, WCD and WMD modules. ++ * ++ * Public Functions: ++ * None. ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 05-Jan-2002 ag Added cChannels(total # of chnls) to CHNL_MGRINFO struct. ++ *! Added private CHNL_[PCPY][ZCPY][DDMA]. ++ *! 17-Nov-2000 jeh Removed IRQ, shared memory from CHNL_MGRATTRS, since these ++ *! now belong to IO_ATTRS. ++ *! 21-Jan-2000 ag: Code review comments added. ++ *! 05-Jan-2000 ag: Text format cleanup. ++ *! 11-Dec-1999 ag: Added CHNL_MAXLOCKPAGES for CHNL_PrepareBuffer(). ++ *! 04-Dec-1999 ag: Added CHNL_MAXEVTNAMELEN for i/o compl named event support. ++ *! 01-Nov-1999 ag: CHNL_MAXCHANNELS set to 16 for 16-bit DSPs. ++ *! 27-Oct-1997 cr: Expanded CHNL_MAXIRQ from 0x0f to 0xff. ++ *! 16-Jan-1997 gp: Moved symbols into here from chnldefs.h. ++ *! 03-Jan-1997 gp: Added CHNL_MAXIRQ define. ++ *! 09-Dec-1996 gp: Removed CHNL_STATEIDLE. ++ *! 15-Jul-1996 gp: Created. ++ */ ++ ++#ifndef CHNLPRIV_ ++#define CHNLPRIV_ ++ ++#include <dspbridge/chnldefs.h> ++#include <dspbridge/devdefs.h> ++#include <dspbridge/sync.h> ++ ++/* CHNL Object validation signatures: */ ++#define CHNL_MGRSIGNATURE 0x52474D43 /* "CMGR" (in reverse). */ ++#define CHNL_SIGNATURE 0x4C4E4843 /* "CHNL" (in reverse). */ ++ ++/* Channel manager limits: */ ++#define CHNL_MAXCHANNELS 32 /* Max channels available per transport */ ++ ++ ++/* ++ * Trans port channel Id definitions:(must match dsp-side). ++ * ++ * For CHNL_MAXCHANNELS = 16: ++ * ++ * ChnlIds: ++ * 0-15 (PCPY) - transport 0) ++ * 16-31 (DDMA) - transport 1) ++ * 32-47 (ZCPY) - transport 2) ++ */ ++#define CHNL_PCPY 0 /* Proc-copy transport 0 */ ++ ++#define CHNL_MAXIRQ 0xff /* Arbitrarily large number. */ ++ ++/* The following modes are private: */ ++#define CHNL_MODEUSEREVENT 0x1000 /* User provided the channel event. */ ++#define CHNL_MODEMASK 0x1001 ++ ++/* Higher level channel states: */ ++#define CHNL_STATEREADY 0x0000 /* Channel ready for I/O. */ ++#define CHNL_STATECANCEL 0x0001 /* I/O was cancelled. */ ++#define CHNL_STATEEOS 0x0002 /* End Of Stream reached. */ ++ ++/* Determine if user supplied an event for this channel: */ ++#define CHNL_IsUserEvent(mode) (mode & CHNL_MODEUSEREVENT) ++ ++/* Macros for checking mode: */ ++#define CHNL_IsInput(mode) (mode & CHNL_MODEFROMDSP) ++#define CHNL_IsOutput(mode) (!CHNL_IsInput(mode)) ++ ++/* Types of channel class libraries: */ ++#define CHNL_TYPESM 1 /* Shared memory driver. */ ++#define CHNL_TYPEBM 2 /* Bus Mastering driver. */ ++ ++/* Max string length of channel I/O completion event name - change if needed */ ++#define CHNL_MAXEVTNAMELEN 32 ++ ++/* Max memory pages lockable in CHNL_PrepareBuffer() - change if needed */ ++#define CHNL_MAXLOCKPAGES 64 ++ ++/* Channel info. */ ++ struct CHNL_INFO { ++ struct CHNL_MGR *hChnlMgr; /* Owning channel manager. */ ++ u32 dwID; /* Channel ID. */ ++ HANDLE hEvent; /* Channel I/O completion event. */ ++ /*Abstraction of I/O completion event.*/ ++ struct SYNC_OBJECT *hSyncEvent; ++ u32 dwMode; /* Channel mode. */ ++ u32 dwState; /* Current channel state. */ ++ u32 cPosition; /* Total bytes transferred. */ ++ u32 cIOCs; /* Number of IOCs in queue. */ ++ u32 cIOReqs; /* Number of IO Requests in queue. */ ++ u32 hProcess; /* Process owning this channel. */ ++ /* ++ * Name of channel I/O completion event. Not required in Linux ++ */ ++ char szEventName[CHNL_MAXEVTNAMELEN + 1]; ++ } ; ++ ++/* Channel manager info: */ ++ struct CHNL_MGRINFO { ++ u32 dwType; /* Type of channel class library. */ ++ /* Channel handle, given the channel id. */ ++ struct CHNL_OBJECT *hChnl; ++ u32 cOpenChannels; /* Number of open channels. */ ++ u32 cChannels; /* total # of chnls supported */ ++ } ; ++ ++/* Channel Manager Attrs: */ ++ struct CHNL_MGRATTRS { ++ /* Max number of channels this manager can use. */ ++ u32 cChannels; ++ u32 uWordSize; /* DSP Word size. */ ++ } ; ++ ++#endif /* CHNLPRIV_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/clk.h b/arch/arm/plat-omap/include/dspbridge/clk.h +new file mode 100644 +index 0000000..4a23dab +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/clk.h +@@ -0,0 +1,155 @@ ++/* ++ * clk.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== clk.h ======== ++ * Purpose: Provides Clock functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 08-May-2007 rg: Moved all clock functions from sync module. ++ */ ++ ++#ifndef _CLK_H ++#define _CLK_H ++ ++ /* Generic TIMER object: */ ++ struct TIMER_OBJECT; ++ enum SERVICES_ClkId { ++ SERVICESCLK_iva2_ck = 0, ++ SERVICESCLK_mailbox_ick, ++ SERVICESCLK_gpt5_fck, ++ SERVICESCLK_gpt5_ick, ++ SERVICESCLK_gpt6_fck, ++ SERVICESCLK_gpt6_ick, ++ SERVICESCLK_gpt7_fck, ++ SERVICESCLK_gpt7_ick, ++ SERVICESCLK_gpt8_fck, ++ SERVICESCLK_gpt8_ick, ++ SERVICESCLK_wdt3_fck, ++ SERVICESCLK_wdt3_ick, ++ SERVICESCLK_mcbsp1_fck, ++ SERVICESCLK_mcbsp1_ick, ++ SERVICESCLK_mcbsp2_fck, ++ SERVICESCLK_mcbsp2_ick, ++ SERVICESCLK_mcbsp3_fck, ++ SERVICESCLK_mcbsp3_ick, ++ SERVICESCLK_mcbsp4_fck, ++ SERVICESCLK_mcbsp4_ick, ++ SERVICESCLK_mcbsp5_fck, ++ SERVICESCLK_mcbsp5_ick, ++ SERVICESCLK_ssi_fck, ++ SERVICESCLK_ssi_ick, ++ SERVICESCLK_sys_32k_ck, ++ SERVICESCLK_sys_ck, ++ SERVICESCLK_NOT_DEFINED ++ } ; ++ ++/* ++ * ======== CLK_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * CLK initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void CLK_Exit(void); ++ ++/* ++ * ======== CLK_Init ======== ++ * Purpose: ++ * Initializes private state of CLK module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * CLK initialized. ++ */ ++ extern bool CLK_Init(void); ++ ++ ++/* ++ * ======== CLK_Enable ======== ++ * Purpose: ++ * Enables the clock requested. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Error occured while enabling the clock. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CLK_Enable(IN enum SERVICES_ClkId clk_id); ++ ++/* ++ * ======== CLK_Disable ======== ++ * Purpose: ++ * Disables the clock requested. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Error occured while disabling the clock. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CLK_Disable(IN enum SERVICES_ClkId clk_id); ++ ++/* ++ * ======== CLK_GetRate ======== ++ * Purpose: ++ * Get the clock rate of requested clock. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Error occured while Getting the clock rate. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CLK_GetRate(IN enum SERVICES_ClkId clk_id, ++ u32 *speedMhz); ++/* ++ * ======== CLK_Set_32KHz ======== ++ * Purpose: ++ * Set the requested clock to 32KHz. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Error occured while setting the clock parent to 32KHz. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS CLK_Set_32KHz(IN enum SERVICES_ClkId clk_id); ++ extern void SSI_Clk_Prepare(bool FLAG); ++ ++/* ++ * ======== CLK_Get_RefCnt ======== ++ * Purpose: ++ * get the reference count for the clock. ++ * Parameters: ++ * Returns: ++ * s32: Reference Count for the clock. ++ * DSP_EFAIL: Error occured while getting the reference count of a clock. ++ * Requires: ++ * Ensures: ++ */ ++ extern s32 CLK_Get_UseCnt(IN enum SERVICES_ClkId clk_id); ++ ++#endif /* _SYNC_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/cmm.h b/arch/arm/plat-omap/include/dspbridge/cmm.h +new file mode 100644 +index 0000000..0df8b83 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/cmm.h +@@ -0,0 +1,420 @@ ++/* ++ * cmm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== cmm.h ======== ++ * Purpose: ++ * The Communication Memory Management(CMM) module provides shared memory ++ * management services for DSP/BIOS Bridge data streaming and messaging. ++ * Multiple shared memory segments can be registered with CMM. Memory is ++ * coelesced back to the appropriate pool when a buffer is freed. ++ * ++ * The CMM_Xlator[xxx] functions are used for node messaging and data ++ * streaming address translation to perform zero-copy inter-processor ++ * data transfer(GPP<->DSP). A "translator" object is created for a node or ++ * stream object that contains per thread virtual address information. This ++ * translator info is used at runtime to perform SM address translation ++ * to/from the DSP address space. ++ * ++ * ++ * Public Functions: ++ * CMM_CallocBuf ++ * CMM_Create ++ * CMM_Destroy ++ * CMM_Exit ++ * CMM_FreeBuf ++ * CMM_GetHandle ++ * CMM_GetInfo ++ * CMM_Init ++ * CMM_RegisterGPPSMSeg ++ * CMM_UnRegisterGPPSMSeg ++ * CMM_XlatorAllocBuf (Note #1 below) ++ * CMM_XlatorCreate " ++ * CMM_XlatorDelete " ++ * CMM_XlatorFreeBuf " ++ * CMM_XlatorTranslate " ++ * ++ * ++ * Notes: ++ * #1: Used by Node and Stream modules for SM address translation. ++ * ++ *! Revision History: ++ *! ================ ++ *! 30-Jan-2002 ag Removed unused CMM_Alloc[Free]Desc & CMM_XlatorRegisterPa. ++ *! Renamed CMM_AllocBuf() to CMM_CallocBuf(). ++ *! 29-Aug-2001 ag: Added dsp virt base and size to CMM_RegisterGPPSMSeg(). ++ *! 12-Aug-2001 ag: Added CMM_UnRegisterGPP[DSP}SMSeg[s](). ++ *! 05-Dec-2000 ag: Added param to CMM_XlatorDelete() to force buf cleanup. ++ *! 30-Oct-2000 ag: Added conversion factor to CMM_RegisterDSP[GPP]SMSeg(). ++ *! 12-Oct-2000 ag: Added CMM_Xlator[xxx] functions. ++ *! 10-Aug-2000 ag: Created. ++ *! ++ */ ++ ++#ifndef CMM_ ++#define CMM_ ++ ++#include <dspbridge/devdefs.h> ++ ++#include <dspbridge/cmmdefs.h> ++#include <dspbridge/host_os.h> ++ ++/* ++ * ======== CMM_CallocBuf ======== ++ * Purpose: ++ * Allocate memory buffers that can be used for data streaming or ++ * messaging. ++ * Parameters: ++ * hCmmMgr: Cmm Mgr handle. ++ * uSize: Number of bytes to allocate. ++ * pAttr: Attributes of memory to allocate. ++ * ppBufVA: Address of where to place VA. ++ * Returns: ++ * Pointer to a zero'd block of SM memory; ++ * NULL if memory couldn't be allocated, ++ * or if cBytes == 0, ++ * Requires: ++ * Valid hCmmMgr. ++ * CMM initialized. ++ * Ensures: ++ * The returned pointer, if not NULL, points to a valid memory block of ++ * the size requested. ++ * ++ */ ++ extern void *CMM_CallocBuf(struct CMM_OBJECT *hCmmMgr, ++ u32 uSize, struct CMM_ATTRS *pAttrs, ++ OUT void **ppBufVA); ++ ++/* ++ * ======== CMM_Create ======== ++ * Purpose: ++ * Create a communication memory manager object. ++ * Parameters: ++ * phCmmMgr: Location to store a communication manager handle on output. ++ * hDevObject: Handle to a device object. ++ * pMgrAttrs: Comm mem manager attributes. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * DSP_EFAIL: Failed to initialize critical sect sync object. ++ * ++ * Requires: ++ * CMM_Init(void) called. ++ * phCmmMgr != NULL. ++ * pMgrAttrs->ulMinBlockSize >= 4 bytes. ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_Create(OUT struct CMM_OBJECT **phCmmMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CMM_MGRATTRS *pMgrAttrs); ++ ++/* ++ * ======== CMM_Destroy ======== ++ * Purpose: ++ * Destroy the communication memory manager object. ++ * Parameters: ++ * hCmmMgr: Cmm Mgr handle. ++ * bForce: Force deallocation of all cmm memory immediately if set TRUE. ++ * If FALSE, and outstanding allocations will return DSP_EFAIL ++ * status. ++ * Returns: ++ * DSP_SOK: CMM object & resources deleted. ++ * DSP_EFAIL: Unable to free CMM object due to outstanding allocation. ++ * DSP_EHANDLE: Unable to free CMM due to bad handle. ++ * Requires: ++ * CMM is initialized. ++ * hCmmMgr != NULL. ++ * Ensures: ++ * Memory resources used by Cmm Mgr are freed. ++ */ ++ extern DSP_STATUS CMM_Destroy(struct CMM_OBJECT *hCmmMgr, bool bForce); ++ ++/* ++ * ======== CMM_Exit ======== ++ * Purpose: ++ * Discontinue usage of module. Cleanup CMM module if CMM cRef reaches zero. ++ * Parameters: ++ * n/a ++ * Returns: ++ * n/a ++ * Requires: ++ * CMM is initialized. ++ * Ensures: ++ */ ++ extern void CMM_Exit(void); ++ ++/* ++ * ======== CMM_FreeBuf ======== ++ * Purpose: ++ * Free the given buffer. ++ * Parameters: ++ * hCmmMgr: Cmm Mgr handle. ++ * pBuf: Pointer to memory allocated by CMM_CallocBuf(). ++ * ulSegId: SM segment Id used in CMM_Calloc() attrs. ++ * Set to 0 to use default segment. ++ * Returns: ++ * DSP_SOK ++ * DSP_EFAIL ++ * Requires: ++ * CMM initialized. ++ * pBufPA != NULL ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_FreeBuf(struct CMM_OBJECT *hCmmMgr, ++ void *pBufPA, u32 ulSegId); ++ ++/* ++ * ======== CMM_GetHandle ======== ++ * Purpose: ++ * Return the handle to the cmm mgr for the given device obj. ++ * Parameters: ++ * hProcessor: Handle to a Processor. ++ * phCmmMgr: Location to store the shared memory mgr handle on output. ++ * ++ * Returns: ++ * DSP_SOK: Cmm Mgr opaque handle returned. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * phCmmMgr != NULL ++ * hDevObject != NULL ++ * Ensures: ++ */ ++ extern DSP_STATUS CMM_GetHandle(DSP_HPROCESSOR hProcessor, ++ OUT struct CMM_OBJECT **phCmmMgr); ++ ++/* ++ * ======== CMM_GetInfo ======== ++ * Purpose: ++ * Return the current SM and VM utilization information. ++ * Parameters: ++ * hCmmMgr: Handle to a Cmm Mgr. ++ * pCmmInfo: Location to store the Cmm information on output. ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid handle. ++ * DSP_EINVALIDARG Invalid input argument. ++ * Requires: ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_GetInfo(struct CMM_OBJECT *hCmmMgr, ++ OUT struct CMM_INFO *pCmmInfo); ++ ++/* ++ * ======== CMM_Init ======== ++ * Purpose: ++ * Initializes private state of CMM module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * CMM initialized. ++ */ ++ extern bool CMM_Init(void); ++ ++/* ++ * ======== CMM_RegisterGPPSMSeg ======== ++ * Purpose: ++ * Register a block of SM with the CMM. ++ * Parameters: ++ * hCmmMgr: Handle to a Cmm Mgr. ++ * lpGPPBasePA: GPP Base Physical address. ++ * ulSize: Size in GPP bytes. ++ * dwDSPAddrOffset GPP PA to DSP PA Offset. ++ * cFactor: Add offset if CMM_ADDTODSPPA, sub if CMM_SUBFROMDSPPA. ++ * dwDSPBase: DSP virtual base byte address. ++ * ulDSPSize: Size of DSP segment in bytes. ++ * pulSegId: Address to store segment Id. ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hCmmMgr handle. ++ * DSP_EINVALIDARG: Invalid input argument. ++ * DSP_EFAIL: Unable to register. ++ * - On success *pulSegId is a valid SM segment ID. ++ * Requires: ++ * ulSize > 0 ++ * pulSegId != NULL ++ * dwGPPBasePA != 0 ++ * cFactor = CMM_ADDTODSPPA || cFactor = CMM_SUBFROMDSPPA ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_RegisterGPPSMSeg(struct CMM_OBJECT *hCmmMgr, ++ unsigned int dwGPPBasePA, ++ u32 ulSize, ++ u32 dwDSPAddrOffset, ++ enum CMM_CNVTTYPE cFactor, ++ unsigned int dwDSPBase, ++ u32 ulDSPSize, ++ u32 *pulSegId, ++ u32 dwGPPBaseBA); ++ ++/* ++ * ======== CMM_UnRegisterGPPSMSeg ======== ++ * Purpose: ++ * Unregister the given memory segment that was previously registered ++ * by CMM_RegisterGPPSMSeg. ++ * Parameters: ++ * hCmmMgr: Handle to a Cmm Mgr. ++ * ulSegId Segment identifier returned by CMM_RegisterGPPSMSeg. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid handle. ++ * DSP_EINVALIDARG: Invalid ulSegId. ++ * DSP_EFAIL: Unable to unregister for unknown reason. ++ * Requires: ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_UnRegisterGPPSMSeg(struct CMM_OBJECT *hCmmMgr, ++ u32 ulSegId); ++ ++/* ++ * ======== CMM_XlatorAllocBuf ======== ++ * Purpose: ++ * Allocate the specified SM buffer and create a local memory descriptor. ++ * Place on the descriptor on the translator's HaQ (Host Alloc'd Queue). ++ * Parameters: ++ * hXlator: Handle to a Xlator object. ++ * pVaBuf: Virtual address ptr(client context) ++ * uPaSize: Size of SM memory to allocate. ++ * Returns: ++ * Ptr to valid physical address(Pa) of uPaSize bytes, NULL if failed. ++ * Requires: ++ * pVaBuf != 0. ++ * uPaSize != 0. ++ * Ensures: ++ * ++ */ ++ extern void *CMM_XlatorAllocBuf(struct CMM_XLATOROBJECT *hXlator, ++ void *pVaBuf, u32 uPaSize); ++ ++/* ++ * ======== CMM_XlatorCreate ======== ++ * Purpose: ++ * Create a translator(xlator) object used for process specific Va<->Pa ++ * address translation. Node messaging and streams use this to perform ++ * inter-processor(GPP<->DSP) zero-copy data transfer. ++ * Parameters: ++ * phXlator: Address to place handle to a new Xlator handle. ++ * hCmmMgr: Handle to Cmm Mgr associated with this translator. ++ * pXlatorAttrs: Translator attributes used for the client NODE or STREAM. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EINVALIDARG: Bad input Attrs. ++ * DSP_EMEMORY: Insufficient memory(local) for requested resources. ++ * Requires: ++ * phXlator != NULL ++ * hCmmMgr != NULL ++ * pXlatorAttrs != NULL ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_XlatorCreate(OUT struct CMM_XLATOROBJECT **phXlator, ++ struct CMM_OBJECT *hCmmMgr, ++ struct CMM_XLATORATTRS *pXlatorAttrs); ++ ++/* ++ * ======== CMM_XlatorDelete ======== ++ * Purpose: ++ * Delete translator resources ++ * Parameters: ++ * hXlator: handle to translator. ++ * bForce: bForce = TRUE will free XLators SM buffers/dscriptrs. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Bad translator handle. ++ * DSP_EFAIL: Unable to free translator resources. ++ * Requires: ++ * cRefs > 0 ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_XlatorDelete(struct CMM_XLATOROBJECT *hXlator, ++ bool bForce); ++ ++/* ++ * ======== CMM_XlatorFreeBuf ======== ++ * Purpose: ++ * Free SM buffer and descriptor. ++ * Does not free client process VM. ++ * Parameters: ++ * hXlator: handle to translator. ++ * pBufVa Virtual address of PA to free. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Bad translator handle. ++ * Requires: ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_XlatorFreeBuf(struct CMM_XLATOROBJECT *hXlator, ++ void *pBufVa); ++ ++/* ++ * ======== CMM_XlatorInfo ======== ++ * Purpose: ++ * Set/Get process specific "translator" address info. ++ * This is used to perform fast virtaul address translation ++ * for shared memory buffers between the GPP and DSP. ++ * Parameters: ++ * hXlator: handle to translator. ++ * pAddr: Virtual base address of segment. ++ * ulSize: Size in bytes. ++ * uSegId: Segment identifier of SM segment(s) ++ * bSetInfo Set xlator fields if TRUE, else return base addr ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Bad translator handle. ++ * Requires: ++ * (cRefs > 0) ++ * (pAddr != NULL) ++ * (ulSize > 0) ++ * Ensures: ++ * ++ */ ++ extern DSP_STATUS CMM_XlatorInfo(struct CMM_XLATOROBJECT *hXlator, ++ IN OUT u8 **pAddr, ++ u32 ulSize, u32 uSegId, ++ bool bSetInfo); ++ ++/* ++ * ======== CMM_XlatorTranslate ======== ++ * Purpose: ++ * Perform address translation VA<->PA for the specified stream or ++ * message shared memory buffer. ++ * Parameters: ++ * hXlator: handle to translator. ++ * pAddr address of buffer to translate. ++ * xType Type of address xlation. CMM_PA2VA or CMM_VA2PA. ++ * Returns: ++ * Valid address on success, else NULL. ++ * Requires: ++ * cRefs > 0 ++ * pAddr != NULL ++ * xType >= CMM_VA2PA) && (xType <= CMM_DSPPA2PA) ++ * Ensures: ++ * ++ */ ++ extern void *CMM_XlatorTranslate(struct CMM_XLATOROBJECT *hXlator, ++ void *pAddr, enum CMM_XLATETYPE xType); ++ ++#endif /* CMM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/cmmdefs.h b/arch/arm/plat-omap/include/dspbridge/cmmdefs.h +new file mode 100644 +index 0000000..a779377 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/cmmdefs.h +@@ -0,0 +1,135 @@ ++/* ++ * cmmdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cmmdefs.h ======== ++ * Purpose: ++ * Global MEM constants and types. ++ * ++ *! Revision History: ++ *! ================ ++ *! 12-Nov-2001 ag CMM_KERNMAPTYPE added for dsp<->device process addr map'n. ++ *! This allows addr conversion from drvr process <-> DSP addr. ++ *! 29-Aug-2001 ag Added CMM_ALLSEGMENTS. ++ *! 08-Dec-2000 ag Added bus address conversion type CMM_POMAPEMIF2DSPBUS. ++ *! 05-Dec-2000 ag Added default CMM_DEFLTCONVFACTOR & CMM_DEFLTDSPADDROFFSET. ++ *! 29-Oct-2000 ag Added converstion factor for GPP DSP Pa translation. ++ *! 15-Oct-2000 ag Added address translator attributes and defaults. ++ *! 12-Jul-2000 ag Created. ++ */ ++ ++#ifndef CMMDEFS_ ++#define CMMDEFS_ ++ ++#include <dspbridge/list.h> ++ ++/* Cmm attributes used in CMM_Create() */ ++ struct CMM_MGRATTRS { ++ /* Minimum SM allocation; default 32 bytes. */ ++ u32 ulMinBlockSize; ++ } ; ++ ++/* Attributes for CMM_AllocBuf() & CMM_AllocDesc() */ ++ struct CMM_ATTRS { ++ u32 ulSegId; /* 1,2... are SM segments. 0 is not. */ ++ u32 ulAlignment; /* 0,1,2,4....ulMinBlockSize */ ++ } ; ++ ++/* ++ * DSPPa to GPPPa Conversion Factor. ++ * ++ * For typical platforms: ++ * converted Address = PaDSP + ( cFactor * addressToConvert). ++ */ ++ enum CMM_CNVTTYPE { ++ CMM_SUBFROMDSPPA = -1, ++ /* PreOMAP is special case: not simple offset */ ++ CMM_POMAPEMIF2DSPBUS = 0, ++ CMM_ADDTODSPPA = 1 ++ } ; ++ ++#define CMM_DEFLTDSPADDROFFSET 0 ++#define CMM_DEFLTCONVFACTOR CMM_POMAPEMIF2DSPBUS /* PreOMAP DSPBUS<->EMIF */ ++#define CMM_ALLSEGMENTS 0xFFFFFF /* All SegIds */ ++#define CMM_MAXGPPSEGS 1 /* Maximum # of SM segs */ ++ ++/* ++ * SMSEGs are SM segments the DSP allocates from. ++ * ++ * This info is used by the GPP to xlate DSP allocated PAs. ++ */ ++ ++ struct CMM_SEGINFO { ++ u32 dwSegBasePa; /* Start Phys address of SM segment */ ++ /* Total size in bytes of segment: DSP+GPP */ ++ u32 ulTotalSegSize; ++ u32 dwGPPBasePA; /* Start Phys addr of Gpp SM seg */ ++ u32 ulGPPSize; /* Size of Gpp SM seg in bytes */ ++ u32 dwDSPBaseVA; /* DSP virt base byte address */ ++ u32 ulDSPSize; /* DSP seg size in bytes */ ++ /* # of current GPP allocations from this segment */ ++ u32 ulInUseCnt; ++ u32 dwSegBaseVa; /* Start Virt address of SM seg */ ++ ++ } ; ++ ++/* CMM useful information */ ++ struct CMM_INFO { ++ /* # of SM segments registered with this Cmm. */ ++ u32 ulNumGPPSMSegs; ++ /* Total # of allocations outstanding for CMM */ ++ u32 ulTotalInUseCnt; ++ /* Min SM block size allocation from CMM_Create() */ ++ u32 ulMinBlockSize; ++ /* Info per registered SM segment. */ ++ struct CMM_SEGINFO segInfo[CMM_MAXGPPSEGS]; ++ } ; ++ ++/* XlatorCreate attributes */ ++ struct CMM_XLATORATTRS { ++ u32 ulSegId; /* segment Id used for SM allocations */ ++ u32 dwDSPBufs; /* # of DSP-side bufs */ ++ u32 dwDSPBufSize; /* size of DSP-side bufs in GPP bytes */ ++ /* Vm base address alloc'd in client process context */ ++ void *pVmBase; ++ /* dwVmSize must be >= (dwMaxNumBufs * dwMaxSize) */ ++ u32 dwVmSize; ++ } ; ++ ++/* ++ * Cmm translation types. Use to map SM addresses to process context. ++ */ ++ enum CMM_XLATETYPE { ++ CMM_VA2PA = 0, /* Virtual to GPP physical address xlation */ ++ CMM_PA2VA = 1, /* GPP Physical to virtual */ ++ CMM_VA2DSPPA = 2, /* Va to DSP Pa */ ++ CMM_PA2DSPPA = 3, /* GPP Pa to DSP Pa */ ++ CMM_DSPPA2PA = 4, /* DSP Pa to GPP Pa */ ++ } ; ++ ++/* ++ * Used to "map" between device process virt addr and dsp addr. ++ */ ++ enum CMM_KERNMAPTYPE { ++ CMM_KERNVA2DSP = 0, /* Device process context to dsp address. */ ++ CMM_DSP2KERNVA = 1, /* Dsp address to device process context. */ ++ } ; ++ ++ struct CMM_OBJECT; ++ struct CMM_XLATOROBJECT; ++ ++#endif /* CMMDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/cod.h b/arch/arm/plat-omap/include/dspbridge/cod.h +new file mode 100644 +index 0000000..a8a12c6 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/cod.h +@@ -0,0 +1,433 @@ ++/* ++ * cod.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cod.h ======== ++ * Description: ++ * Code management module for DSPs. This module provides an interface ++ * interface for loading both static and dynamic code objects onto DSP ++ * systems. ++ * ++ * Public Functions: ++ * COD_Close ++ * COD_Create ++ * COD_Delete ++ * COD_Exit ++ * COD_GetBaseLib ++ * COD_GetBaseName ++ * COD_GetLoader ++ * COD_GetSection ++ * COD_GetSymValue ++ * COD_Init ++ * COD_LoadBase ++ * COD_Open ++ * COD_OpenBase ++ * COD_ReadSection ++ * COD_UnloadSection ++ * ++ * Note: ++ * Currently, only static loading is supported. ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Apr-2003 map: Changed DBL to DBLL ++ *! 07-Aug-2002 jeh: Added COD_GetBaseName(). ++ *! 17-Jul-2002 jeh: Added COD_Open(), COD_Close(). ++ *! 15-Mar-2002 jeh: Added DBL_Flags param to COD_OpenBase(). ++ *! 19-Oct-2001 jeh: Added COD_GetBaseLib, COD_GetLoader, (left in ++ *! COD_LoadSection(), COD_UnloadSection(), since they ++ *! may be needed for BridgeLite). ++ *! 07-Sep-2001 jeh: Added COD_LoadSection(), COD_UnloadSection(). ++ *! 11-Jan-2001 jeh: Added COD_OpenBase. ++ *! 29-Sep-2000 kc: Added size param to COD_ReadSection for input buffer ++ *! validation. ++ *! 02-Aug-2000 kc: Added COD_ReadSection. ++ *! 04-Sep-1997 gp: Added CDECL identifier to COD_WRITEFXN (for NT).. ++ *! 18-Aug-1997 cr: Added explicit CDECL identifier. ++ *! 28-Oct-1996 gp: Added COD_GetSection. ++ *! 30-Jul-1996 gp: Added envp[] argument to COD_LoadBase(). ++ *! 12-Jun-1996 gp: Moved OUT param first in _Create(). Updated _Create() ++ *! call to take a ZLFileName. Moved COD_ processor types ++ *! to CFG. ++ *! 29-May-1996 gp: Changed WCD_STATUS to DSP_STATUS. Removed include's. ++ *! 07-May-1996 mg: Created. ++ * ++ */ ++ ++#ifndef COD_ ++#define COD_ ++ ++#include <dspbridge/dblldefs.h> ++ ++#define COD_MAXPATHLENGTH 255 ++#define COD_TRACEBEG "SYS_PUTCBEG" ++#define COD_TRACEEND "SYS_PUTCEND" ++#define COD_TRACESECT "trace" ++#define COD_TRACEBEGOLD "PUTCBEG" ++#define COD_TRACEENDOLD "PUTCEND" ++ ++#define COD_NOLOAD DBLL_NOLOAD ++#define COD_SYMB DBLL_SYMB ++ ++/* Flags passed to COD_Open */ ++ typedef DBLL_Flags COD_FLAGS; ++ ++/* COD code manager handle */ ++ struct COD_MANAGER; ++ ++/* COD library handle */ ++ struct COD_LIBRARYOBJ; ++ ++/* COD attributes */ ++ struct COD_ATTRS { ++ u32 ulReserved; ++ } ; ++ ++/* ++ * Function prototypes for writing memory to a DSP system, allocating ++ * and freeing DSP memory. ++ */ ++ typedef u32(*COD_WRITEFXN) (void *pPrivRef, u32 ulDspAddr, ++ void *pBuf, u32 ulNumBytes, ++ u32 nMemSpace); ++ ++ ++/* ++ * ======== COD_Close ======== ++ * Purpose: ++ * Close a library opened with COD_Open(). ++ * Parameters: ++ * lib - Library handle returned by COD_Open(). ++ * Returns: ++ * None. ++ * Requires: ++ * COD module initialized. ++ * valid lib. ++ * Ensures: ++ * ++ */ ++ extern void COD_Close(struct COD_LIBRARYOBJ *lib); ++ ++/* ++ * ======== COD_Create ======== ++ * Purpose: ++ * Create an object to manage code on a DSP system. This object can be ++ * used to load an initial program image with arguments that can later ++ * be expanded with dynamically loaded object files. ++ * Symbol table information is managed by this object and can be retrieved ++ * using the COD_GetSymValue() function. ++ * Parameters: ++ * phManager: created manager object ++ * pstrZLFile: ZL DLL filename, of length < COD_MAXPATHLENGTH. ++ * attrs: attributes to be used by this object. A NULL value ++ * will cause default attrs to be used. ++ * Returns: ++ * DSP_SOK: Success. ++ * COD_E_NOZLFUNCTIONS: Could not initialize ZL functions. ++ * COD_E_ZLCREATEFAILED: ZL_Create failed. ++ * DSP_ENOTIMPL: attrs was not NULL. We don't yet support ++ * non default values of attrs. ++ * Requires: ++ * COD module initialized. ++ * pstrZLFile != NULL ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_Create(OUT struct COD_MANAGER **phManager, ++ char *pstrZLFile, ++ IN OPTIONAL CONST struct COD_ATTRS *attrs); ++ ++/* ++ * ======== COD_Delete ======== ++ * Purpose: ++ * Delete a code manager object. ++ * Parameters: ++ * hManager: handle of manager to be deleted ++ * Returns: ++ * None. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * Ensures: ++ */ ++ extern void COD_Delete(struct COD_MANAGER *hManager); ++ ++/* ++ * ======== COD_Exit ======== ++ * Purpose: ++ * Discontinue usage of the COD module. ++ * Parameters: ++ * None. ++ * Returns: ++ * None. ++ * Requires: ++ * COD initialized. ++ * Ensures: ++ * Resources acquired in COD_Init(void) are freed. ++ */ ++ extern void COD_Exit(void); ++ ++/* ++ * ======== COD_GetBaseLib ======== ++ * Purpose: ++ * Get handle to the base image DBL library. ++ * Parameters: ++ * hManager: handle of manager to be deleted ++ * plib: location to store library handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * plib != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_GetBaseLib(struct COD_MANAGER *hManager, ++ struct DBLL_LibraryObj **plib); ++ ++/* ++ * ======== COD_GetBaseName ======== ++ * Purpose: ++ * Get the name of the base image DBL library. ++ * Parameters: ++ * hManager: handle of manager to be deleted ++ * pszName: location to store library name on output. ++ * uSize: size of name buffer. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Buffer too small. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * pszName != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_GetBaseName(struct COD_MANAGER *hManager, ++ char *pszName, u32 uSize); ++ ++/* ++ * ======== COD_GetEntry ======== ++ * Purpose: ++ * Retrieve the entry point of a loaded DSP program image ++ * Parameters: ++ * hManager: handle of manager to be deleted ++ * pulEntry: pointer to location for entry point ++ * Returns: ++ * DSP_SOK: Success. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * pulEntry != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_GetEntry(struct COD_MANAGER *hManager, ++ u32 *pulEntry); ++ ++/* ++ * ======== COD_GetLoader ======== ++ * Purpose: ++ * Get handle to the DBL loader. ++ * Parameters: ++ * hManager: handle of manager to be deleted ++ * phLoader: location to store loader handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * phLoader != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_GetLoader(struct COD_MANAGER *hManager, ++ struct DBLL_TarObj **phLoader); ++ ++/* ++ * ======== COD_GetSection ======== ++ * Purpose: ++ * Retrieve the starting address and length of a section in the COFF file ++ * given the section name. ++ * Parameters: ++ * lib Library handle returned from COD_Open(). ++ * pstrSect: name of the section, with or without leading "." ++ * puAddr: Location to store address. ++ * puLen: Location to store length. ++ * Returns: ++ * DSP_SOK: Success ++ * COD_E_NOSYMBOLSLOADED: Symbols have not been loaded onto the board. ++ * COD_E_SYMBOLNOTFOUND: The symbol could not be found. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * pstrSect != NULL; ++ * puAddr != NULL; ++ * puLen != NULL; ++ * Ensures: ++ * DSP_SOK: *puAddr and *puLen contain the address and length of the ++ * section. ++ * else: *puAddr == 0 and *puLen == 0; ++ * ++ */ ++ extern DSP_STATUS COD_GetSection(struct COD_LIBRARYOBJ *lib, ++ IN char *pstrSect, ++ OUT u32 *puAddr, ++ OUT u32 *puLen); ++ ++/* ++ * ======== COD_GetSymValue ======== ++ * Purpose: ++ * Retrieve the value for the specified symbol. The symbol is first ++ * searched for literally and then, if not found, searched for as a ++ * C symbol. ++ * Parameters: ++ * lib: library handle returned from COD_Open(). ++ * pstrSymbol: name of the symbol ++ * value: value of the symbol ++ * Returns: ++ * DSP_SOK: Success. ++ * COD_E_NOSYMBOLSLOADED: Symbols have not been loaded onto the board. ++ * COD_E_SYMBOLNOTFOUND: The symbol could not be found. ++ * Requires: ++ * COD module initialized. ++ * Valid hManager. ++ * pstrSym != NULL. ++ * pulValue != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_GetSymValue(struct COD_MANAGER *hManager, ++ IN char *pstrSym, ++ OUT u32 *pulValue); ++ ++/* ++ * ======== COD_Init ======== ++ * Purpose: ++ * Initialize the COD module's private state. ++ * Parameters: ++ * None. ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public COD functions. ++ */ ++ extern bool COD_Init(void); ++ ++/* ++ * ======== COD_LoadBase ======== ++ * Purpose: ++ * Load the initial program image, optionally with command-line arguments, ++ * on the DSP system managed by the supplied handle. The program to be ++ * loaded must be the first element of the args array and must be a fully ++ * qualified pathname. ++ * Parameters: ++ * hMgr: manager to load the code with ++ * nArgc: number of arguments in the args array ++ * args: array of strings for arguments to DSP program ++ * writeFxn: board-specific function to write data to DSP system ++ * pArb: arbitrary pointer to be passed as first arg to writeFxn ++ * envp: array of environment strings for DSP exec. ++ * Returns: ++ * DSP_SOK: Success. ++ * COD_E_OPENFAILED: Failed to open target code. ++ * COD_E_LOADFAILED: Failed to load code onto target. ++ * Requires: ++ * COD module initialized. ++ * hMgr is valid. ++ * nArgc > 0. ++ * aArgs != NULL. ++ * aArgs[0] != NULL. ++ * pfnWrite != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_LoadBase(struct COD_MANAGER *hManager, ++ u32 nArgc, char *aArgs[], ++ COD_WRITEFXN pfnWrite, void *pArb, ++ char *envp[]); ++ ++ ++/* ++ * ======== COD_Open ======== ++ * Purpose: ++ * Open a library for reading sections. Does not load or set the base. ++ * Parameters: ++ * hMgr: manager to load the code with ++ * pszCoffPath: Coff file to open. ++ * flags: COD_NOLOAD (don't load symbols) or COD_SYMB (load ++ * symbols). ++ * pLib: Handle returned that can be used in calls to COD_Close ++ * and COD_GetSection. ++ * Returns: ++ * S_OK: Success. ++ * COD_E_OPENFAILED: Failed to open target code. ++ * Requires: ++ * COD module initialized. ++ * hMgr is valid. ++ * flags == COD_NOLOAD || flags == COD_SYMB. ++ * pszCoffPath != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS COD_Open(struct COD_MANAGER *hMgr, ++ IN char *pszCoffPath, ++ COD_FLAGS flags, ++ OUT struct COD_LIBRARYOBJ **pLib); ++ ++/* ++ * ======== COD_OpenBase ======== ++ * Purpose: ++ * Open base image for reading sections. Does not load the base. ++ * Parameters: ++ * hMgr: manager to load the code with ++ * pszCoffPath: Coff file to open. ++ * flags: Specifies whether to load symbols. ++ * Returns: ++ * DSP_SOK: Success. ++ * COD_E_OPENFAILED: Failed to open target code. ++ * Requires: ++ * COD module initialized. ++ * hMgr is valid. ++ * pszCoffPath != NULL. ++ * Ensures: ++ */ ++extern DSP_STATUS COD_OpenBase(struct COD_MANAGER *hMgr, IN char *pszCoffPath, ++ DBLL_Flags flags); ++ ++/* ++ * ======== COD_ReadSection ======== ++ * Purpose: ++ * Retrieve the content of a code section given the section name. ++ * Parameters: ++ * hManager - manager in which to search for the symbol ++ * pstrSect - name of the section, with or without leading "." ++ * pstrContent - buffer to store content of the section. ++ * Returns: ++ * DSP_SOK: on success, error code on failure ++ * COD_E_NOSYMBOLSLOADED: Symbols have not been loaded onto the board. ++ * COD_E_READFAILED: Failed to read content of code section. ++ * Requires: ++ * COD module initialized. ++ * valid hManager. ++ * pstrSect != NULL; ++ * pstrContent != NULL; ++ * Ensures: ++ * DSP_SOK: *pstrContent stores the content of the named section. ++ */ ++ extern DSP_STATUS COD_ReadSection(struct COD_LIBRARYOBJ *lib, ++ IN char *pstrSect, ++ OUT char *pstrContent, ++ IN u32 cContentSize); ++ ++ ++ ++#endif /* COD_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/csl.h b/arch/arm/plat-omap/include/dspbridge/csl.h +new file mode 100644 +index 0000000..b90d6ff +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/csl.h +@@ -0,0 +1,135 @@ ++/* ++ * csl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== csl.h ======== ++ * Purpose: ++ * Platform independent C Standard library functions. ++ * ++ * Public Functions: ++ * CSL_AnsiToWchar ++ * CSL_ByteSwap ++ * CSL_Exit ++ * CSL_Init ++ * CSL_NumToAscii ++ * CSL_Strtok ++ * CSL_Strtokr ++ * CSL_WcharToAnsi ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Aug-2002 jeh: Added CSL_Strtokr(). ++ *! 21-Sep-2001 jeh: Added CSL_Strncmp. ++ *! 22-Nov-2000 map: Added CSL_Atoi and CSL_Strtok ++ *! 19-Nov-2000 kc: Added CSL_ByteSwap(). ++ *! 09-Nov-2000 kc: Added CSL_Strncat. ++ *! 29-Oct-1999 kc: Added CSL_Wstrlen(). ++ *! 20-Sep-1999 ag: Added CSL_Wchar2Ansi(). ++ *! 19-Jan-1998 cr: Code review cleanup (mostly documentation fixes). ++ *! 29-Dec-1997 cr: Changed CSL_lowercase to CSL_Uppercase, added ++ *! CSL_AnsiToWchar. ++ *! 30-Sep-1997 cr: Added explicit cdecl descriptors to fxn definitions. ++ *! 25-Jun-1997 cr: Added CSL_strcmp. ++ *! 12-Jun-1996 gp: Created. ++ */ ++ ++#ifndef CSL_ ++#define CSL_ ++ ++#include <dspbridge/host_os.h> ++ ++/* ++ * ======== CSL_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CSL module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * CSL initialized. ++ * Ensures: ++ * Resources acquired in CSL_Init(void) are freed. ++ */ ++ extern void CSL_Exit(void); ++ ++/* ++ * ======== CSL_Init ======== ++ * Purpose: ++ * Initialize the CSL module's private state. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public CSL functions. ++ */ ++ extern bool CSL_Init(void); ++ ++/* ++ * ======== CSL_NumToAscii ======== ++ * Purpose: ++ * Convert a 1 or 2 digit number to a 2 digit string. ++ * Parameters: ++ * pstrNumber: Buffer to store converted string. ++ * dwNum: Number to convert. ++ * Returns: ++ * Requires: ++ * pstrNumber must be able to hold at least three characters. ++ * Ensures: ++ * pstrNumber will be null terminated. ++ */ ++ extern void CSL_NumToAscii(OUT char *pstrNumber, IN u32 dwNum); ++ ++ ++/* ++ * ======== CSL_Strtok ======== ++ * Purpose: ++ * Tokenize a NULL terminated string ++ * Parameters: ++ * ptstrSrc: pointer to string. ++ * szSeparators: pointer to a string of seperators ++ * Returns: ++ * char * ++ * Requires: ++ * CSL initialized. ++ * ptstrSrc is a valid string pointer. ++ * szSeparators is a valid string pointer. ++ * Ensures: ++ */ ++ extern char *CSL_Strtok(IN char *ptstrSrc, ++ IN CONST char *szSeparators); ++ ++/* ++ * ======== CSL_Strtokr ======== ++ * Purpose: ++ * Re-entrant version of strtok. ++ * Parameters: ++ * pstrSrc: Pointer to string. May be NULL on subsequent calls. ++ * szSeparators: Pointer to a string of seperators ++ * ppstrCur: Location to store start of string for next call to ++ * to CSL_Strtokr. ++ * Returns: ++ * char * (the token) ++ * Requires: ++ * CSL initialized. ++ * szSeparators != NULL ++ * ppstrCur != NULL ++ * Ensures: ++ */ ++ extern char *CSL_Strtokr(IN char *pstrSrc, ++ IN CONST char *szSeparators, ++ OUT char **ppstrCur); ++ ++#endif /* CSL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbc.h b/arch/arm/plat-omap/include/dspbridge/dbc.h +new file mode 100644 +index 0000000..0e6a67d +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbc.h +@@ -0,0 +1,66 @@ ++/* ++ * dbc.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbc.h ======== ++ * Purpose: ++ * "Design by Contract" programming macros. ++ * ++ * Public Functions: ++ * DBC_Assert ++ * DBC_Require ++ * DBC_Ensure ++ * ++ * Notes: ++ * Requires that the GT->ERROR function has been defaulted to a valid ++ * error handler for the given execution environment. ++ * ++ * Does not require that GT_init() be called. ++ * ++ *! Revision History: ++ *! ================ ++ *! 11-Aug-2000 ag: Removed include <dspbridge/std.h> ++ *! 22-Apr-1996 gp: Created. ++ */ ++ ++#ifndef DBC_ ++#define DBC_ ++ ++#ifndef GT_TRACE ++#define GT_TRACE 0 /* 0 = "trace compiled out"; 1 = "trace active" */ ++#endif ++ ++/* Assertion Macros: */ ++#if GT_TRACE ++ ++#include <dspbridge/gt.h> ++ ++#define DBC_Assert(exp) \ ++ if (!(exp)) \ ++ printk("%s, line %d: Assertion (" #exp ") failed.\n", \ ++ __FILE__, __LINE__) ++#define DBC_Require DBC_Assert /* Function Precondition. */ ++#define DBC_Ensure DBC_Assert /* Function Postcondition. */ ++ ++#else ++ ++#define DBC_Assert(exp) ++#define DBC_Require(exp) ++#define DBC_Ensure(exp) ++ ++#endif /* DEBUG */ ++ ++#endif /* DBC_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbdcd.h b/arch/arm/plat-omap/include/dspbridge/dbdcd.h +new file mode 100644 +index 0000000..fbc3870 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbdcd.h +@@ -0,0 +1,388 @@ ++/* ++ * dbdcd.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbdcd.h ======== ++ * Description: ++ * Defines the DSP/BIOS Bridge Configuration Database (DCD) API. ++ * ++ *! Revision History ++ *! ================ ++ *! 03-Dec-2003 map Changed DCD_OBJTYPE to DSP_DCDOBJTYPE ++ *! 24-Feb-2003 kc Updated DCD_AutoUnregister and DCD_GetObjects to simplify ++ *! DCD implementation. ++ *! 05-Aug-2002 jeh Added DCD_GetObjects(). ++ *! 11-Jul-2002 jeh Added DCD_GetDepLibs(), DCD_GetNumDepLibs(). ++ *! 22-Apr-2002 jeh Added DCD_GetLibraryName(). ++ *! 03-Apr-2001 sg Changed error names to have DCD_E* format. ++ *! 13-Feb-2001 kc Name changed from dcdbs.h to dbdcd.h. ++ *! 12-Dec-2000 kc Added DCD_AutoUnregister. ++ *! 09-Nov-2000 kc Updated usage of DCD_EnumerateObject. ++ *! 30-Oct-2000 kc Added DCD_AutoRegister. Updated error DCD error codes. ++ *! 29-Sep-2000 kc Incorporated code review comments. See ++ *! /src/reviews/dcd_review.txt. ++ *! 26-Jul-2000 kc Created. ++ *! ++ */ ++ ++#ifndef DBDCD_ ++#define DBDCD_ ++ ++#include <dspbridge/dbdcddef.h> ++#include <dspbridge/host_os.h> ++#include <dspbridge/nldrdefs.h> ++ ++/* ++ * ======== DCD_AutoRegister ======== ++ * Purpose: ++ * This function automatically registers DCD objects specified in a ++ * special COFF section called ".dcd_register" ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pszCoffPath: Pointer to name of COFF file containing DCD ++ * objects to be registered. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EDCDNOAUTOREGISTER: Unable to find auto-registration section. ++ * DSP_EDCDREADSECT: Unable to read object code section. ++ * DSP_EDCDLOADBASE: Unable to load code base. ++ * DSP_EHANDLE: Invalid DCD_HMANAGER handle.. ++ * Requires: ++ * DCD initialized. ++ * Ensures: ++ * Note: ++ * Due to the DCD database construction, it is essential for a DCD-enabled ++ * COFF file to contain the right COFF sections, especially ++ * ".dcd_register", which is used for auto registration. ++ */ ++ extern DSP_STATUS DCD_AutoRegister(IN struct DCD_MANAGER *hDcdMgr, ++ IN char *pszCoffPath); ++ ++/* ++ * ======== DCD_AutoUnregister ======== ++ * Purpose: ++ * This function automatically unregisters DCD objects specified in a ++ * special COFF section called ".dcd_register" ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pszCoffPath: Pointer to name of COFF file containing ++ * DCD objects to be unregistered. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EDCDNOAUTOREGISTER: Unable to find auto-registration section. ++ * DSP_EDCDREADSECT: Unable to read object code section. ++ * DSP_EDCDLOADBASE: Unable to load code base. ++ * DSP_EHANDLE: Invalid DCD_HMANAGER handle.. ++ * Requires: ++ * DCD initialized. ++ * Ensures: ++ * Note: ++ * Due to the DCD database construction, it is essential for a DCD-enabled ++ * COFF file to contain the right COFF sections, especially ++ * ".dcd_register", which is used for auto unregistration. ++ */ ++ extern DSP_STATUS DCD_AutoUnregister(IN struct DCD_MANAGER *hDcdMgr, ++ IN char *pszCoffPath); ++ ++/* ++ * ======== DCD_CreateManager ======== ++ * Purpose: ++ * This function creates a DCD module manager. ++ * Parameters: ++ * pszZlDllName: Pointer to a DLL name string. ++ * phDcdMgr: A pointer to a DCD manager handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Unable to allocate memory for DCD manager handle. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * DCD initialized. ++ * pszZlDllName is non-NULL. ++ * phDcdMgr is non-NULL. ++ * Ensures: ++ * A DCD manager handle is created. ++ */ ++ extern DSP_STATUS DCD_CreateManager(IN char *pszZlDllName, ++ OUT struct DCD_MANAGER **phDcdMgr); ++ ++/* ++ * ======== DCD_DestroyManager ======== ++ * Purpose: ++ * This function destroys a DCD module manager. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid DCD manager handle. ++ * Requires: ++ * DCD initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_DestroyManager(IN struct DCD_MANAGER *hDcdMgr); ++ ++/* ++ * ======== DCD_EnumerateObject ======== ++ * Purpose: ++ * This function enumerates currently visible DSP/BIOS Bridge objects ++ * and returns the UUID and type of each enumerated object. ++ * Parameters: ++ * cIndex: The object enumeration index. ++ * objType: Type of object to enumerate. ++ * pUuid: Pointer to a DSP_UUID object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Unable to enumerate through the DCD database. ++ * DSP_SENUMCOMPLETE: Enumeration completed. This is not an error code. ++ * Requires: ++ * DCD initialized. ++ * pUuid is a valid pointer. ++ * Ensures: ++ * Details: ++ * This function can be used in conjunction with DCD_GetObjectDef to ++ * retrieve object properties. ++ */ ++ extern DSP_STATUS DCD_EnumerateObject(IN s32 cIndex, ++ IN enum DSP_DCDOBJTYPE objType, ++ OUT struct DSP_UUID *pUuid); ++ ++/* ++ * ======== DCD_Exit ======== ++ * Purpose: ++ * This function cleans up the DCD module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * DCD initialized. ++ * Ensures: ++ */ ++ extern void DCD_Exit(void); ++ ++/* ++ * ======== DCD_GetDepLibs ======== ++ * Purpose: ++ * Given the uuid of a library and size of array of uuids, this function ++ * fills the array with the uuids of all dependent libraries of the input ++ * library. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pUuid: Pointer to a DSP_UUID for a library. ++ * numLibs: Size of uuid array (number of library uuids). ++ * pDepLibUuids: Array of dependent library uuids to be filled in. ++ * pPersistentDepLibs: Array indicating if corresponding lib is persistent. ++ * phase: phase to obtain correct input library ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EDCDREADSECT: Failure to read section containing library info. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * DCD initialized. ++ * Valid hDcdMgr. ++ * pUuid != NULL ++ * pDepLibUuids != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_GetDepLibs(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ u16 numLibs, ++ OUT struct DSP_UUID *pDepLibUuids, ++ OUT bool *pPersistentDepLibs, ++ IN enum NLDR_PHASE phase); ++ ++/* ++ * ======== DCD_GetNumDepLibs ======== ++ * Purpose: ++ * Given the uuid of a library, determine its number of dependent ++ * libraries. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pUuid: Pointer to a DSP_UUID for a library. ++ * pNumLibs: Size of uuid array (number of library uuids). ++ * pNumPersLibs: number of persistent dependent library. ++ * phase: Phase to obtain correct input library ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EDCDREADSECT: Failure to read section containing library info. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * DCD initialized. ++ * Valid hDcdMgr. ++ * pUuid != NULL ++ * pNumLibs != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_GetNumDepLibs(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ OUT u16 *pNumLibs, ++ OUT u16 *pNumPersLibs, ++ IN enum NLDR_PHASE phase); ++ ++/* ++ * ======== DCD_GetLibraryName ======== ++ * Purpose: ++ * This function returns the name of a (dynamic) library for a given ++ * UUID. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pUuid: Pointer to a DSP_UUID that represents a unique DSP/BIOS ++ * Bridge object. ++ * pstrLibName: Buffer to hold library name. ++ * pdwSize: Contains buffer size. Set to string size on output. ++ * phase: Which phase to load ++ * fPhaseSplit: Are phases in multiple libraries ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * DCD initialized. ++ * Valid hDcdMgr. ++ * pstrLibName != NULL. ++ * pUuid != NULL ++ * pdwSize != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_GetLibraryName(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ IN OUT char *pstrLibName, ++ IN OUT u32 *pdwSize, ++ IN enum NLDR_PHASE phase, ++ OUT bool *fPhaseSplit); ++ ++/* ++ * ======== DCD_GetObjectDef ======== ++ * Purpose: ++ * This function returns the properties/attributes of a DSP/BIOS Bridge ++ * object. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pUuid: Pointer to a DSP_UUID that represents a unique ++ * DSP/BIOS Bridge object. ++ * objType: The type of DSP/BIOS Bridge object to be ++ * referenced (node, processor, etc). ++ * pObjDef: Pointer to an object definition structure. A ++ * union of various possible DCD object types. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EDCDPARSESECT: Unable to parse content of object code section. ++ * DSP_EDCDREADSECT: Unable to read object code section. ++ * DSP_EDCDGETSECT: Unable to access object code section. ++ * DSP_EDCDLOADBASE: Unable to load code base. ++ * DSP_EFAIL: General failure. ++ * DSP_EHANDLE: Invalid DCD_HMANAGER handle. ++ * Requires: ++ * DCD initialized. ++ * pObjUuid is non-NULL. ++ * pObjDef is non-NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_GetObjectDef(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pObjUuid, ++ IN enum DSP_DCDOBJTYPE objType, ++ OUT struct DCD_GENERICOBJ *pObjDef); ++ ++/* ++ * ======== DCD_GetObjects ======== ++ * Purpose: ++ * This function finds all DCD objects specified in a special ++ * COFF section called ".dcd_register", and for each object, ++ * call a "register" function. The "register" function may perform ++ * various actions, such as 1) register nodes in the node database, 2) ++ * unregister nodes from the node database, and 3) add overlay nodes. ++ * Parameters: ++ * hDcdMgr: A DCD manager handle. ++ * pszCoffPath: Pointer to name of COFF file containing DCD ++ * objects. ++ * registerFxn: Callback fxn to be applied on each located ++ * DCD object. ++ * handle: Handle to pass to callback. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EDCDNOAUTOREGISTER: Unable to find .dcd_register section. ++ * DSP_EDCDREADSECT: Unable to read object code section. ++ * DSP_EDCDLOADBASE: Unable to load code base. ++ * DSP_EHANDLE: Invalid DCD_HMANAGER handle.. ++ * Requires: ++ * DCD initialized. ++ * Ensures: ++ * Note: ++ * Due to the DCD database construction, it is essential for a DCD-enabled ++ * COFF file to contain the right COFF sections, especially ++ * ".dcd_register", which is used for auto registration. ++ */ ++ extern DSP_STATUS DCD_GetObjects(IN struct DCD_MANAGER *hDcdMgr, ++ IN char *pszCoffPath, ++ DCD_REGISTERFXN registerFxn, ++ void *handle); ++ ++/* ++ * ======== DCD_Init ======== ++ * Purpose: ++ * This function initializes DCD. ++ * Parameters: ++ * Returns: ++ * FALSE: Initialization failed. ++ * TRUE: Initialization succeeded. ++ * Requires: ++ * Ensures: ++ * DCD initialized. ++ */ ++ extern bool DCD_Init(void); ++ ++/* ++ * ======== DCD_RegisterObject ======== ++ * Purpose: ++ * This function registers a DSP/BIOS Bridge object in the DCD database. ++ * Parameters: ++ * pUuid: Pointer to a DSP_UUID that identifies a DSP/BIOS ++ * Bridge object. ++ * objType: Type of object. ++ * pszPathName: Path to the object's COFF file. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Failed to register object. ++ * Requires: ++ * DCD initialized. ++ * pUuid and szPathName are non-NULL values. ++ * objType is a valid type value. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_RegisterObject(IN struct DSP_UUID *pUuid, ++ IN enum DSP_DCDOBJTYPE objType, ++ IN char *pszPathName); ++ ++/* ++ * ======== DCD_UnregisterObject ======== ++ * Purpose: ++ * This function de-registers a valid DSP/BIOS Bridge object from the DCD ++ * database. ++ * Parameters: ++ * pUuid: Pointer to a DSP_UUID that identifies a DSP/BIOS Bridge ++ * object. ++ * objType: Type of object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Unable to de-register the specified object. ++ * Requires: ++ * DCD initialized. ++ * pUuid is a non-NULL value. ++ * objType is a valid type value. ++ * Ensures: ++ */ ++ extern DSP_STATUS DCD_UnregisterObject(IN struct DSP_UUID *pUuid, ++ IN enum DSP_DCDOBJTYPE objType); ++ ++#endif /* _DBDCD_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbdcddef.h b/arch/arm/plat-omap/include/dspbridge/dbdcddef.h +new file mode 100644 +index 0000000..91b1c45 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbdcddef.h +@@ -0,0 +1,94 @@ ++/* ++ * dbdcddef.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbdcddef.h ======== ++ * Description: ++ * DCD (DSP/BIOS Bridge Configuration Database) constants and types. ++ * ++ *! Revision History: ++ *! ================ ++ *! 03-Dec-2003 map Moved and renamed DCD_OBJTYPE to DSP_DCDOBJTYPE in dbdefs.h ++ *! 05-Dec-2002 map Added DCD_CREATELIBTYPE, DCD_EXECUTELIBTYPE, ++ * DCD_DELETELIBTYPE ++ *! 24-Feb-2003 kc Updated REG entry names to DspBridge. ++ *! 22-Nov-2002 gp Cleaned up comments, formatting. ++ *! 05-Aug-2002 jeh Added DCD_REGISTERFXN. ++ *! 19-Apr-2002 jeh Added DCD_LIBRARYTYPE to DCD_OBJTYPE, dynamic load ++ *! properties to DCD_NODEPROPS. ++ *! 29-Jul-2001 ag Added extended procObj. ++ *! 13-Feb-2001 kc: Named changed from dcdbsdef.h dbdcddef.h. ++ *! 12-Dec-2000 jeh Added DAIS iAlg name to DCD_NODEPROPS. ++ *! 30-Oct-2000 kc: Added #defines for DCD_AutoRegister function. ++ *! 05-Sep-2000 jeh Added DCD_NODEPROPS. ++ *! 12-Aug-2000 kc: Incoroporated the use of types defined in <dspdefs.h>. ++ *! 29-Jul-2000 kc: Created. ++ */ ++ ++#ifndef DBDCDDEF_ ++#define DBDCDDEF_ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/mgrpriv.h> /* for MGR_PROCESSOREXTINFO */ ++ ++/* ++ * The following defines are critical elements for the DCD module: ++ * ++ * - DCD_REGKEY enables DCD functions to locate registered DCD objects. ++ * - DCD_REGISTER_SECTION identifies the COFF section where the UUID of ++ * registered DCD objects are stored. ++ */ ++#define DCD_REGKEY "Software\\TexasInstruments\\DspBridge\\DCD" ++#define DCD_REGISTER_SECTION ".dcd_register" ++ ++/* DCD Manager Object */ ++ struct DCD_MANAGER; ++ ++/* DCD Node Properties */ ++ struct DCD_NODEPROPS { ++ struct DSP_NDBPROPS ndbProps; ++ u32 uMsgSegid; ++ u32 uMsgNotifyType; ++ char *pstrCreatePhaseFxn; ++ char *pstrDeletePhaseFxn; ++ char *pstrExecutePhaseFxn; ++ char *pstrIAlgName; ++ ++ /* Dynamic load properties */ ++ u16 usLoadType; /* Static, dynamic, overlay */ ++ u32 ulDataMemSegMask; /* Data memory requirements */ ++ u32 ulCodeMemSegMask; /* Code memory requirements */ ++ } ; ++ ++/* DCD Generic Object Type */ ++ struct DCD_GENERICOBJ { ++ union dcdObjUnion { ++ struct DCD_NODEPROPS nodeObj; /* node object. */ ++ /* processor object. */ ++ struct DSP_PROCESSORINFO procObj; ++ /* extended proc object (private) */ ++ struct MGR_PROCESSOREXTINFO extProcObj; ++ } objData; ++ } ; ++ ++/* DCD Internal Callback Type */ ++ typedef DSP_STATUS(*DCD_REGISTERFXN) (IN struct DSP_UUID *pUuid, ++ IN enum DSP_DCDOBJTYPE objType, ++ IN void *handle); ++ ++#endif /* DBDCDDEF_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbdefs.h b/arch/arm/plat-omap/include/dspbridge/dbdefs.h +new file mode 100644 +index 0000000..9782693 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbdefs.h +@@ -0,0 +1,580 @@ ++/* ++ * dbdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbdefs.h ======== ++ * Description: ++ * Global definitions and constants for DSP/BIOS Bridge. ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added MAPATTR & ELEM_SIZE for Dynamic Memory Mapping feature ++ *! 09-Feb-2004 vp Added processor ID numbers for DSP and IVA ++ *! 06-Feb-2003 kc Removed DSP_POSTMESSAGE. Updated IsValid*Event macros. ++ *! 22-Nov-2002 gp Cleaned up comments, formatting. ++ *! Removed unused DSP_ENUMLASTNODE define. ++ *! 13-Feb-2002 jeh Added uSysStackSize to DSP_NDBPROPS. ++ *! 23-Jan-2002 ag Added #define DSP_SHMSEG0. ++ *! 12-Dec-2001 ag Added DSP_ESTRMMODE error code. ++ *! 04-Dec-2001 jeh Added DSP_ENOTCONNECTED error code. ++ *! 10-Dec-2001 kc: Modified macros and definitions to disable DSP_POSTMESSAGE. ++ *! 01-Nov-2001 jeh Added DSP_EOVERLAYMEMORY. ++ *! 18-Oct-2001 ag Added DSP_STRMMODE type. ++ *! Added DSP_ENOTSHAREDMEM. ++ *! 21-Sep-2001 ag Added additional error codes. ++ *! 07-Jun-2001 sg Made DSPStream_AllocateBuffer fxn name plural. ++ *! 11-May-2001 jeh Changed DSP_NODE_MIN_PRIORITY from 0 to 1. Removed hNode ++ *! from DSP_NODEINFO. ++ *! 02-Apr-2001 sg Added missing error codes, rearranged codes, switched to ++ *! hex offsets, renamed some codes to match API spec. ++ *! 16-Jan-2001 jeh Added DSP_ESYMBOL, DSP_EUUID. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 05-Dec-2000 ag: Added DSP_RMSxxx user available message command codes. ++ *! 09-Nov-2000 rr: Added DSP_PROCEESORRESTART define; Removed DSP_PBUFFER. ++ *! Added DSP_DCD_ENOAUTOREGISTER, DSP_EUSER1-16, DSP_ESTRMFUL ++ *! Removed DSP_EDONE. Macros's modified. ++ *! 23-Oct-2000 jeh Replaced DSP_STREAMSTATECHANGE with DSP_STREAMDONE. ++ *! 09-Oct-2000 jeh Updated to version 0.9 DSP Bridge API spec. ++ *! 29-Sep-2000 kc Added error codes for DCD and REG to simplify use of ++ *! these codes within the RM module. ++ *! 27-Sep-2000 jeh Added segid, alignment, uNumBufs to DSP_STREAMATTRIN. ++ *! 29-Aug-2000 jeh Added DSP_NODETYPE enum, changed DSP_EALREADYATTACHED to ++ *! DSP_EALREADYCONNECTED. Changed scStreamConnection[1] ++ *! to scStreamConnection[16] in DSP_NODEINFO structure. ++ *! Added DSP_NOTIFICATION, DSP_STRMATTR. PSTRING changed ++ *! back to TCHAR * and moved to dbtype.h. ++ *! 11-Aug-2000 rr: Macros to check valid events and notify masks added. ++ *! 09-Aug-2000 rr: Changed PSTRING to *s8 ++ *! 07-Aug-2000 rr: PROC_IDLE/SYNCINIT/UNKNOWN state removed. ++ *! 20-Jul-2000 rr: Updated to version 0.8 ++ *! 17-Jul-2000 rr: New PROC states added to the DSP_PROCSTATE. ++ *! 27-Jun-2000 rr: Created from dspapi.h ++ */ ++ ++#ifndef DBDEFS_ ++#define DBDEFS_ ++ ++#include <linux/types.h> ++ ++#include <dspbridge/dbtype.h> /* GPP side type definitions */ ++#include <dspbridge/std.h> /* DSP/BIOS type definitions */ ++#include <dspbridge/rms_sh.h> /* Types shared between GPP and DSP */ ++ ++#define PG_SIZE_4K 4096 ++#define PG_MASK(pg_size) (~((pg_size)-1)) ++#define PG_ALIGN_LOW(addr, pg_size) ((addr) & PG_MASK(pg_size)) ++#define PG_ALIGN_HIGH(addr, pg_size) (((addr)+(pg_size)-1) & PG_MASK(pg_size)) ++ ++/* API return value and calling convention */ ++#define DBAPI DSP_STATUS ++ ++/* Infinite time value for the uTimeout parameter to DSPStream_Select() */ ++#define DSP_FOREVER (-1) ++ ++/* Maximum length of node name, used in DSP_NDBPROPS */ ++#define DSP_MAXNAMELEN 32 ++ ++/* uNotifyType values for the RegisterNotify() functions. */ ++#define DSP_SIGNALEVENT 0x00000001 ++ ++/* Types of events for processors */ ++#define DSP_PROCESSORSTATECHANGE 0x00000001 ++#define DSP_PROCESSORATTACH 0x00000002 ++#define DSP_PROCESSORDETACH 0x00000004 ++#define DSP_PROCESSORRESTART 0x00000008 ++ ++/* DSP exception events (DSP/BIOS and DSP MMU fault) */ ++#define DSP_MMUFAULT 0x00000010 ++#define DSP_SYSERROR 0x00000020 ++#define DSP_EXCEPTIONABORT 0x00000300 ++ ++/* IVA exception events (IVA MMU fault) */ ++#define IVA_MMUFAULT 0x00000040 ++/* Types of events for nodes */ ++#define DSP_NODESTATECHANGE 0x00000100 ++#define DSP_NODEMESSAGEREADY 0x00000200 ++ ++/* Types of events for streams */ ++#define DSP_STREAMDONE 0x00001000 ++#define DSP_STREAMIOCOMPLETION 0x00002000 ++ ++/* Handle definition representing the GPP node in DSPNode_Connect() calls */ ++#define DSP_HGPPNODE 0xFFFFFFFF ++ ++/* Node directions used in DSPNode_Connect() */ ++#define DSP_TONODE 1 ++#define DSP_FROMNODE 2 ++ ++/* Define Node Minimum and Maximum Priorities */ ++#define DSP_NODE_MIN_PRIORITY 1 ++#define DSP_NODE_MAX_PRIORITY 15 ++ ++/* Pre-Defined Message Command Codes available to user: */ ++#define DSP_RMSUSERCODESTART RMS_USER /* Start of RMS user cmd codes */ ++/* end of user codes */ ++#define DSP_RMSUSERCODEEND (RMS_USER + RMS_MAXUSERCODES); ++#define DSP_RMSBUFDESC RMS_BUFDESC /* MSG contains SM buffer description */ ++ ++/* Shared memory identifier for MEM segment named "SHMSEG0" */ ++#define DSP_SHMSEG0 (u32)(-1) ++ ++/* Processor ID numbers */ ++#define DSP_UNIT 0 ++#define IVA_UNIT 1 ++ ++#define DSPWORD unsigned char ++#define DSPWORDSIZE sizeof(DSPWORD) ++ ++/* Success & Failure macros */ ++#define DSP_SUCCEEDED(Status) likely((s32)(Status) >= 0) ++#define DSP_FAILED(Status) unlikely((s32)(Status) < 0) ++ ++/* Power control enumerations */ ++#define PROC_PWRCONTROL 0x8070 ++ ++#define PROC_PWRMGT_ENABLE (PROC_PWRCONTROL + 0x3) ++#define PROC_PWRMGT_DISABLE (PROC_PWRCONTROL + 0x4) ++ ++/* Bridge Code Version */ ++#define BRIDGE_VERSION_CODE 333 ++ ++#define MAX_PROFILES 16 ++ ++/* Types defined for 'Bridge API */ ++ typedef u32 DSP_STATUS; /* API return code type */ ++ ++ typedef HANDLE DSP_HNODE; /* Handle to a DSP Node object */ ++ typedef HANDLE DSP_HPROCESSOR; /* Handle to a Processor object */ ++ typedef HANDLE DSP_HSTREAM; /* Handle to a Stream object */ ++ ++ typedef u32 DSP_PROCFAMILY; /* Processor family */ ++ typedef u32 DSP_PROCTYPE; /* Processor type (w/in family) */ ++ typedef u32 DSP_RTOSTYPE; /* Type of DSP RTOS */ ++ ++/* Handy Macros */ ++#define IsValidProcEvent(x) (((x) == 0) || (((x) & (DSP_PROCESSORSTATECHANGE | \ ++ DSP_PROCESSORATTACH | \ ++ DSP_PROCESSORDETACH | \ ++ DSP_PROCESSORRESTART | \ ++ DSP_NODESTATECHANGE | \ ++ DSP_STREAMDONE | \ ++ DSP_STREAMIOCOMPLETION | \ ++ DSP_MMUFAULT | \ ++ DSP_SYSERROR)) && \ ++ !((x) & ~(DSP_PROCESSORSTATECHANGE | \ ++ DSP_PROCESSORATTACH | \ ++ DSP_PROCESSORDETACH | \ ++ DSP_PROCESSORRESTART | \ ++ DSP_NODESTATECHANGE | \ ++ DSP_STREAMDONE | \ ++ DSP_STREAMIOCOMPLETION | \ ++ DSP_MMUFAULT | \ ++ DSP_SYSERROR)))) ++ ++#define IsValidNodeEvent(x) (((x) == 0) || (((x) & (DSP_NODESTATECHANGE | \ ++ DSP_NODEMESSAGEREADY)) && \ ++ !((x) & ~(DSP_NODESTATECHANGE | \ ++ DSP_NODEMESSAGEREADY)))) ++ ++#define IsValidStrmEvent(x) (((x) == 0) || (((x) & (DSP_STREAMDONE | \ ++ DSP_STREAMIOCOMPLETION)) && \ ++ !((x) & ~(DSP_STREAMDONE | \ ++ DSP_STREAMIOCOMPLETION)))) ++ ++#define IsValidNotifyMask(x) ((x) & DSP_SIGNALEVENT) ++ ++/* The Node UUID structure */ ++ struct DSP_UUID { ++ u32 ulData1; ++ u16 usData2; ++ u16 usData3; ++ u8 ucData4; ++ u8 ucData5; ++ u8 ucData6[6]; ++ }; ++ ++/* DCD types */ ++ enum DSP_DCDOBJTYPE { ++ DSP_DCDNODETYPE, ++ DSP_DCDPROCESSORTYPE, ++ DSP_DCDLIBRARYTYPE, ++ DSP_DCDCREATELIBTYPE, ++ DSP_DCDEXECUTELIBTYPE, ++ DSP_DCDDELETELIBTYPE ++ } ; ++ ++/* Processor states */ ++ enum DSP_PROCSTATE { ++ PROC_STOPPED, ++ PROC_LOADED, ++ PROC_RUNNING, ++ PROC_ERROR ++ } ; ++ ++/* ++ * Node types: Message node, task node, xDAIS socket node, and ++ * device node. _NODE_GPP is used when defining a stream connection ++ * between a task or socket node and the GPP. ++ * ++ */ ++ enum NODE_TYPE { ++ NODE_DEVICE, ++ NODE_TASK, ++ NODE_DAISSOCKET, ++ NODE_MESSAGE, ++ NODE_GPP ++ } ; ++ ++/* ++ * ======== NODE_STATE ======== ++ * Internal node states. ++ */ ++ enum NODE_STATE { ++ NODE_ALLOCATED, ++ NODE_CREATED, ++ NODE_RUNNING, ++ NODE_PAUSED, ++ NODE_DONE, ++ NODE_CREATING, ++ NODE_STARTING, ++ NODE_PAUSING, ++ NODE_TERMINATING, ++ NODE_DELETING, ++ } ; ++ ++/* Stream states */ ++ enum DSP_STREAMSTATE { ++ STREAM_IDLE, ++ STREAM_READY, ++ STREAM_PENDING, ++ STREAM_DONE ++ } ; ++ ++/* Stream connect types */ ++ enum DSP_CONNECTTYPE { ++ CONNECTTYPE_NODEOUTPUT, ++ CONNECTTYPE_GPPOUTPUT, ++ CONNECTTYPE_NODEINPUT, ++ CONNECTTYPE_GPPINPUT ++ } ; ++ ++/* Stream mode types */ ++ enum DSP_STRMMODE { ++ STRMMODE_PROCCOPY, /* Processor(s) copy stream data payloads */ ++ STRMMODE_ZEROCOPY, /* Strm buffer ptrs swapped no data copied */ ++ STRMMODE_LDMA, /* Local DMA : OMAP's System-DMA device */ ++ STRMMODE_RDMA /* Remote DMA: OMAP's DSP-DMA device */ ++ } ; ++ ++/* Resource Types */ ++ enum DSP_RESOURCEINFOTYPE { ++ DSP_RESOURCE_DYNDARAM = 0, ++ DSP_RESOURCE_DYNSARAM, ++ DSP_RESOURCE_DYNEXTERNAL, ++ DSP_RESOURCE_DYNSRAM, ++ DSP_RESOURCE_PROCLOAD ++ } ; ++ ++/* Memory Segment Types */ ++ enum DSP_MEMTYPE { ++ DSP_DYNDARAM = 0, ++ DSP_DYNSARAM, ++ DSP_DYNEXTERNAL, ++ DSP_DYNSRAM ++ } ; ++ ++/* Memory Flush Types */ ++ enum DSP_FLUSHTYPE { ++ PROC_INVALIDATE_MEM = 0, ++ PROC_WRITEBACK_MEM, ++ PROC_WRITEBACK_INVALIDATE_MEM, ++ } ; ++ ++/* Memory Segment Status Values */ ++ struct DSP_MEMSTAT { ++ u32 ulSize; ++ u32 ulTotalFreeSize; ++ u32 ulLenMaxFreeBlock; ++ u32 ulNumFreeBlocks; ++ u32 ulNumAllocBlocks; ++ } ; ++ ++/* Processor Load information Values */ ++ struct DSP_PROCLOADSTAT { ++ u32 uCurrLoad; ++ u32 uPredictedLoad; ++ u32 uCurrDspFreq; ++ u32 uPredictedFreq; ++ } ; ++ ++/* Attributes for STRM connections between nodes */ ++ struct DSP_STRMATTR { ++ u32 uSegid; /* Memory segment on DSP to allocate buffers */ ++ u32 uBufsize; /* Buffer size (DSP words) */ ++ u32 uNumBufs; /* Number of buffers */ ++ u32 uAlignment; /* Buffer alignment */ ++ u32 uTimeout; /* Timeout for blocking STRM calls */ ++ enum DSP_STRMMODE lMode; /* mode of stream when opened */ ++ /* DMA chnl id if DSP_STRMMODE is LDMA or RDMA */ ++ u32 uDMAChnlId; ++ u32 uDMAPriority; /* DMA channel priority 0=lowest, >0=high */ ++ } ; ++ ++/* The DSP_CBDATA structure */ ++ struct DSP_CBDATA { ++ u32 cbData; ++ u8 cData[1]; ++ } ; ++ ++/* The DSP_MSG structure */ ++ struct DSP_MSG { ++ u32 dwCmd; ++ u32 dwArg1; ++ u32 dwArg2; ++ } ; ++ ++/* The DSP_RESOURCEREQMTS structure for node's resource requirements */ ++ struct DSP_RESOURCEREQMTS { ++ u32 cbStruct; ++ u32 uStaticDataSize; ++ u32 uGlobalDataSize; ++ u32 uProgramMemSize; ++ u32 uWCExecutionTime; ++ u32 uWCPeriod; ++ u32 uWCDeadline; ++ u32 uAvgExectionTime; ++ u32 uMinimumPeriod; ++ } ; ++ ++/* ++ * The DSP_STREAMCONNECT structure describes a stream connection ++ * between two nodes, or between a node and the GPP ++ */ ++ struct DSP_STREAMCONNECT { ++ u32 cbStruct; ++ enum DSP_CONNECTTYPE lType; ++ u32 uThisNodeStreamIndex; ++ DSP_HNODE hConnectedNode; ++ struct DSP_UUID uiConnectedNodeID; ++ u32 uConnectedNodeStreamIndex; ++ } ; ++ ++ struct DSP_NODEPROFS { ++ u32 ulHeapSize; ++ } ; ++ ++/* The DSP_NDBPROPS structure reports the attributes of a node */ ++ struct DSP_NDBPROPS { ++ u32 cbStruct; ++ struct DSP_UUID uiNodeID; ++ char acName[DSP_MAXNAMELEN]; ++ enum NODE_TYPE uNodeType; ++ u32 bCacheOnGPP; ++ struct DSP_RESOURCEREQMTS dspResourceReqmts; ++ s32 iPriority; ++ u32 uStackSize; ++ u32 uSysStackSize; ++ u32 uStackSeg; ++ u32 uMessageDepth; ++ u32 uNumInputStreams; ++ u32 uNumOutputStreams; ++ u32 uTimeout; ++ u32 uCountProfiles; /* Number of supported profiles */ ++ /* Array of profiles */ ++ struct DSP_NODEPROFS aProfiles[MAX_PROFILES]; ++ u32 uStackSegName; /* Stack Segment Name */ ++ } ; ++ ++ /* The DSP_NODEATTRIN structure describes the attributes of a ++ * node client */ ++ struct DSP_NODEATTRIN { ++ u32 cbStruct; ++ s32 iPriority; ++ u32 uTimeout; ++ u32 uProfileID; ++ /* Reserved, for Bridge Internal use only */ ++ u32 uHeapSize; ++ void *pGPPVirtAddr; /* Reserved, for Bridge Internal use only */ ++ } ; ++ ++ /* The DSP_NODEINFO structure is used to retrieve information ++ * about a node */ ++ struct DSP_NODEINFO { ++ u32 cbStruct; ++ struct DSP_NDBPROPS nbNodeDatabaseProps; ++ u32 uExecutionPriority; ++ enum NODE_STATE nsExecutionState; ++ DSP_HNODE hDeviceOwner; ++ u32 uNumberStreams; ++ struct DSP_STREAMCONNECT scStreamConnection[16]; ++ u32 uNodeEnv; ++ } ; ++ ++ /* The DSP_NODEATTR structure describes the attributes of a node */ ++ struct DSP_NODEATTR { ++ u32 cbStruct; ++ struct DSP_NODEATTRIN inNodeAttrIn; ++ u32 uInputs; ++ u32 uOutputs; ++ struct DSP_NODEINFO iNodeInfo; ++ } ; ++ ++/* ++ * Notification type: either the name of an opened event, or an event or ++ * window handle. ++ */ ++ struct DSP_NOTIFICATION { ++ char *psName; ++ HANDLE handle; ++ } ; ++ ++/* The DSP_PROCESSORATTRIN structure describes the attributes of a processor */ ++ struct DSP_PROCESSORATTRIN{ ++ u32 cbStruct; ++ u32 uTimeout; ++ } ; ++ ++ enum chipTypes { ++ DSPTYPE_55 = 6, ++ IVA_ARM7 = 0x97, ++ DSPTYPE_64 = 0x99 ++ }; ++ ++/* ++ * The DSP_PROCESSORINFO structure describes basic capabilities of a ++ * DSP processor ++ */ ++ struct DSP_PROCESSORINFO { ++ u32 cbStruct; ++ DSP_PROCFAMILY uProcessorFamily; ++ DSP_PROCTYPE uProcessorType; ++ u32 uClockRate; ++ u32 ulInternalMemSize; ++ u32 ulExternalMemSize; ++ u32 uProcessorID; ++ DSP_RTOSTYPE tyRunningRTOS; ++ s32 nNodeMinPriority; ++ s32 nNodeMaxPriority; ++ } ; ++ ++/* Error information of last DSP exception signalled to the GPP */ ++ struct DSP_ERRORINFO { ++ u32 dwErrMask; ++ u32 dwVal1; ++ u32 dwVal2; ++ u32 dwVal3; ++ } ; ++ ++/* The DSP_PROCESSORSTATE structure describes the state of a DSP processor */ ++ struct DSP_PROCESSORSTATE { ++ u32 cbStruct; ++ enum DSP_PROCSTATE iState; ++ struct DSP_ERRORINFO errInfo; ++ } ; ++ ++/* ++ * The DSP_RESOURCEINFO structure is used to retrieve information about a ++ * processor's resources ++ */ ++ struct DSP_RESOURCEINFO { ++ u32 cbStruct; ++ enum DSP_RESOURCEINFOTYPE uResourceType; ++ union { ++ u32 ulResource; ++ struct DSP_MEMSTAT memStat; ++ struct DSP_PROCLOADSTAT procLoadStat; ++ } result; ++ } ; ++ ++/* ++ * The DSP_STREAMATTRIN structure describes the attributes of a stream, ++ * including segment and alignment of data buffers allocated with ++ * DSPStream_AllocateBuffers(), if applicable ++ */ ++ struct DSP_STREAMATTRIN { ++ u32 cbStruct; ++ u32 uTimeout; ++ u32 uSegment; ++ u32 uAlignment; ++ u32 uNumBufs; ++ enum DSP_STRMMODE lMode; ++ u32 uDMAChnlId; ++ u32 uDMAPriority; ++ } ; ++ ++/* The DSP_BUFFERATTR structure describes the attributes of a data buffer */ ++ struct DSP_BUFFERATTR { ++ u32 cbStruct; ++ u32 uSegment; ++ u32 uAlignment; ++ } ; ++ ++/* ++ * The DSP_STREAMINFO structure is used to retrieve information ++ * about a stream. ++ */ ++ struct DSP_STREAMINFO { ++ u32 cbStruct; ++ u32 uNumberBufsAllowed; ++ u32 uNumberBufsInStream; ++ u32 ulNumberBytes; ++ HANDLE hSyncObjectHandle; ++ enum DSP_STREAMSTATE ssStreamState; ++ } ; ++ ++/* DMM MAP attributes ++It is a bit mask with each bit value indicating a specific attribute ++bit 0 - GPP address type (user virtual=0, physical=1) ++bit 1 - MMU Endianism (Big Endian=1, Little Endian=0) ++bit 2 - MMU mixed page attribute (Mixed/ CPUES=1, TLBES =0) ++bit 3 - MMU element size = 8bit (valid only for non mixed page entries) ++bit 4 - MMU element size = 16bit (valid only for non mixed page entries) ++bit 5 - MMU element size = 32bit (valid only for non mixed page entries) ++bit 6 - MMU element size = 64bit (valid only for non mixed page entries) ++*/ ++ ++/* Types of mapping attributes */ ++ ++/* MPU address is virtual and needs to be translated to physical addr */ ++#define DSP_MAPVIRTUALADDR 0x00000000 ++#define DSP_MAPPHYSICALADDR 0x00000001 ++ ++/* Mapped data is big endian */ ++#define DSP_MAPBIGENDIAN 0x00000002 ++#define DSP_MAPLITTLEENDIAN 0x00000000 ++ ++/* Element size is based on DSP r/w access size */ ++#define DSP_MAPMIXEDELEMSIZE 0x00000004 ++ ++/* ++ * Element size for MMU mapping (8, 16, 32, or 64 bit) ++ * Ignored if DSP_MAPMIXEDELEMSIZE enabled ++ */ ++#define DSP_MAPELEMSIZE8 0x00000008 ++#define DSP_MAPELEMSIZE16 0x00000010 ++#define DSP_MAPELEMSIZE32 0x00000020 ++#define DSP_MAPELEMSIZE64 0x00000040 ++ ++#define DSP_MAPVMALLOCADDR 0x00000080 ++ ++#define DSP_MAPDONOTLOCK 0x00000100 ++ ++ ++#define GEM_CACHE_LINE_SIZE 128 ++#define GEM_L1P_PREFETCH_SIZE 128 ++ ++#endif /* DBDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbg.h b/arch/arm/plat-omap/include/dspbridge/dbg.h +new file mode 100644 +index 0000000..7f44ff9 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbg.h +@@ -0,0 +1,110 @@ ++/* ++ * dbg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbg.h ======== ++ * Purpose: ++ * Provide debugging services for 'Bridge Mini Drivers. ++ * ++ * Public Functions: ++ * DBG_Exit ++ * DBG_Init ++ * DBG_Printf ++ * DBG_Trace ++ * ++ * Notes: ++ * WMD's must not call DBG_Init or DBG_Exit. ++ * ++ *! Revision History: ++ *! ================ ++ *! 03-Feb-2000 rr: DBG Levels redefined. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 10-Oct-1997 cr: Added DBG_Printf service. ++ *! 29-May-1996 gp: Removed WCD_ prefix. ++ *! 15-May-1996 gp: Created. ++ */ ++ ++#ifndef DBG_ ++#define DBG_ ++#include <dspbridge/host_os.h> ++#include <linux/types.h> ++ ++/* Levels of trace debug messages: */ ++#define DBG_ENTER (u8)(0x01) /* Function entry point. */ ++#define DBG_LEVEL1 (u8)(0x02) /* Display debugging state/varibles */ ++#define DBG_LEVEL2 (u8)(0x04) /* Display debugging state/varibles */ ++#define DBG_LEVEL3 (u8)(0x08) /* Display debugging state/varibles */ ++#define DBG_LEVEL4 (u8)(0x10) /* Display debugging state/varibles */ ++#define DBG_LEVEL5 (u8)(0x20) /* Module Init, Exit */ ++#define DBG_LEVEL6 (u8)(0x40) /* Warn SERVICES Failures */ ++#define DBG_LEVEL7 (u8)(0x80) /* Warn Critical Errors */ ++ ++#if (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE ++ ++/* ++ * ======== DBG_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * DBG initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void DBG_Exit(void); ++ ++/* ++ * ======== DBG_Init ======== ++ * Purpose: ++ * Initializes private state of DBG module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ */ ++ extern bool DBG_Init(void); ++ ++/* ++ * ======== DBG_Trace ======== ++ * Purpose: ++ * Output a trace message to the debugger, if the given trace level ++ * is unmasked. ++ * Parameters: ++ * bLevel: Trace level. ++ * pstrFormat: sprintf-style format string. ++ * ...: Arguments for format string. ++ * Returns: ++ * DSP_SOK: Success, or trace level masked. ++ * DSP_EFAIL: On Error. ++ * Requires: ++ * DBG initialized. ++ * Ensures: ++ * Debug message is printed to debugger output window, if trace level ++ * is unmasked. ++ */ ++ extern DSP_STATUS DBG_Trace(IN u8 bLevel, IN char *pstrFormat, ...); ++#else ++ ++#define DBG_Exit(void) ++#define DBG_Init(void) true ++#define DBG_Trace(bLevel, pstrFormat, args...) ++ ++#endif /* (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE */ ++ ++#endif /* DBG_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbl.h b/arch/arm/plat-omap/include/dspbridge/dbl.h +new file mode 100644 +index 0000000..19847f9 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbl.h +@@ -0,0 +1,354 @@ ++/* ++ * dbl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbl.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Mar-2002 jeh Pass DBL_Symbol pointer to DBL_getAddr, DBL_getCAddr ++ *! to accomodate dynamic loader library. ++ *! 20-Nov-2001 jeh Removed DBL_loadArgs(). ++ *! 24-Sep-2001 jeh Code review changes. ++ *! 07-Sep-2001 jeh Added DBL_LoadSect(), DBL_UnloadSect(). ++ *! 05-Jun-2001 jeh Created based on zl.h. ++ */ ++ ++#ifndef DBL_ ++#define DBL_ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/dbldefs.h> ++ ++/* ++ * ======== DBL_close ======== ++ * Close library opened with DBL_open. ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * Ensures: ++ */ ++ extern void DBL_close(struct DBL_LibraryObj *lib); ++ ++/* ++ * ======== DBL_create ======== ++ * Create a target object by specifying the alloc, free, and write ++ * functions for the target. ++ * Parameters: ++ * pTarget - Location to store target handle on output. ++ * pAttrs - Attributes. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failed. ++ * Requires: ++ * DBL initialized. ++ * pAttrs != NULL. ++ * pTarget != NULL; ++ * Ensures: ++ * Success: *pTarget != NULL. ++ * Failure: *pTarget == NULL. ++ */ ++ extern DSP_STATUS DBL_create(struct DBL_TargetObj **pTarget, ++ struct DBL_Attrs *pAttrs); ++ ++/* ++ * ======== DBL_delete ======== ++ * Delete target object and free resources for any loaded libraries. ++ * Parameters: ++ * target - Handle returned from DBL_Create(). ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * Ensures: ++ */ ++ extern void DBL_delete(struct DBL_TargetObj *target); ++ ++/* ++ * ======== DBL_exit ======== ++ * Discontinue use of DBL module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * cRefs > 0. ++ * Ensures: ++ * cRefs >= 0. ++ */ ++ extern void DBL_exit(void); ++ ++/* ++ * ======== DBL_getAddr ======== ++ * Get address of name in the specified library. ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * name - Name of symbol ++ * ppSym - Location to store symbol address on output. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Symbol not found. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pAddr != NULL. ++ * Ensures: ++ */ ++ extern bool DBL_getAddr(struct DBL_LibraryObj *lib, char *name, ++ struct DBL_Symbol **ppSym); ++ ++/* ++ * ======== DBL_getAttrs ======== ++ * Retrieve the attributes of the target. ++ * Parameters: ++ * target - Handle returned from DBL_Create(). ++ * pAttrs - Location to store attributes on output. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * pAttrs != NULL. ++ * Ensures: ++ */ ++ extern void DBL_getAttrs(struct DBL_TargetObj *target, ++ struct DBL_Attrs *pAttrs); ++ ++/* ++ * ======== DBL_getCAddr ======== ++ * Get address of "C" name in the specified library. ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * name - Name of symbol ++ * ppSym - Location to store symbol address on output. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Symbol not found. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pAddr != NULL. ++ * Ensures: ++ */ ++ extern bool DBL_getCAddr(struct DBL_LibraryObj *lib, char *name, ++ struct DBL_Symbol **ppSym); ++ ++/* ++ * ======== DBL_getEntry ======== ++ * Get program entry point. ++ * ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * pEntry - Location to store entry address on output. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Failure. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * pEntry != NULL. ++ * Ensures: ++ */ ++ extern bool DBL_getEntry(struct DBL_LibraryObj *lib, u32 *pEntry); ++ ++/* ++ * ======== DBL_getSect ======== ++ * Get address and size of a named section. ++ * Parameters: ++ * lib - Library handle returned from DBL_open(). ++ * name - Name of section. ++ * pAddr - Location to store section address on output. ++ * pSize - Location to store section size on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Section not found. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pAddr != NULL; ++ * pSize != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DBL_getSect(struct DBL_LibraryObj *lib, char *name, ++ u32 *pAddr, u32 *pSize); ++ ++/* ++ * ======== DBL_init ======== ++ * Initialize DBL module. ++ * Parameters: ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Failure. ++ * Requires: ++ * cRefs >= 0. ++ * Ensures: ++ * Success: cRefs > 0. ++ * Failure: cRefs >= 0. ++ */ ++ extern bool DBL_init(void); ++ ++/* ++ * ======== DBL_load ======== ++ * Add symbols/code/data defined in file to that already present on ++ * the target. ++ * ++ * Parameters: ++ * lib - Library handle returned from DBL_open(). ++ * flags - Specifies whether loading code, data, and/or symbols. ++ * attrs - May contain write, alloc, and free functions. ++ * pulEntry - Location to store program entry on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFREAD: File read failed. ++ * DSP_EFWRITE: Write to target failed. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * pEntry != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DBL_load(struct DBL_LibraryObj *lib, DBL_Flags flags, ++ struct DBL_Attrs *attrs, u32 *pEntry); ++ ++/* ++ * ======== DBL_loadSect ======== ++ * Load a named section from an library (for overlay support). ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * sectName - Name of section to load. ++ * attrs - Contains write function and handle to pass to it. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Section not found. ++ * DSP_EFWRITE: Write function failed. ++ * Requires: ++ * Valid lib. ++ * sectName != NULL. ++ * attrs != NULL. ++ * attrs->write != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DBL_loadSect(struct DBL_LibraryObj *lib, ++ char *sectName, ++ struct DBL_Attrs *attrs); ++ ++/* ++ * ======== DBL_open ======== ++ * DBL_open() returns a library handle that can be used to load/unload ++ * the symbols/code/data via DBL_load()/DBL_unload(). ++ * Parameters: ++ * target - Handle returned from DBL_create(). ++ * file - Name of file to open. ++ * flags - Specifies whether to load symbols now. ++ * pLib - Location to store library handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EFOPEN: File open failure. ++ * DSP_EFREAD: File read failure. ++ * DSP_ECORRUPTFILE: Unable to determine target type. ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * file != NULL. ++ * pLib != NULL. ++ * struct DBL_Attrs fopen function non-NULL. ++ * Ensures: ++ * Success: Valid *pLib. ++ * Failure: *pLib == NULL. ++ */ ++ extern DSP_STATUS DBL_open(struct DBL_TargetObj *target, char *file, ++ DBL_Flags flags, ++ struct DBL_LibraryObj **pLib); ++ ++/* ++ * ======== DBL_readSect ======== ++ * Read COFF section into a character buffer. ++ * Parameters: ++ * lib - Library handle returned from DBL_open(). ++ * name - Name of section. ++ * pBuf - Buffer to write section contents into. ++ * size - Buffer size ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Named section does not exists. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pBuf != NULL. ++ * size != 0. ++ * Ensures: ++ */ ++ extern DSP_STATUS DBL_readSect(struct DBL_LibraryObj *lib, char *name, ++ char *pBuf, u32 size); ++ ++/* ++ * ======== DBL_setAttrs ======== ++ * Set the attributes of the target. ++ * Parameters: ++ * target - Handle returned from DBL_create(). ++ * pAttrs - New attributes. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * pAttrs != NULL. ++ * Ensures: ++ */ ++ extern void DBL_setAttrs(struct DBL_TargetObj *target, ++ struct DBL_Attrs *pAttrs); ++ ++/* ++ * ======== DBL_unload ======== ++ * Remove the symbols/code/data corresponding to the library lib. ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * attrs - Contains free() function and handle to pass to it. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * Ensures: ++ */ ++ extern void DBL_unload(struct DBL_LibraryObj *lib, ++ struct DBL_Attrs *attrs); ++ ++/* ++ * ======== DBL_unloadSect ======== ++ * Unload a named section from an library (for overlay support). ++ * Parameters: ++ * lib - Handle returned from DBL_open(). ++ * sectName - Name of section to load. ++ * attrs - Contains free() function and handle to pass to it. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Named section not found. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * sectName != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DBL_unloadSect(struct DBL_LibraryObj *lib, ++ char *sectName, ++ struct DBL_Attrs *attrs); ++ ++#endif /* DBL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbldefs.h b/arch/arm/plat-omap/include/dspbridge/dbldefs.h +new file mode 100644 +index 0000000..79b9e54 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbldefs.h +@@ -0,0 +1,155 @@ ++/* ++ * dbldefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbldefs.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Mar-2002 jeh Added DBL_Fxns type (to make it easier to switch ++ *! between different loaders). ++ *! 28-Sep-2001 jeh Created from zl.h. ++ */ ++#ifndef DBLDEFS_ ++#define DBLDEFS_ ++ ++/* ++ * Bit masks for DBL_Flags. ++ */ ++#define DBL_NOLOAD 0x0 /* Don't load symbols, code, or data */ ++#define DBL_SYMB 0x1 /* load symbols */ ++#define DBL_CODE 0x2 /* load code */ ++#define DBL_DATA 0x4 /* load data */ ++#define DBL_DYNAMIC 0x8 /* dynamic load */ ++#define DBL_BSS 0x20 /* Unitialized section */ ++ ++#define DBL_MAXPATHLENGTH 255 ++ ++ ++ ++/* ++ * ======== DBL_Flags ======== ++ * Specifies whether to load code, data, or symbols ++ */ ++typedef s32 DBL_Flags; ++ ++/* ++ * ======== DBL_SectInfo ======== ++ * For collecting info on overlay sections ++ */ ++struct DBL_SectInfo { ++ const char *name; /* name of section */ ++ u32 runAddr; /* run address of section */ ++ u32 loadAddr; /* load address of section */ ++ u32 size; /* size of section (target MAUs) */ ++ DBL_Flags type; /* Code, data, or BSS */ ++} ; ++ ++/* ++ * ======== DBL_Symbol ======== ++ * (Needed for dynamic load library) ++ */ ++struct DBL_Symbol { ++ u32 value; ++}; ++ ++/* ++ * ======== DBL_AllocFxn ======== ++ * Allocate memory function. Allocate or reserve (if reserved == TRUE) ++ * "size" bytes of memory from segment "space" and return the address in ++ * *dspAddr (or starting at *dspAddr if reserve == TRUE). Returns 0 on ++ * success, or an error code on failure. ++ */ ++typedef s32(*DBL_AllocFxn) (void *hdl, s32 space, u32 size, u32 align, ++ u32 *dspAddr, s32 segId, s32 req, bool reserved); ++ ++ ++ ++/* ++ * ======== DBL_FreeFxn ======== ++ * Free memory function. Free, or unreserve (if reserved == TRUE) "size" ++ * bytes of memory from segment "space" ++ */ ++typedef bool(*DBL_FreeFxn) (void *hdl, u32 addr, s32 space, u32 size, ++ bool reserved); ++ ++/* ++ * ======== DBL_LogWriteFxn ======== ++ * Function to call when writing data from a section, to log the info. ++ * Can be NULL if no logging is required. ++ */ ++typedef DSP_STATUS(*DBL_LogWriteFxn) (void *handle, struct DBL_SectInfo *sect, ++ u32 addr, u32 nBytes); ++ ++ ++/* ++ * ======== DBL_SymLookup ======== ++ * Symbol lookup function - Find the symbol name and return its value. ++ * ++ * Parameters: ++ * handle - Opaque handle ++ * pArg - Opaque argument. ++ * name - Name of symbol to lookup. ++ * sym - Location to store address of symbol structure. ++ * ++ * Returns: ++ * TRUE: Success (symbol was found). ++ * FALSE: Failed to find symbol. ++ */ ++typedef bool(*DBL_SymLookup) (void *handle, void *pArg, void *rmmHandle, ++ const char *name, struct DBL_Symbol **sym); ++ ++ ++/* ++ * ======== DBL_WriteFxn ======== ++ * Write memory function. Write "n" HOST bytes of memory to segment "mtype" ++ * starting at address "dspAddr" from the buffer "buf". The buffer is ++ * formatted as an array of words appropriate for the DSP. ++ */ ++typedef s32(*DBL_WriteFxn) (void *hdl, u32 dspAddr, void *buf, ++ u32 n, s32 mtype); ++ ++/* ++ * ======== DBL_Attrs ======== ++ */ ++struct DBL_Attrs { ++ DBL_AllocFxn alloc; ++ DBL_FreeFxn free; ++ void *rmmHandle; /* Handle to pass to alloc, free functions */ ++ DBL_WriteFxn write; ++ void *wHandle; /* Handle to pass to write, cinit function */ ++ ++ DBL_LogWriteFxn logWrite; ++ void *logWriteHandle; ++ ++ /* Symbol matching function and handle to pass to it */ ++ DBL_SymLookup symLookup; ++ void *symHandle; ++ void *symArg; ++ ++ /* ++ * These file manipulation functions should be compatible with the ++ * "C" run time library functions of the same name. ++ */ ++ s32(*fread) (void *, size_t, size_t, void *); ++ s32(*fseek) (void *, long, int); ++ s32(*ftell) (void *); ++ s32(*fclose) (void *); ++ void *(*fopen) (const char *, const char *); ++} ; ++ ++#endif /* DBLDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbll.h b/arch/arm/plat-omap/include/dspbridge/dbll.h +new file mode 100644 +index 0000000..c3aa212 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbll.h +@@ -0,0 +1,70 @@ ++/* ++ * dbll.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbll.h ======== ++ * DSP/BIOS Bridge Dynamic load library module interface. Function header ++ * comments are in the file dblldefs.h. ++ * ++ *! Revision History ++ *! ================ ++ *! 31-Jul-2002 jeh Removed function comments (now in dblldefs.h). ++ *! 17-Apr-2002 jeh Created based on zl.h. ++ */ ++ ++#ifndef DBLL_ ++#define DBLL_ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/dblldefs.h> ++ ++ extern void DBLL_close(struct DBLL_LibraryObj *lib); ++ extern DSP_STATUS DBLL_create(struct DBLL_TarObj **pTarget, ++ struct DBLL_Attrs *pAttrs); ++ extern void DBLL_delete(struct DBLL_TarObj *target); ++ extern void DBLL_exit(void); ++ extern bool DBLL_getAddr(struct DBLL_LibraryObj *lib, char *name, ++ struct DBLL_Symbol **ppSym); ++ extern void DBLL_getAttrs(struct DBLL_TarObj *target, ++ struct DBLL_Attrs *pAttrs); ++ extern bool DBLL_getCAddr(struct DBLL_LibraryObj *lib, char *name, ++ struct DBLL_Symbol **ppSym); ++ extern DSP_STATUS DBLL_getSect(struct DBLL_LibraryObj *lib, char *name, ++ u32 *pAddr, u32 *pSize); ++ extern bool DBLL_init(void); ++ extern DSP_STATUS DBLL_load(struct DBLL_LibraryObj *lib, ++ DBLL_Flags flags, ++ struct DBLL_Attrs *attrs, u32 *pEntry); ++ extern DSP_STATUS DBLL_loadSect(struct DBLL_LibraryObj *lib, ++ char *sectName, ++ struct DBLL_Attrs *attrs); ++ extern DSP_STATUS DBLL_open(struct DBLL_TarObj *target, char *file, ++ DBLL_Flags flags, ++ struct DBLL_LibraryObj **pLib); ++ extern DSP_STATUS DBLL_readSect(struct DBLL_LibraryObj *lib, ++ char *name, ++ char *pBuf, u32 size); ++ extern void DBLL_setAttrs(struct DBLL_TarObj *target, ++ struct DBLL_Attrs *pAttrs); ++ extern void DBLL_unload(struct DBLL_LibraryObj *lib, ++ struct DBLL_Attrs *attrs); ++ extern DSP_STATUS DBLL_unloadSect(struct DBLL_LibraryObj *lib, ++ char *sectName, ++ struct DBLL_Attrs *attrs); ++ ++#endif /* DBLL_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/dblldefs.h b/arch/arm/plat-omap/include/dspbridge/dblldefs.h +new file mode 100644 +index 0000000..2361ce8 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dblldefs.h +@@ -0,0 +1,509 @@ ++/* ++ * dblldefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dblldefs.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Apr-2003 map Consolidated DBL into DBLL name ++ *! 19-Mar-2002 jeh Added DBL_Fxns type (to make it easier to switch ++ *! between different loaders). ++ *! 28-Sep-2001 jeh Created from zl.h. ++ */ ++#ifndef DBLLDEFS_ ++#define DBLLDEFS_ ++ ++/* ++ * Bit masks for DBL_Flags. ++ */ ++#define DBLL_NOLOAD 0x0 /* Don't load symbols, code, or data */ ++#define DBLL_SYMB 0x1 /* load symbols */ ++#define DBLL_CODE 0x2 /* load code */ ++#define DBLL_DATA 0x4 /* load data */ ++#define DBLL_DYNAMIC 0x8 /* dynamic load */ ++#define DBLL_BSS 0x20 /* Unitialized section */ ++ ++#define DBLL_MAXPATHLENGTH 255 ++ ++ ++/* ++ * ======== DBLL_Target ======== ++ * ++ */ ++struct DBLL_TarObj; ++ ++/* ++ * ======== DBLL_Flags ======== ++ * Specifies whether to load code, data, or symbols ++ */ ++typedef s32 DBLL_Flags; ++ ++/* ++ * ======== DBLL_Library ======== ++ * ++ */ ++struct DBLL_LibraryObj; ++ ++/* ++ * ======== DBLL_SectInfo ======== ++ * For collecting info on overlay sections ++ */ ++struct DBLL_SectInfo { ++ const char *name; /* name of section */ ++ u32 runAddr; /* run address of section */ ++ u32 loadAddr; /* load address of section */ ++ u32 size; /* size of section (target MAUs) */ ++ DBLL_Flags type; /* Code, data, or BSS */ ++} ; ++ ++/* ++ * ======== DBLL_Symbol ======== ++ * (Needed for dynamic load library) ++ */ ++struct DBLL_Symbol { ++ u32 value; ++}; ++ ++/* ++ * ======== DBLL_AllocFxn ======== ++ * Allocate memory function. Allocate or reserve (if reserved == TRUE) ++ * "size" bytes of memory from segment "space" and return the address in ++ * *dspAddr (or starting at *dspAddr if reserve == TRUE). Returns 0 on ++ * success, or an error code on failure. ++ */ ++typedef s32(*DBLL_AllocFxn) (void *hdl, s32 space, u32 size, u32 align, ++ u32 *dspAddr, s32 segId, s32 req, ++ bool reserved); ++ ++/* ++ * ======== DBLL_CloseFxn ======== ++ */ ++typedef s32(*DBLL_FCloseFxn) (void *); ++ ++/* ++ * ======== DBLL_FreeFxn ======== ++ * Free memory function. Free, or unreserve (if reserved == TRUE) "size" ++ * bytes of memory from segment "space" ++ */ ++typedef bool(*DBLL_FreeFxn) (void *hdl, u32 addr, s32 space, u32 size, ++ bool reserved); ++ ++/* ++ * ======== DBLL_FOpenFxn ======== ++ */ ++typedef void *(*DBLL_FOpenFxn) (const char *, const char *); ++ ++/* ++ * ======== DBLL_LogWriteFxn ======== ++ * Function to call when writing data from a section, to log the info. ++ * Can be NULL if no logging is required. ++ */ ++typedef DSP_STATUS(*DBLL_LogWriteFxn)(void *handle, struct DBLL_SectInfo *sect, ++ u32 addr, u32 nBytes); ++ ++/* ++ * ======== DBLL_ReadFxn ======== ++ */ ++typedef s32(*DBLL_ReadFxn) (void *, size_t, size_t, void *); ++ ++/* ++ * ======== DBLL_SeekFxn ======== ++ */ ++typedef s32(*DBLL_SeekFxn) (void *, long, int); ++ ++/* ++ * ======== DBLL_SymLookup ======== ++ * Symbol lookup function - Find the symbol name and return its value. ++ * ++ * Parameters: ++ * handle - Opaque handle ++ * pArg - Opaque argument. ++ * name - Name of symbol to lookup. ++ * sym - Location to store address of symbol structure. ++ * ++ * Returns: ++ * TRUE: Success (symbol was found). ++ * FALSE: Failed to find symbol. ++ */ ++typedef bool(*DBLL_SymLookup) (void *handle, void *pArg, void *rmmHandle, ++ const char *name, struct DBLL_Symbol **sym); ++ ++/* ++ * ======== DBLL_TellFxn ======== ++ */ ++typedef s32(*DBLL_TellFxn) (void *); ++ ++/* ++ * ======== DBLL_WriteFxn ======== ++ * Write memory function. Write "n" HOST bytes of memory to segment "mtype" ++ * starting at address "dspAddr" from the buffer "buf". The buffer is ++ * formatted as an array of words appropriate for the DSP. ++ */ ++typedef s32(*DBLL_WriteFxn) (void *hdl, u32 dspAddr, void *buf, ++ u32 n, s32 mtype); ++ ++/* ++ * ======== DBLL_Attrs ======== ++ */ ++struct DBLL_Attrs { ++ DBLL_AllocFxn alloc; ++ DBLL_FreeFxn free; ++ void *rmmHandle; /* Handle to pass to alloc, free functions */ ++ DBLL_WriteFxn write; ++ void *wHandle; /* Handle to pass to write, cinit function */ ++ bool baseImage; ++ DBLL_LogWriteFxn logWrite; ++ void *logWriteHandle; ++ ++ /* Symbol matching function and handle to pass to it */ ++ DBLL_SymLookup symLookup; ++ void *symHandle; ++ void *symArg; ++ ++ /* ++ * These file manipulation functions should be compatible with the ++ * "C" run time library functions of the same name. ++ */ ++ s32(*fread) (void *, size_t, size_t, void *); ++ s32(*fseek) (void *, long, int); ++ s32(*ftell) (void *); ++ s32(*fclose) (void *); ++ void *(*fopen) (const char *, const char *); ++} ; ++ ++/* ++ * ======== DBLL_close ======== ++ * Close library opened with DBLL_open. ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * Ensures: ++ */ ++typedef void(*DBLL_CloseFxn) (struct DBLL_LibraryObj *library); ++ ++/* ++ * ======== DBLL_create ======== ++ * Create a target object, specifying the alloc, free, and write functions. ++ * Parameters: ++ * pTarget - Location to store target handle on output. ++ * pAttrs - Attributes. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failed. ++ * Requires: ++ * DBL initialized. ++ * pAttrs != NULL. ++ * pTarget != NULL; ++ * Ensures: ++ * Success: *pTarget != NULL. ++ * Failure: *pTarget == NULL. ++ */ ++typedef DSP_STATUS(*DBLL_CreateFxn)(struct DBLL_TarObj **pTarget, ++ struct DBLL_Attrs *attrs); ++ ++/* ++ * ======== DBLL_delete ======== ++ * Delete target object and free resources for any loaded libraries. ++ * Parameters: ++ * target - Handle returned from DBLL_Create(). ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * Ensures: ++ */ ++typedef void(*DBLL_DeleteFxn) (struct DBLL_TarObj *target); ++ ++/* ++ * ======== DBLL_exit ======== ++ * Discontinue use of DBL module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * cRefs > 0. ++ * Ensures: ++ * cRefs >= 0. ++ */ ++typedef void(*DBLL_ExitFxn) (void); ++ ++/* ++ * ======== DBLL_getAddr ======== ++ * Get address of name in the specified library. ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * name - Name of symbol ++ * ppSym - Location to store symbol address on output. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Symbol not found. ++ * Requires: ++ * DBL initialized. ++ * Valid library. ++ * name != NULL. ++ * ppSym != NULL. ++ * Ensures: ++ */ ++typedef bool(*DBLL_GetAddrFxn) (struct DBLL_LibraryObj *lib, char *name, ++ struct DBLL_Symbol **ppSym); ++ ++/* ++ * ======== DBLL_getAttrs ======== ++ * Retrieve the attributes of the target. ++ * Parameters: ++ * target - Handle returned from DBLL_Create(). ++ * pAttrs - Location to store attributes on output. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * pAttrs != NULL. ++ * Ensures: ++ */ ++typedef void(*DBLL_GetAttrsFxn) (struct DBLL_TarObj *target, ++ struct DBLL_Attrs *attrs); ++ ++/* ++ * ======== DBLL_getCAddr ======== ++ * Get address of "C" name on the specified library. ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * name - Name of symbol ++ * ppSym - Location to store symbol address on output. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Symbol not found. ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * name != NULL. ++ * ppSym != NULL. ++ * Ensures: ++ */ ++typedef bool(*DBLL_GetCAddrFxn) (struct DBLL_LibraryObj *lib, char *name, ++ struct DBLL_Symbol **ppSym); ++ ++/* ++ * ======== DBLL_getSect ======== ++ * Get address and size of a named section. ++ * Parameters: ++ * lib - Library handle returned from DBLL_open(). ++ * name - Name of section. ++ * pAddr - Location to store section address on output. ++ * pSize - Location to store section size on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Section not found. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pAddr != NULL; ++ * pSize != NULL. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*DBLL_GetSectFxn) (struct DBLL_LibraryObj *lib, char *name, ++ u32 *addr, u32 *size); ++ ++/* ++ * ======== DBLL_init ======== ++ * Initialize DBL module. ++ * Parameters: ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Failure. ++ * Requires: ++ * cRefs >= 0. ++ * Ensures: ++ * Success: cRefs > 0. ++ * Failure: cRefs >= 0. ++ */ ++typedef bool(*DBLL_InitFxn) (void); ++ ++/* ++ * ======== DBLL_load ======== ++ * Load library onto the target. ++ * ++ * Parameters: ++ * lib - Library handle returned from DBLL_open(). ++ * flags - Load code, data and/or symbols. ++ * attrs - May contain alloc, free, and write function. ++ * pulEntry - Location to store program entry on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFREAD: File read failed. ++ * DSP_EFWRITE: Write to target failed. ++ * DSP_EDYNLOAD: Failure in dynamic loader library. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * pEntry != NULL. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*DBLL_LoadFxn) (struct DBLL_LibraryObj *lib, ++ DBLL_Flags flags, ++ struct DBLL_Attrs *attrs, u32 *entry); ++ ++/* ++ * ======== DBLL_loadSect ======== ++ * Load a named section from an library (for overlay support). ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * sectName - Name of section to load. ++ * attrs - Contains write function and handle to pass to it. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Section not found. ++ * DSP_EFWRITE: Write function failed. ++ * DSP_ENOTIMPL: Function not implemented. ++ * Requires: ++ * Valid lib. ++ * sectName != NULL. ++ * attrs != NULL. ++ * attrs->write != NULL. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*DBLL_LoadSectFxn) (struct DBLL_LibraryObj *lib, ++ char *pszSectName, ++ struct DBLL_Attrs *attrs); ++ ++/* ++ * ======== DBLL_open ======== ++ * DBLL_open() returns a library handle that can be used to load/unload ++ * the symbols/code/data via DBLL_load()/DBLL_unload(). ++ * Parameters: ++ * target - Handle returned from DBLL_create(). ++ * file - Name of file to open. ++ * flags - If flags & DBLL_SYMB, load symbols. ++ * pLib - Location to store library handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EFOPEN: File open failure. ++ * DSP_EFREAD: File read failure. ++ * DSP_ECORRUPTFILE: Unable to determine target type. ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * file != NULL. ++ * pLib != NULL. ++ * DBLL_Attrs fopen function non-NULL. ++ * Ensures: ++ * Success: Valid *pLib. ++ * Failure: *pLib == NULL. ++ */ ++typedef DSP_STATUS(*DBLL_OpenFxn) (struct DBLL_TarObj *target, char *file, ++ DBLL_Flags flags, ++ struct DBLL_LibraryObj **pLib); ++ ++/* ++ * ======== DBLL_readSect ======== ++ * Read COFF section into a character buffer. ++ * Parameters: ++ * lib - Library handle returned from DBLL_open(). ++ * name - Name of section. ++ * pBuf - Buffer to write section contents into. ++ * size - Buffer size ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Named section does not exists. ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * name != NULL. ++ * pBuf != NULL. ++ * size != 0. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*DBLL_ReadSectFxn) (struct DBLL_LibraryObj *lib, char *name, ++ char *content, u32 uContentSize); ++ ++/* ++ * ======== DBLL_setAttrs ======== ++ * Set the attributes of the target. ++ * Parameters: ++ * target - Handle returned from DBLL_create(). ++ * pAttrs - New attributes. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid target. ++ * pAttrs != NULL. ++ * Ensures: ++ */ ++typedef void(*DBLL_SetAttrsFxn)(struct DBLL_TarObj *target, ++ struct DBLL_Attrs *attrs); ++ ++/* ++ * ======== DBLL_unload ======== ++ * Unload library loaded with DBLL_load(). ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * attrs - Contains free() function and handle to pass to it. ++ * Returns: ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * Ensures: ++ */ ++typedef void(*DBLL_UnloadFxn) (struct DBLL_LibraryObj *library, ++ struct DBLL_Attrs *attrs); ++ ++/* ++ * ======== DBLL_unloadSect ======== ++ * Unload a named section from an library (for overlay support). ++ * Parameters: ++ * lib - Handle returned from DBLL_open(). ++ * sectName - Name of section to load. ++ * attrs - Contains free() function and handle to pass to it. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ENOSECT: Named section not found. ++ * DSP_ENOTIMPL ++ * Requires: ++ * DBL initialized. ++ * Valid lib. ++ * sectName != NULL. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*DBLL_UnloadSectFxn) (struct DBLL_LibraryObj *lib, ++ char *pszSectName, ++ struct DBLL_Attrs *attrs); ++ ++struct DBLL_Fxns { ++ DBLL_CloseFxn closeFxn; ++ DBLL_CreateFxn createFxn; ++ DBLL_DeleteFxn deleteFxn; ++ DBLL_ExitFxn exitFxn; ++ DBLL_GetAttrsFxn getAttrsFxn; ++ DBLL_GetAddrFxn getAddrFxn; ++ DBLL_GetCAddrFxn getCAddrFxn; ++ DBLL_GetSectFxn getSectFxn; ++ DBLL_InitFxn initFxn; ++ DBLL_LoadFxn loadFxn; ++ DBLL_LoadSectFxn loadSectFxn; ++ DBLL_OpenFxn openFxn; ++ DBLL_ReadSectFxn readSectFxn; ++ DBLL_SetAttrsFxn setAttrsFxn; ++ DBLL_UnloadFxn unloadFxn; ++ DBLL_UnloadSectFxn unloadSectFxn; ++} ; ++ ++#endif /* DBLDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbof.h b/arch/arm/plat-omap/include/dspbridge/dbof.h +new file mode 100644 +index 0000000..54f4250 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbof.h +@@ -0,0 +1,117 @@ ++/* ++ * dbof.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbof.h ======== ++ * Description: ++ * Defines and typedefs for DSP/BIOS Bridge Object File Format (DBOF). ++ * ++ *! Revision History ++ *! ================ ++ *! 12-Jul-2002 jeh Added defines for DBOF_SectHdr page. ++ *! 12-Oct-2001 jeh Converted to std.h format. ++ *! 07-Sep-2001 jeh Added overlay support. ++ *! 06-Jul-2001 jeh Created. ++ */ ++ ++#ifndef DBOF_ ++#define DBOF_ ++ ++/* Enough to hold DCD section names: 32 digit ID + underscores */ ++#define DBOF_DCDSECTNAMELEN 40 ++ ++/* Values for DBOF_SectHdr page field. */ ++#define DBOF_PROGRAM 0 ++#define DBOF_DATA 1 ++#define DBOF_CINIT 2 ++ ++/* ++ * ======== DBOF_FileHdr ======== ++ */ ++ struct DBOF_FileHdr { ++ u32 magic; /* COFF magic number */ ++ u32 entry; /* Program entry point */ ++ u16 numSymbols; /* Number of bridge symbols */ ++ u16 numDCDSects; /* Number of DCD sections */ ++ u16 numSects; /* Number of sections to load */ ++ u16 numOvlySects; /* Number of overlay sections */ ++ u32 symOffset; /* Offset in file to symbols */ ++ u32 dcdSectOffset; /* Offset to DCD sections */ ++ u32 loadSectOffset; /* Offset to loadable sections */ ++ u32 ovlySectOffset; /* Offset to overlay data */ ++ u16 version; /* DBOF version number */ ++ u16 resvd; /* Reserved for future use */ ++ } ; ++ ++/* ++ * ======== DBOF_DCDSectHdr ======== ++ */ ++ struct DBOF_DCDSectHdr { ++ u32 size; /* Sect size (target MAUs) */ ++ char name[DBOF_DCDSECTNAMELEN]; /* DCD section name */ ++ } ; ++ ++/* ++ * ======== DBOF_OvlySectHdr ======== ++ */ ++ struct DBOF_OvlySectHdr { ++ u16 nameLen; /* Length of section name */ ++ u16 numCreateSects; /* # of sects loaded for create phase */ ++ u16 numDeleteSects; /* # of sects loaded for delete phase */ ++ u16 numExecuteSects; /* # of sects loaded for execute phase */ ++ ++ /* ++ * Number of sections where load/unload phase is not specified. ++ * These sections will be loaded when create phase sects are ++ * loaded, and unloaded when the delete phase is unloaded. ++ */ ++ u16 numOtherSects; ++ u16 resvd; /* Reserved for future use */ ++ }; ++ ++/* ++ * ======== DBOF_OvlySectData ======== ++ */ ++ struct DBOF_OvlySectData { ++ u32 loadAddr; /* Section load address */ ++ u32 runAddr; /* Section run address */ ++ u32 size; /* Section size (target MAUs) */ ++ u16 page; /* Memory page number */ ++ u16 resvd; /* Reserved */ ++ } ; ++ ++/* ++ * ======== DBOF_SectHdr ======== ++ */ ++ struct DBOF_SectHdr { ++ u32 addr; /* Section address */ ++ u32 size; /* Section size (target MAUs) */ ++ u16 page; /* Page number */ ++ u16 resvd; /* Reserved for future use */ ++ } ; ++ ++/* ++ * ======== DBOF_SymbolHdr ======== ++ */ ++ struct DBOF_SymbolHdr { ++ u32 value; /* Symbol value */ ++ u16 nameLen; /* Length of symbol name */ ++ u16 resvd; /* Reserved for future use */ ++ } ; ++ ++#endif /* DBOF_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbreg.h b/arch/arm/plat-omap/include/dspbridge/dbreg.h +new file mode 100644 +index 0000000..d311b88 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbreg.h +@@ -0,0 +1,113 @@ ++/* ++ * dbreg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbreg.h ======== ++ * Purpose: ++ * Registry keys for use in Linux. This is the clearinghouse for ++ * registry definitions, hopefully eliminating overlapping between ++ * modules. ++ * ++ *! Revision History: ++ *! ================ ++ *! 10-Apr-2003 vp: Added macro for subkey TCWORDSWAP. ++ *! 21-Mar-2003 sb: Added macro for subkey SHMSize ++ *! 27-Aug-2001 jeh Added WSXREG_LOADERFILENAME. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 29-Nov-2000 rr: Added WSXREG_DSPTYPE_55 as 6. ++ *! 06-Sep-2000 jeh: Added WSXREG_CHNLOFFSET, WSXREG_NUMCHNLS, ++ *! WSXREG_CHNLBUFSIZE. ++ *! 26-Aug-2000 rr: MEMBASE expanded to 9 entries. ++ *! 26-Jul-2000 rr: Added WSXREG_DCDNAME for the DCD Dll name. It will ++ *! live under WSXREG_WINSPOXCONFIG. ++ *! 17-Jul-2000 rr: REG_MGR_OBJECT and REG_DRV_OBJECT defined. They ++ *! are stored in the Registrty under WSXREG_WINSPOXCONFIG ++ *! when they are created in DSP_Init. WSXREG_DEVOBJECT ++ *! and WSXREG_MGROBJECT defined. ++ *! 11-Dec-1999 ag: Renamed Isa to IsaBus due to conflict with ceddk.h. ++ *! 12-Nov-1999 rr: New Registry Defnitions. ++ *! 15-Oct-1999 rr: New entry for DevObject created. WSXREG_DEVOBJECT ++ *! under WSXREG_DDSPDRIVERPATH ++ *! 10-Nov-1997 cr: Added WSXREG_INFPATH, WSXREG_WINDEVICEPATH, ++ *! WSXREG_WINCURVERSION ++ *! 21-Oct-1997 cr: Added WSXREG_BUSTYPE. ++ *! 08-Sep-1997 cr: Added WSXREG_SERVICES, WSXREG_SERVICENAME and ++ *! WSXREG_CLASSINDEX. ++ *! 30-Aug-1997 cr: Added WSXREG_SOFTWAREPATHNT & WSXREG_WBCLASSGUID. ++ *! 24-Mar-1997 gp: Added MAXCHIPINFOSUBKEY def. ++ *! 18-Feb-1997 cr: Changed Version1.1 -> Version1.0 ++ *! 12-Feb-1997 cr: Changed WinSPOX -> WinBRIDGE. ++ *! 11-Dec-1996 gp: Added Perf key name in WinSPOX Config. ++ *! 22-Jul-1996 gp: Added Trace key name. ++ *! 30-May-1996 cr: Created. ++ */ ++ ++#ifndef DBREG_ ++#define DBREG_ 1 /* Defined as "1" so InstallShield programs compile. */ ++ ++#define REG_MGR_OBJECT 1 ++#define REG_DRV_OBJECT 2 ++/* general registry definitions */ ++#define MAXREGPATHLENGTH 255 /* Max registry path length. Also the ++ max registry value length. */ ++#define DSPTYPE_55 6 /* This is the DSP Chip type for 55 */ ++#define DSPTYPE_64 0x99 ++#define IVA_ARM7 0x97 /* This is the DSP Chip type for IVA/ARM7 */ ++ ++#define DSPPROCTYPE_C55 5510 ++#define DSPPROCTYPE_C64 6410 ++#define IVAPROCTYPE_ARM7 470 ++/* registry */ ++#define DEVNODESTRING "DevNode" /* u32 devnode */ ++#define CONFIG "Software\\TexasInstruments\\DirectDSP\\Config" ++#define DRVOBJECT "DrvObject" ++#define MGROBJECT "MgrObject" ++#define CLASS "Device" /* device class */ ++#define TRACE "Trace" /* GT Trace settings. */ ++#define PERFR "Perf" /* Enable perf bool. */ ++#define ROOT "Root" /* root dir */ ++ ++/* MiniDriver related definitions */ ++/* The following definitions are under "Drivers\\DirectDSP\\Device\\XXX " ++ * Where XXX is the device or board name */ ++ ++#define WMDFILENAME "MiniDriver" /* WMD entry name */ ++#define CHIPTYPE "ChipType" /* Chip type */ ++#define CHIPNUM "NumChips" /* Number of chips */ ++#define NUMPROCS "NumOfProcessors" /* Number of processors */ ++#define DEFEXEC "DefaultExecutable" /* Default executable */ ++#define AUTOSTART "AutoStart" /* Statically load flag */ ++#define IVAAUTOSTART "IvaAutoStart" /* Statically load flag */ ++#define BOARDNAME "BoardName" /* Name of the Board */ ++#define UNITNUMBER "UnitNumber" /* Unit # of the Board */ ++#define BUSTYPE "BusType" /* Bus type board is on */ ++#define BUSNUMBER "BusNumber" /* Bus number board is on */ ++#define CURRENTCONFIG "CurrentConfig" /* Current resources */ ++#define PCIVENDEVID "VendorDeviceId" /* The board's id */ ++#define INFPATH "InfPath" /* wmd's inf filename */ ++#define DEVOBJECT "DevObject" ++#define ZLFILENAME "ZLFileName" /* Name of ZL file */ ++#define WORDSIZE "WordSize" /* NumBytes in DSP Word */ ++#define SHMSIZE "SHMSize" /* Size of SHM reservd on MPU */ ++#define IVAEXTMEMSIZE "IVAEXTMEMSize" /* IVA External Memeory size */ ++#define TCWORDSWAP "TCWordSwap" /* Traffic Contoller Word Swap */ ++#define DSPRESOURCES "DspTMSResources" /* C55 DSP resurces on OMAP */ ++#define IVA1RESOURCES "ARM7IvaResources" /* ARM7 IVA resurces on OMAP */ ++#define PHYSMEMPOOLBASE "PhysicalMemBase" /* Physical mem passed to driver */ ++#define PHYSMEMPOOLSIZE "PhysicalMemSize" /* Physical mem passed to driver */ ++ ++#endif /* DBREG_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dbtype.h b/arch/arm/plat-omap/include/dspbridge/dbtype.h +new file mode 100644 +index 0000000..b4953a0 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dbtype.h +@@ -0,0 +1,103 @@ ++/* ++ * dbtype.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbtype.h ======== ++ * Description: ++ * This header defines data types for DSP/BIOS Bridge APIs and device ++ * driver modules. It also defines the Hungarian ++ * prefix to use for each base type. ++ * ++ * ++ *! Revision History: ++ *! ================= ++ *! 23-Nov-2002 gp: Purpose -> Description in file header. ++ *! 13-Feb-2001 kc: Name changed from ddsptype.h dbtype.h. ++ *! 09-Oct-2000 jeh Added CHARACTER. ++ *! 11-Aug-2000 ag: Added 'typedef void void'. ++ *! 08-Apr-2000 ww: Cloned. ++ */ ++ ++#ifndef DBTYPE_ ++#define DBTYPE_ ++ ++/*============================================================================*/ ++/* Argument specification syntax */ ++/*============================================================================*/ ++ ++#ifndef IN ++#define IN /* Following parameter is for input. */ ++#endif ++ ++#ifndef OUT ++#define OUT /* Following parameter is for output. */ ++#endif ++ ++#ifndef OPTIONAL ++#define OPTIONAL /* Function may optionally use previous parameter. */ ++#endif ++ ++#ifndef CONST ++#define CONST const ++#endif ++ ++/*============================================================================*/ ++/* Boolean constants */ ++/*============================================================================*/ ++ ++#ifndef FALSE ++#define FALSE 0 ++#endif ++#ifndef TRUE ++#define TRUE 1 ++#endif ++ ++/*============================================================================*/ ++/* NULL (Definition is language specific) */ ++/*============================================================================*/ ++ ++#ifndef NULL ++#define NULL ((void *)0) /* Null pointer. */ ++#endif ++ ++/*============================================================================*/ ++/* NULL character (normally used for string termination) */ ++/*============================================================================*/ ++ ++#ifndef NULL_CHAR ++#define NULL_CHAR '\0' /* Null character. */ ++#endif ++ ++/*============================================================================*/ ++/* Basic Type definitions (with Prefixes for Hungarian notation) */ ++/*============================================================================*/ ++ ++#ifndef OMAPBRIDGE_TYPES ++#define OMAPBRIDGE_TYPES ++typedef volatile unsigned short REG_UWORD16; ++#endif ++ ++typedef void *HANDLE; /* h */ ++ ++#define TEXT(x) x ++ ++#define DLLIMPORT ++#define DLLEXPORT ++ ++/* Define DSPAPIDLL correctly in dspapi.h */ ++#define _DSPSYSDLL32_ ++ ++#endif /* DBTYPE_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dehdefs.h b/arch/arm/plat-omap/include/dspbridge/dehdefs.h +new file mode 100644 +index 0000000..06e5582 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dehdefs.h +@@ -0,0 +1,42 @@ ++/* ++ * dehdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dehdefs.h ======== ++ * Purpose: ++ * Definition for mini-driver module DEH. ++ * ++ *! Revision History: ++ *! ================ ++ *! 17-Dec-2001 ag: added #include <dspbridge/mbx_sh.h> for shared mailbox codes. ++ *! 10-Dec-2001 kc: added DEH error base value and error max value. ++ *! 11-Sep-2001 kc: created. ++ */ ++ ++#ifndef DEHDEFS_ ++#define DEHDEFS_ ++ ++#include <dspbridge/mbx_sh.h> /* shared mailbox codes */ ++ ++/* DEH object manager */ ++ struct DEH_MGR; ++ ++/* Magic code used to determine if DSP signaled exception. */ ++#define DEH_BASE MBX_DEH_BASE ++#define DEH_USERS_BASE MBX_DEH_USERS_BASE ++#define DEH_LIMIT MBX_DEH_LIMIT ++ ++#endif /* _DEHDEFS_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dev.h b/arch/arm/plat-omap/include/dspbridge/dev.h +new file mode 100644 +index 0000000..5f468c9 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dev.h +@@ -0,0 +1,785 @@ ++/* ++ * dev.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dev.h ======== ++ * Description: ++ * 'Bridge Mini-driver device operations. ++ * ++ * Public Functions: ++ * DEV_BrdWriteFxn ++ * DEV_CreateDevice ++ * DEV_Create2 ++ * DEV_Destroy2 ++ * DEV_DestroyDevice ++ * DEV_GetChnlMgr ++ * DEV_GetCmmMgr ++ * DEV_GetCodMgr ++ * DEV_GetDehMgr ++ * DEV_GetDevNode ++ * DEV_GetDSPWordSize ++ * DEV_GetFirst ++ * DEV_GetIntfFxns ++ * DEV_GetIOMgr ++ * DEV_GetMsgMgr ++ * DEV_GetNext ++ * DEV_GetNodeManager ++ * DEV_GetSymbol ++ * DEV_GetWMDContext ++ * DEV_Exit ++ * DEV_Init ++ * DEV_InsertProcObject ++ * DEV_IsLocked ++ * DEV_NotifyClient ++ * DEV_RegisterNotify ++ * DEV_ReleaseCodMgr ++ * DEV_RemoveDevice ++ * DEV_RemoveProcObject ++ * DEV_SetChnlMgr ++ * DEV_SetMsgMgr ++ * DEV_SetLockOwner ++ * DEV_StartDevice ++ * ++ *! Revision History: ++ *! ================ ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping feature - Dev_GetDmmMgr ++ *! 09-Feb-2004 vp Added functions required for IVA ++ *! 25-Feb-2003 swa PMGR Code Review changes incorporated ++ *! 05-Nov-2001 kc: Added DEV_GetDehMgr. ++ *! 05-Dec-2000 jeh Added DEV_SetMsgMgr. ++ *! 29-Nov-2000 rr: Incorporated code review changes. ++ *! 17-Nov-2000 jeh Added DEV_GetMsgMgr. ++ *! 05-Oct-2000 rr: DEV_Create2 & DEV_Destroy2 Added. ++ *! 02-Oct-2000 rr: Added DEV_GetNodeManager. ++ *! 11-Aug-2000 ag: Added DEV_GetCmmMgr() for shared memory management. ++ *! 10-Aug-2000 rr: DEV_InsertProcObject/RemoveProcObject added. ++ *! 06-Jun-2000 jeh Added DEV_GetSymbol(). ++ *! 05-Nov-1999 kc: Updated function prototypes. ++ *! 08-Oct-1997 cr: Added explicit CDECL function identifiers. ++ *! 07-Nov-1996 gp: Updated for code review. ++ *! 22-Oct-1996 gp: Added DEV_CleanupProcessState(). ++ *! 29-May-1996 gp: Changed DEV_HDEVNODE --> CFG_HDEVNODE. ++ *! 18-May-1996 gp: Created. ++ */ ++ ++#ifndef DEV_ ++#define DEV_ ++ ++/* ----------------------------------- Module Dependent Headers */ ++#include <dspbridge/chnldefs.h> ++#include <dspbridge/cmm.h> ++#include <dspbridge/cod.h> ++#include <dspbridge/dehdefs.h> ++#include <dspbridge/nodedefs.h> ++#include <dspbridge/dispdefs.h> ++#include <dspbridge/wmd.h> ++#include <dspbridge/dmm.h> ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/devdefs.h> ++ ++ ++/* ++ * ======== DEV_BrdWriteFxn ======== ++ * Purpose: ++ * Exported function to be used as the COD write function. This function ++ * is passed a handle to a DEV_hObject by ZL in pArb, then calls the ++ * device's WMD_BRD_Write() function. ++ * Parameters: ++ * pArb: Handle to a Device Object. ++ * hDevContext: Handle to mini-driver defined device info. ++ * dwDSPAddr: Address on DSP board (Destination). ++ * pHostBuf: Pointer to host buffer (Source). ++ * ulNumBytes: Number of bytes to transfer. ++ * ulMemType: Memory space on DSP to which to transfer. ++ * Returns: ++ * Number of bytes written. Returns 0 if the DEV_hObject passed in via ++ * pArb is invalid. ++ * Requires: ++ * DEV Initialized. ++ * pHostBuf != NULL ++ * Ensures: ++ */ ++ extern u32 DEV_BrdWriteFxn(void *pArb, ++ u32 ulDspAddr, ++ void *pHostBuf, ++ u32 ulNumBytes, u32 nMemSpace); ++ ++/* ++ * ======== DEV_CreateDevice ======== ++ * Purpose: ++ * Called by the operating system to load the 'Bridge Mini Driver for a ++ * 'Bridge device. ++ * Parameters: ++ * phDevObject: Ptr to location to receive the device object handle. ++ * pstrWMDFileName: Name of WMD PE DLL file to load. If the absolute ++ * path is not provided, the file is loaded through ++ * 'Bridge's module search path. ++ * pHostConfig: Host configuration information, to be passed down ++ * to the WMD when WMD_DEV_Create() is called. ++ * pDspConfig: DSP resources, to be passed down to the WMD when ++ * WMD_DEV_Create() is called. ++ * hDevNode: Platform (Windows) specific device node. ++ * Returns: ++ * DSP_SOK: Module is loaded, device object has been created ++ * DSP_EMEMORY: Insufficient memory to create needed resources. ++ * DEV_E_NEWWMD: The WMD was compiled for a newer version of WCD. ++ * DEV_E_NULLWMDINTF: WMD passed back a NULL Fxn Interface Struct Ptr ++ * DEV_E_NOCODMODULE: No ZL file name was specified in the registry ++ * for this hDevNode. ++ * LDR_E_FILEUNABLETOOPEN: Unable to open the specified WMD. ++ * LDR_E_NOMEMORY: PELDR is out of resources. ++ * DSP_EFAIL: Unable to find WMD entry point function. ++ * COD_E_NOZLFUNCTIONS: One or more ZL functions exports not found. ++ * COD_E_ZLCREATEFAILED: Unable to load ZL DLL. ++ * Requires: ++ * DEV Initialized. ++ * phDevObject != NULL. ++ * pstrWMDFileName != NULL. ++ * pHostConfig != NULL. ++ * pDspConfig != NULL. ++ * Ensures: ++ * DSP_SOK: *phDevObject will contain handle to the new device object. ++ * Otherwise, does not create the device object, ensures the WMD module is ++ * unloaded, and sets *phDevObject to NULL. ++ */ ++ extern DSP_STATUS DEV_CreateDevice(OUT struct DEV_OBJECT ++ **phDevObject, ++ IN CONST char *pstrWMDFileName, ++ IN CONST struct CFG_HOSTRES ++ *pHostConfig, ++ IN CONST struct CFG_DSPRES ++ *pDspConfig, ++ struct CFG_DEVNODE *hDevNode); ++ ++/* ++ * ======== DEV_CreateIVADevice ======== ++ * Purpose: ++ * Called by the operating system to load the 'Bridge Mini Driver for IVA. ++ * Parameters: ++ * phDevObject: Ptr to location to receive the device object handle. ++ * pstrWMDFileName: Name of WMD PE DLL file to load. If the absolute ++ * path is not provided, the file is loaded through ++ * 'Bridge's module search path. ++ * pHostConfig: Host configuration information, to be passed down ++ * to the WMD when WMD_DEV_Create() is called. ++ * pDspConfig: DSP resources, to be passed down to the WMD when ++ * WMD_DEV_Create() is called. ++ * hDevNode: Platform (Windows) specific device node. ++ * Returns: ++ * DSP_SOK: Module is loaded, device object has been created ++ * DSP_EMEMORY: Insufficient memory to create needed resources. ++ * DEV_E_NEWWMD: The WMD was compiled for a newer version of WCD. ++ * DEV_E_NULLWMDINTF: WMD passed back a NULL Fxn Interface Struct Ptr ++ * DEV_E_NOCODMODULE: No ZL file name was specified in the registry ++ * for this hDevNode. ++ * LDR_E_FILEUNABLETOOPEN: Unable to open the specified WMD. ++ * LDR_E_NOMEMORY: PELDR is out of resources. ++ * DSP_EFAIL: Unable to find WMD entry point function. ++ * COD_E_NOZLFUNCTIONS: One or more ZL functions exports not found. ++ * COD_E_ZLCREATEFAILED: Unable to load ZL DLL. ++ * Requires: ++ * DEV Initialized. ++ * phDevObject != NULL. ++ * pstrWMDFileName != NULL. ++ * pHostConfig != NULL. ++ * pDspConfig != NULL. ++ * Ensures: ++ * DSP_SOK: *phDevObject will contain handle to the new device object. ++ * Otherwise, does not create the device object, ensures the WMD module is ++ * unloaded, and sets *phDevObject to NULL. ++ */ ++ extern DSP_STATUS DEV_CreateIVADevice(OUT struct DEV_OBJECT ++ **phDevObject, ++ IN CONST char *pstrWMDFileName, ++ IN CONST struct CFG_HOSTRES *pHostConfig, ++ IN CONST struct CFG_DSPRES *pDspConfig, ++ struct CFG_DEVNODE *hDevNode); ++ ++/* ++ * ======== DEV_Create2 ======== ++ * Purpose: ++ * After successful loading of the image from WCD_InitComplete2 ++ * (PROC Auto_Start) or PROC_Load this fxn is called. This creates ++ * the Node Manager and updates the DEV Object. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice(). ++ * Returns: ++ * DSP_SOK: Successful Creation of Node Manager ++ * DSP_EFAIL: Some Error Occurred. ++ * Requires: ++ * DEV Initialized ++ * Valid hDevObject ++ * Ensures: ++ * DSP_SOK and hDevObject->hNodeMgr != NULL ++ * else hDevObject->hNodeMgr == NULL ++ */ ++ extern DSP_STATUS DEV_Create2(IN struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== DEV_Destroy2 ======== ++ * Purpose: ++ * Destroys the Node manager for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice(). ++ * Returns: ++ * DSP_SOK: Successful Creation of Node Manager ++ * DSP_EFAIL: Some Error Occurred. ++ * Requires: ++ * DEV Initialized ++ * Valid hDevObject ++ * Ensures: ++ * DSP_SOK and hDevObject->hNodeMgr == NULL ++ * else DSP_EFAIL. ++ */ ++ extern DSP_STATUS DEV_Destroy2(IN struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== DEV_DestroyDevice ======== ++ * Purpose: ++ * Destroys the channel manager for this device, if any, calls ++ * WMD_DEV_Destroy(), and then attempts to unload the WMD module. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * DSP_EFAIL: The WMD failed it's WMD_DEV_Destroy() function. ++ * Requires: ++ * DEV Initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS DEV_DestroyDevice(struct DEV_OBJECT ++ *hDevObject); ++ ++/* ++ * ======== DEV_GetChnlMgr ======== ++ * Purpose: ++ * Retrieve the handle to the channel manager created for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *phMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phMgr != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phMgr contains a handle to a channel manager object, ++ * or NULL. ++ * else: *phMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetChnlMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct CHNL_MGR **phMgr); ++ ++/* ++ * ======== DEV_GetCmmMgr ======== ++ * Purpose: ++ * Retrieve the handle to the shared memory manager created for this ++ * device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *phMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phMgr != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phMgr contains a handle to a channel manager object, ++ * or NULL. ++ * else: *phMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetCmmMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct CMM_OBJECT **phMgr); ++ ++/* ++ * ======== DEV_GetDmmMgr ======== ++ * Purpose: ++ * Retrieve the handle to the dynamic memory manager created for this ++ * device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *phMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phMgr != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phMgr contains a handle to a channel manager object, ++ * or NULL. ++ * else: *phMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetDmmMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct DMM_OBJECT **phMgr); ++ ++/* ++ * ======== DEV_GetCodMgr ======== ++ * Purpose: ++ * Retrieve the COD manager create for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *phCodMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phCodMgr != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phCodMgr contains a handle to a COD manager object. ++ * else: *phCodMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetCodMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct COD_MANAGER **phCodMgr); ++ ++/* ++ * ======== DEV_GetDehMgr ======== ++ * Purpose: ++ * Retrieve the DEH manager created for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice(). ++ * *phDehMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phDehMgr != NULL. ++ * DEH Initialized. ++ * Ensures: ++ * DSP_SOK: *phDehMgr contains a handle to a DEH manager object. ++ * else: *phDehMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetDehMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct DEH_MGR **phDehMgr); ++ ++/* ++ * ======== DEV_GetDevNode ======== ++ * Purpose: ++ * Retrieve the platform specific device ID for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * phDevNode: Ptr to location to get the device node handle. ++ * Returns: ++ * DSP_SOK: In Win95, returns a DEVNODE in *hDevNode; In NT, ??? ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phDevNode != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phDevNode contains a platform specific device ID; ++ * else: *phDevNode is NULL. ++ */ ++ extern DSP_STATUS DEV_GetDevNode(struct DEV_OBJECT *hDevObject, ++ OUT struct CFG_DEVNODE **phDevNode); ++ ++/* ++ * ======== DEV_GetDevType ======== ++ * Purpose: ++ * Retrieve the platform specific device ID for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * phDevNode: Ptr to location to get the device node handle. ++ * Returns: ++ * DSP_SOK: Success ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phDevNode != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phDevNode contains a platform specific device ID; ++ * else: *phDevNode is NULL. ++ */ ++ extern DSP_STATUS DEV_GetDevType(struct DEV_OBJECT *hdevObject, ++ u32 *devType); ++ ++/* ++ * ======== DEV_GetFirst ======== ++ * Purpose: ++ * Retrieve the first Device Object handle from an internal linked list of ++ * of DEV_OBJECTs maintained by DEV. ++ * Parameters: ++ * Returns: ++ * NULL if there are no device objects stored; else ++ * a valid DEV_HOBJECT. ++ * Requires: ++ * No calls to DEV_CreateDevice or DEV_DestroyDevice (which my modify the ++ * internal device object list) may occur between calls to DEV_GetFirst ++ * and DEV_GetNext. ++ * Ensures: ++ * The DEV_HOBJECT returned is valid. ++ * A subsequent call to DEV_GetNext will return the next device object in ++ * the list. ++ */ ++ extern struct DEV_OBJECT *DEV_GetFirst(void); ++ ++/* ++ * ======== DEV_GetIntfFxns ======== ++ * Purpose: ++ * Retrieve the WMD interface function structure for the loaded WMD. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *ppIntfFxns: Ptr to location to store fxn interface. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * ppIntfFxns != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *ppIntfFxns contains a pointer to the WMD interface; ++ * else: *ppIntfFxns is NULL. ++ */ ++ extern DSP_STATUS DEV_GetIntfFxns(struct DEV_OBJECT *hDevObject, ++ OUT struct WMD_DRV_INTERFACE **ppIntfFxns); ++ ++/* ++ * ======== DEV_GetIOMgr ======== ++ * Purpose: ++ * Retrieve the handle to the IO manager created for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * *phMgr: Ptr to location to store handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phMgr != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phMgr contains a handle to an IO manager object. ++ * else: *phMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetIOMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct IO_MGR **phMgr); ++ ++/* ++ * ======== DEV_GetNext ======== ++ * Purpose: ++ * Retrieve the next Device Object handle from an internal linked list of ++ * of DEV_OBJECTs maintained by DEV, after having previously called ++ * DEV_GetFirst() and zero or more DEV_GetNext ++ * Parameters: ++ * hDevObject: Handle to the device object returned from a previous ++ * call to DEV_GetFirst() or DEV_GetNext(). ++ * Returns: ++ * NULL if there are no further device objects on the list or hDevObject ++ * was invalid; ++ * else the next valid DEV_HOBJECT in the list. ++ * Requires: ++ * No calls to DEV_CreateDevice or DEV_DestroyDevice (which my modify the ++ * internal device object list) may occur between calls to DEV_GetFirst ++ * and DEV_GetNext. ++ * Ensures: ++ * The DEV_HOBJECT returned is valid. ++ * A subsequent call to DEV_GetNext will return the next device object in ++ * the list. ++ */ ++ extern struct DEV_OBJECT *DEV_GetNext(struct DEV_OBJECT ++ *hDevObject); ++ ++/* ++ * ========= DEV_GetMsgMgr ======== ++ * Purpose: ++ * Retrieve the MSG Manager Handle from the DevObject. ++ * Parameters: ++ * hDevObject: Handle to the Dev Object ++ * phMsgMgr: Location where MSG Manager handle will be returned. ++ * Returns: ++ * Requires: ++ * DEV Initialized. ++ * Valid hDevObject. ++ * phNodeMgr != NULL. ++ * Ensures: ++ */ ++ extern void DEV_GetMsgMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct MSG_MGR **phMsgMgr); ++ ++/* ++ * ========= DEV_GetNodeManager ======== ++ * Purpose: ++ * Retrieve the Node Manager Handle from the DevObject. It is an ++ * accessor function ++ * Parameters: ++ * hDevObject: Handle to the Dev Object ++ * phNodeMgr: Location where Handle to the Node Manager will be ++ * returned.. ++ * Returns: ++ * DSP_SOK: Success ++ * DSP_EHANDLE: Invalid Dev Object handle. ++ * Requires: ++ * DEV Initialized. ++ * phNodeMgr is not null ++ * Ensures: ++ * DSP_SOK: *phNodeMgr contains a handle to a Node manager object. ++ * else: *phNodeMgr is NULL. ++ */ ++ extern DSP_STATUS DEV_GetNodeManager(struct DEV_OBJECT ++ *hDevObject, ++ OUT struct NODE_MGR **phNodeMgr); ++ ++/* ++ * ======== DEV_GetSymbol ======== ++ * Purpose: ++ * Get the value of a symbol in the currently loaded program. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * pstrSym: Name of symbol to look up. ++ * pulValue: Ptr to symbol value. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * COD_E_NOSYMBOLSLOADED: Symbols have not been loaded onto the board. ++ * COD_E_SYMBOLNOTFOUND: The symbol could not be found. ++ * Requires: ++ * pstrSym != NULL. ++ * pulValue != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *pulValue contains the symbol value; ++ */ ++ extern DSP_STATUS DEV_GetSymbol(struct DEV_OBJECT *hDevObject, ++ IN CONST char *pstrSym, ++ OUT u32 *pulValue); ++ ++/* ++ * ======== DEV_GetWMDContext ======== ++ * Purpose: ++ * Retrieve the WMD Context handle, as returned by the WMD_Create fxn. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice() ++ * *phWmdContext: Ptr to location to store context handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * phWmdContext != NULL. ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: *phWmdContext contains context handle; ++ * else: *phWmdContext is NULL; ++ */ ++ extern DSP_STATUS DEV_GetWMDContext(struct DEV_OBJECT *hDevObject, ++ OUT struct WMD_DEV_CONTEXT **phWmdContext); ++ ++/* ++ * ======== DEV_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * DEV is initialized. ++ * Ensures: ++ * When reference count == 0, DEV's private resources are freed. ++ */ ++ extern void DEV_Exit(void); ++ ++/* ++ * ======== DEV_Init ======== ++ * Purpose: ++ * Initialize DEV's private state, keeping a reference count on each call. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * TRUE: A requirement for the other public DEV functions. ++ */ ++ extern bool DEV_Init(void); ++ ++/* ++ * ======== DEV_IsLocked ======== ++ * Purpose: ++ * Predicate function to determine if the device has been ++ * locked by a client for exclusive access. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * Returns: ++ * DSP_SOK: TRUE: device has been locked. ++ * DSP_SFALSE: FALSE: device not locked. ++ * DSP_EHANDLE: hDevObject was invalid. ++ * Requires: ++ * DEV Initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS DEV_IsLocked(IN struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== DEV_InsertProcObject ======== ++ * Purpose: ++ * Inserts the Processor Object into the List of PROC Objects ++ * kept in the DEV Object ++ * Parameters: ++ * hProcObject: Handle to the Proc Object ++ * hDevObject Handle to the Dev Object ++ * bAttachedNew Specifies if there are already processors attached ++ * Returns: ++ * DSP_SOK: Successfully inserted into the list ++ * Requires: ++ * hProcObject is not NULL ++ * hDevObject is a valid handle to the DEV. ++ * DEV Initialized. ++ * List(of Proc object in Dev) Exists. ++ * Ensures: ++ * DSP_SOK & the PROC Object is inserted and the list is not empty ++ * Details: ++ * If the List of Proc Object is empty bAttachedNew is TRUE, it indicated ++ * this is the first Processor attaching. ++ * If it is False, there are already processors attached. ++ */ ++ extern DSP_STATUS DEV_InsertProcObject(IN struct DEV_OBJECT ++ *hDevObject, ++ IN u32 hProcObject, ++ OUT bool * ++ pbAlreadyAttached); ++ ++/* ++ * ======== DEV_RemoveProcObject ======== ++ * Purpose: ++ * Search for and remove a Proc object from the given list maintained ++ * by the DEV ++ * Parameters: ++ * pProcObject: Ptr to ProcObject to insert. ++ * pDevObject: Ptr to Dev Object where the list is. ++ * pbAlreadyAttached: Ptr to return the bool ++ * Returns: ++ * DSP_SOK: If successful. ++ * DSP_EFAIL Failure to Remove the PROC Object from the list ++ * Requires: ++ * DevObject is Valid ++ * hProcObject != 0 ++ * pDevObject->procList != NULL ++ * !LST_IsEmpty(pDevObject->procList) ++ * pbAlreadyAttached !=NULL ++ * Ensures: ++ * Details: ++ * List will be deleted when the DEV is destroyed. ++ * ++ */ ++ extern DSP_STATUS DEV_RemoveProcObject(struct DEV_OBJECT ++ *hDevObject, ++ u32 hProcObject); ++ ++/* ++ * ======== DEV_NotifyClients ======== ++ * Purpose: ++ * Notify all clients of this device of a change in device status. ++ * Clients may include multiple users of BRD, as well as CHNL. ++ * This function is asychronous, and may be called by a timer event ++ * set up by a watchdog timer. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice(). ++ * ulStatus: A status word, most likely a BRD_STATUS. ++ * Returns: ++ * DSP_SOK: All registered clients were asynchronously notified. ++ * DSP_EINVALIDARG: Invalid hDevObject. ++ * Requires: ++ * DEV Initialized. ++ * Ensures: ++ * DSP_SOK: Notifications are queued by the operating system to be ++ * delivered to clients. This function does not ensure that ++ * the notifications will ever be delivered. ++ */ ++ extern DSP_STATUS DEV_NotifyClients(struct DEV_OBJECT *hDevObject, ++ u32 ulStatus); ++ ++ ++ ++/* ++ * ======== DEV_RemoveDevice ======== ++ * Purpose: ++ * Destroys the Device Object created by DEV_StartDevice. ++ * Parameters: ++ * hDevNode: Device node as it is know to OS. ++ * Returns: ++ * DSP_SOK: If success; ++ * <error code> Otherwise. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS DEV_RemoveDevice(struct CFG_DEVNODE *hDevNode); ++ ++/* ++ * ======== DEV_SetChnlMgr ======== ++ * Purpose: ++ * Set the channel manager for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * hMgr: Handle to a channel manager, or NULL. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * DEV Initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS DEV_SetChnlMgr(struct DEV_OBJECT *hDevObject, ++ struct CHNL_MGR *hMgr); ++ ++/* ++ * ======== DEV_SetMsgMgr ======== ++ * Purpose: ++ * Set the Message manager for this device. ++ * Parameters: ++ * hDevObject: Handle to device object created with DEV_CreateDevice(). ++ * hMgr: Handle to a message manager, or NULL. ++ * Returns: ++ * Requires: ++ * DEV Initialized. ++ * Ensures: ++ */ ++ extern void DEV_SetMsgMgr(struct DEV_OBJECT *hDevObject, ++ struct MSG_MGR *hMgr); ++ ++/* ++ * ======== DEV_StartDevice ======== ++ * Purpose: ++ * Initializes the new device with the WinBRIDGE environment. This ++ * involves querying CM for allocated resources, querying the registry ++ * for necessary dsp resources (requested in the INF file), and using ++ * this information to create a WinBRIDGE device object. ++ * Parameters: ++ * hDevNode: Device node as it is know to OS. ++ * Returns: ++ * DSP_SOK: If success; ++ * <error code> Otherwise. ++ * Requires: ++ * DEV initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS DEV_StartDevice(struct CFG_DEVNODE *hDevNode); ++ ++#endif /* DEV_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/devdefs.h b/arch/arm/plat-omap/include/dspbridge/devdefs.h +new file mode 100644 +index 0000000..e9ff725 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/devdefs.h +@@ -0,0 +1,35 @@ ++/* ++ * devdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== devdefs.h ======== ++ * Purpose: ++ * Definition of common include typedef between wmd.h and dev.h. Required ++ * to break circular dependency between WMD and DEV include files. ++ * ++ *! Revision History: ++ *! ================ ++ *! 12-Nov-1996 gp: Renamed from dev1.h. ++ *! 30-May-1996 gp: Broke out from dev.h ++ */ ++ ++#ifndef DEVDEFS_ ++#define DEVDEFS_ ++ ++/* WCD Device Object */ ++ struct DEV_OBJECT; ++ ++#endif /* DEVDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/disp.h b/arch/arm/plat-omap/include/dspbridge/disp.h +new file mode 100644 +index 0000000..e116734 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/disp.h +@@ -0,0 +1,236 @@ ++/* ++ * disp.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== disp.h ======== ++ * ++ * Description: ++ * DSP/BIOS Bridge Node Dispatcher. ++ * ++ * Public Functions: ++ * DISP_Create ++ * DISP_Delete ++ * DISP_Exit ++ * DISP_Init ++ * DISP_NodeChangePriority ++ * DISP_NodeCreate ++ * DISP_NodeDelete ++ * DISP_NodeRun ++ * ++ *! Revision History: ++ *! ================= ++ *! 28-Jan-2003 map Removed DISP_DoCinit(). ++ *! 15-May-2002 jeh Added DISP_DoCinit(). ++ *! 24-Apr-2002 jeh Added DISP_MemWrite(). ++ *! 07-Sep-2001 jeh Added DISP_MemCopy(). ++ *! 10-May-2001 jeh Code review cleanup. ++ *! 08-Aug-2000 jeh Removed DISP_NodeTerminate since it no longer uses RMS. ++ *! 17-Jul-2000 jeh Updates to function headers. ++ *! 19-Jun-2000 jeh Created. ++ */ ++ ++#ifndef DISP_ ++#define DISP_ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/nodedefs.h> ++#include <dspbridge/nodepriv.h> ++#include <dspbridge/dispdefs.h> ++ ++/* ++ * ======== DISP_Create ======== ++ * Create a NODE Dispatcher object. This object handles the creation, ++ * deletion, and execution of nodes on the DSP target, through communication ++ * with the Resource Manager Server running on the target. Each NODE ++ * Manager object should have exactly one NODE Dispatcher. ++ * ++ * Parameters: ++ * phDispObject: Location to store node dispatcher object on output. ++ * hDevObject: Device for this processor. ++ * pDispAttrs: Node dispatcher attributes. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * DSP_EFAIL: Unable to create dispatcher. ++ * Requires: ++ * DISP_Init(void) called. ++ * pDispAttrs != NULL. ++ * hDevObject != NULL. ++ * phDispObject != NULL. ++ * Ensures: ++ * DSP_SOK: IsValid(*phDispObject). ++ * error: *phDispObject == NULL. ++ */ ++ extern DSP_STATUS DISP_Create(OUT struct DISP_OBJECT **phDispObject, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct DISP_ATTRS *pDispAttrs); ++ ++/* ++ * ======== DISP_Delete ======== ++ * Delete the NODE Dispatcher. ++ * ++ * Parameters: ++ * hDispObject: Node Dispatcher object. ++ * Returns: ++ * Requires: ++ * DISP_Init(void) called. ++ * Valid hDispObject. ++ * Ensures: ++ * hDispObject is invalid. ++ */ ++ extern void DISP_Delete(struct DISP_OBJECT *hDispObject); ++ ++/* ++ * ======== DISP_Exit ======== ++ * Discontinue usage of DISP module. ++ * ++ * Parameters: ++ * Returns: ++ * Requires: ++ * DISP_Init(void) previously called. ++ * Ensures: ++ * Any resources acquired in DISP_Init(void) will be freed when last DISP ++ * client calls DISP_Exit(void). ++ */ ++ extern void DISP_Exit(void); ++ ++/* ++ * ======== DISP_Init ======== ++ * Initialize the DISP module. ++ * ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Ensures: ++ */ ++ extern bool DISP_Init(void); ++ ++/* ++ * ======== DISP_NodeChangePriority ======== ++ * Change the priority of a node currently running on the target. ++ * ++ * Parameters: ++ * hDispObject: Node Dispatcher object. ++ * hNode: Node object representing a node currently ++ * allocated or running on the DSP. ++ * ulFxnAddress: Address of RMS function for changing priority. ++ * nodeEnv: Address of node's environment structure. ++ * nPriority: New priority level to set node's priority to. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * Requires: ++ * DISP_Init(void) called. ++ * Valid hDispObject. ++ * hNode != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DISP_NodeChangePriority(struct DISP_OBJECT ++ *hDispObject, ++ struct NODE_OBJECT *hNode, ++ u32 ulFxnAddr, ++ NODE_ENV nodeEnv, ++ s32 nPriority); ++ ++/* ++ * ======== DISP_NodeCreate ======== ++ * Create a node on the DSP by remotely calling the node's create function. ++ * ++ * Parameters: ++ * hDispObject: Node Dispatcher object. ++ * hNode: Node handle obtained from NODE_Allocate(). ++ * ulFxnAddr: Address or RMS create node function. ++ * ulCreateFxn: Address of node's create function. ++ * pArgs: Arguments to pass to RMS node create function. ++ * pNodeEnv: Location to store node environment pointer on ++ * output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETASK: Unable to create the node's task or process on the DSP. ++ * DSP_ESTREAM: Stream creation failure on the DSP. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_EUSER: A user-defined failure occurred. ++ * DSP_EFAIL: A failure occurred, unable to create node. ++ * Requires: ++ * DISP_Init(void) called. ++ * Valid hDispObject. ++ * pArgs != NULL. ++ * hNode != NULL. ++ * pNodeEnv != NULL. ++ * NODE_GetType(hNode) != NODE_DEVICE. ++ * Ensures: ++ */ ++ extern DSP_STATUS DISP_NodeCreate(struct DISP_OBJECT *hDispObject, ++ struct NODE_OBJECT *hNode, ++ u32 ulFxnAddr, ++ u32 ulCreateFxn, ++ IN CONST struct NODE_CREATEARGS ++ *pArgs, ++ OUT NODE_ENV *pNodeEnv); ++ ++/* ++ * ======== DISP_NodeDelete ======== ++ * Delete a node on the DSP by remotely calling the node's delete function. ++ * ++ * Parameters: ++ * hDispObject: Node Dispatcher object. ++ * hNode: Node object representing a node currently ++ * loaded on the DSP. ++ * ulFxnAddr: Address or RMS delete node function. ++ * ulDeleteFxn: Address of node's delete function. ++ * nodeEnv: Address of node's environment structure. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * Requires: ++ * DISP_Init(void) called. ++ * Valid hDispObject. ++ * hNode != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DISP_NodeDelete(struct DISP_OBJECT *hDispObject, ++ struct NODE_OBJECT *hNode, ++ u32 ulFxnAddr, ++ u32 ulDeleteFxn, NODE_ENV nodeEnv); ++ ++/* ++ * ======== DISP_NodeRun ======== ++ * Start execution of a node's execute phase, or resume execution of a node ++ * that has been suspended (via DISP_NodePause()) on the DSP. ++ * ++ * Parameters: ++ * hDispObject: Node Dispatcher object. ++ * hNode: Node object representing a node to be executed ++ * on the DSP. ++ * ulFxnAddr: Address or RMS node execute function. ++ * ulExecuteFxn: Address of node's execute function. ++ * nodeEnv: Address of node's environment structure. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * Requires: ++ * DISP_Init(void) called. ++ * Valid hDispObject. ++ * hNode != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS DISP_NodeRun(struct DISP_OBJECT *hDispObject, ++ struct NODE_OBJECT *hNode, ++ u32 ulFxnAddr, ++ u32 ulExecuteFxn, NODE_ENV nodeEnv); ++ ++#endif /* DISP_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dispdefs.h b/arch/arm/plat-omap/include/dspbridge/dispdefs.h +new file mode 100644 +index 0000000..401ad4f +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dispdefs.h +@@ -0,0 +1,45 @@ ++/* ++ * dispdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dispdefs.h ======== ++ * Description: ++ * Global DISP constants and types, shared by PROCESSOR, NODE, and DISP. ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Aug-2000 jeh Added fields to DISP_ATTRS. ++ *! 06-Jul-2000 jeh Created. ++ */ ++ ++#ifndef DISPDEFS_ ++#define DISPDEFS_ ++ ++ struct DISP_OBJECT; ++ ++/* Node Dispatcher attributes */ ++ struct DISP_ATTRS { ++ u32 ulChnlOffset; /* Offset of channel ids reserved for RMS */ ++ /* Size of buffer for sending data to RMS */ ++ u32 ulChnlBufSize; ++ DSP_PROCFAMILY procFamily; /* eg, 5000 */ ++ DSP_PROCTYPE procType; /* eg, 5510 */ ++ HANDLE hReserved1; /* Reserved for future use. */ ++ u32 hReserved2; /* Reserved for future use. */ ++ } ; ++ ++#endif /* DISPDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dmm.h b/arch/arm/plat-omap/include/dspbridge/dmm.h +new file mode 100644 +index 0000000..ef37668 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dmm.h +@@ -0,0 +1,85 @@ ++/* ++ * dmm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dmm.h ======== ++ * Purpose: ++ * The Dynamic Memory Mapping(DMM) module manages the DSP Virtual address ++ * space that can be directly mapped to any MPU buffer or memory region ++ * ++ * Public Functions: ++ * ++ *! Revision History: ++ *! ================ ++ *! 20-Feb-2004 sb: Created. ++ *! ++ */ ++ ++#ifndef DMM_ ++#define DMM_ ++ ++#include <dspbridge/dbdefs.h> ++ ++ struct DMM_OBJECT; ++ ++/* DMM attributes used in DMM_Create() */ ++ struct DMM_MGRATTRS { ++ u32 reserved; ++ } ; ++ ++#define DMMPOOLSIZE 0x4000000 ++ ++/* ++ * ======== DMM_GetHandle ======== ++ * Purpose: ++ * Return the dynamic memory manager object for this device. ++ * This is typically called from the client process. ++ */ ++ ++ extern DSP_STATUS DMM_GetHandle(DSP_HPROCESSOR hProcessor, ++ OUT struct DMM_OBJECT **phDmmMgr); ++ ++ extern DSP_STATUS DMM_ReserveMemory(struct DMM_OBJECT *hDmmMgr, ++ u32 size, ++ u32 *pRsvAddr); ++ ++ extern DSP_STATUS DMM_UnReserveMemory(struct DMM_OBJECT *hDmmMgr, ++ u32 rsvAddr); ++ ++ extern DSP_STATUS DMM_MapMemory(struct DMM_OBJECT *hDmmMgr, u32 addr, ++ u32 size); ++ ++ extern DSP_STATUS DMM_UnMapMemory(struct DMM_OBJECT *hDmmMgr, ++ u32 addr, ++ u32 *pSize); ++ ++ extern DSP_STATUS DMM_Destroy(struct DMM_OBJECT *hDmmMgr); ++ ++ extern DSP_STATUS DMM_DeleteTables(struct DMM_OBJECT *hDmmMgr); ++ ++ extern DSP_STATUS DMM_Create(OUT struct DMM_OBJECT **phDmmMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct DMM_MGRATTRS *pMgrAttrs); ++ ++ extern bool DMM_Init(void); ++ ++ extern void DMM_Exit(void); ++ ++ extern DSP_STATUS DMM_CreateTables(struct DMM_OBJECT *hDmmMgr, ++ u32 addr, u32 size); ++ extern u32 *DMM_GetPhysicalAddrTable(void); ++#endif /* DMM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dpc.h b/arch/arm/plat-omap/include/dspbridge/dpc.h +new file mode 100644 +index 0000000..8c20506 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dpc.h +@@ -0,0 +1,167 @@ ++/* ++ * dpc.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dpc.h ======== ++ * Purpose: ++ * Deferred Procedure Call(DPC) Services. ++ * ++ * Public Functions: ++ * DPC_Cancel ++ * DPC_Create ++ * DPC_Destroy ++ * DPC_Exit ++ * DPC_Init ++ * DPC_Schedule ++ * ++ *! Revision History: ++ *! ================ ++ *! 31-Jan-2000 rr: DPC_Destroy ensures Suceess and DPC Object is NULL. ++ *! 21-Jan-2000 ag: Updated comments per code review. ++ *! 06-Jan-2000 ag: Removed DPC_[Lower|Raise]IRQL[From|To]DispatchLevel. ++ *! 14-Jan-1998 gp: Added DPC_[Lower|Raise]IRQL[From|To]DispatchLevel. ++ *! 18-Aug-1997 cr: Added explicit CDECL identifiers. ++ *! 28-Jul-1996 gp: Created. ++ */ ++ ++#ifndef DPC_ ++#define DPC_ ++ ++ struct DPC_OBJECT; ++ ++/* ++ * ======== DPC_PROC ======== ++ * Purpose: ++ * Deferred processing routine. Typically scheduled from an ISR to ++ * complete I/O processing. ++ * Parameters: ++ * pRefData: Ptr to user data: passed in via ISR_ScheduleDPC. ++ * Returns: ++ * Requires: ++ * The DPC should not block, or otherwise acquire resources. ++ * Interrupts to the processor are enabled. ++ * DPC_PROC executes in a critical section. ++ * Ensures: ++ * This DPC will not be reenterred on the same thread. ++ * However, the DPC may take hardware interrupts during execution. ++ * Interrupts to the processor are enabled. ++ */ ++ typedef void(*DPC_PROC) (void *pRefData); ++ ++/* ++ * ======== DPC_Cancel ======== ++ * Purpose: ++ * Cancel a DPC previously scheduled by DPC_Schedule. ++ * Parameters: ++ * hDPC: A DPC object handle created in DPC_Create(). ++ * Returns: ++ * DSP_SOK: Scheduled DPC, if any, is cancelled. ++ * DSP_SFALSE: No DPC is currently scheduled for execution. ++ * DSP_EHANDLE: Invalid hDPC. ++ * Requires: ++ * Ensures: ++ * If the DPC has already executed, is executing, or was not yet ++ * scheduled, this function will have no effect. ++ */ ++ extern DSP_STATUS DPC_Cancel(IN struct DPC_OBJECT *hDPC); ++ ++/* ++ * ======== DPC_Create ======== ++ * Purpose: ++ * Create a DPC object, allowing a client's own DPC procedure to be ++ * scheduled for a call with client reference data. ++ * Parameters: ++ * phDPC: Pointer to location to store DPC object. ++ * pfnDPC: Client's DPC procedure. ++ * pRefData: Pointer to user-defined reference data. ++ * Returns: ++ * DSP_SOK: DPC object created. ++ * DSP_EPOINTER: phDPC == NULL or pfnDPC == NULL. ++ * DSP_EMEMORY: Insufficient memory. ++ * Requires: ++ * Must not be called at interrupt time. ++ * Ensures: ++ * DSP_SOK: DPC object is created; ++ * else: *phDPC is set to NULL. ++ */ ++ extern DSP_STATUS DPC_Create(OUT struct DPC_OBJECT **phDPC, ++ IN DPC_PROC pfnDPC, ++ IN void *pRefData); ++ ++/* ++ * ======== DPC_Destroy ======== ++ * Purpose: ++ * Cancel the last scheduled DPC, and deallocate a DPC object previously ++ * allocated with DPC_Create().Frees the Object only if the thread and ++ * the events are terminated successfuly. ++ * Parameters: ++ * hDPC: A DPC object handle created in DPC_Create(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDPC. ++ * Requires: ++ * All DPC's scheduled for the DPC object must have completed their ++ * processing. ++ * Ensures: ++ * (SUCCESS && hDPC is NULL) or DSP_EFAILED status ++ */ ++ extern DSP_STATUS DPC_Destroy(IN struct DPC_OBJECT *hDPC); ++ ++/* ++ * ======== DPC_Exit ======== ++ * Purpose: ++ * Discontinue usage of the DPC module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * DPC_Init(void) was previously called. ++ * Ensures: ++ * Resources acquired in DPC_Init(void) are freed. ++ */ ++ extern void DPC_Exit(void); ++ ++/* ++ * ======== DPC_Init ======== ++ * Purpose: ++ * Initialize the DPC module's private state. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public DPC functions. ++ */ ++ extern bool DPC_Init(void); ++ ++/* ++ * ======== DPC_Schedule ======== ++ * Purpose: ++ * Schedule a deferred procedure call to be executed at a later time. ++ * Latency and order of DPC execution is platform specific. ++ * Parameters: ++ * hDPC: A DPC object handle created in DPC_Create(). ++ * Returns: ++ * DSP_SOK: An event is scheduled for deferred processing. ++ * DSP_EHANDLE: Invalid hDPC. ++ * Requires: ++ * See requirements for DPC_PROC. ++ * Ensures: ++ * DSP_SOK: The DPC will not be called before this function returns. ++ */ ++ extern DSP_STATUS DPC_Schedule(IN struct DPC_OBJECT *hDPC); ++ ++#endif /* DPC_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/drv.h b/arch/arm/plat-omap/include/dspbridge/drv.h +new file mode 100644 +index 0000000..c468461 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/drv.h +@@ -0,0 +1,449 @@ ++/* ++ * drv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== drv.h ======== ++ * Purpose: ++ * DRV Resource allocation module. Driver Object gets Created ++ * at the time of Loading. It holds the List of Device Objects ++ * in the Syste, ++ * ++ * Public Functions: ++ * DRV_Create ++ * DRV_Destroy ++ * DRV_Exit ++ * DRV_GetDevObject ++ * DRV_GetDevExtension ++ * DRV_GetFirstDevObject ++ * DRV_GetNextDevObject ++ * DRV_GetNextDevExtension ++ * DRV_Init ++ * DRV_InsertDevObject ++ * DRV_RemoveDevObject ++ * DRV_RequestResources ++ * DRV_ReleaseResources ++ * ++ *! Revision History ++ *! ================ ++ *! 10-Feb-2004 vp: Added OMAP24xx specific definitions. ++ *! 14-Aug-2000 rr: Cleaned up. ++ *! 27-Jul-2000 rr: DRV_RequestResources split into two(Request and Release) ++ *! Device extension created to hold the DevNodeString. ++ *! 17-Jul-2000 rr: Driver Object holds the list of Device Objects. ++ *! Added DRV_Create, DRV_Destroy, DRV_GetDevObject, ++ *! DRV_GetFirst/NextDevObject, DRV_Insert/RemoveDevObject. ++ *! 12-Nov-1999 rr: New Flag defines for DRV_ASSIGN and DRV_RELEASE ++ *! 25-Oct-1999 rr: Resource Structure removed. ++ *! 15-Oct-1999 rr: New Resource structure created. ++ *! 05-Oct-1999 rr: Added DRV_RequestResources ++ *! Removed fxn'sDRV_RegisterMiniDriver(), ++ *! DRV_UnRegisterMiniDriver() ++ *! Removed Structures DSP_DRIVER & DRV_EXTENSION. ++ *! ++ *! 24-Sep-1999 rr: Added DRV_EXTENSION and DSP_DRIVER structures. ++ *! ++ */ ++ ++#ifndef DRV_ ++#define DRV_ ++ ++#include <dspbridge/devdefs.h> ++ ++#include <dspbridge/drvdefs.h> ++ ++#define DRV_ASSIGN 1 ++#define DRV_RELEASE 0 ++ ++/* Provide the DSP Internal memory windows that can be accessed from L3 address ++ * space */ ++ ++#define OMAP_GEM_BASE 0x107F8000 ++#define OMAP_DSP_SIZE 0x00720000 ++ ++/* MEM1 is L2 RAM + L2 Cache space */ ++#define OMAP_DSP_MEM1_BASE 0x5C7F8000 ++#define OMAP_DSP_MEM1_SIZE 0x18000 ++#define OMAP_DSP_GEM1_BASE 0x107F8000 ++ ++ ++/* MEM2 is L1P RAM/CACHE space */ ++#define OMAP_DSP_MEM2_BASE 0x5CE00000 ++#define OMAP_DSP_MEM2_SIZE 0x8000 ++#define OMAP_DSP_GEM2_BASE 0x10E00000 ++ ++/* MEM3 is L1D RAM/CACHE space */ ++#define OMAP_DSP_MEM3_BASE 0x5CF04000 ++#define OMAP_DSP_MEM3_SIZE 0x14000 ++#define OMAP_DSP_GEM3_BASE 0x10F04000 ++ ++ ++#define OMAP_IVA2_PRM_BASE 0x48306000 ++#define OMAP_IVA2_PRM_SIZE 0x1000 ++ ++#define OMAP_IVA2_CM_BASE 0x48004000 ++#define OMAP_IVA2_CM_SIZE 0x1000 ++ ++#define OMAP_PER_CM_BASE 0x48005000 ++#define OMAP_PER_CM_SIZE 0x1000 ++ ++#define OMAP_PER_PRM_BASE 0x48307000 ++#define OMAP_PER_PRM_SIZE 0x1000 ++ ++#define OMAP_CORE_PRM_BASE 0x48306A00 ++#define OMAP_CORE_PRM_SIZE 0x1000 ++ ++#define OMAP_SYSC_BASE 0x48002000 ++#define OMAP_SYSC_SIZE 0x1000 ++ ++#define OMAP_MBOX_BASE 0x48094000 ++#define OMAP_MBOX_SIZE 0x1000 ++ ++#define OMAP_DMMU_BASE 0x5D000000 ++#define OMAP_DMMU_SIZE 0x1000 ++ ++#define OMAP_PRCM_VDD1_DOMAIN 1 ++#define OMAP_PRCM_VDD2_DOMAIN 2 ++ ++#ifndef RES_CLEANUP_DISABLE ++ ++/* GPP PROCESS CLEANUP Data structures */ ++ ++/* New structure (member of process context) abstracts NODE resource info */ ++struct NODE_RES_OBJECT { ++ DSP_HNODE hNode; ++ s32 nodeAllocated; /* Node status */ ++ s32 heapAllocated; /* Heap status */ ++ s32 streamsAllocated; /* Streams status */ ++ struct NODE_RES_OBJECT *next; ++} ; ++ ++/* New structure (member of process context) abstracts DMM resource info */ ++struct DMM_RES_OBJECT { ++ s32 dmmAllocated; /* DMM status */ ++ u32 ulMpuAddr; ++ u32 ulDSPAddr; ++ u32 ulDSPResAddr; ++ u32 dmmSize; ++ HANDLE hProcessor; ++ struct DMM_RES_OBJECT *next; ++} ; ++ ++/* New structure (member of process context) abstracts DMM resource info */ ++struct DSPHEAP_RES_OBJECT { ++ s32 heapAllocated; /* DMM status */ ++ u32 ulMpuAddr; ++ u32 ulDSPAddr; ++ u32 ulDSPResAddr; ++ u32 heapSize; ++ HANDLE hProcessor; ++ struct DSPHEAP_RES_OBJECT *next; ++} ; ++ ++/* New structure (member of process context) abstracts stream resource info */ ++struct STRM_RES_OBJECT { ++ s32 streamAllocated; /* Stream status */ ++ DSP_HSTREAM hStream; ++ u32 uNumBufs; ++ u32 uDir; ++ struct STRM_RES_OBJECT *next; ++} ; ++ ++/* Overall Bridge process resource usage state */ ++enum GPP_PROC_RES_STATE { ++ PROC_RES_ALLOCATED, ++ PROC_RES_FREED ++} ; ++ ++/* Process Context */ ++struct PROCESS_CONTEXT{ ++ /* Process State */ ++ enum GPP_PROC_RES_STATE resState; ++ ++ /* Process ID (Same as UNIX process ID) */ ++ u32 pid; ++ ++ /* Pointer to next process context ++ * (To maintain a linked list of process contexts) */ ++ struct PROCESS_CONTEXT *next; ++ ++ /* Processor info to which the process is related */ ++ DSP_HPROCESSOR hProcessor; ++ ++ /* DSP Node resources */ ++ struct NODE_RES_OBJECT *pNodeList; ++ ++ /* DMM resources */ ++ struct DMM_RES_OBJECT *pDMMList; ++ ++ /* DSP Heap resources */ ++ struct DSPHEAP_RES_OBJECT *pDSPHEAPList; ++ ++ /* Stream resources */ ++ struct STRM_RES_OBJECT *pSTRMList; ++} ; ++#endif ++ ++/* ++ * ======== DRV_Create ======== ++ * Purpose: ++ * Creates the Driver Object. This is done during the driver loading. ++ * There is only one Driver Object in the DSP/BIOS Bridge. ++ * Parameters: ++ * phDrvObject: Location to store created DRV Object handle. ++ * Returns: ++ * DSP_SOK: Sucess ++ * DSP_EMEMORY: Failed in Memory allocation ++ * DSP_EFAIL: General Failure ++ * Requires: ++ * DRV Initialized (cRefs > 0 ) ++ * phDrvObject != NULL. ++ * Ensures: ++ * DSP_SOK: - *phDrvObject is a valid DRV interface to the device. ++ * - List of DevObject Created and Initialized. ++ * - List of DevNode String created and intialized. ++ * - Registry is updated with the DRV Object. ++ * !DSP_SOK: DRV Object not created ++ * Details: ++ * There is one Driver Object for the Driver representing ++ * the driver itself. It contains the list of device ++ * Objects and the list of Device Extensions in the system. ++ * Also it can hold other neccessary ++ * information in its storage area. ++ */ ++ extern DSP_STATUS DRV_Create(struct DRV_OBJECT **phDrvObject); ++ ++/* ++ * ======== DRV_Destroy ======== ++ * Purpose: ++ * destroys the Dev Object list, DrvExt list ++ * and destroy the DRV object ++ * Called upon driver unLoading.or unsuccesful loading of the driver. ++ * Parameters: ++ * hDrvObject: Handle to Driver object . ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Failed to destroy DRV Object ++ * Requires: ++ * DRV Initialized (cRegs > 0 ) ++ * hDrvObject is not NULL and a valid DRV handle . ++ * List of DevObject is Empty. ++ * List of DrvExt is Empty ++ * Ensures: ++ * DSP_SOK: - DRV Object destroyed and hDrvObject is not a valid ++ * DRV handle. ++ * - Registry is updated with "0" as the DRV Object. ++ */ ++ extern DSP_STATUS DRV_Destroy(struct DRV_OBJECT *hDrvObject); ++ ++/* ++ * ======== DRV_Exit ======== ++ * Purpose: ++ * Exit the DRV module, freeing any modules initialized in DRV_Init. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * Ensures: ++ */ ++ extern void DRV_Exit(void); ++ ++/* ++ * ======== DRV_GetFirstDevObject ======== ++ * Purpose: ++ * Returns the Ptr to the FirstDev Object in the List ++ * Parameters: ++ * Requires: ++ * DRV Initialized ++ * Returns: ++ * dwDevObject: Ptr to the First Dev Object as a u32 ++ * 0 if it fails to retrieve the First Dev Object ++ * Ensures: ++ */ ++ extern u32 DRV_GetFirstDevObject(void); ++ ++/* ++ * ======== DRV_GetFirstDevExtension ======== ++ * Purpose: ++ * Returns the Ptr to the First Device Extension in the List ++ * Parameters: ++ * Requires: ++ * DRV Initialized ++ * Returns: ++ * dwDevExtension: Ptr to the First Device Extension as a u32 ++ * 0: Failed to Get the Device Extension ++ * Ensures: ++ */ ++ extern u32 DRV_GetFirstDevExtension(void); ++ ++/* ++ * ======== DRV_GetDevObject ======== ++ * Purpose: ++ * Given a index, returns a handle to DevObject from the list ++ * Parameters: ++ * hDrvObject: Handle to the Manager ++ * phDevObject: Location to store the Dev Handle ++ * Requires: ++ * DRV Initialized ++ * uIndex >= 0 ++ * hDrvObject is not NULL and Valid DRV Object ++ * phDevObject is not NULL ++ * Device Object List not Empty ++ * Returns: ++ * DSP_SOK: Success ++ * DSP_EFAIL: Failed to Get the Dev Object ++ * Ensures: ++ * DSP_SOK: *phDevObject != NULL ++ * DSP_EFAIL: *phDevObject = NULL ++ */ ++ extern DSP_STATUS DRV_GetDevObject(u32 uIndex, ++ struct DRV_OBJECT *hDrvObject, ++ struct DEV_OBJECT **phDevObject); ++ ++/* ++ * ======== DRV_GetNextDevObject ======== ++ * Purpose: ++ * Returns the Ptr to the Next Device Object from the the List ++ * Parameters: ++ * hDevObject: Handle to the Device Object ++ * Requires: ++ * DRV Initialized ++ * hDevObject != 0 ++ * Returns: ++ * dwDevObject: Ptr to the Next Dev Object as a u32 ++ * 0: If it fail to get the next Dev Object. ++ * Ensures: ++ */ ++ extern u32 DRV_GetNextDevObject(u32 hDevObject); ++ ++/* ++ * ======== DRV_GetNextDevExtension ======== ++ * Purpose: ++ * Returns the Ptr to the Next Device Extension from the the List ++ * Parameters: ++ * hDevExtension: Handle to the Device Extension ++ * Requires: ++ * DRV Initialized ++ * hDevExtension != 0. ++ * Returns: ++ * dwDevExtension: Ptr to the Next Dev Extension ++ * 0: If it fail to Get the next Dev Extension ++ * Ensures: ++ */ ++ extern u32 DRV_GetNextDevExtension(u32 hDevExtension); ++ ++/* ++ * ======== DRV_Init ======== ++ * Purpose: ++ * Initialize the DRV module. ++ * Parameters: ++ * Returns: ++ * TRUE if success; FALSE otherwise. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS DRV_Init(void); ++ ++/* ++ * ======== DRV_InsertDevObject ======== ++ * Purpose: ++ * Insert a DeviceObject into the list of Driver object. ++ * Parameters: ++ * hDrvObject: Handle to DrvObject ++ * hDevObject: Handle to DeviceObject to insert. ++ * Returns: ++ * DSP_SOK: If successful. ++ * DSP_EFAIL: General Failure: ++ * Requires: ++ * hDrvObject != NULL and Valid DRV Handle. ++ * hDevObject != NULL. ++ * Ensures: ++ * DSP_SOK: Device Object is inserted and the List is not empty. ++ */ ++ extern DSP_STATUS DRV_InsertDevObject(struct DRV_OBJECT *hDrvObject, ++ struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== DRV_RemoveDevObject ======== ++ * Purpose: ++ * Search for and remove a Device object from the given list of Device Obj ++ * objects. ++ * Parameters: ++ * hDrvObject: Handle to DrvObject ++ * hDevObject: Handle to DevObject to Remove ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Unable to find pDevObject. ++ * Requires: ++ * hDrvObject != NULL and a Valid DRV Handle. ++ * hDevObject != NULL. ++ * List exists and is not empty. ++ * Ensures: ++ * List either does not exist (NULL), or is not empty if it does exist. ++*/ ++ extern DSP_STATUS DRV_RemoveDevObject(struct DRV_OBJECT *hDrvObject, ++ struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== DRV_RequestResources ======== ++ * Purpose: ++ * Assigns the Resources or Releases them. ++ * Parameters: ++ * dwContext: Path to the driver Registry Key. ++ * pDevNodeString: Ptr to DevNode String stored in the Device Ext. ++ * Returns: ++ * TRUE if success; FALSE otherwise. ++ * Requires: ++ * Ensures: ++ * The Resources are assigned based on Bus type. ++ * The hardware is initialized. Resource information is ++ * gathered from the Registry(ISA, PCMCIA)or scanned(PCI) ++ * Resource structure is stored in the registry which will be ++ * later used by the CFG module. ++ */ ++ extern DSP_STATUS DRV_RequestResources(IN u32 dwContext, ++ OUT u32 *pDevNodeString); ++ ++/* ++ * ======== DRV_ReleaseResources ======== ++ * Purpose: ++ * Assigns the Resources or Releases them. ++ * Parameters: ++ * dwContext: Path to the driver Registry Key. ++ * hDrvObject: Handle to the Driver Object. ++ * Returns: ++ * TRUE if success; FALSE otherwise. ++ * Requires: ++ * Ensures: ++ * The Resources are released based on Bus type. ++ * Resource structure is deleted from the registry ++ */ ++ extern DSP_STATUS DRV_ReleaseResources(IN u32 dwContext, ++ struct DRV_OBJECT *hDrvObject); ++ ++/* ++ * ======== DRV_ProcFreeDMMRes ======== ++ * Purpose: ++ * Actual DMM De-Allocation. ++ * Parameters: ++ * hPCtxt: Path to the driver Registry Key. ++ * Returns: ++ * DSP_SOK if success; ++ */ ++ ++ ++ extern DSP_STATUS DRV_ProcFreeDMMRes(HANDLE hPCtxt); ++ ++#endif /* DRV_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/drvdefs.h b/arch/arm/plat-omap/include/dspbridge/drvdefs.h +new file mode 100644 +index 0000000..ed86010 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/drvdefs.h +@@ -0,0 +1,34 @@ ++/* ++ * drvdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== drvdefs.h ======== ++ * Purpose: ++ * Definition of common include typedef between wmd.h and drv.h. ++ * ++ *! Revision History: ++ *! ================ ++ *! 17-Jul-2000 rr: Created ++ */ ++ ++#ifndef DRVDEFS_ ++#define DRVDEFS_ ++ ++/* WCD Driver Object */ ++ struct DRV_OBJECT; ++ ++#endif /* DRVDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/dspdrv.h b/arch/arm/plat-omap/include/dspbridge/dspdrv.h +new file mode 100644 +index 0000000..f500ffb +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dspdrv.h +@@ -0,0 +1,106 @@ ++/* ++ * dspdrv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dspdrv.h ======== ++ * Purpose: ++ * This is the Stream Interface for the DDSP Class driver. ++ * All Device operations are performed via DeviceIOControl. ++ * Read, Seek and Write not used. ++ * ++ * Public Functions ++ * DSP_Close ++ * DSP_Deinit ++ * DSP_Init ++ * DSP_IOControl ++ * DSP_Open ++ * DSP_PowerUp ++ * DSP_PowerDown ++ * ++ *! Revision History ++ *! ================ ++ *! 28-Jan-2000 rr: Type void changed to Void. ++ *! 02-Dec-1999 rr: MAX_DEV define moved from wcdce.c file.Code cleaned up. ++ *! 12-Nov-1999 rr: "#include<wncnxerr.h> removed. ++ *! 05-Oct-1999 rr Renamed the file name to wcdce.h Removed Bus Specific ++ *! code and #defines to PCCARD.h. ++ *! 24-Sep-1999 rr Changed the DSP_COMMON_WINDOW_SIZE to 0x4000(16k) for the ++ *! Memory windows. ++ *! 16-Jul-1999 ag Adapted from rkw's CAC Bullet driver. ++ *! ++ */ ++ ++#if !defined __DSPDRV_h__ ++#define __DSPDRV_h__ ++ ++#define MAX_DEV 10 /* Max support of 10 devices */ ++ ++/* ++ * ======== DSP_Close ======== ++ * Purpose: ++ * Called when the client application/driver unloads the DDSP DLL. Upon ++ * unloading, the DDSP DLL will call CloseFile(). ++ * Parameters: ++ * dwDeviceContext: Handle returned by XXX_Open used to identify ++ * the open context of the device ++ * Returns: ++ * TRUE indicates the device is successfully closed. FALSE indicates ++ * otherwise. ++ * Requires: ++ * dwOpenContext!= NULL. ++ * Ensures:The Application instance owned objects are cleaned up. ++ */ ++extern bool DSP_Close(u32 dwDeviceContext); ++ ++/* ++ * ======== DSP_Deinit ======== ++ * Purpose: ++ * This function is called by Device Manager to de-initialize a device. ++ * This function is not called by applications. ++ * Parameters: ++ * dwDeviceContext:Handle to the device context. The XXX_Init function ++ * creates and returns this identifier. ++ * Returns: ++ * TRUE indicates the device successfully de-initialized. Otherwise it ++ * returns FALSE. ++ * Requires: ++ * dwDeviceContext!= NULL. For a built in device this should never ++ * get called. ++ * Ensures: ++ */ ++extern bool DSP_Deinit(u32 dwDeviceContext); ++ ++/* ++ * ======== DSP_Init ======== ++ * Purpose: ++ * This function is called by Device Manager to initialize a device. ++ * This function is not called by applications ++ * Parameters: ++ * dwContext: Specifies a pointer to a string containing the registry ++ * path to the active key for the stream interface driver. ++ * HKEY_LOCAL_MACHINE\Drivers\Active ++ * Returns: ++ * Returns a handle to the device context created. This is the our actual ++ * Device Object representing the DSP Device instance. ++ * Requires: ++ * Ensures: ++ * Succeeded: device context > 0 ++ * Failed: device Context = 0 ++ */ ++extern u32 DSP_Init(OUT u32 *initStatus); ++ ++#endif +diff --git a/arch/arm/plat-omap/include/dspbridge/dynamic_loader.h b/arch/arm/plat-omap/include/dspbridge/dynamic_loader.h +new file mode 100644 +index 0000000..ea5f77f +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/dynamic_loader.h +@@ -0,0 +1,505 @@ ++/* ++ * dynamic_loader.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#ifndef _DYNAMIC_LOADER_H_ ++#define _DYNAMIC_LOADER_H_ ++#include <linux/kernel.h> ++#include <linux/types.h> ++ ++/* ++ * Dynamic Loader ++ * ++ * The function of the dynamic loader is to load a "module" containing ++ * instructions for a "target" processor into that processor. In the process ++ * it assigns memory for the module, resolves symbol references made by the ++ * module, and remembers symbols defined by the module. ++ * ++ * The dynamic loader is parameterized for a particular system by 4 classes ++ * that supply the module and system specific functions it requires ++ */ ++ /* The read functions for the module image to be loaded */ ++ struct Dynamic_Loader_Stream; ++ ++ /* This class defines "host" symbol and support functions */ ++ struct Dynamic_Loader_Sym; ++ ++ /* This class defines the allocator for "target" memory */ ++ struct Dynamic_Loader_Allocate; ++ ++ /* This class defines the copy-into-target-memory functions */ ++ struct Dynamic_Loader_Initialize; ++ ++/* ++ * Option flags to modify the behavior of module loading ++ */ ++#define DLOAD_INITBSS 0x1 /* initialize BSS sections to zero */ ++#define DLOAD_BIGEND 0x2 /* require big-endian load module */ ++#define DLOAD_LITTLE 0x4 /* require little-endian load module */ ++ ++ typedef void *DLOAD_mhandle; /* module handle for loaded modules */ ++ ++/***************************************************************************** ++ * Procedure Dynamic_Load_Module ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * init Target-side memory initialization, or NULL for symbol read only ++ * options Option flags DLOAD_* ++ * mhandle A module handle for use with Dynamic_Unload ++ * ++ * Effect: ++ * The module image is read using *module. Target storage for the new image is ++ * obtained from *alloc. Symbols defined and referenced by the module are ++ * managed using *syms. The image is then relocated and references resolved ++ * as necessary, and the resulting executable bits are placed into target memory ++ * using *init. ++ * ++ * Returns: ++ * On a successful load, a module handle is placed in *mhandle, and zero is ++ * returned. On error, the number of errors detected is returned. Individual ++ * errors are reported during the load process using syms->Error_Report(). ++ *****************************************************************************/ ++ extern int Dynamic_Load_Module( ++ /* the source for the module image*/ ++ struct Dynamic_Loader_Stream *module, ++ /* host support for symbols and storage*/ ++ struct Dynamic_Loader_Sym *syms, ++ /* the target memory allocator*/ ++ struct Dynamic_Loader_Allocate *alloc, ++ /* the target memory initializer*/ ++ struct Dynamic_Loader_Initialize *init, ++ unsigned options, /* option flags*/ ++ /* the returned module handle*/ ++ DLOAD_mhandle *mhandle ++ ); ++ ++/***************************************************************************** ++ * Procedure Dynamic_Open_Module ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * init Target-side memory initialization, or NULL for symbol read only ++ * options Option flags DLOAD_* ++ * mhandle A module handle for use with Dynamic_Unload ++ * ++ * Effect: ++ * The module image is read using *module. Target storage for the new image is ++ * obtained from *alloc. Symbols defined and referenced by the module are ++ * managed using *syms. The image is then relocated and references resolved ++ * as necessary, and the resulting executable bits are placed into target memory ++ * using *init. ++ * ++ * Returns: ++ * On a successful load, a module handle is placed in *mhandle, and zero is ++ * returned. On error, the number of errors detected is returned. Individual ++ * errors are reported during the load process using syms->Error_Report(). ++ *****************************************************************************/ ++ extern int Dynamic_Open_Module( ++ /* the source for the module image */ ++ struct Dynamic_Loader_Stream *module, ++ /* host support for symbols and storage */ ++ struct Dynamic_Loader_Sym *syms, ++ /* the target memory allocator */ ++ struct Dynamic_Loader_Allocate *alloc, ++ /* the target memory initializer */ ++ struct Dynamic_Loader_Initialize *init, ++ unsigned options, /* option flags */ ++ /* the returned module handle */ ++ DLOAD_mhandle *mhandle ++ ); ++ ++/***************************************************************************** ++ * Procedure Dynamic_Unload_Module ++ * ++ * Parameters: ++ * mhandle A module handle from Dynamic_Load_Module ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * ++ * Effect: ++ * The module specified by mhandle is unloaded. Unloading causes all ++ * target memory to be deallocated, all symbols defined by the module to ++ * be purged, and any host-side storage used by the dynamic loader for ++ * this module to be released. ++ * ++ * Returns: ++ * Zero for success. On error, the number of errors detected is returned. ++ * Individual errors are reported using syms->Error_Report(). ++ *****************************************************************************/ ++ extern int Dynamic_Unload_Module(DLOAD_mhandle mhandle, /* the module ++ * handle*/ ++ /* host support for symbols and ++ * storage */ ++ struct Dynamic_Loader_Sym *syms, ++ /* the target memory allocator*/ ++ struct Dynamic_Loader_Allocate *alloc, ++ /* the target memory initializer*/ ++ struct Dynamic_Loader_Initialize *init ++ ); ++ ++/***************************************************************************** ++ ***************************************************************************** ++ * A class used by the dynamic loader for input of the module image ++ ***************************************************************************** ++ *****************************************************************************/ ++ struct Dynamic_Loader_Stream { ++/* public: */ ++ /************************************************************************* ++ * read_buffer ++ * ++ * PARAMETERS : ++ * buffer Pointer to the buffer to fill ++ * bufsiz Amount of data desired in sizeof() units ++ * ++ * EFFECT : ++ * Reads the specified amount of data from the module input stream ++ * into the specified buffer. Returns the amount of data read in sizeof() ++ * units (which if less than the specification, represents an error). ++ * ++ * NOTES: ++ * In release 1 increments the file position by the number of bytes read ++ * ++ *************************************************************************/ ++ int (*read_buffer) (struct Dynamic_Loader_Stream *thisptr, ++ void *buffer, unsigned bufsiz); ++ ++ /************************************************************************* ++ * set_file_posn (release 1 only) ++ * ++ * PARAMETERS : ++ * posn Desired file position relative to start of file in sizeof() units. ++ * ++ * EFFECT : ++ * Adjusts the internal state of the stream object so that the next ++ * read_buffer call will begin to read at the specified offset from ++ * the beginning of the input module. Returns 0 for success, non-zero ++ * for failure. ++ * ++ *************************************************************************/ ++ int (*set_file_posn) (struct Dynamic_Loader_Stream *thisptr, ++ /* to be eliminated in release 2*/ ++ unsigned int posn); ++ ++ }; ++ ++/***************************************************************************** ++ ***************************************************************************** ++ * A class used by the dynamic loader for symbol table support and ++ * miscellaneous host-side functions ++ ***************************************************************************** ++ *****************************************************************************/ ++ ++ typedef u32 LDR_ADDR; ++ ++/* ++ * the structure of a symbol known to the dynamic loader ++ */ ++ struct dynload_symbol { ++ LDR_ADDR value; ++ } ; ++ ++ struct Dynamic_Loader_Sym { ++/* public: */ ++ /************************************************************************* ++ * Find_Matching_Symbol ++ * ++ * PARAMETERS : ++ * name The name of the desired symbol ++ * ++ * EFFECT : ++ * Locates a symbol matching the name specified. A pointer to the ++ * symbol is returned if it exists; 0 is returned if no such symbol is ++ * found. ++ * ++ *************************************************************************/ ++ struct dynload_symbol *(*Find_Matching_Symbol) ++ (struct Dynamic_Loader_Sym * ++ thisptr, ++ const char *name); ++ ++ /************************************************************************* ++ * Add_To_Symbol_Table ++ * ++ * PARAMETERS : ++ * nname Pointer to the name of the new symbol ++ * moduleid An opaque module id assigned by the dynamic loader ++ * ++ * EFFECT : ++ * The new symbol is added to the table. A pointer to the symbol is ++ * returned, or NULL is returned for failure. ++ * ++ * NOTES: ++ * It is permissible for this function to return NULL; the effect is that ++ * the named symbol will not be available to resolve references in ++ * subsequent loads. Returning NULL will not cause the current load ++ * to fail. ++ *************************************************************************/ ++ struct dynload_symbol *(*Add_To_Symbol_Table) ++ (struct Dynamic_Loader_Sym * ++ thisptr, ++ const char *nname, ++ unsigned moduleid); ++ ++ /************************************************************************* ++ * Purge_Symbol_Table ++ * ++ * PARAMETERS : ++ * moduleid An opaque module id assigned by the dynamic loader ++ * ++ * EFFECT : ++ * Each symbol in the symbol table whose moduleid matches the argument ++ * is removed from the table. ++ *************************************************************************/ ++ void (*Purge_Symbol_Table) (struct Dynamic_Loader_Sym *thisptr, ++ unsigned moduleid); ++ ++ /************************************************************************* ++ * Allocate ++ * ++ * PARAMETERS : ++ * memsiz size of desired memory in sizeof() units ++ * ++ * EFFECT : ++ * Returns a pointer to some "host" memory for use by the dynamic ++ * loader, or NULL for failure. ++ * This function is serves as a replaceable form of "malloc" to ++ * allow the user to configure the memory usage of the dynamic loader. ++ *************************************************************************/ ++ void *(*Allocate) (struct Dynamic_Loader_Sym *thisptr, ++ unsigned memsiz); ++ ++ /************************************************************************* ++ * Deallocate ++ * ++ * PARAMETERS : ++ * memptr pointer to previously allocated memory ++ * ++ * EFFECT : ++ * Releases the previously allocated "host" memory. ++ *************************************************************************/ ++ void (*Deallocate) (struct Dynamic_Loader_Sym *thisptr, ++ void *memptr); ++ ++ /************************************************************************* ++ * Error_Report ++ * ++ * PARAMETERS : ++ * errstr pointer to an error string ++ * args additional arguments ++ * ++ * EFFECT : ++ * This function provides an error reporting interface for the dynamic ++ * loader. The error string and arguments are designed as for the ++ * library function vprintf. ++ *************************************************************************/ ++ void (*Error_Report) (struct Dynamic_Loader_Sym *thisptr, ++ const char *errstr, va_list args); ++ ++ }; /* class Dynamic_Loader_Sym */ ++ ++/***************************************************************************** ++ ***************************************************************************** ++ * A class used by the dynamic loader to allocate and deallocate target memory. ++ ***************************************************************************** ++ *****************************************************************************/ ++ ++ struct LDR_SECTION_INFO { ++ /* Name of the memory section assigned at build time */ ++ const char *name; ++ LDR_ADDR run_addr; /* execution address of the section */ ++ LDR_ADDR load_addr; /* load address of the section */ ++ LDR_ADDR size; /* size of the section in addressable units */ ++#ifndef _BIG_ENDIAN ++ u16 page; /* memory page or view */ ++ u16 type; /* one of the section types below */ ++#else ++ u16 type; /* one of the section types below */ ++ u16 page; /* memory page or view */ ++#endif ++ /* a context field for use by Dynamic_Loader_Allocate; ++ * ignored but maintained by the dynamic loader */ ++ u32 context; ++ } ; ++ ++/* use this macro to extract type of section from LDR_SECTION_INFO.type field */ ++#define DLOAD_SECTION_TYPE(typeinfo) (typeinfo & 0xF) ++ ++/* type of section to be allocated */ ++#define DLOAD_TEXT 0 ++#define DLOAD_DATA 1 ++#define DLOAD_BSS 2 ++ /* internal use only, run-time cinit will be of type DLOAD_DATA */ ++#define DLOAD_CINIT 3 ++ ++ struct Dynamic_Loader_Allocate { ++/* public: */ ++ ++ /************************************************************************* ++ * Function allocate ++ * ++ * Parameters: ++ * info A pointer to an information block for the section ++ * align The alignment of the storage in target AUs ++ * ++ * Effect: ++ * Allocates target memory for the specified section and fills in the ++ * load_addr and run_addr fields of the section info structure. Returns TRUE ++ * for success, FALSE for failure. ++ * ++ * Notes: ++ * Frequently load_addr and run_addr are the same, but if they are not ++ * load_addr is used with Dynamic_Loader_Initialize, and run_addr is ++ * used for almost all relocations. This function should always initialize ++ * both fields. ++ *************************************************************************/ ++ int (*Allocate) (struct Dynamic_Loader_Allocate *thisptr, ++ struct LDR_SECTION_INFO *info, unsigned align); ++ ++ /************************************************************************* ++ * Function deallocate ++ * ++ * Parameters: ++ * info A pointer to an information block for the section ++ * ++ * Effect: ++ * Releases the target memory previously allocated. ++ * ++ * Notes: ++ * The content of the info->name field is undefined on call to this function. ++ *************************************************************************/ ++ void (*Deallocate) (struct Dynamic_Loader_Allocate *thisptr, ++ struct LDR_SECTION_INFO *info); ++ ++ }; /* class Dynamic_Loader_Allocate */ ++ ++/***************************************************************************** ++ ***************************************************************************** ++ * A class used by the dynamic loader to load data into a target. This class ++ * provides the interface-specific functions needed to load data. ++ ***************************************************************************** ++ *****************************************************************************/ ++ ++ struct Dynamic_Loader_Initialize { ++/* public: */ ++ /************************************************************************* ++ * Function connect ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Connect to the initialization interface. Returns TRUE for success, ++ * FALSE for failure. ++ * ++ * Notes: ++ * This function is called prior to use of any other functions in ++ * this interface. ++ *************************************************************************/ ++ int (*connect) (struct Dynamic_Loader_Initialize *thisptr); ++ ++ /************************************************************************* ++ * Function readmem ++ * ++ * Parameters: ++ * bufr Pointer to a word-aligned buffer for the result ++ * locn Target address of first data element ++ * info Section info for the section in which the address resides ++ * bytsiz Size of the data to be read in sizeof() units ++ * ++ * Effect: ++ * Fills the specified buffer with data from the target. Returns TRUE for ++ * success, FALSE for failure. ++ *************************************************************************/ ++ int (*readmem) (struct Dynamic_Loader_Initialize *thisptr, ++ void *bufr, ++ LDR_ADDR locn, ++ struct LDR_SECTION_INFO *info, ++ unsigned bytsiz); ++ ++ /************************************************************************* ++ * Function writemem ++ * ++ * Parameters: ++ * bufr Pointer to a word-aligned buffer of data ++ * locn Target address of first data element to be written ++ * info Section info for the section in which the address resides ++ * bytsiz Size of the data to be written in sizeof() units ++ * ++ * Effect: ++ * Writes the specified buffer to the target. Returns TRUE for success, ++ * FALSE for failure. ++ *************************************************************************/ ++ int (*writemem) (struct Dynamic_Loader_Initialize *thisptr, ++ void *bufr, ++ LDR_ADDR locn, ++ struct LDR_SECTION_INFO *info, ++ unsigned bytsiz); ++ ++ /************************************************************************* ++ * Function fillmem ++ * ++ * Parameters: ++ * locn Target address of first data element to be written ++ * info Section info for the section in which the address resides ++ * bytsiz Size of the data to be written in sizeof() units ++ * val Value to be written in each byte ++ * Effect: ++ * Fills the specified area of target memory. Returns TRUE for success, ++ * FALSE for failure. ++ *************************************************************************/ ++ int (*fillmem) (struct Dynamic_Loader_Initialize *thisptr, ++ LDR_ADDR locn, struct LDR_SECTION_INFO *info, ++ unsigned bytsiz, unsigned val); ++ ++ /************************************************************************* ++ * Function execute ++ * ++ * Parameters: ++ * start Starting address ++ * ++ * Effect: ++ * The target code at the specified starting address is executed. ++ * ++ * Notes: ++ * This function is called at the end of the dynamic load process ++ * if the input module has specified a starting address. ++ *************************************************************************/ ++ int (*execute) (struct Dynamic_Loader_Initialize *thisptr, ++ LDR_ADDR start); ++ ++ /************************************************************************* ++ * Function release ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Releases the connection to the load interface. ++ * ++ * Notes: ++ * This function is called at the end of the dynamic load process. ++ *************************************************************************/ ++ void (*release) (struct Dynamic_Loader_Initialize *thisptr); ++ ++ }; /* class Dynamic_Loader_Initialize */ ++ ++#endif /* _DYNAMIC_LOADER_H_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/errbase.h b/arch/arm/plat-omap/include/dspbridge/errbase.h +new file mode 100644 +index 0000000..f04c005 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/errbase.h +@@ -0,0 +1,509 @@ ++/* ++ * errbase.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== errbase.h ======== ++ * Description: ++ * Central repository for DSP/BIOS Bridge error and status code. ++ * ++ * Error codes are of the form: ++ * [<MODULE>]_E<ERRORCODE> ++ * ++ * Success codes are of the form: ++ * [<MODULE>]_S<SUCCESSCODE> ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Jan-2003 map Added DSP_SALREADYLOADED for persistent library checking ++ *! 23-Nov-2002 gp: Minor comment cleanup. ++ *! 13-May-2002 sg Added DSP_SALREADYASLEEP and DSP_SALREADYWAKE. ++ *! 18-Feb-2002 mk: Added DSP_EOVERLAYMEMORY, EFWRITE, ENOSECT. ++ *! 31-Jan-2002 mk: Added definitions of DSP_STRUE and DSP_SFALSE. ++ *! 29-Jan-2002 mk: Added definition of CFG_E_INSUFFICIENTBUFSIZE. ++ *! 24-Oct-2001 sp: Consolidated all the error codes into this file. ++ *! 24-Jul-2001 mk: Type-casted all definitions of WSX_STATUS types for ++ *! removal of compile warnings. ++ *! 22-Nov-1999 kc: Changes from code review. ++ *! 18-Aug-1999 rr: Ported From WSX. ++ *! 29-May-1996 gp: Removed WCD_ and WMD_ error ranges. Redefined format of ++ *! error codes. ++ *! 10-May-1996 gp: Created. ++ */ ++ ++#ifndef ERRBASE_ ++#define ERRBASE_ ++ ++/* Base of generic errors and component errors */ ++#define DSP_SBASE (DSP_STATUS)0x00008000 ++#define DSP_EBASE (DSP_STATUS)0x80008000 ++ ++#define DSP_COMP_EBASE (DSP_STATUS)0x80040200 ++#define DSP_COMP_ELAST (DSP_STATUS)0x80047fff ++ ++/* SUCCESS Codes */ ++ ++/* Generic success code */ ++#define DSP_SOK (DSP_SBASE + 0) ++ ++/* GPP is already attached to this DSP processor */ ++#define DSP_SALREADYATTACHED (DSP_SBASE + 1) ++ ++/* This is the last object available for enumeration. */ ++#define DSP_SENUMCOMPLETE (DSP_SBASE + 2) ++ ++/* The DSP is already asleep. */ ++#define DSP_SALREADYASLEEP (DSP_SBASE + 3) ++ ++/* The DSP is already awake. */ ++#define DSP_SALREADYAWAKE (DSP_SBASE + 4) ++ ++/* TRUE */ ++#define DSP_STRUE (DSP_SBASE + 5) ++ ++/* FALSE */ ++#define DSP_SFALSE (DSP_SBASE + 6) ++ ++/* A library contains no dependent library references */ ++#define DSP_SNODEPENDENTLIBS (DSP_SBASE + 7) ++ ++/* A persistent library is already loaded by the dynamic loader */ ++#define DSP_SALREADYLOADED (DSP_SBASE + 8) ++ ++/* Some error occured, but it is OK to continue */ ++#define DSP_OKTO_CONTINUE (DSP_SBASE + 9) ++ ++/* FAILURE Codes */ ++ ++/* The caller does not have access privileges to call this function */ ++#define DSP_EACCESSDENIED (DSP_EBASE + 0) ++ ++/* The Specified Connection already exists */ ++#define DSP_EALREADYCONNECTED (DSP_EBASE + 1) ++ ++/* The GPP must be detached from the DSP before this function is called */ ++#define DSP_EATTACHED (DSP_EBASE + 2) ++ ++/* During enumeration a change in the number or properties of the objects ++ * has occurred. */ ++#define DSP_ECHANGEDURINGENUM (DSP_EBASE + 3) ++ ++/* An error occurred while parsing the DSP executable file */ ++#define DSP_ECORRUPTFILE (DSP_EBASE + 4) ++ ++/* A failure occurred during a delete operation */ ++#define DSP_EDELETE (DSP_EBASE + 5) ++ ++/* The specified direction is invalid */ ++#define DSP_EDIRECTION (DSP_EBASE + 6) ++ ++/* A stream has been issued the maximum number of buffers allowed in the ++ * stream at once ; buffers must be reclaimed from the stream before any ++ * more can be issued. */ ++#define DSP_ESTREAMFULL (DSP_EBASE + 7) ++ ++/* A general failure occurred */ ++#define DSP_EFAIL (DSP_EBASE + 8) ++ ++/* The specified executable file could not be found. */ ++#define DSP_EFILE (DSP_EBASE + 9) ++ ++/* The specified handle is invalid. */ ++#define DSP_EHANDLE (DSP_EBASE + 0xa) ++ ++/* An invalid argument was specified. */ ++#define DSP_EINVALIDARG (DSP_EBASE + 0xb) ++ ++/* A memory allocation failure occurred. */ ++#define DSP_EMEMORY (DSP_EBASE + 0xc) ++ ++/* The requested operation is invalid for this node type. */ ++#define DSP_ENODETYPE (DSP_EBASE + 0xd) ++ ++/* No error text was found for the specified error code. */ ++#define DSP_ENOERRTEXT (DSP_EBASE + 0xe) ++ ++/* No more connections can be made for this node. */ ++#define DSP_ENOMORECONNECTIONS (DSP_EBASE + 0xf) ++ ++/* The indicated operation is not supported. */ ++#define DSP_ENOTIMPL (DSP_EBASE + 0x10) ++ ++/* I/O is currently pending. */ ++#define DSP_EPENDING (DSP_EBASE + 0x11) ++ ++/* An invalid pointer was specified. */ ++#define DSP_EPOINTER (DSP_EBASE + 0x12) ++ ++/* A parameter is specified outside its valid range. */ ++#define DSP_ERANGE (DSP_EBASE + 0x13) ++ ++/* An invalid size parameter was specified. */ ++#define DSP_ESIZE (DSP_EBASE + 0x14) ++ ++/* A stream creation failure occurred on the DSP. */ ++#define DSP_ESTREAM (DSP_EBASE + 0x15) ++ ++/* A task creation failure occurred on the DSP. */ ++#define DSP_ETASK (DSP_EBASE + 0x16) ++ ++/* A timeout occurred before the requested operation could complete. */ ++ ++#define DSP_ETIMEOUT (DSP_EBASE + 0x17) ++ ++/* A data truncation occurred, e.g., when requesting a descriptive error ++ * string, not enough space was allocated for the complete error message. */ ++ ++#define DSP_ETRUNCATED (DSP_EBASE + 0x18) ++ ++/* A parameter is invalid. */ ++#define DSP_EVALUE (DSP_EBASE + 0x1a) ++ ++/* The state of the specified object is incorrect for the requested ++ * operation. */ ++#define DSP_EWRONGSTATE (DSP_EBASE + 0x1b) ++ ++/* Symbol not found in the COFF file. DSPNode_Create will return this if ++ * the iAlg function table for an xDAIS socket is not found in the COFF file. ++ * In this case, force the symbol to be linked into the COFF file. ++ * DSPNode_Create, DSPNode_Execute, and DSPNode_Delete will return this if ++ * the create, execute, or delete phase function, respectively, could not be ++ * found in the COFF file. */ ++#define DSP_ESYMBOL (DSP_EBASE + 0x1c) ++ ++/* UUID not found in registry. */ ++#define DSP_EUUID (DSP_EBASE + 0x1d) ++ ++/* Unable to read content of DCD data section ; this is typically caused by ++ * improperly configured nodes. */ ++#define DSP_EDCDREADSECT (DSP_EBASE + 0x1e) ++ ++/* Unable to decode DCD data section content ; this is typically caused by ++ * changes to DSP/BIOS Bridge data structures. */ ++#define DSP_EDCDPARSESECT (DSP_EBASE + 0x1f) ++ ++/* Unable to get pointer to DCD data section ; this is typically caused by ++ * improperly configured UUIDs. */ ++#define DSP_EDCDGETSECT (DSP_EBASE + 0x20) ++ ++/* Unable to load file containing DCD data section ; this is typically ++ * caused by a missing COFF file. */ ++#define DSP_EDCDLOADBASE (DSP_EBASE + 0x21) ++ ++/* The specified COFF file does not contain a valid node registration ++ * section. */ ++#define DSP_EDCDNOAUTOREGISTER (DSP_EBASE + 0x22) ++ ++/* A requested resource is not available. */ ++#define DSP_ERESOURCE (DSP_EBASE + 0x28) ++ ++/* A critical error has occurred, and the DSP is being re-started. */ ++#define DSP_ERESTART (DSP_EBASE + 0x29) ++ ++/* A DSP memory free operation failed. */ ++#define DSP_EFREE (DSP_EBASE + 0x2a) ++ ++/* A DSP I/O free operation failed. */ ++#define DSP_EIOFREE (DSP_EBASE + 0x2b) ++ ++/* Multiple instances are not allowed. */ ++#define DSP_EMULINST (DSP_EBASE + 0x2c) ++ ++/* A specified entity was not found. */ ++#define DSP_ENOTFOUND (DSP_EBASE + 0x2d) ++ ++/* A DSP I/O resource is not available. */ ++#define DSP_EOUTOFIO (DSP_EBASE + 0x2e) ++ ++/* A shared memory buffer contained in a message or stream could not be ++ * mapped to the GPP client process's virtual space. */ ++#define DSP_ETRANSLATE (DSP_EBASE + 0x2f) ++ ++/* File or section load write function failed to write to DSP */ ++#define DSP_EFWRITE (DSP_EBASE + 0x31) ++ ++/* Unable to find a named section in DSP executable */ ++#define DSP_ENOSECT (DSP_EBASE + 0x32) ++ ++/* Unable to open file */ ++#define DSP_EFOPEN (DSP_EBASE + 0x33) ++ ++/* Unable to read file */ ++#define DSP_EFREAD (DSP_EBASE + 0x34) ++ ++/* A non-existent memory segment identifier was specified */ ++#define DSP_EOVERLAYMEMORY (DSP_EBASE + 0x37) ++ ++/* Invalid segment ID */ ++#define DSP_EBADSEGID (DSP_EBASE + 0x38) ++ ++/* Invalid alignment */ ++#define DSP_EALIGNMENT (DSP_EBASE + 0x39) ++ ++/* Invalid stream mode */ ++#define DSP_ESTRMMODE (DSP_EBASE + 0x3a) ++ ++/* Nodes not connected */ ++#define DSP_ENOTCONNECTED (DSP_EBASE + 0x3b) ++ ++/* Not shared memory */ ++#define DSP_ENOTSHAREDMEM (DSP_EBASE + 0x3c) ++ ++/* Error occurred in a dynamic loader library function */ ++#define DSP_EDYNLOAD (DSP_EBASE + 0x3d) ++ ++/* Device in 'sleep/suspend' mode due to DPM */ ++#define DSP_EDPMSUSPEND (DSP_EBASE + 0x3e) ++ ++/* A node-specific error has occurred. */ ++#define DSP_EUSER1 (DSP_EBASE + 0x40) ++#define DSP_EUSER2 (DSP_EBASE + 0x41) ++#define DSP_EUSER3 (DSP_EBASE + 0x42) ++#define DSP_EUSER4 (DSP_EBASE + 0x43) ++#define DSP_EUSER5 (DSP_EBASE + 0x44) ++#define DSP_EUSER6 (DSP_EBASE + 0x45) ++#define DSP_EUSER7 (DSP_EBASE + 0x46) ++#define DSP_EUSER8 (DSP_EBASE + 0x47) ++#define DSP_EUSER9 (DSP_EBASE + 0x48) ++#define DSP_EUSER10 (DSP_EBASE + 0x49) ++#define DSP_EUSER11 (DSP_EBASE + 0x4a) ++#define DSP_EUSER12 (DSP_EBASE + 0x4b) ++#define DSP_EUSER13 (DSP_EBASE + 0x4c) ++#define DSP_EUSER14 (DSP_EBASE + 0x4d) ++#define DSP_EUSER15 (DSP_EBASE + 0x4e) ++#define DSP_EUSER16 (DSP_EBASE + 0x4f) ++ ++/* FAILURE Codes : DEV */ ++#define DEV_EBASE (DSP_COMP_EBASE + 0x000) ++ ++/* The mini-driver expected a newer version of the class driver. */ ++#define DEV_E_NEWWMD (DEV_EBASE + 0x00) ++ ++/* WMD_DRV_Entry function returned a NULL function interface table. */ ++#define DEV_E_NULLWMDINTF (DEV_EBASE + 0x01) ++ ++/* FAILURE Codes : LDR */ ++#define LDR_EBASE (DSP_COMP_EBASE + 0x100) ++ ++/* Insufficient memory to export class driver services. */ ++#define LDR_E_NOMEMORY (LDR_EBASE + 0x00) ++ ++/* Unable to find WMD file in system directory. */ ++#define LDR_E_FILEUNABLETOOPEN (LDR_EBASE + 0x01) ++ ++/* FAILURE Codes : CFG */ ++#define CFG_EBASE (DSP_COMP_EBASE + 0x200) ++ ++/* Invalid pointer passed into a configuration module function */ ++#define CFG_E_INVALIDPOINTER (CFG_EBASE + 0x00) ++ ++/* Invalid device node handle passed into a configuration module function. */ ++#define CFG_E_INVALIDHDEVNODE (CFG_EBASE + 0x01) ++ ++/* Unable to retrieve resource information from the registry. */ ++#define CFG_E_RESOURCENOTAVAIL (CFG_EBASE + 0x02) ++ ++/* Unable to find board name key in registry. */ ++#define CFG_E_INVALIDBOARDNAME (CFG_EBASE + 0x03) ++ ++/* Unable to find a device node in registry with given unit number. */ ++#define CFG_E_INVALIDUNITNUM (CFG_EBASE + 0x04) ++ ++/* Insufficient buffer size */ ++#define CFG_E_INSUFFICIENTBUFSIZE (CFG_EBASE + 0x05) ++ ++/* FAILURE Codes : BRD */ ++#define BRD_EBASE (DSP_COMP_EBASE + 0x300) ++ ++/* Board client does not have sufficient access rights for this operation. */ ++#define BRD_E_ACCESSDENIED (BRD_EBASE + 0x00) ++ ++/* Unable to find trace buffer symbols in the DSP executable COFF file. */ ++#define BRD_E_NOTRACEBUFFER (BRD_EBASE + 0x01) ++ ++/* Attempted to auto-start board, but no default DSP executable configured. */ ++#define BRD_E_NOEXEC (BRD_EBASE + 0x02) ++ ++/* The operation failed because it was started from a wrong state */ ++#define BRD_E_WRONGSTATE (BRD_EBASE + 0x03) ++ ++/* FAILURE Codes : COD */ ++#define COD_EBASE (DSP_COMP_EBASE + 0x400) ++ ++/* No symbol table is loaded for this board. */ ++#define COD_E_NOSYMBOLSLOADED (COD_EBASE + 0x00) ++ ++/* Symbol not found in for this board. */ ++#define COD_E_SYMBOLNOTFOUND (COD_EBASE + 0x01) ++ ++/* ZL DLL module is not exporting the correct function interface. */ ++#define COD_E_NOZLFUNCTIONS (COD_EBASE + 0x02) ++ ++/* Unable to initialize the ZL COFF parsing module. */ ++#define COD_E_ZLCREATEFAILED (COD_EBASE + 0x03) ++ ++/* Unable to open DSP executable COFF file. */ ++#define COD_E_OPENFAILED (COD_EBASE + 0x04) ++ ++/* Unable to parse DSP executable COFF file. */ ++#define COD_E_LOADFAILED (COD_EBASE + 0x05) ++ ++/* Unable to read DSP executable COFF file. */ ++#define COD_E_READFAILED (COD_EBASE + 0x06) ++ ++/* FAILURE Codes : CHNL */ ++#define CHNL_EBASE (DSP_COMP_EBASE + 0x500) ++ ++/* Attempt to created channel manager with too many channels. */ ++#define CHNL_E_MAXCHANNELS (CHNL_EBASE + 0x00) ++ ++/* No channel manager exists for this mini-driver. */ ++#define CHNL_E_NOMGR (CHNL_EBASE + 0x01) ++ ++/* No free channels are available. */ ++#define CHNL_E_OUTOFSTREAMS (CHNL_EBASE + 0x02) ++ ++/* Channel ID is out of range. */ ++#define CHNL_E_BADCHANID (CHNL_EBASE + 0x03) ++ ++/* Channel is already in use. */ ++#define CHNL_E_CHANBUSY (CHNL_EBASE + 0x04) ++ ++/* Invalid channel mode argument. */ ++#define CHNL_E_BADMODE (CHNL_EBASE + 0x05) ++ ++/* dwTimeOut parameter was CHNL_IOCNOWAIT, yet no I/O completions were ++ * queued. */ ++#define CHNL_E_NOIOC (CHNL_EBASE + 0x06) ++ ++/* I/O has been cancelled on this channel. */ ++#define CHNL_E_CANCELLED (CHNL_EBASE + 0x07) ++ ++/* End of stream was already requested on this output channel. */ ++#define CHNL_E_EOS (CHNL_EBASE + 0x09) ++ ++/* Unable to create the channel event object. */ ++#define CHNL_E_CREATEEVENT (CHNL_EBASE + 0x0A) ++ ++/* Board name and unit number do not identify a valid board name. */ ++#define CHNL_E_BRDID (CHNL_EBASE + 0x0B) ++ ++/* Invalid IRQ configured for this WMD for this system. */ ++#define CHNL_E_INVALIDIRQ (CHNL_EBASE + 0x0C) ++ ++/* DSP word size of zero configured for this device. */ ++#define CHNL_E_INVALIDWORDSIZE (CHNL_EBASE + 0x0D) ++ ++/* A zero length memory base was specified for a shared memory class driver. */ ++#define CHNL_E_INVALIDMEMBASE (CHNL_EBASE + 0x0E) ++ ++/* Memory map is not configured, or unable to map physical to linear ++ * address. */ ++#define CHNL_E_NOMEMMAP (CHNL_EBASE + 0x0F) ++ ++/* Attempted to create a channel manager when one already exists. */ ++#define CHNL_E_MGREXISTS (CHNL_EBASE + 0x10) ++ ++/* Unable to plug channel ISR for configured IRQ. */ ++#define CHNL_E_ISR (CHNL_EBASE + 0x11) ++ ++/* No free I/O request packets are available. */ ++#define CHNL_E_NOIORPS (CHNL_EBASE + 0x12) ++ ++/* Buffer size is larger than the size of physical channel. */ ++#define CHNL_E_BUFSIZE (CHNL_EBASE + 0x13) ++ ++/* User cannot mark end of stream on an input channel. */ ++#define CHNL_E_NOEOS (CHNL_EBASE + 0x14) ++ ++/* Wait for flush operation on an output channel timed out. */ ++#define CHNL_E_WAITTIMEOUT (CHNL_EBASE + 0x15) ++ ++/* User supplied hEvent must be specified with pstrEventName attribute */ ++#define CHNL_E_BADUSEREVENT (CHNL_EBASE + 0x16) ++ ++/* Illegal user event name specified */ ++#define CHNL_E_USEREVENTNAME (CHNL_EBASE + 0x17) ++ ++/* Unable to prepare buffer specified */ ++#define CHNL_E_PREPFAILED (CHNL_EBASE + 0x18) ++ ++/* Unable to Unprepare buffer specified */ ++#define CHNL_E_UNPREPFAILED (CHNL_EBASE + 0x19) ++ ++/* FAILURE Codes : SYNC */ ++#define SYNC_EBASE (DSP_COMP_EBASE + 0x600) ++ ++/* Wait on a kernel event failed. */ ++#define SYNC_E_FAIL (SYNC_EBASE + 0x00) ++ ++/* Timeout expired while waiting for event to be signalled. */ ++#define SYNC_E_TIMEOUT (SYNC_EBASE + 0x01) ++ ++/* FAILURE Codes : WMD */ ++#define WMD_EBASE (DSP_COMP_EBASE + 0x700) ++ ++/* A test of hardware assumptions or integrity failed. */ ++#define WMD_E_HARDWARE (WMD_EBASE + 0x00) ++ ++/* One or more configuration parameters violated WMD hardware assumptions. */ ++#define WMD_E_BADCONFIG (WMD_EBASE + 0x01) ++ ++/* Timeout occurred waiting for a response from the hardware. */ ++#define WMD_E_TIMEOUT (WMD_EBASE + 0x02) ++ ++/* FAILURE Codes : REG */ ++#define REG_EBASE (DSP_COMP_EBASE + 0x800) ++ ++/* Invalid subkey parameter. */ ++#define REG_E_INVALIDSUBKEY (REG_EBASE + 0x00) ++ ++/* Invalid entry parameter. */ ++#define REG_E_INVALIDENTRY (REG_EBASE + 0x01) ++ ++/* No more registry values. */ ++#define REG_E_NOMOREITEMS (REG_EBASE + 0x02) ++ ++/* Insufficient space to hold data in registry value. */ ++#define REG_E_MOREDATA (REG_EBASE + 0x03) ++ ++/* FAILURE Codes : KFILE */ ++#define KFILE_EBASE (DSP_COMP_EBASE + 0x900) ++ ++/* Invalid file handle. */ ++#define E_KFILE_INVALIDHANDLE (KFILE_EBASE + 0x01) ++ ++/* Bad file name. */ ++#define E_KFILE_BADFILENAME (KFILE_EBASE + 0x02) ++ ++/* Invalid file mode. */ ++#define E_KFILE_INVALIDMODE (KFILE_EBASE + 0x03) ++ ++/* No resources available. */ ++#define E_KFILE_NORESOURCES (KFILE_EBASE + 0x04) ++ ++/* Invalid file buffer . */ ++#define E_KFILE_INVALIDBUFFER (KFILE_EBASE + 0x05) ++ ++/* Bad origin argument. */ ++#define E_KFILE_BADORIGINFLAG (KFILE_EBASE + 0x06) ++ ++/* Invalid file offset value. */ ++#define E_KFILE_INVALIDOFFSET (KFILE_EBASE + 0x07) ++ ++/* General KFILE error condition */ ++#define E_KFILE_ERROR (KFILE_EBASE + 0x08) ++ ++#endif /* ERRBASE_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/gb.h b/arch/arm/plat-omap/include/dspbridge/gb.h +new file mode 100644 +index 0000000..f147751 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/gb.h +@@ -0,0 +1,85 @@ ++/* ++ * gb.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== gb.h ======== ++ * Generic bitmap manager. ++ * ++ *! Revision History ++ *! ================ ++ */ ++ ++#ifndef GB_ ++#define GB_ ++ ++#define GB_NOBITS (~0) ++#include <dspbridge/host_os.h> ++typedef s32 GB_BitNum; ++struct GB_TMap; ++ ++/* ++ * ======== GB_clear ======== ++ * Clear the bit in position bitn in the bitmap map. Bit positions are ++ * zero based. ++ */ ++ ++extern void GB_clear(struct GB_TMap *map, GB_BitNum bitn); ++ ++/* ++ * ======== GB_create ======== ++ * Create a bit map with len bits. Initially all bits are cleared. ++ */ ++ ++extern struct GB_TMap *GB_create(GB_BitNum len); ++ ++/* ++ * ======== GB_delete ======== ++ * Delete previously created bit map ++ */ ++ ++extern void GB_delete(struct GB_TMap *map); ++ ++/* ++ * ======== GB_findandset ======== ++ * Finds a clear bit, sets it, and returns the position ++ */ ++ ++extern GB_BitNum GB_findandset(struct GB_TMap *map); ++ ++/* ++ * ======== GB_minclear ======== ++ * GB_minclear returns the minimum clear bit position. If no bit is ++ * clear, GB_minclear returns -1. ++ */ ++extern GB_BitNum GB_minclear(struct GB_TMap *map); ++ ++/* ++ * ======== GB_set ======== ++ * Set the bit in position bitn in the bitmap map. Bit positions are ++ * zero based. ++ */ ++ ++extern void GB_set(struct GB_TMap *map, GB_BitNum bitn); ++ ++/* ++ * ======== GB_test ======== ++ * Returns TRUE if the bit in position bitn is set in map; otherwise ++ * GB_test returns FALSE. Bit positions are zero based. ++ */ ++ ++extern bool GB_test(struct GB_TMap *map, GB_BitNum bitn); ++ ++#endif /*GB_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/getsection.h b/arch/arm/plat-omap/include/dspbridge/getsection.h +new file mode 100644 +index 0000000..33ff50d +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/getsection.h +@@ -0,0 +1,118 @@ ++/* ++ * getsection.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++#ifndef _GETSECTION_H_ ++#define _GETSECTION_H_ ++ ++ ++#include "dynamic_loader.h" ++ ++/* ++ * Get Section Information ++ * ++ * This file provides an API add-on to the dynamic loader that allows the user ++ * to query section information and extract section data from dynamic load ++ * modules. ++ * ++ * NOTE: ++ * Functions in this API assume that the supplied Dynamic_Loader_Stream object ++ * supports the set_file_posn method. ++ */ ++ ++ /* opaque handle for module information */ ++ typedef void *DLOAD_module_info; ++ ++/* ++ * Procedure DLOAD_module_open ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side malloc/free and error reporting functions. ++ * Other methods are unused. ++ * ++ * Effect: ++ * Reads header information from a dynamic loader module using the specified ++ * stream object, and returns a handle for the module information. This ++ * handle may be used in subsequent query calls to obtain information ++ * contained in the module. ++ * ++ * Returns: ++ * NULL if an error is encountered, otherwise a module handle for use ++ * in subsequent operations. ++ */ ++ extern DLOAD_module_info DLOAD_module_open(struct Dynamic_Loader_Stream ++ *module, ++ struct Dynamic_Loader_Sym ++ *syms); ++ ++/* ++ * Procedure DLOAD_GetSectionInfo ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * sectionName Pointer to the string name of the section desired ++ * sectionInfo Address of a section info structure pointer to be initialized ++ * ++ * Effect: ++ * Finds the specified section in the module information, and fills in ++ * the provided LDR_SECTION_INFO structure. ++ * ++ * Returns: ++ * TRUE for success, FALSE for section not found ++ */ ++ extern int DLOAD_GetSectionInfo(DLOAD_module_info minfo, ++ const char *sectionName, ++ const struct LDR_SECTION_INFO ++ ** const sectionInfo); ++ ++/* ++ * Procedure DLOAD_GetSection ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * sectionInfo Pointer to a section info structure for the desired section ++ * sectionData Buffer to contain the section initialized data ++ * ++ * Effect: ++ * Copies the initialized data for the specified section into the ++ * supplied buffer. ++ * ++ * Returns: ++ * TRUE for success, FALSE for section not found ++ */ ++ extern int DLOAD_GetSection(DLOAD_module_info minfo, ++ const struct LDR_SECTION_INFO *sectionInfo, ++ void *sectionData); ++ ++/* ++ * Procedure DLOAD_module_close ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * ++ * Effect: ++ * Releases any storage associated with the module handle. On return, ++ * the module handle is invalid. ++ * ++ * Returns: ++ * Zero for success. On error, the number of errors detected is returned. ++ * Individual errors are reported using syms->Error_Report(), where syms was ++ * an argument to DLOAD_module_open ++ */ ++ extern void DLOAD_module_close(DLOAD_module_info minfo); ++ ++#endif /* _GETSECTION_H_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/gh.h b/arch/arm/plat-omap/include/dspbridge/gh.h +new file mode 100644 +index 0000000..089a042 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/gh.h +@@ -0,0 +1,37 @@ ++/* ++ * gh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gh.h ======== ++ * ++ *! Revision History ++ *! ================ ++ */ ++ ++#ifndef GH_ ++#define GH_ ++#include <dspbridge/host_os.h> ++ ++extern struct GH_THashTab *GH_create(u16 maxBucket, u16 valSize, ++ u16(*hash) (void *, u16), bool(*match) (void *, void *), ++ void(*delete) (void *)); ++extern void GH_delete(struct GH_THashTab *hashTab); ++extern void GH_exit(void); ++extern void *GH_find(struct GH_THashTab *hashTab, void *key); ++extern void GH_init(void); ++extern void *GH_insert(struct GH_THashTab *hashTab, void *key, void *value); ++#endif /* GH_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/gs.h b/arch/arm/plat-omap/include/dspbridge/gs.h +new file mode 100644 +index 0000000..fd5ef27 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/gs.h +@@ -0,0 +1,64 @@ ++/* ++ * gs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== gs.h ======== ++ * Memory allocation/release wrappers. This module allows clients to ++ * avoid OS spacific issues related to memory allocation. It also provides ++ * simple diagnostic capabilities to assist in the detection of memory ++ * leaks. ++ *! Revision History ++ *! ================ ++ */ ++ ++#ifndef GS_ ++#define GS_ ++ ++/* ++ * ======== GS_alloc ======== ++ * Alloc size bytes of space. Returns pointer to space ++ * allocated, otherwise NULL. ++ */ ++extern void *GS_alloc(u32 size); ++ ++/* ++ * ======== GS_exit ======== ++ * Module exit. Do not change to "#define GS_init()"; in ++ * some environments this operation must actually do some work! ++ */ ++extern void GS_exit(void); ++ ++/* ++ * ======== GS_free ======== ++ * Free space allocated by GS_alloc() or GS_calloc(). ++ */ ++extern void GS_free(void *ptr); ++ ++/* ++ * ======== GS_frees ======== ++ * Free space allocated by GS_alloc() or GS_calloc() and assert that ++ * the size of the allocation is size bytes. ++ */ ++extern void GS_frees(void *ptr, u32 size); ++ ++/* ++ * ======== GS_init ======== ++ * Module initialization. Do not change to "#define GS_init()"; in ++ * some environments this operation must actually do some work! ++ */ ++extern void GS_init(void); ++ ++#endif /*GS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/gt.h b/arch/arm/plat-omap/include/dspbridge/gt.h +new file mode 100644 +index 0000000..456c866 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/gt.h +@@ -0,0 +1,315 @@ ++/* ++ * gt.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gt.h ======== ++ * Purpose: ++ * There are two definitions that affect which portions of trace ++ * are acutally compiled into the client: GT_TRACE and GT_ASSERT. If ++ * GT_TRACE is set to 0 then all trace statements (except for assertions) ++ * will be compiled out of the client. If GT_ASSERT is set to 0 then ++ * assertions will be compiled out of the client. GT_ASSERT can not be ++ * set to 0 unless GT_TRACE is also set to 0 (i.e. GT_TRACE == 1 implies ++ * GT_ASSERT == 1). ++ * ++ *! Revision History ++ *! ================ ++ *! 02-Feb-2000 rr: Renamed this file to gtce.h. GT CLASS and trace definitions ++ *! are WinCE Specific. ++ *! 03-Jan-1997 ge Replaced "GT_" prefix to GT_Config structure members ++ *! to eliminate preprocessor confusion with other macros. ++ */ ++#include <linux/types.h> ++#ifndef GT_ ++#define GT_ ++ ++#ifndef GT_TRACE ++#define GT_TRACE 0 /* 0 = "trace compiled out"; 1 = "trace active" */ ++#endif ++ ++#include <dspbridge/host_os.h> ++ ++#if !defined(GT_ASSERT) || GT_TRACE ++#define GT_ASSERT 1 ++#endif ++ ++struct GT_Config { ++ Fxn PRINTFXN; ++ Fxn PIDFXN; ++ Fxn TIDFXN; ++ Fxn ERRORFXN; ++}; ++ ++extern struct GT_Config *GT; ++ ++struct GT_Mask { ++ char *modName; ++ u8 *flags; ++} ; ++ ++/* ++ * New GT Class defenitions. ++ * ++ * The following are the explanations and how it could be used in the code ++ * ++ * - GT_ENTER On Entry to Functions ++ * ++ * - GT_1CLASS Display level of debugging status- Object/Automatic ++ * variables ++ * - GT_2CLASS ---- do ---- ++ * ++ * - GT_3CLASS ---- do ---- + It can be used(recommended) for debug ++ * status in the ISR, IST ++ * - GT_4CLASS ---- do ---- ++ * ++ * - GT_5CLASS Display entry for module init/exit functions ++ * ++ * - GT_6CLASS Warn whenever SERVICES function fails ++ * ++ * - GT_7CLASS Warn failure of Critical failures ++ * ++ */ ++ ++#define GT_ENTER ((u8)0x01) ++#define GT_1CLASS ((u8)0x02) ++#define GT_2CLASS ((u8)0x04) ++#define GT_3CLASS ((u8)0x08) ++#define GT_4CLASS ((u8)0x10) ++#define GT_5CLASS ((u8)0x20) ++#define GT_6CLASS ((u8)0x40) ++#define GT_7CLASS ((u8)0x80) ++ ++#ifdef _LINT_ ++ ++/* LINTLIBRARY */ ++ ++/* ++ * ======== GT_assert ======== ++ */ ++/* ARGSUSED */ ++void GT_assert(struct GT_Mask mask, s32 expr) ++{ ++} ++ ++/* ++ * ======== GT_config ======== ++ */ ++/* ARGSUSED */ ++void GT_config(struct GT_Config config) ++{ ++} ++ ++/* ++ * ======== GT_create ======== ++ */ ++/* ARGSUSED */ ++void GT_create(struct GT_Mask *mask, char *modName) ++{ ++} ++ ++/* ++ * ======== GT_curLine ======== ++ * Purpose: ++ * Returns the current source code line number. Is useful for performing ++ * branch testing using trace. For example, ++ * ++ * GT_1trace(curTrace, GT_1CLASS, ++ * "in module XX_mod, executing line %u\n", GT_curLine()); ++ */ ++/* ARGSUSED */ ++u16 GT_curLine(void) ++{ ++ return (u16)NULL; ++} ++ ++/* ++ * ======== GT_exit ======== ++ */ ++/* ARGSUSED */ ++void GT_exit(void) ++{ ++} ++ ++/* ++ * ======== GT_init ======== ++ */ ++/* ARGSUSED */ ++void GT_init(void) ++{ ++} ++ ++/* ++ * ======== GT_query ======== ++ */ ++/* ARGSUSED */ ++bool GT_query(struct GT_Mask mask, u8 class) ++{ ++ return false; ++} ++ ++/* ++ * ======== GT_set ======== ++ * sets trace mask according to settings ++ */ ++ ++/* ARGSUSED */ ++void GT_set(char *settings) ++{ ++} ++ ++/* ++ * ======== GT_setprintf ======== ++ * sets printf function ++ */ ++ ++/* ARGSUSED */ ++void GT_setprintf(Fxn fxn) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_0trace(struct GT_Mask mask, u8 class, char *format) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_1trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_2trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_3trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_4trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_5trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++/* ARGSUSED */ ++void GT_6trace(struct GT_Mask mask, u8 class, char *format, ...) ++{ ++} ++ ++#else ++ ++#define GT_BOUND 26 /* 26 letters in alphabet */ ++ ++extern void _GT_create(struct GT_Mask *mask, char *modName); ++ ++#define GT_exit() ++ ++extern void GT_init(void); ++extern void _GT_set(char *str); ++extern s32 _GT_trace(struct GT_Mask *mask, char *format, ...); ++ ++#if GT_ASSERT == 0 ++ ++#define GT_assert(mask, expr) ++#define GT_config(config) ++#define GT_configInit(config) ++#define GT_seterror(fxn) ++ ++#else ++ ++extern struct GT_Config _GT_params; ++ ++#define GT_assert(mask, expr) \ ++ (!(expr) ? \ ++ printk("assertion violation: %s, line %d\n", \ ++ __FILE__, __LINE__), NULL : NULL) ++ ++#define GT_config(config) (_GT_params = *(config)) ++#define GT_configInit(config) (*(config) = _GT_params) ++#define GT_seterror(fxn) (_GT_params.ERRORFXN = (Fxn)(fxn)) ++ ++#endif ++ ++#if GT_TRACE == 0 ++ ++#define GT_curLine() ((u16)__LINE__) ++#define GT_create(mask, modName) ++#define GT_exit() ++#define GT_init() ++#define GT_set(settings) ++#define GT_setprintf(fxn) ++ ++#define GT_query(mask, class) false ++ ++#define GT_0trace(mask, class, format) ++#define GT_1trace(mask, class, format, arg1) ++#define GT_2trace(mask, class, format, arg1, arg2) ++#define GT_3trace(mask, class, format, arg1, arg2, arg3) ++#define GT_4trace(mask, class, format, arg1, arg2, arg3, arg4) ++#define GT_5trace(mask, class, format, arg1, arg2, arg3, arg4, arg5) ++#define GT_6trace(mask, class, format, arg1, arg2, arg3, arg4, arg5, arg6) ++ ++#else /* GT_TRACE == 1 */ ++ ++ ++#define GT_create(mask, modName) _GT_create((mask), (modName)) ++#define GT_curLine() ((u16)__LINE__) ++#define GT_set(settings) _GT_set(settings) ++#define GT_setprintf(fxn) (_GT_params.PRINTFXN = (Fxn)(fxn)) ++ ++#define GT_query(mask, class) ((*(mask).flags & (class))) ++ ++#define GT_0trace(mask, class, format) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format)) : 0) ++ ++#define GT_1trace(mask, class, format, arg1) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1)) : 0) ++ ++#define GT_2trace(mask, class, format, arg1, arg2) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1), (arg2)) : 0) ++ ++#define GT_3trace(mask, class, format, arg1, arg2, arg3) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1), (arg2), (arg3)) : 0) ++ ++#define GT_4trace(mask, class, format, arg1, arg2, arg3, arg4) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1), (arg2), (arg3), (arg4)) : 0) ++ ++#define GT_5trace(mask, class, format, arg1, arg2, arg3, arg4, arg5) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1), (arg2), (arg3), (arg4), (arg5)) : 0) ++ ++#define GT_6trace(mask, class, format, arg1, arg2, arg3, arg4, arg5, arg6) \ ++ ((*(mask).flags & (class)) ? \ ++ _GT_trace(&(mask), (format), (arg1), (arg2), (arg3), (arg4), (arg5), \ ++ (arg6)) : 0) ++ ++#endif /* GT_TRACE */ ++ ++#endif /* _LINT_ */ ++ ++#endif /* GTCE_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/host_os.h b/arch/arm/plat-omap/include/dspbridge/host_os.h +new file mode 100644 +index 0000000..f539bd0 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/host_os.h +@@ -0,0 +1,96 @@ ++/* ++ * host_os.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== windows.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Mar-2004 sb Added cacheflush.h to support Dynamic Memory Mapping feature ++ *! 16-Feb-2004 sb Added headers required for consistent_alloc ++ */ ++ ++#ifndef _HOST_OS_H_ ++#define _HOST_OS_H_ ++ ++#include <linux/autoconf.h> ++#include <asm/system.h> ++#include <asm/atomic.h> ++#include <linux/semaphore.h> ++#include <linux/uaccess.h> ++#include <linux/irq.h> ++#include <linux/io.h> ++#include <linux/syscalls.h> ++#include <linux/version.h> ++#include <linux/kernel.h> ++#include <linux/string.h> ++#include <linux/stddef.h> ++#include <linux/types.h> ++#include <linux/interrupt.h> ++#include <linux/spinlock.h> ++#include <linux/sched.h> ++#include <linux/fs.h> ++#include <linux/file.h> ++#include <linux/slab.h> ++#include <linux/delay.h> ++#include <linux/ctype.h> ++#include <linux/mm.h> ++#include <linux/device.h> ++#include <linux/vmalloc.h> ++#include <linux/ioport.h> ++#include <linux/platform_device.h> ++#include <dspbridge/dbtype.h> ++#include <mach/clock.h> ++#include <linux/clk.h> ++#include <linux/pagemap.h> ++#include <asm/cacheflush.h> ++#include <linux/dma-mapping.h> ++ ++/* ----------------------------------- Macros */ ++ ++#define SEEK_SET 0 /* Seek from beginning of file. */ ++#define SEEK_CUR 1 /* Seek from current position. */ ++#define SEEK_END 2 /* Seek from end of file. */ ++ ++/* TODO -- Remove, once BP defines them */ ++#define INT_MAIL_MPU_IRQ 26 ++#define INT_DSP_MMU_IRQ 28 ++ ++struct dspbridge_platform_data { ++ void (*dsp_set_min_opp)(u8 opp_id); ++ u8 (*dsp_get_opp)(void); ++ void (*cpu_set_freq)(unsigned long f); ++ unsigned long (*cpu_get_freq)(void); ++ unsigned long mpu_speed[6]; ++ ++ u32 phys_mempool_base; ++ u32 phys_mempool_size; ++}; ++ ++#define PRCM_VDD1 1 ++ ++extern struct platform_device *omap_dspbridge_dev; ++ ++#if defined(CONFIG_MPU_BRIDGE) || defined(CONFIG_MPU_BRIDGE_MODULE) ++extern void dspbridge_reserve_sdram(void); ++#else ++static inline void dspbridge_reserve_sdram(void) {} ++#endif ++ ++extern unsigned long dspbridge_get_mempool_base(void); ++#endif ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/io.h b/arch/arm/plat-omap/include/dspbridge/io.h +new file mode 100644 +index 0000000..6dc63f2 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/io.h +@@ -0,0 +1,132 @@ ++/* ++ * io.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== io.h ======== ++ * Description: ++ * The io module manages IO between CHNL and MSG. ++ * ++ * Public Functions: ++ * IO_Create ++ * IO_Destroy ++ * IO_Exit ++ * IO_Init ++ * IO_OnLoaded ++ * ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Nov-2000 jeh Created. ++ */ ++ ++#ifndef IO_ ++#define IO_ ++ ++#include <dspbridge/cfgdefs.h> ++#include <dspbridge/devdefs.h> ++ ++#include <dspbridge/iodefs.h> ++ ++/* ++ * ======== IO_Create ======== ++ * Purpose: ++ * Create an IO manager object, responsible for managing IO between ++ * CHNL and MSG. ++ * Parameters: ++ * phChnlMgr: Location to store a channel manager object on ++ * output. ++ * hDevObject: Handle to a device object. ++ * pMgrAttrs: IO manager attributes. ++ * pMgrAttrs->bIRQ: I/O IRQ number. ++ * pMgrAttrs->fShared: TRUE if the IRQ is shareable. ++ * pMgrAttrs->uWordSize: DSP Word size in equivalent PC bytes.. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * CHNL_E_ISR: Unable to plug channel ISR for configured IRQ. ++ * CHNL_E_INVALIDIRQ: Invalid IRQ number. Must be 0 <= bIRQ <= 15. ++ * CHNL_E_INVALIDWORDSIZE: Invalid DSP word size. Must be > 0. ++ * CHNL_E_INVALIDMEMBASE: Invalid base address for DSP communications. ++ * Requires: ++ * IO_Init(void) called. ++ * phIOMgr != NULL. ++ * pMgrAttrs != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS IO_Create(OUT struct IO_MGR **phIOMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct IO_ATTRS *pMgrAttrs); ++ ++/* ++ * ======== IO_Destroy ======== ++ * Purpose: ++ * Destroy the IO manager. ++ * Parameters: ++ * hIOMgr: IOmanager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: hIOMgr was invalid. ++ * Requires: ++ * IO_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS IO_Destroy(struct IO_MGR *hIOMgr); ++ ++/* ++ * ======== IO_Exit ======== ++ * Purpose: ++ * Discontinue usage of the IO module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * IO_Init(void) previously called. ++ * Ensures: ++ * Resources, if any acquired in IO_Init(void), are freed when the last ++ * client of IO calls IO_Exit(void). ++ */ ++ extern void IO_Exit(void); ++ ++/* ++ * ======== IO_Init ======== ++ * Purpose: ++ * Initialize the IO module's private state. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occurred. ++ * Requires: ++ * Ensures: ++ * A requirement for each of the other public CHNL functions. ++ */ ++ extern bool IO_Init(void); ++ ++/* ++ * ======== IO_OnLoaded ======== ++ * Purpose: ++ * Called when a program is loaded so IO manager can update its ++ * internal state. ++ * Parameters: ++ * hIOMgr: IOmanager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: hIOMgr was invalid. ++ * Requires: ++ * IO_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS IO_OnLoaded(struct IO_MGR *hIOMgr); ++ ++#endif /* CHNL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/io_sm.h b/arch/arm/plat-omap/include/dspbridge/io_sm.h +new file mode 100644 +index 0000000..3dcbf74 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/io_sm.h +@@ -0,0 +1,335 @@ ++/* ++ * io_sm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== io_sm.h ======== ++ * Description: ++ * IO dispatcher for a shared memory channel driver. ++ * Also, includes macros to simulate SHM via port io calls. ++ * ++ * Public Functions: ++ * IO_Dispatch ++ * IO_DPC ++ * IO_ISR ++ * IO_RequestChnl ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 01-Mar-2004 vp: Added IVA releated functions. ++ *! 23-Apr-2003 sb: Fixed mailbox deadlock ++ *! 06-Feb-2003 kc Added IO_DDMAClearChnlDesc and IO_DDZCClearChnlDesc. ++ *! 21-Dec-2001 ag Removed unused param in IO_DDMAInitChnlDesc(). ++ * Updated comments. Removed #ifdef CHNL_NOIPCINTR. ++ *! 05-Nov-2001 kc Updated IO_CALLISR macro. ++ *! 01-May-2001 jeh Removed IO_RequestMsg. ++ *! 29-Mar-2001 ag Added #ifdef CHNL_NOIPCINTR. ++ *! 04-Dec-2000 jeh Added IO_RequestMsg. ++ *! 26-Oct-2000 jeh Added IO_GetLong, IO_SetLong, IO_ReadValueLong, and ++ *! IO_WriteValueLong, for passing arg in SHM structure. ++ *! 20-Jan-2000 ag: Updated header comments per code review. ++ *! 05-Jan-2000 ag: Text format clean-up. ++ *! 02-Nov-1999 ag: Updated header descriptions. ++ *! 25-May-1999 jg: Removed assumption of 4 bytes / word. ++ *! 12-Aug-1996 gp: Created. ++ */ ++ ++#ifndef IOSM_ ++#define IOSM_ ++ ++#include <dspbridge/_chnl_sm.h> ++#include <dspbridge/host_os.h> ++ ++#include <dspbridge/iodefs.h> ++ ++#define IO_INPUT 0 ++#define IO_OUTPUT 1 ++#define IO_SERVICE 2 ++#define IO_MAXSERVICE IO_SERVICE ++ ++#define IO_MGRSIGNATURE 0x494f4D43 /* "IOGR" */ ++ ++#define DSPFieldAddr(type, field, base, wordsize) \ ++ ((((s32)&(((type *)0)->field)) / wordsize) + (u32)base) ++ ++/* Access can be different SM access word size (e.g. 16/32 bit words) */ ++#define IO_SetValue(pContext, type, base, field, value) (base->field = value) ++#define IO_GetValue(pContext, type, base, field) (base->field) ++#define IO_OrValue(pContext, type, base, field, value) (base->field |= value) ++#define IO_AndValue(pContext, type, base, field, value) (base->field &= value) ++#define IO_SetLong(pContext, type, base, field, value) (base->field = value) ++#define IO_GetLong(pContext, type, base, field) (base->field) ++ ++#define IO_DisableInterrupt(h) CHNLSM_DisableInterrupt(h) ++#define IO_EnableInterrupt(h) CHNLSM_EnableInterrupt(h) ++#define IO_CALLISR(h, pFlag, pwMBRegVal) CHNLSM_ISR(h, pFlag, pwMBRegVal) ++ ++/* ++ * ======== IO_CancelChnl ======== ++ * Purpose: ++ * Cancel IO on a given channel. ++ * Parameters: ++ * hIOMgr: IO Manager. ++ * ulChnl: Index of channel to cancel IO on. ++ * Returns: ++ * Requires: ++ * Valid hIOMgr. ++ * Ensures: ++ */ ++ extern void IO_CancelChnl(struct IO_MGR *hIOMgr, u32 ulChnl); ++ ++/* ++ * ======== IO_DPC ======== ++ * Purpose: ++ * Deferred procedure call for shared memory channel driver ISR. Carries ++ * out the dispatch of I/O. ++ * Parameters: ++ * pRefData: Pointer to reference data registered via a call to ++ * DPC_Create(). ++ * Returns: ++ * Requires: ++ * Must not block. ++ * Must not acquire resources. ++ * All data touched must be locked in memory if running in kernel mode. ++ * Ensures: ++ * Non-preemptible (but interruptible). ++ */ ++ extern void IO_DPC(IN OUT void *pRefData); ++ ++/* ++ * ======== IO_ISR ======== ++ * Purpose: ++ * Main interrupt handler for the shared memory WMD channel manager. ++ * Calls the WMD's CHNLSM_ISR to determine if this interrupt is ours, then ++ * schedules a DPC to dispatch I/O.. ++ * Parameters: ++ * pRefData: Pointer to the channel manager object for this board. ++ * Set in an initial call to ISR_Install(). ++ * Returns: ++ * TRUE if interrupt handled; FALSE otherwise. ++ * Requires: ++ * Must be in locked memory if executing in kernel mode. ++ * Must only call functions which are in locked memory if Kernel mode. ++ * Must only call asynchronous services. ++ * Interrupts are disabled and EOI for this interrupt has been sent. ++ * Ensures: ++ */ ++ irqreturn_t IO_ISR(int irq, IN void *pRefData); ++/* ++ * ======== IO_RequestChnl ======== ++ * Purpose: ++ * Request I/O from the DSP. Sets flags in shared memory, then interrupts ++ * the DSP. ++ * Parameters: ++ * hIOMgr: IO manager handle. ++ * pChnl: Ptr to the channel requesting I/O. ++ * iMode: Mode of channel: {IO_INPUT | IO_OUTPUT}. ++ * Returns: ++ * Requires: ++ * pChnl != NULL ++ * Ensures: ++ */ ++ extern void IO_RequestChnl(struct IO_MGR *hIOMgr, ++ struct CHNL_OBJECT *pChnl, ++ u32 iMode, OUT u16 *pwMbVal); ++ ++/* ++ * ======== IO_Schedule ======== ++ * Purpose: ++ * Schedule DPC for IO. ++ * Parameters: ++ * pIOMgr: Ptr to a I/O manager. ++ * Returns: ++ * Requires: ++ * pChnl != NULL ++ * Ensures: ++ */ ++ extern void IO_Schedule(struct IO_MGR *hIOMgr); ++ ++/* ++ * DSP-DMA IO functions ++ */ ++ ++/* ++ * ======== IO_DDMAInitChnlDesc ======== ++ * Purpose: ++ * Initialize DSP DMA channel descriptor. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * uDDMAChnlId: DDMA channel identifier. ++ * uNumDesc: Number of buffer descriptors(equals # of IOReqs & ++ * Chirps) ++ * pDsp: Dsp address; ++ * Returns: ++ * Requires: ++ * uDDMAChnlId < DDMA_MAXDDMACHNLS ++ * uNumDesc > 0 ++ * pVa != NULL ++ * pDspPa != NULL ++ * ++ * Ensures: ++ */ ++ extern void IO_DDMAInitChnlDesc(struct IO_MGR *hIOMgr, u32 uDDMAChnlId, ++ u32 uNumDesc, void *pDsp); ++ ++/* ++ * ======== IO_DDMAClearChnlDesc ======== ++ * Purpose: ++ * Clear DSP DMA channel descriptor. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * uDDMAChnlId: DDMA channel identifier. ++ * Returns: ++ * Requires: ++ * uDDMAChnlId < DDMA_MAXDDMACHNLS ++ * Ensures: ++ */ ++ extern void IO_DDMAClearChnlDesc(struct IO_MGR *hIOMgr, ++ u32 uDDMAChnlId); ++ ++/* ++ * ======== IO_DDMARequestChnl ======== ++ * Purpose: ++ * Request channel DSP-DMA from the DSP. Sets up SM descriptors and ++ * control fields in shared memory. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * pChnl: Ptr to channel object ++ * pChirp: Ptr to channel i/o request packet. ++ * Returns: ++ * Requires: ++ * pChnl != NULL ++ * pChnl->cIOReqs > 0 ++ * pChirp != NULL ++ * Ensures: ++ */ ++ extern void IO_DDMARequestChnl(struct IO_MGR *hIOMgr, ++ struct CHNL_OBJECT *pChnl, ++ struct CHNL_IRP *pChirp, ++ OUT u16 *pwMbVal); ++ ++/* ++ * Zero-copy IO functions ++ */ ++ ++/* ++ * ======== IO_DDZCInitChnlDesc ======== ++ * Purpose: ++ * Initialize ZCPY channel descriptor. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * uZId: zero-copy channel identifier. ++ * Returns: ++ * Requires: ++ * uDDMAChnlId < DDMA_MAXZCPYCHNLS ++ * hIOMgr != Null ++ * Ensures: ++ */ ++ extern void IO_DDZCInitChnlDesc(struct IO_MGR *hIOMgr, u32 uZId); ++ ++/* ++ * ======== IO_DDZCClearChnlDesc ======== ++ * Purpose: ++ * Clear DSP ZC channel descriptor. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * uChnlId: ZC channel identifier. ++ * Returns: ++ * Requires: ++ * hIOMgr is valid ++ * uChnlId < DDMA_MAXZCPYCHNLS ++ * Ensures: ++ */ ++ extern void IO_DDZCClearChnlDesc(struct IO_MGR *hIOMgr, u32 uChnlId); ++ ++/* ++ * ======== IO_DDZCRequestChnl ======== ++ * Purpose: ++ * Request zero-copy channel transfer. Sets up SM descriptors and ++ * control fields in shared memory. ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * pChnl: Ptr to channel object ++ * pChirp: Ptr to channel i/o request packet. ++ * Returns: ++ * Requires: ++ * pChnl != NULL ++ * pChnl->cIOReqs > 0 ++ * pChirp != NULL ++ * Ensures: ++ */ ++ extern void IO_DDZCRequestChnl(struct IO_MGR *hIOMgr, ++ struct CHNL_OBJECT *pChnl, ++ struct CHNL_IRP *pChirp, ++ OUT u16 *pwMbVal); ++ ++/* ++ * ======== IO_SHMsetting ======== ++ * Purpose: ++ * Sets the shared memory setting ++ * Parameters: ++ * hIOMgr: Handle to a I/O manager. ++ * desc: Shared memory type ++ * pArgs: Ptr to SHM setting ++ * Returns: ++ * Requires: ++ * hIOMgr != NULL ++ * pArgs != NULL ++ * Ensures: ++ */ ++ extern DSP_STATUS IO_SHMsetting(IN struct IO_MGR *hIOMgr, ++ IN enum SHM_DESCTYPE desc, ++ IN void *pArgs); ++ ++/* ++ * Misc functions for the CHNL_IO shared memory library: ++ */ ++ ++/* Maximum channel bufsize that can be used. */ ++ extern u32 IO_BufSize(struct IO_MGR *hIOMgr); ++ ++ extern u32 IO_ReadValue(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr); ++ ++ extern void IO_WriteValue(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr, u32 dwValue); ++ ++ extern u32 IO_ReadValueLong(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr); ++ ++ extern void IO_WriteValueLong(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr, u32 dwValue); ++ ++ extern void IO_OrSetValue(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr, u32 dwValue); ++ ++ extern void IO_AndSetValue(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr, u32 dwValue); ++ ++ extern void IO_IntrDSP2(IN struct IO_MGR *pIOMgr, IN u16 wMbVal); ++ ++ extern void IO_SM_init(void); ++ ++/* ++ * ========PrintDspTraceBuffer ======== ++ * Print DSP tracebuffer. ++ */ ++ extern DSP_STATUS PrintDspTraceBuffer(struct WMD_DEV_CONTEXT ++ *hWmdContext); ++ ++#endif /* IOSM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/iodefs.h b/arch/arm/plat-omap/include/dspbridge/iodefs.h +new file mode 100644 +index 0000000..f45890a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/iodefs.h +@@ -0,0 +1,45 @@ ++/* ++ * iodefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== iodefs.h ======== ++ * Description: ++ * System-wide channel objects and constants. ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Nov-2000 jeh Created. ++ */ ++ ++#ifndef IODEFS_ ++#define IODEFS_ ++ ++#define IO_MAXIRQ 0xff /* Arbitrarily large number. */ ++ ++/* IO Objects: */ ++ struct IO_MGR; ++ ++/* IO manager attributes: */ ++ struct IO_ATTRS { ++ u8 bIRQ; /* Channel's I/O IRQ number. */ ++ bool fShared; /* TRUE if the IRQ is shareable. */ ++ u32 uWordSize; /* DSP Word size. */ ++ u32 dwSMBase; /* Physical base address of shared memory. */ ++ u32 uSMLength; /* Size (in bytes) of shared memory. */ ++ } ; ++ ++#endif /* IODEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/kfile.h b/arch/arm/plat-omap/include/dspbridge/kfile.h +new file mode 100644 +index 0000000..23c89b0 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/kfile.h +@@ -0,0 +1,216 @@ ++/* ++ * kfile.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== kfile.h ======== ++ * Purpose: ++ * Provide file I/O management capabilities. ++ * ++ * Public Functions: ++ * KFILE_Close ++ * KFILE_Exit ++ * KFILE_Init ++ * KFILE_Open ++ * KFILE_Read ++ * KFILE_Seek ++ * KFILE_Tell ++ * KFILE_Write ++ * ++ * Notes: ++ * The KFILE module is not like most of the other DSP/BIOS Bridge modules ++ * in that it doesn't return WSX_STATUS type values. Rather, it's ++ * prototypes are meant to match the stdio file prototypes ++ * (ie, fopen, fclose, etc.). ++ * ++ *! Revision History ++ *! ================ ++ *! 29-Oct-1999 kc: Clean up for code review. ++ *! 07-Jan-1998 cr: Clean up for code review. ++ *! 15-Aug-1997 cr: Added E_KFILE_ERROR for general error condition. ++ *! 04-Aug-1997 cr: Added explicit CDECL descriptions. ++ *! 11-Nov-1996 cr: Implemented changes based on code review. ++ *! 05-Nov-1996 cr: Cleaned up for code review. ++ *! 29-May-1996 gp: Added requirement that size != 0 in _Write() and _Read(). ++ *! 28-May-1996 mg: Changed return values for Read/Write. ++ *! 14-Dec-1995 cr: Created. ++ */ ++ ++#ifndef KFILE_ ++#define KFILE_ ++ ++/* ++ * Constants for KFILE_Seek. Note that these MUST be the same definitions as ++ * those defined for fseek. ++ */ ++#define KFILE_SEEK_SET 0x00 /* seek from beginning of file */ ++#define KFILE_SEEK_CUR 0x01 /* seek from current position */ ++#define KFILE_SEEK_END 0x02 /* seek from end of file */ ++ ++ struct KFILE_FileObj; ++ ++/* ++ * ======== KFILE_Close ======== ++ * Purpose: ++ * This function closes a file's stream. ++ * Parameters: ++ * hFile: Handle of the file stream returned by KFILE_Open. ++ * Returns: ++ * E_KFILE_INVALIDHANDLE: bad handle. ++ * 0: success. ++ * E_KFILE_ERROR: unable to close specified handle. ++ * Requires: ++ * KFILE initialized. ++ * Ensures: ++ */ ++ extern s32 KFILE_Close(IN struct KFILE_FileObj *hFile); ++ ++/* ++ * ======== KFILE_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * KFILE initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void KFILE_Exit(void); ++ ++/* ++ * ======== KFILE_Init ======== ++ * Purpose: ++ * Initializes private state of KFILE module. ++ * Parameters: ++ * Returns: ++ * TRUE if success, else FALSE. ++ * Requires: ++ * Ensures: ++ * KFILE initialized. ++ */ ++ extern bool KFILE_Init(void); ++ ++/* ++ * ======== KFILE_Open ======== ++ * Purpose: ++ * Opens a file for use. ++ * Parameters: ++ * pszFileName: Full path to name of the file to open. ++ * pszMode: String containing open status. Only the first ++ * character of the string is examined, for either ++ * "r" (read) or "w" (write) mode. ++ * Returns: ++ * A valid file handle if success, else NULL. ++ * Requires: ++ * - KFILE initialized. ++ * - pszMode != NULL. ++ * - pszFileName != NULL. ++ * Ensures: ++ */ ++ extern struct KFILE_FileObj *KFILE_Open(IN CONST char *filename, ++ IN CONST char *mode); ++ ++/* ++ * ======== KFILE_Read ======== ++ * Purpose: ++ * This function reads a specified number of bytes into a buffer. ++ * Parameters: ++ * pBuffer: Array to which the file data is copied. ++ * cSize: Number of characters in each object. ++ * cCount: Number of objects to read in. ++ * hFile: Handle of the file stream returned by KFILE_Open. ++ * Returns: ++ * E_KFILE_INVALIDHANDLE: bad file handle. ++ * E_KFILE_ERROR: general failure. ++ * > 0: success; # of objects read from file. ++ * Requires: ++ * KFILE initialized. ++ * pBuffer is a valid pointer. ++ * Ensures: ++ */ ++ extern s32 KFILE_Read(OUT void __user*buffer, ++ IN s32 size, IN s32 count, ++ IN struct KFILE_FileObj *hFile); ++ ++/* ++ * ======== KFILE_Seek ======== ++ * Purpose: ++ * This function sets the file position indicator. NOTE: we don't ++ * support seeking beyond the boundaries of a file. ++ * Parameters: ++ * hFile: Handle of the file stream returned by KFILE_Open. ++ * offset: Number of bytes from the origin to move. ++ * origin: File reference point, one of the following values: ++ * KFILE_SEEK_SET: Seek from beginning of file. ++ * KFILE_SEEK_CUR: Seek from current position. ++ * KFILE_SEEK_END: Seek from end of file. ++ * Returns: ++ * 0: success. ++ * E_KFILE_INVALIDHANDLE: bad handle. ++ * E_KFILE_BADORIGIN: invalid origin paramater. ++ * E_KFILE_ERROR: general failure. ++ * Requires: ++ * KFILE initialized. ++ * Ensures: ++ */ ++ extern s32 KFILE_Seek(IN struct KFILE_FileObj *hFile, ++ IN s32 offset, IN s32 origin); ++ ++/* ++ * ======== KFILE_Tell ======== ++ * Purpose: ++ * This function reports the current value of the position indicator. ++ * Parameters: ++ * hFile: Handle of the file stream returned by KFILE_Open. ++ * Return value: ++ * > 0: success; returns # of bytes the position indicator is from ++ * beginning of file. ++ * E_KFILE_ERROR: general failure. ++ * E_KFILE_INVALIDHANDLE: bad file handle. ++ * Requires: ++ * KFILE initialized. ++ * Ensures: ++ */ ++ extern s32 KFILE_Tell(IN struct KFILE_FileObj *hFile); ++ ++/* ++ * ======== KFILE_Write ======== ++ * Purpose: ++ * This function writes a number of objects to the stream. ++ * Parameters: ++ * pBuffer: Array from which the file data is written. ++ * cSize: Number of characters in each object. ++ * cCount: Number of objects to write out. ++ * hFile: Handle of the file stream returned by KFILE_Open. ++ * Returns: ++ * E_KFILE_INVALIDHANDLE: bad file handle. ++ * E_KFILE_ERROR: general failure. ++ * > 0: success; # of objects written to file. ++ * Requires: ++ * KFILE initialized. ++ * pBuffer != NULL. ++ * Postcondition: ++ * The file position indicator is advanced by the number of ++ * characters written. ++ */ ++ extern s32 KFILE_Write(OUT void *buffer, ++ IN s32 size, ++ IN s32 count, ++ IN struct KFILE_FileObj *hFile); ++ ++#endif /* KFILE_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/ldr.h b/arch/arm/plat-omap/include/dspbridge/ldr.h +new file mode 100644 +index 0000000..7e13c93 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/ldr.h +@@ -0,0 +1,51 @@ ++/* ++ * ldr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== ldr.h ======== ++ * Purpose: ++ * Provide module loading services and symbol export services. ++ * ++ * Public Functions: ++ * LDR_Exit ++ * LDR_FreeModule ++ * LDR_GetProcAddress ++ * LDR_Init ++ * LDR_LoadModule ++ * ++ * Notes: ++ * This service is meant to be used by modules of the DSP/BIOS Bridge ++ * class driver. ++ * ++ *! Revision History: ++ *! ================ ++ *! 22-Nov-1999 kc: Changes from code review. ++ *! 12-Nov-1999 kc: Removed declaration of unused loader object. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 12-Jan-1998 cr: Cleaned up for code review. ++ *! 04-Aug-1997 cr: Added explicit CDECL identifiers. ++ *! 11-Nov-1996 cr: Cleaned up for code review. ++ *! 16-May-1996 gp: Created. ++ */ ++ ++#ifndef LDR_ ++#define LDR_ ++ ++/* Loader objects: */ ++ struct LDR_MODULE; ++ ++#endif /* LDR_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/list.h b/arch/arm/plat-omap/include/dspbridge/list.h +new file mode 100644 +index 0000000..2e3f995 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/list.h +@@ -0,0 +1,296 @@ ++/* ++ * list.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== list.h ======== ++ * Purpose: ++ * Declarations of list management control structures and definitions ++ * of inline list management functions. ++ * ++ * Public Functions: ++ * LST_Create ++ * LST_Delete ++ * LST_Exit ++ * LST_First ++ * LST_GetHead ++ * LST_InitElem ++ * LST_Init ++ * LST_InsertBefore ++ * LST_IsEmpty ++ * LST_Next ++ * LST_PutTail ++ * LST_RemoveElem ++ * ++ * Notes: ++ * ++ *! Revision History ++ *! ================ ++ *! 10-Aug-2000 ag: Added LST_InsertBefore(). ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 16-Aug-1997 cr: added explicit identifiers. ++ *! 10-Aug-1996 gp: Acquired from SMM for WinSPOX v.1.1; renamed identifiers. ++ *! 21-Oct-1994 dh4: Cleaned / commented for code review. ++ *! 08-Jun-1994 dh4: Converted to SPM (added extern "C"). ++ */ ++ ++#ifndef LIST_ ++#define LIST_ ++ ++#include <dspbridge/host_os.h> ++ ++#define LST_IsEmpty(l) (((l)->head.next == &(l)->head)) ++ ++ struct LST_ELEM { ++ struct LST_ELEM *next; ++ struct LST_ELEM *prev; ++ struct LST_ELEM *self; ++ } ; ++ ++ struct LST_LIST { ++ struct LST_ELEM head; ++ } ; ++ ++/* ++ * ======== LST_Create ======== ++ * Purpose: ++ * Allocates and initializes a circular list. ++ * Details: ++ * Uses portable MEM_Calloc() function to allocate a list containing ++ * a single element and initializes that element to indicate that it ++ * is the "end of the list" (i.e., the list is empty). ++ * An empty list is indicated by the "next" pointer in the element ++ * at the head of the list pointing to the head of the list, itself. ++ * Parameters: ++ * Returns: ++ * Pointer to beginning of created list (success) ++ * NULL --> Allocation failed ++ * Requires: ++ * LST initialized. ++ * Ensures: ++ * Notes: ++ * The created list contains a single element. This element is the ++ * "empty" element, because its "next" and "prev" pointers point at ++ * the same location (the element itself). ++ */ ++ extern struct LST_LIST *LST_Create(void); ++ ++/* ++ * ======== LST_Delete ======== ++ * Purpose: ++ * Removes a list by freeing its control structure's memory space. ++ * Details: ++ * Uses portable MEM_Free() function to deallocate the memory ++ * block pointed at by the input parameter. ++ * Parameters: ++ * pList: Pointer to list control structure of list to be deleted ++ * Returns: ++ * Void ++ * Requires: ++ * - LST initialized. ++ * - pList != NULL. ++ * Ensures: ++ * Notes: ++ * Must ONLY be used for empty lists, because it does not walk the ++ * chain of list elements. Calling this function on a non-empty list ++ * will cause a memory leak. ++ */ ++ extern void LST_Delete(IN struct LST_LIST *pList); ++ ++/* ++ * ======== LST_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * LST initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void LST_Exit(void); ++ ++/* ++ * ======== LST_First ======== ++ * Purpose: ++ * Returns a pointer to the first element of the list, or NULL if the list ++ * is empty. ++ * Parameters: ++ * pList: Pointer to list control structure. ++ * Returns: ++ * Pointer to first list element, or NULL. ++ * Requires: ++ * - LST initialized. ++ * - pList != NULL. ++ * Ensures: ++ */ ++ extern struct LST_ELEM *LST_First(IN struct LST_LIST *pList); ++ ++/* ++ * ======== LST_GetHead ======== ++ * Purpose: ++ * Pops the head off the list and returns a pointer to it. ++ * Details: ++ * If the list is empty, returns NULL. ++ * Else, removes the element at the head of the list, making the next ++ * element the head of the list. ++ * The head is removed by making the tail element of the list point its ++ * "next" pointer at the next element after the head, and by making the ++ * "prev" pointer of the next element after the head point at the tail ++ * element. So the next element after the head becomes the new head of ++ * the list. ++ * Parameters: ++ * pList: Pointer to list control structure of list whose head ++ * element is to be removed ++ * Returns: ++ * Pointer to element that was at the head of the list (success) ++ * NULL No elements in list ++ * Requires: ++ * - head.self must be correctly set to &head. ++ * - LST initialized. ++ * - pList != NULL. ++ * Ensures: ++ * Notes: ++ * Because the tail of the list points forward (its "next" pointer) to ++ * the head of the list, and the head of the list points backward (its ++ * "prev" pointer) to the tail of the list, this list is circular. ++ */ ++ extern struct LST_ELEM *LST_GetHead(IN struct LST_LIST *pList); ++ ++/* ++ * ======== LST_Init ======== ++ * Purpose: ++ * Initializes private state of LST module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE otherwise. ++ * Requires: ++ * Ensures: ++ * LST initialized. ++ */ ++ extern bool LST_Init(void); ++ ++/* ++ * ======== LST_InitElem ======== ++ * Purpose: ++ * Initializes a list element to default (cleared) values ++ * Details: ++ * Parameters: ++ * pElem: Pointer to list element to be reset ++ * Returns: ++ * Requires: ++ * LST initialized. ++ * Ensures: ++ * Notes: ++ * This function must not be called to "reset" an element in the middle ++ * of a list chain -- that would break the chain. ++ * ++ */ ++ extern void LST_InitElem(IN struct LST_ELEM *pListElem); ++ ++/* ++ * ======== LST_InsertBefore ======== ++ * Purpose: ++ * Insert the element before the existing element. ++ * Parameters: ++ * pList: Pointer to list control structure. ++ * pElem: Pointer to element in list to insert. ++ * pElemExisting: Pointer to existing list element. ++ * Returns: ++ * Requires: ++ * - LST initialized. ++ * - pList != NULL. ++ * - pElem != NULL. ++ * - pElemExisting != NULL. ++ * Ensures: ++ */ ++ extern void LST_InsertBefore(IN struct LST_LIST *pList, ++ IN struct LST_ELEM *pElem, ++ IN struct LST_ELEM *pElemExisting); ++ ++/* ++ * ======== LST_Next ======== ++ * Purpose: ++ * Returns a pointer to the next element of the list, or NULL if the next ++ * element is the head of the list or the list is empty. ++ * Parameters: ++ * pList: Pointer to list control structure. ++ * pCurElem: Pointer to element in list to remove. ++ * Returns: ++ * Pointer to list element, or NULL. ++ * Requires: ++ * - LST initialized. ++ * - pList != NULL. ++ * - pCurElem != NULL. ++ * Ensures: ++ */ ++ extern struct LST_ELEM *LST_Next(IN struct LST_LIST *pList, ++ IN struct LST_ELEM *pCurElem); ++ ++/* ++ * ======== LST_PutTail ======== ++ * Purpose: ++ * Adds the specified element to the tail of the list ++ * Details: ++ * Sets new element's "prev" pointer to the address previously held by ++ * the head element's prev pointer. This is the previous tail member of ++ * the list. ++ * Sets the new head's prev pointer to the address of the element. ++ * Sets next pointer of the previous tail member of the list to point to ++ * the new element (rather than the head, which it had been pointing at). ++ * Sets new element's next pointer to the address of the head element. ++ * Sets head's prev pointer to the address of the new element. ++ * Parameters: ++ * pList: Pointer to list control structure to which *pElem will be ++ * added ++ * pElem: Pointer to list element to be added ++ * Returns: ++ * Void ++ * Requires: ++ * *pElem and *pList must both exist. ++ * pElem->self = pElem before pElem is passed to this function. ++ * LST initialized. ++ * Ensures: ++ * Notes: ++ * Because the tail is always "just before" the head of the list (the ++ * tail's "next" pointer points at the head of the list, and the head's ++ * "prev" pointer points at the tail of the list), the list is circular. ++ * Warning: if pElem->self is not set beforehand, LST_GetHead() will ++ * return an erroneous pointer when it is called for this element. ++ */ ++ extern void LST_PutTail(IN struct LST_LIST *pList, ++ IN struct LST_ELEM *pListElem); ++ ++/* ++ * ======== LST_RemoveElem ======== ++ * Purpose: ++ * Removes (unlinks) the given element from the list, if the list is not ++ * empty. Does not free the list element. ++ * Parameters: ++ * pList: Pointer to list control structure. ++ * pCurElem: Pointer to element in list to remove. ++ * Returns: ++ * Requires: ++ * - LST initialized. ++ * - pList != NULL. ++ * - pCurElem != NULL. ++ * Ensures: ++ */ ++extern void LST_RemoveElem(IN struct LST_LIST *pList, ++ IN struct LST_ELEM *pCurElem); ++ ++#endif /* LIST_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/mbx_sh.h b/arch/arm/plat-omap/include/dspbridge/mbx_sh.h +new file mode 100644 +index 0000000..be0909e +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/mbx_sh.h +@@ -0,0 +1,213 @@ ++/* ++ * mbx_sh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mbx_sh.h ======== ++ * Definitions for shared mailbox cmd/data values.(used on both ++ * the GPP and DSP sides). ++ * ++ * Bridge usage of OMAP mailbox 1 is determined by the "class" of the ++ * mailbox interrupt's cmd value received. The class value are defined ++ * as a bit (10 thru 15) being set. ++ * ++ * Note: Only 16 bits of each is used. Other 16 bit data reg available. ++ * ++ * 16 bit Mbx bit defns: ++ * ++ * A). Exception/Error handling (Module DEH) : class = 0. ++ * ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|0|0|0|0|x|x|x|x|x|x|x|x|x|x| ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * ++ * ++ * B: DSP-DMA link driver channels (DDMA) : class = 1. ++ * ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|0|0|0|1|b|b|b|b|b|c|c|c|c|c| ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * where b -> buffer index (32 DDMA buffers/chnl max) ++ * c -> channel Id (32 DDMA chnls max) ++ * ++ * ++ * ++ * ++ * C: Proc-copy link driver channels (PCPY) : class = 2. ++ * ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|0|0|1|0|x|x|x|x|x|x|x|x|x|x| ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * ++ * D: Zero-copy link driver channels (DDZC) : class = 4. ++ * ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|0|1|0|0|x|x|x|x|x|c|c|c|c|c| ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * where x -> not used ++ * c -> channel Id (32 ZCPY chnls max) ++ * ++ * ++ * E: Power management : class = 8. ++ * ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|1|0|0|0|x|x|x|x|x|c|c|c|c|c| ++ ++ * 0010 00xx xxxc cccc ++ * 0010 00nn pppp qqqq ++ * nn: ++ * 00 = reserved ++ * 01 = pwr state change ++ * 10 = opp pre-change ++ * 11 = opp post-change ++ * ++ * if nn = pwr state change: ++ * pppp = don't care ++ * qqqq: ++ * 0010 = hibernate ++ * 0010 0001 0000 0010 ++ * 0110 = retention ++ * 0010 0001 0000 0110 ++ * others reserved ++ * ++ * if nn = opp pre-change: ++ * pppp = current opp ++ * qqqq = next opp ++ * ++ * if nn = opp post-change: ++ * pppp = prev opp ++ * qqqq = current opp ++ * ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * where x -> not used ++ * c -> Power management command ++ * ++ * ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Sep-2002 mr Added DEH reset const ++ *! 24-Apr-2002 sg Added more PM commands. ++ *! 04-Mar-2002 gv Added MBX_PM_CLASS ++ *! 22-Jan-2002 ag Bug fix in MBX_SETZCPYVAL(x) macro. ++ *! 21-Dec-2001 ag Added bit masks defns. ++ *! 17-Dec-2001 ag: created. ++ */ ++ ++#ifndef _MBX_SH_H ++#define _MBX_SH_H ++ ++#define MBX_CLASS_MSK 0xFC00 /* Class bits are 10 thru 15 */ ++#define MBX_VALUE_MSK 0x03FF /* Value is 0 thru 9 */ ++ ++#define MBX_DEH_CLASS 0x0000 /* DEH owns Mbx INTR */ ++#define MBX_DDMA_CLASS 0x0400 /* DSP-DMA link drvr chnls owns INTR */ ++#define MBX_PCPY_CLASS 0x0800 /* PROC-COPY " */ ++#define MBX_ZCPY_CLASS 0x1000 /* ZERO-COPY " */ ++#define MBX_PM_CLASS 0x2000 /* Power Management */ ++#define MBX_DBG_CLASS 0x4000 /* For debugging purpose */ ++ ++/* ++ * Exception Handler codes ++ * Magic code used to determine if DSP signaled exception. ++ */ ++#define MBX_DEH_BASE 0x0 ++#define MBX_DEH_USERS_BASE 0x100 /* 256 */ ++#define MBX_DEH_LIMIT 0x3FF /* 1023 */ ++#define MBX_DEH_RESET 0x101 /* DSP RESET (DEH) */ ++#define MBX_DEH_EMMU 0X103 /*DSP MMU FAULT RECOVERY*/ ++ ++/* ++ * Link driver command/status codes. ++ */ ++/* DSP-DMA */ ++#define MBX_DDMA_NUMCHNLBITS 5 /* # chnl Id: # bits available */ ++#define MBX_DDMA_CHNLSHIFT 0 /* # of bits to shift */ ++#define MBX_DDMA_CHNLMSK 0x01F /* bits 0 thru 4 */ ++ ++#define MBX_DDMA_NUMBUFBITS 5 /* buffer index: # of bits avail */ ++#define MBX_DDMA_BUFSHIFT (MBX_DDMA_NUMCHNLBITS + MBX_DDMA_CHNLSHIFT) ++#define MBX_DDMA_BUFMSK 0x3E0 /* bits 5 thru 9 */ ++ ++/* Zero-Copy */ ++#define MBX_ZCPY_NUMCHNLBITS 5 /* # chnl Id: # bits available */ ++#define MBX_ZCPY_CHNLSHIFT 0 /* # of bits to shift */ ++#define MBX_ZCPY_CHNLMSK 0x01F /* bits 0 thru 4 */ ++ ++/* Power Management Commands */ ++#define MBX_PM_DSPIDLE (MBX_PM_CLASS + 0x0) ++#define MBX_PM_DSPWAKEUP (MBX_PM_CLASS + 0x1) ++#define MBX_PM_EMERGENCYSLEEP (MBX_PM_CLASS + 0x2) ++#define MBX_PM_SLEEPUNTILRESTART (MBX_PM_CLASS + 0x3) ++#define MBX_PM_DSPGLOBALIDLE_OFF (MBX_PM_CLASS + 0x4) ++#define MBX_PM_DSPGLOBALIDLE_ON (MBX_PM_CLASS + 0x5) ++#define MBX_PM_SETPOINT_PRENOTIFY (MBX_PM_CLASS + 0x6) ++#define MBX_PM_SETPOINT_POSTNOTIFY (MBX_PM_CLASS + 0x7) ++#define MBX_PM_DSPRETN (MBX_PM_CLASS + 0x8) ++#define MBX_PM_DSPRETENTION (MBX_PM_CLASS + 0x8) ++#define MBX_PM_DSPHIBERNATE (MBX_PM_CLASS + 0x9) ++#define MBX_PM_HIBERNATE_EN (MBX_PM_CLASS + 0xA) ++#define MBX_PM_OPP_REQ (MBX_PM_CLASS + 0xB) ++#define MBX_PM_OPP_CHG (MBX_PM_CLASS + 0xC) ++ ++#define MBX_PM_TYPE_MASK 0x0300 ++#define MBX_PM_TYPE_PWR_CHNG 0x0100 ++#define MBX_PM_TYPE_OPP_PRECHNG 0x0200 ++#define MBX_PM_TYPE_OPP_POSTCHNG 0x0300 ++#define MBX_PM_TYPE_OPP_MASK 0x0300 ++#define MBX_PM_OPP_PRECHNG (MBX_PM_CLASS | MBX_PM_TYPE_OPP_PRECHNG) ++/* DSP to MPU */ ++#define MBX_PM_OPP_CHNG(OPP) (MBX_PM_CLASS | MBX_PM_TYPE_OPP_PRECHNG | (OPP)) ++#define MBX_PM_RET (MBX_PM_CLASS | MBX_PM_TYPE_PWR_CHNG | 0x0006) ++#define MBX_PM_HIB (MBX_PM_CLASS | MBX_PM_TYPE_PWR_CHNG | 0x0002) ++#define MBX_PM_OPP_1 0 ++#define MBX_PM_OPP_2 1 ++#define MBX_PM_OPP_3 2 ++#define MBX_PM_OPP_4 3 ++#define MBX_OLDOPP_EXTRACT(OPPMSG) ((0x00F0 & (OPPMSG)) >> 4) ++#define MBX_NEWOPP_EXTRACT(OPPMSG) (0x000F & (OPPMSG)) ++#define MBX_PREVOPP_EXTRACT(OPPMSG) ((0x00F0 & (OPPMSG)) >> 4) ++#define MBX_CUROPP_EXTRACT(OPPMSG) (0x000F & (OPPMSG)) ++ ++/* Bridge Debug Commands */ ++#define MBX_DBG_SYSPRINTF (MBX_DBG_CLASS + 0x0) ++ ++/* ++ * Useful macros ++ */ ++/* DSP-DMA channel */ ++#define MBX_SETDDMAVAL(x, y) (MBX_DDMA_CLASS | (x << MBX_DDMA_BUFSHIFT) | \ ++ (y << MBX_DDMA_CHNLSHIFT)) ++ ++/* Zero-Copy channel */ ++#define MBX_SETZCPYVAL(x) (MBX_ZCPY_CLASS | (x << MBX_ZCPY_CHNLSHIFT)) ++ ++#endif /* _MBX_SH_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/mem.h b/arch/arm/plat-omap/include/dspbridge/mem.h +new file mode 100644 +index 0000000..535ac3a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/mem.h +@@ -0,0 +1,340 @@ ++/* ++ * mem.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mem.h ======== ++ * Purpose: ++ * Memory management and address mapping services for the DSP/BIOS Bridge ++ * class driver and mini-driver. ++ * ++ * Public Functions: ++ * MEM_Alloc ++ * MEM_AllocObject ++ * MEM_AllocPhysMem ++ * MEM_Calloc ++ * MEM_Exit ++ * MEM_FlushCache ++ * MEM_Free ++ * MEM_FreeObject ++ * MEM_FreePhysMem ++ * MEM_GetNumPages ++ * MEM_Init ++ * MEM_IsValidHandle ++ * MEM_LinearAddress ++ * MEM_PageLock ++ * MEM_PageUnlock ++ * MEM_UnMapLinearAddress ++ * MEM_VirtualToPhysical ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb: Added Alloc/Free PhysMem, FlushCache, VirtualToPhysical ++ *! 01-Sep-2001 ag: Cleaned up notes for MEM_LinearAddress() does not ++ *! require phys address to be page aligned! ++ *! 02-Dec-1999 rr: stdwin.h included for retail build ++ *! 12-Nov-1999 kc: Added warning about use of MEM_LinearAddress. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 10-Aug-1999 kc: Based on wsx-c18. ++ *! 07-Jan-1998 gp: Added MEM_AllocUMB and MEM_UMBFree for User Mapped Buffers ++ *! used by WMD_CHNL. ++ *! 23-Dec-1997 cr: Code review cleanup, removed dead Ring 3 code. ++ *! 04-Aug-1997 cr: Added explicit CDECL identifiers. ++ *! 01-Nov-1996 gp: Updated based on code review. ++ *! 04-Sep-1996 gp: Added MEM_PageLock() and MEM_PageUnlock() services. ++ *! 14-Aug-1996 mg: Added MEM_GetPhysAddr() and MEM_GetNumPages() ++ *! 25-Jul-1996 gp: Added MEM_IsValidHandle() macro. ++ *! 10-May-1996 gp: Added MEM_Calloc(). ++ *! 25-Apr-1996 gp: Added MEM_PhysicalAddress() ++ *! 17-Apr-1996 gp: Added MEM_Exit function; updated to latest naming standard. ++ *! 08-Apr-1996 gp: Created. ++ */ ++ ++#ifndef MEM_ ++#define MEM_ ++ ++#include <dspbridge/host_os.h> ++#include <dspbridge/memdefs.h> ++ ++/* ++ * ======== MEM_Alloc ======== ++ * Purpose: ++ * Allocate memory from the paged or non-paged pools. ++ * Parameters: ++ * cBytes: Number of bytes to allocate. ++ * type: Type of memory to allocate; one of: ++ * MEM_PAGED: Allocate from pageable memory. ++ * MEM_NONPAGED: Allocate from page locked memory. ++ * Returns: ++ * Pointer to a block of memory; ++ * NULL if memory couldn't be allocated, if cBytes == 0, or if type is ++ * not one of MEM_PAGED or MEM_NONPAGED. ++ * Requires: ++ * MEM initialized. ++ * Ensures: ++ * The returned pointer, if not NULL, points to a valid memory block of ++ * the size requested. ++ */ ++ extern void *MEM_Alloc(IN u32 cBytes, IN enum MEM_POOLATTRS type); ++ ++/* ++ * ======== MEM_AllocObject ======== ++ * Purpose: ++ * Allocate an object, and set it's signature. ++ * Parameters: ++ * pObj: Pointer to the new object. ++ * Obj: Type of the object to allocate. ++ * Signature: Magic field value. Must be non-zero. ++ * Returns: ++ * Requires: ++ * Same requirements as MEM_Calloc(); and ++ * The object structure has a dwSignature field. The compiler ensures ++ * this requirement. ++ * Ensures: ++ * A subsequent call to MEM_IsValidHandle() will succeed for this object. ++ */ ++#define MEM_AllocObject(pObj, Obj, Signature) \ ++{ \ ++ pObj = MEM_Calloc(sizeof(Obj), MEM_NONPAGED); \ ++ if (pObj) { \ ++ pObj->dwSignature = Signature; \ ++ } \ ++} ++ ++/* ======== MEM_AllocPhysMem ======== ++ * Purpose: ++ * Allocate physically contiguous, uncached memory ++ * Parameters: ++ * cBytes: Number of bytes to allocate. ++ * ulAlign: Alignment Mask. ++ * pPhysicalAddress: Physical address of allocated memory. ++ * Returns: ++ * Pointer to a block of memory; ++ * NULL if memory couldn't be allocated, or if cBytes == 0. ++ * Requires: ++ * MEM initialized. ++ * Ensures: ++ * The returned pointer, if not NULL, points to a valid memory block of ++ * the size requested. Returned physical address refers to physical ++ * location of memory. ++ */ ++ extern void *MEM_AllocPhysMem(IN u32 cBytes, ++ IN u32 ulAlign, ++ OUT u32 *pPhysicalAddress); ++ ++/* ++ * ======== MEM_Calloc ======== ++ * Purpose: ++ * Allocate zero-initialized memory from the paged or non-paged pools. ++ * Parameters: ++ * cBytes: Number of bytes to allocate. ++ * type: Type of memory to allocate; one of: ++ * MEM_PAGED: Allocate from pageable memory. ++ * MEM_NONPAGED: Allocate from page locked memory. ++ * Returns: ++ * Pointer to a block of zeroed memory; ++ * NULL if memory couldn't be allocated, if cBytes == 0, or if type is ++ * not one of MEM_PAGED or MEM_NONPAGED. ++ * Requires: ++ * MEM initialized. ++ * Ensures: ++ * The returned pointer, if not NULL, points to a valid memory block ++ * of the size requested. ++ */ ++ extern void *MEM_Calloc(IN u32 cBytes, IN enum MEM_POOLATTRS type); ++ ++/* ++ * ======== MEM_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * MEM is initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void MEM_Exit(void); ++ ++/* ++ * ======== MEM_FlushCache ======== ++ * Purpose: ++ * Performs system cache sync with discard ++ * Parameters: ++ * pMemBuf: Pointer to memory region to be flushed. ++ * pMemBuf: Size of the memory region to be flushed. ++ * Returns: ++ * Requires: ++ * MEM is initialized. ++ * Ensures: ++ * Cache is synchronized ++ */ ++ extern void MEM_FlushCache(void *pMemBuf, u32 cBytes, s32 FlushType); ++ ++/* ++ * ======== MEM_Free ======== ++ * Purpose: ++ * Free the given block of system memory. ++ * Parameters: ++ * pMemBuf: Pointer to memory allocated by MEM_Calloc/Alloc(). ++ * Returns: ++ * Requires: ++ * MEM initialized. ++ * pMemBuf is a valid memory address returned by MEM_Calloc/Alloc(). ++ * Ensures: ++ * pMemBuf is no longer a valid pointer to memory. ++ */ ++ extern void MEM_Free(IN void *pMemBuf); ++ ++/* ++ * ======== MEM_FreePhysMem ======== ++ * Purpose: ++ * Free the given block of physically contiguous memory. ++ * Parameters: ++ * pVirtualAddress: Pointer to virtual memory region allocated ++ * by MEM_AllocPhysMem(). ++ * pPhysicalAddress: Pointer to physical memory region allocated ++ * by MEM_AllocPhysMem(). ++ * cBytes: Size of the memory region allocated by MEM_AllocPhysMem(). ++ * Returns: ++ * Requires: ++ * MEM initialized. ++ * pVirtualAddress is a valid memory address returned by ++ * MEM_AllocPhysMem() ++ * Ensures: ++ * pVirtualAddress is no longer a valid pointer to memory. ++ */ ++ extern void MEM_FreePhysMem(void *pVirtualAddress, ++ u32 pPhysicalAddress, u32 cBytes); ++ ++/* ++ * ======== MEM_FreeObject ======== ++ * Purpose: ++ * Utility macro to invalidate an object's signature, and deallocate it. ++ * Parameters: ++ * pObj: Pointer to the object to free. ++ * Returns: ++ * Requires: ++ * Same requirements as MEM_Free(). ++ * Ensures: ++ * A subsequent call to MEM_IsValidHandle() will fail for this object. ++ */ ++#define MEM_FreeObject(pObj) \ ++{ \ ++ pObj->dwSignature = 0x00; \ ++ MEM_Free(pObj); \ ++} ++ ++/* ++ * ======== MEM_GetNumPages ======== ++ * Purpose: ++ * Calculate the number of pages corresponding to the supplied buffer. ++ * Parameters: ++ * pAddr: Linear (virtual) address of the buffer. ++ * cBytes: Number of bytes in the buffer. ++ * Returns: ++ * Number of pages. ++ * Requires: ++ * MEM initialized. ++ * Ensures: ++ * If cBytes > 0, number of pages returned > 0. ++ */ ++ extern s32 MEM_GetNumPages(IN void *pAddr, IN u32 cBytes); ++ ++/* ++ * ======== MEM_Init ======== ++ * Purpose: ++ * Initializes private state of MEM module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * MEM initialized. ++ */ ++ extern bool MEM_Init(void); ++ ++/* ++ * ======== MEM_IsValidHandle ======== ++ * Purpose: ++ * Validate the object handle. ++ * Parameters: ++ * hObj: Handle to object created with MEM_AllocObject(). ++ * Sig: Expected signature u32. ++ * Returns: ++ * TRUE if handle is valid; FALSE otherwise. ++ * Requires: ++ * The object structure has a dwSignature field. Ensured by compiler. ++ * Ensures: ++ */ ++#define MEM_IsValidHandle(hObj, Sig) \ ++ ((hObj != NULL) && (hObj->dwSignature == Sig)) ++ ++/* ++ * ======== MEM_LinearAddress ======== ++ * Purpose: ++ * Get the linear address corresponding to the given physical address. ++ * Parameters: ++ * pPhysAddr: Physical address to be mapped. ++ * cBytes: Number of bytes in physical range to map. ++ * Returns: ++ * The corresponding linear address, or NULL if unsuccessful. ++ * Requires: ++ * MEM initialized. ++ * Ensures: ++ * Notes: ++ * If valid linear address is returned, be sure to call ++ * MEM_UnmapLinearAddress(). ++ */ ++#define MEM_LinearAddress(pPhyAddr, cBytes) pPhyAddr ++ ++/* ++ * ======== MEM_UnmapLinearAddress ======== ++ * Purpose: ++ * Unmap the linear address mapped in MEM_LinearAddress. ++ * Parameters: ++ * pBaseAddr: Ptr to mapped memory (as returned by MEM_LinearAddress()). ++ * Returns: ++ * Requires: ++ * - MEM initialized. ++ * - pBaseAddr is a valid linear address mapped in MEM_LinearAddress. ++ * Ensures: ++ * - pBaseAddr no longer points to a valid linear address. ++ */ ++#define MEM_UnmapLinearAddress(pBaseAddr) ++ ++/* ++ * ======== MEM_ExtPhysPoolInit ======== ++ * Purpose: ++ * Uses the physical memory chunk passed for internal consitent memory ++ * allocations. ++ * physical address based on the page frame address. ++ * Parameters: ++ * poolPhysBase starting address of the physical memory pool. ++ * poolSize size of the physical memory pool. ++ * Returns: ++ * none. ++ * Requires: ++ * - MEM initialized. ++ * - valid physical address for the base and size > 0 ++ */ ++ extern void MEM_ExtPhysPoolInit(IN u32 poolPhysBase, ++ IN u32 poolSize); ++ ++#endif /* MEM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/memdefs.h b/arch/arm/plat-omap/include/dspbridge/memdefs.h +new file mode 100644 +index 0000000..a5bb259 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/memdefs.h +@@ -0,0 +1,52 @@ ++/* ++ * memdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== memdefs.h ======== ++ * Purpose: ++ * Global MEM constants and types, shared between WSX, WCD, and WMD. ++ * ++ *! Revision History: ++ *! ================ ++ *! 28-Aug-2001 ag: Added MEM_[SET][GET]VIRTUALSEGID. ++ *! 10-Aug-1999 kc: Based on wsx-c18. ++ *! 15-Nov-1996 gp: Renamed from wsxmem.h and moved to kwinos. ++ *! 21-Aug-1996 cr: Created from mem.h. ++ */ ++ ++#ifndef MEMDEFS_ ++#define MEMDEFS_ ++ ++/* Memory Pool Attributes: */ ++ enum MEM_POOLATTRS { ++ MEM_PAGED = 0, ++ MEM_NONPAGED = 1, ++ MEM_LARGEVIRTMEM = 2 ++ } ; ++ ++/* ++ * MEM_VIRTUALSEGID is used by Node & Strm to access virtual address space in ++ * the correct client process context. ++ */ ++#define MEM_SETVIRTUALSEGID 0x10000000 ++#define MEM_GETVIRTUALSEGID 0x20000000 ++#define MEM_MASKVIRTUALSEGID (MEM_SETVIRTUALSEGID | MEM_GETVIRTUALSEGID) ++ ++#define TO_VIRTUAL_UNCACHED(x) x ++#define INTREG_TO_VIRTUAL_UNCACHED(x) x ++ ++#endif /* MEMDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/mgr.h b/arch/arm/plat-omap/include/dspbridge/mgr.h +new file mode 100644 +index 0000000..24c4472 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/mgr.h +@@ -0,0 +1,234 @@ ++/* ++ * mgr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mgr.h ======== ++ * Description: ++ * This is the Class driver RM module interface. ++ * ++ * Public Functions: ++ * MGR_Create ++ * MGR_Destroy ++ * MGR_EnumNodeInfo ++ * MGR_EnumProcessorInfo ++ * MGR_Exit ++ * MGR_GetDCDHandle ++ * MGR_Init ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 15-Oct-2002 kc: Removed legacy PERF definitions. ++ *! 11-Jul-2001 jeh Added CFG_HDEVNODE parameter to MGR_Create(). ++ *! 22-Nov-2000 kc: Added MGR_GetPerfData for acquiring PERF stats. ++ *! 03-Nov-2000 rr: Added MGR_GetDCDHandle. Modified after code review. ++ *! 25-Sep-2000 rr: Updated to Version 0.9 ++ *! 14-Aug-2000 rr: Cleaned up. ++ *! 07-Aug-2000 rr: MGR_Create does the job of Loading DCD Dll. ++ *! 27-Jul-2000 rr: Updated to ver 0.8 of DSPAPI(types). ++ *! 20-Jun-2000 rr: Created. ++ */ ++ ++#ifndef MGR_ ++#define MGR_ ++ ++#include <dspbridge/mgrpriv.h> ++ ++#define MAX_EVENTS 32 ++ ++/* ++ * ======== MGR_WaitForBridgeEvents ======== ++ * Purpose: ++ * Block on any Bridge event(s) ++ * Parameters: ++ * aNotifications : array of pointers to notification objects. ++ * uCount : number of elements in above array ++ * puIndex : index of signaled event object ++ * uTimeout : timeout interval in milliseocnds ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_ETIMEOUT : Wait timed out. *puIndex is undetermined. ++ * Details: ++ */ ++ ++ DSP_STATUS MGR_WaitForBridgeEvents(struct DSP_NOTIFICATION ++ **aNotifications, ++ u32 uCount, OUT u32 *puIndex, ++ u32 uTimeout); ++ ++/* ++ * ======== MGR_Create ======== ++ * Purpose: ++ * Creates the Manager Object. This is done during the driver loading. ++ * There is only one Manager Object in the DSP/BIOS Bridge. ++ * Parameters: ++ * phMgrObject: Location to store created MGR Object handle. ++ * hDevNode: Device object as known to Windows system. ++ * Returns: ++ * DSP_SOK: Success ++ * DSP_EMEMORY: Failed to Create the Object ++ * DSP_EFAIL: General Failure ++ * Requires: ++ * MGR Initialized (cRefs > 0 ) ++ * phMgrObject != NULL. ++ * Ensures: ++ * DSP_SOK: *phMgrObject is a valid MGR interface to the device. ++ * MGR Object stores the DCD Manager Handle. ++ * MGR Object stored in the Regsitry. ++ * !DSP_SOK: MGR Object not created ++ * Details: ++ * DCD Dll is loaded and MGR Object stores the handle of the DLL. ++ */ ++ extern DSP_STATUS MGR_Create(OUT struct MGR_OBJECT **hMgrObject, ++ struct CFG_DEVNODE *hDevNode); ++ ++/* ++ * ======== MGR_Destroy ======== ++ * Purpose: ++ * Destroys the MGR object. Called upon driver unloading. ++ * Parameters: ++ * hMgrObject: Handle to Manager object . ++ * Returns: ++ * DSP_SOK: Success. ++ * DCD Manager freed; MGR Object destroyed; ++ * MGR Object deleted from the Registry. ++ * DSP_EFAIL: Failed to destroy MGR Object ++ * Requires: ++ * MGR Initialized (cRefs > 0 ) ++ * hMgrObject is a valid MGR handle . ++ * Ensures: ++ * DSP_SOK: MGR Object destroyed and hMgrObject is Invalid MGR ++ * Handle. ++ */ ++ extern DSP_STATUS MGR_Destroy(struct MGR_OBJECT *hMgrObject); ++ ++/* ++ * ======== MGR_EnumNodeInfo ======== ++ * Purpose: ++ * Enumerate and get configuration information about nodes configured ++ * in the node database. ++ * Parameters: ++ * uNode: The node index (base 0). ++ * pNDBProps: Ptr to the DSP_NDBPROPS structure for output. ++ * uNDBPropsSize: Size of the DSP_NDBPROPS structure. ++ * puNumNodes: Location where the number of nodes configured ++ * in the database will be returned. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EINVALIDARG: Parameter uNode is > than the number of nodes. ++ * configutred in the system ++ * DSP_ECHANGEDURINGENUM: During Enumeration there has been a change in ++ * the number of nodes configured or in the ++ * the properties of the enumerated nodes. ++ * DSP_EFAIL: Failed to querry the Node Data Base ++ * Requires: ++ * pNDBPROPS is not null ++ * uNDBPropsSize >= sizeof(DSP_NDBPROPS) ++ * puNumNodes is not null ++ * MGR Initialized (cRefs > 0 ) ++ * Ensures: ++ * SUCCESS on successful retreival of data and *puNumNodes > 0 OR ++ * DSP_FAILED && *puNumNodes == 0. ++ * Details: ++ */ ++ extern DSP_STATUS MGR_EnumNodeInfo(u32 uNode, ++ OUT struct DSP_NDBPROPS *pNDBProps, ++ u32 uNDBPropsSize, ++ OUT u32 *puNumNodes); ++ ++/* ++ * ======== MGR_EnumProcessorInfo ======== ++ * Purpose: ++ * Enumerate and get configuration information about available DSP ++ * processors ++ * Parameters: ++ * uProcessor: The processor index (zero-based). ++ * pProcessorInfo: Ptr to the DSP_PROCESSORINFO structure . ++ * uProcessorInfoSize: Size of DSP_PROCESSORINFO structure. ++ * puNumProcs: Location where the number of DSPs configured ++ * in the database will be returned ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EINVALIDARG: Parameter uProcessor is > than the number of ++ * DSP Processors in the system. ++ * DSP_EFAIL: Failed to querry the Node Data Base ++ * Requires: ++ * pProcessorInfo is not null ++ * puNumProcs is not null ++ * uProcessorInfoSize >= sizeof(DSP_PROCESSORINFO) ++ * MGR Initialized (cRefs > 0 ) ++ * Ensures: ++ * SUCCESS on successful retreival of data and *puNumProcs > 0 OR ++ * DSP_FAILED && *puNumProcs == 0. ++ * Details: ++ */ ++ extern DSP_STATUS MGR_EnumProcessorInfo(u32 uProcessor, ++ OUT struct DSP_PROCESSORINFO * ++ pProcessorInfo, ++ u32 uProcessorInfoSize, ++ OUT u32 *puNumProcs); ++/* ++ * ======== MGR_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * MGR is initialized. ++ * Ensures: ++ * When reference count == 0, MGR's private resources are freed. ++ */ ++ extern void MGR_Exit(void); ++ ++/* ++ * ======== MGR_GetDCDHandle ======== ++ * Purpose: ++ * Retrieves the MGR handle. Accessor Function ++ * Parameters: ++ * hMGRHandle: Handle to the Manager Object ++ * phDCDHandle: Ptr to receive the DCD Handle. ++ * Returns: ++ * DSP_SOK: Sucess ++ * DSP_EFAIL: Failure to get the Handle ++ * Requires: ++ * MGR is initialized. ++ * phDCDHandle != NULL ++ * Ensures: ++ * DSP_SOK and *phDCDHandle != NULL || ++ * DSP_EFAIL and *phDCDHandle == NULL ++ */ ++ extern DSP_STATUS MGR_GetDCDHandle(IN struct MGR_OBJECT ++ *hMGRHandle, ++ OUT u32 *phDCDHandle); ++ ++/* ++ * ======== MGR_Init ======== ++ * Purpose: ++ * Initialize MGR's private state, keeping a reference count on each ++ * call. Intializes the DCD. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * TRUE: A requirement for the other public MGR functions. ++ */ ++ extern bool MGR_Init(void); ++ ++#endif /* MGR_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/mgrpriv.h b/arch/arm/plat-omap/include/dspbridge/mgrpriv.h +new file mode 100644 +index 0000000..4a34086 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/mgrpriv.h +@@ -0,0 +1,55 @@ ++/* ++ * mgrpriv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mgrpriv.h ======== ++ * Description: ++ * Global MGR constants and types, shared by PROC, MGR, and WCD. ++ * ++ *! Revision History: ++ *! ================ ++ *! 29-July-2001 ag: added MGR_PROCESSOREXTINFO. ++ *! 05-July-2000 rr: Created ++ */ ++ ++#ifndef MGRPRIV_ ++#define MGRPRIV_ ++ ++/* ++ * OMAP1510 specific ++ */ ++#define MGR_MAXTLBENTRIES 32 ++ ++/* RM MGR Object */ ++ struct MGR_OBJECT; ++ ++ struct MGR_TLBENTRY { ++ u32 ulDspVirt; /* DSP virtual address */ ++ u32 ulGppPhys; /* GPP physical address */ ++ } ; ++ ++/* ++ * The DSP_PROCESSOREXTINFO structure describes additional extended ++ * capabilities of a DSP processor not exposed to user. ++ */ ++ struct MGR_PROCESSOREXTINFO { ++ struct DSP_PROCESSORINFO tyBasic; /* user processor info */ ++ /* private dsp mmu entries */ ++ struct MGR_TLBENTRY tyTlb[MGR_MAXTLBENTRIES]; ++ } ; ++ ++#endif /* MGRPRIV_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/msg.h b/arch/arm/plat-omap/include/dspbridge/msg.h +new file mode 100644 +index 0000000..f2872cc +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/msg.h +@@ -0,0 +1,106 @@ ++/* ++ * msg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== msg.h ======== ++ * Description: ++ * DSP/BIOS Bridge MSG Module. ++ * ++ * Public Functions: ++ * MSG_Create ++ * MSG_Delete ++ * MSG_Exit ++ * MSG_Init ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================= ++ *! 17-Nov-2000 jeh Removed MSG_Get, MSG_Put, MSG_CreateQueue, ++ *! MSG_DeleteQueue, and MSG_RegisterNotify, since these ++ *! are now part of mini-driver. ++ *! 12-Sep-2000 jeh Created. ++ */ ++ ++#ifndef MSG_ ++#define MSG_ ++ ++#include <dspbridge/devdefs.h> ++#include <dspbridge/msgdefs.h> ++ ++/* ++ * ======== MSG_Create ======== ++ * Purpose: ++ * Create an object to manage message queues. Only one of these objects ++ * can exist per device object. The MSG manager must be created before ++ * the IO Manager. ++ * Parameters: ++ * phMsgMgr: Location to store MSG manager handle on output. ++ * hDevObject: The device object. ++ * msgCallback: Called whenever an RMS_EXIT message is received. ++ * Returns: ++ * Requires: ++ * MSG_Init(void) called. ++ * phMsgMgr != NULL. ++ * hDevObject != NULL. ++ * msgCallback != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS MSG_Create(OUT struct MSG_MGR **phMsgMgr, ++ struct DEV_OBJECT *hDevObject, ++ MSG_ONEXIT msgCallback); ++ ++/* ++ * ======== MSG_Delete ======== ++ * Purpose: ++ * Delete a MSG manager allocated in MSG_Create(). ++ * Parameters: ++ * hMsgMgr: Handle returned from MSG_Create(). ++ * Returns: ++ * Requires: ++ * MSG_Init(void) called. ++ * Valid hMsgMgr. ++ * Ensures: ++ */ ++ extern void MSG_Delete(struct MSG_MGR *hMsgMgr); ++ ++/* ++ * ======== MSG_Exit ======== ++ * Purpose: ++ * Discontinue usage of MSG module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * MSG_Init(void) successfully called before. ++ * Ensures: ++ * Any resources acquired in MSG_Init(void) will be freed when last MSG ++ * client calls MSG_Exit(void). ++ */ ++ extern void MSG_Exit(void); ++ ++/* ++ * ======== MSG_Init ======== ++ * Purpose: ++ * Initialize the MSG module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Ensures: ++ */ ++ extern bool MSG_Init(void); ++ ++#endif /* MSG_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/msgdefs.h b/arch/arm/plat-omap/include/dspbridge/msgdefs.h +new file mode 100644 +index 0000000..8ea4551 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/msgdefs.h +@@ -0,0 +1,43 @@ ++/* ++ * msgdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== msgdefs.h ======== ++ * Description: ++ * Global MSG constants and types. ++ * ++ *! Revision History ++ *! ================ ++ *! 09-May-2001 jeh Removed MSG_TODSP, MSG_FROMDSP. ++ *! 17-Nov-2000 jeh Added MSGMGR_SIGNATURE. ++ *! 12-Sep-2000 jeh Created. ++ */ ++ ++#ifndef MSGDEFS_ ++#define MSGDEFS_ ++ ++#define MSGMGR_SIGNATURE 0x4d47534d /* "MGSM" */ ++ ++/* MSG Objects: */ ++ struct MSG_MGR; ++ struct MSG_QUEUE; ++ ++/* Function prototype for callback to be called on RMS_EXIT message received */ ++ typedef void(*MSG_ONEXIT) (HANDLE h, s32 nStatus); ++ ++#endif /* MSGDEFS_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/nldr.h b/arch/arm/plat-omap/include/dspbridge/nldr.h +new file mode 100644 +index 0000000..0915846 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/nldr.h +@@ -0,0 +1,81 @@ ++/* ++ * nldr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== nldr.h ======== ++ * ++ * Description: ++ * DSP/BIOS Bridge dynamic loader interface. See the file dldrdefs.h ++ * for a description of these functions. ++ * ++ * Public Functions: ++ * NLDR_Allocate ++ * NLDR_Create ++ * NLDR_Delete ++ * NLDR_Exit ++ * NLDR_Free ++ * NLDR_GetFxnAddr ++ * NLDR_Init ++ * NLDR_Load ++ * NLDR_Unload ++ * ++ * Notes: ++ * ++ *! Revision History ++ *! ================ ++ *! 31-Jul-2002 jeh Removed function header comments. ++ *! 17-Apr-2002 jeh Created. ++ */ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/dbdcddef.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/rmm.h> ++#include <dspbridge/nldrdefs.h> ++ ++#ifndef NLDR_ ++#define NLDR_ ++ ++ extern DSP_STATUS NLDR_Allocate(struct NLDR_OBJECT *hNldr, ++ void *pPrivRef, ++ IN CONST struct DCD_NODEPROPS ++ *pNodeProps, ++ OUT struct NLDR_NODEOBJECT **phNldrNode, ++ IN bool *pfPhaseSplit); ++ ++ extern DSP_STATUS NLDR_Create(OUT struct NLDR_OBJECT **phNldr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct NLDR_ATTRS *pAttrs); ++ ++ extern void NLDR_Delete(struct NLDR_OBJECT *hNldr); ++ extern void NLDR_Exit(void); ++ extern void NLDR_Free(struct NLDR_NODEOBJECT *hNldrNode); ++ ++ extern DSP_STATUS NLDR_GetFxnAddr(struct NLDR_NODEOBJECT *hNldrNode, ++ char *pstrFxn, u32 *pulAddr); ++ ++ extern DSP_STATUS NLDR_GetRmmManager(struct NLDR_OBJECT *hNldrObject, ++ OUT struct RMM_TargetObj ++ **phRmmMgr); ++ ++ extern bool NLDR_Init(void); ++ extern DSP_STATUS NLDR_Load(struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++ extern DSP_STATUS NLDR_Unload(struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++ ++#endif /* NLDR_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/nldrdefs.h b/arch/arm/plat-omap/include/dspbridge/nldrdefs.h +new file mode 100644 +index 0000000..84b36a3 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/nldrdefs.h +@@ -0,0 +1,307 @@ ++/* ++ * nldrdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== nldrdefs.h ======== ++ * Description: ++ * Global Dynamic + static/overlay Node loader (NLDR) constants and types. ++ * ++ *! Revision History ++ *! ================ ++ *! 07-Apr-2003 map Consolidated dldrdefs.h into nldrdefs.h ++ *! 05-Aug-2002 jeh Created. ++ */ ++ ++#ifndef NLDRDEFS_ ++#define NLDRDEFS_ ++ ++#include <dspbridge/dbdcddef.h> ++#include <dspbridge/devdefs.h> ++ ++#define NLDR_MAXPATHLENGTH 255 ++/* NLDR Objects: */ ++ struct NLDR_OBJECT; ++ struct NLDR_NODEOBJECT; ++ ++/* ++ * ======== NLDR_LOADTYPE ======== ++ * Load types for a node. Must match values in node.h55. ++ */ ++ enum NLDR_LOADTYPE { ++ NLDR_STATICLOAD, /* Linked in base image, not overlay */ ++ NLDR_DYNAMICLOAD, /* Dynamically loaded node */ ++ NLDR_OVLYLOAD /* Linked in base image, overlay node */ ++ } ; ++ ++/* ++ * ======== NLDR_OVLYFXN ======== ++ * Causes code or data to be copied from load address to run address. This ++ * is the "COD_WRITEFXN" that gets passed to the DBLL_Library and is used as ++ * the ZL write function. ++ * ++ * Parameters: ++ * pPrivRef: Handle to identify the node. ++ * ulDspRunAddr: Run address of code or data. ++ * ulDspLoadAddr: Load address of code or data. ++ * ulNumBytes: Number of (GPP) bytes to copy. ++ * nMemSpace: RMS_CODE or RMS_DATA. ++ * Returns: ++ * ulNumBytes: Success. ++ * 0: Failure. ++ * Requires: ++ * Ensures: ++ */ ++ typedef u32(*NLDR_OVLYFXN) (void *pPrivRef, u32 ulDspRunAddr, ++ u32 ulDspLoadAddr, ++ u32 ulNumBytes, u32 nMemSpace); ++ ++/* ++ * ======== NLDR_WRITEFXN ======== ++ * Write memory function. Used for dynamic load writes. ++ * Parameters: ++ * pPrivRef: Handle to identify the node. ++ * ulDspAddr: Address of code or data. ++ * pBuf: Code or data to be written ++ * ulNumBytes: Number of (GPP) bytes to write. ++ * nMemSpace: DBLL_DATA or DBLL_CODE. ++ * Returns: ++ * ulNumBytes: Success. ++ * 0: Failure. ++ * Requires: ++ * Ensures: ++ */ ++ typedef u32(*NLDR_WRITEFXN) (void *pPrivRef, ++ u32 ulDspAddr, void *pBuf, ++ u32 ulNumBytes, u32 nMemSpace); ++ ++/* ++ * ======== NLDR_ATTRS ======== ++ * Attributes passed to NLDR_Create function. ++ */ ++ struct NLDR_ATTRS { ++ NLDR_OVLYFXN pfnOvly; ++ NLDR_WRITEFXN pfnWrite; ++ u16 usDSPWordSize; ++ u16 usDSPMauSize; ++ } ; ++ ++/* ++ * ======== NLDR_PHASE ======== ++ * Indicates node create, delete, or execute phase function. ++ */ ++ enum NLDR_PHASE { ++ NLDR_CREATE, ++ NLDR_DELETE, ++ NLDR_EXECUTE, ++ NLDR_NOPHASE ++ } ; ++ ++/* ++ * Typedefs of loader functions imported from a DLL, or defined in a ++ * function table. ++ */ ++ ++/* ++ * ======== NLDR_Allocate ======== ++ * Allocate resources to manage the loading of a node on the DSP. ++ * ++ * Parameters: ++ * hNldr: Handle of loader that will load the node. ++ * pPrivRef: Handle to identify the node. ++ * pNodeProps: Pointer to a DCD_NODEPROPS for the node. ++ * phNldrNode: Location to store node handle on output. This handle ++ * will be passed to NLDR_Load/NLDR_Unload. ++ * pfPhaseSplit: pointer to boolean variable referenced in node.c ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldr. ++ * pNodeProps != NULL. ++ * phNldrNode != NULL. ++ * Ensures: ++ * DSP_SOK: IsValidNode(*phNldrNode). ++ * error: *phNldrNode == NULL. ++ */ ++ typedef DSP_STATUS(*NLDR_ALLOCATEFXN) (struct NLDR_OBJECT *hNldr, ++ void *pPrivRef, ++ IN CONST struct DCD_NODEPROPS ++ *pNodeProps, ++ OUT struct NLDR_NODEOBJECT ++ **phNldrNode, ++ OUT bool *pfPhaseSplit); ++ ++/* ++ * ======== NLDR_Create ======== ++ * Create a loader object. This object handles the loading and unloading of ++ * create, delete, and execute phase functions of nodes on the DSP target. ++ * ++ * Parameters: ++ * phNldr: Location to store loader handle on output. ++ * hDevObject: Device for this processor. ++ * pAttrs: Loader attributes. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * Requires: ++ * NLDR_Init(void) called. ++ * phNldr != NULL. ++ * hDevObject != NULL. ++ * pAttrs != NULL. ++ * Ensures: ++ * DSP_SOK: Valid *phNldr. ++ * error: *phNldr == NULL. ++ */ ++ typedef DSP_STATUS(*NLDR_CREATEFXN) (OUT struct NLDR_OBJECT **phNldr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct NLDR_ATTRS ++ *pAttrs); ++ ++/* ++ * ======== NLDR_Delete ======== ++ * Delete the NLDR loader. ++ * ++ * Parameters: ++ * hNldr: Node manager object. ++ * Returns: ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldr. ++ * Ensures: ++ * hNldr invalid ++ */ ++ typedef void(*NLDR_DELETEFXN) (struct NLDR_OBJECT *hNldr); ++ ++/* ++ * ======== NLDR_Exit ======== ++ * Discontinue usage of NLDR module. ++ * ++ * Parameters: ++ * Returns: ++ * Requires: ++ * NLDR_Init(void) successfully called before. ++ * Ensures: ++ * Any resources acquired in NLDR_Init(void) will be freed when last NLDR ++ * client calls NLDR_Exit(void). ++ */ ++ typedef void(*NLDR_EXITFXN) (void); ++ ++/* ++ * ======== NLDR_Free ======== ++ * Free resources allocated in NLDR_Allocate. ++ * ++ * Parameters: ++ * hNldrNode: Handle returned from NLDR_Allocate(). ++ * Returns: ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldrNode. ++ * Ensures: ++ */ ++ typedef void(*NLDR_FREEFXN) (struct NLDR_NODEOBJECT *hNldrNode); ++ ++/* ++ * ======== NLDR_GetFxnAddr ======== ++ * Get address of create, delete, or execute phase function of a node on ++ * the DSP. ++ * ++ * Parameters: ++ * hNldrNode: Handle returned from NLDR_Allocate(). ++ * pstrFxn: Name of function. ++ * pulAddr: Location to store function address. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ESYMBOL: Address of function not found. ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldrNode. ++ * pulAddr != NULL; ++ * pstrFxn != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*NLDR_GETFXNADDRFXN) (struct NLDR_NODEOBJECT ++ *hNldrNode, ++ char *pstrFxn, u32 *pulAddr); ++ ++/* ++ * ======== NLDR_Init ======== ++ * Initialize the NLDR module. ++ * ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Ensures: ++ */ ++ typedef bool(*NLDR_INITFXN) (void); ++ ++/* ++ * ======== NLDR_Load ======== ++ * Load create, delete, or execute phase function of a node on the DSP. ++ * ++ * Parameters: ++ * hNldrNode: Handle returned from NLDR_Allocate(). ++ * phase: Type of function to load (create, delete, or execute). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * DSP_EOVERLAYMEMORY: Can't overlay phase because overlay memory ++ * is already in use. ++ * DSP_EDYNLOAD: Failure in dynamic loader library. ++ * DSP_EFWRITE: Failed to write phase's code or date to target. ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldrNode. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*NLDR_LOADFXN) (struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++ ++/* ++ * ======== NLDR_Unload ======== ++ * Unload create, delete, or execute phase function of a node on the DSP. ++ * ++ * Parameters: ++ * hNldrNode: Handle returned from NLDR_Allocate(). ++ * phase: Node function to unload (create, delete, or execute). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * Requires: ++ * NLDR_Init(void) called. ++ * Valid hNldrNode. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*NLDR_UNLOADFXN) (struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++ ++/* ++ * ======== NLDR_FXNS ======== ++ */ ++ struct NLDR_FXNS { ++ NLDR_ALLOCATEFXN pfnAllocate; ++ NLDR_CREATEFXN pfnCreate; ++ NLDR_DELETEFXN pfnDelete; ++ NLDR_EXITFXN pfnExit; ++ NLDR_FREEFXN pfnFree; ++ NLDR_GETFXNADDRFXN pfnGetFxnAddr; ++ NLDR_INITFXN pfnInit; ++ NLDR_LOADFXN pfnLoad; ++ NLDR_UNLOADFXN pfnUnload; ++ } ; ++ ++#endif /* NLDRDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/node.h b/arch/arm/plat-omap/include/dspbridge/node.h +new file mode 100644 +index 0000000..d253962 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/node.h +@@ -0,0 +1,619 @@ ++/* ++ * node.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== node.h ======== ++ * Description: ++ * DSP/BIOS Bridge Node Manager. ++ * ++ * Public Functions: ++ * NODE_Allocate ++ * NODE_AllocMsgBuf ++ * NODE_ChangePriority ++ * NODE_Connect ++ * NODE_Create ++ * NODE_CreateMgr ++ * NODE_Delete ++ * NODE_DeleteMgr ++ * NODE_EnumNodes ++ * NODE_Exit ++ * NODE_FreeMsgBuf ++ * NODE_GetAttr ++ * NODE_GetMessage ++ * NODE_GetProcessor ++ * NODE_Init ++ * NODE_OnExit ++ * NODE_Pause ++ * NODE_PutMessage ++ * NODE_RegisterNotify ++ * NODE_Run ++ * NODE_Terminate ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================= ++ *! 23-Apr-2001 jeh Updated with code review changes. ++ *! 16-Jan-2001 jeh Added DSP_ESYMBOL, DSP_EUUID to return codes. ++ *! 17-Nov-2000 jeh Added NODE_OnExit(). ++ *! 27-Oct-2000 jeh Added timeouts to NODE_GetMessage, NODE_PutMessage. ++ *! 12-Oct-2000 jeh Changed NODE_EnumNodeInfo to NODE_EnumNodes. Removed ++ *! NODE_RegisterAllNodes(). ++ *! 07-Sep-2000 jeh Changed type HANDLE in NODE_RegisterNotify to ++ *! DSP_HNOTIFICATION. Added DSP_STRMATTR param to ++ *! NODE_Connect(). Removed NODE_GetMessageStream(). ++ *! 17-Jul-2000 jeh Updated function header descriptions. ++ *! 19-Jun-2000 jeh Created. ++ */ ++ ++#ifndef NODE_ ++#define NODE_ ++ ++#include <dspbridge/procpriv.h> ++ ++#include <dspbridge/nodedefs.h> ++#include <dspbridge/dispdefs.h> ++#include <dspbridge/nldrdefs.h> ++ ++/* ++ * ======== NODE_Allocate ======== ++ * Purpose: ++ * Allocate GPP resources to manage a node on the DSP. ++ * Parameters: ++ * hProcessor: Handle of processor that is allocating the node. ++ * pNodeId: Pointer to a DSP_UUID for the node. ++ * pArgs: Optional arguments to be passed to the node. ++ * pAttrIn: Optional pointer to node attributes (priority, ++ * timeout...) ++ * phNode: Location to store node handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * DSP_EUUID: Node UUID has not been registered. ++ * DSP_ESYMBOL: iAlg functions not found for a DAIS node. ++ * DSP_ERANGE: pAttrIn != NULL and pAttrIn->iPriority out of ++ * range. ++ * DSP_EFAIL: A failure occured, unable to allocate node. ++ * DSP_EWRONGSTATE: Proccessor is not in the running state. ++ * Requires: ++ * NODE_Init(void) called. ++ * hProcessor != NULL. ++ * pNodeId != NULL. ++ * phNode != NULL. ++ * Ensures: ++ * DSP_SOK: IsValidNode(*phNode). ++ * error: *phNode == NULL. ++ */ ++ extern DSP_STATUS NODE_Allocate(struct PROC_OBJECT *hProcessor, ++ IN CONST struct DSP_UUID *pNodeId, ++ OPTIONAL IN CONST struct DSP_CBDATA ++ *pArgs, ++ OPTIONAL IN CONST struct DSP_NODEATTRIN ++ *pAttrIn, ++ OUT struct NODE_OBJECT **phNode); ++ ++/* ++ * ======== NODE_AllocMsgBuf ======== ++ * Purpose: ++ * Allocate and Prepare a buffer whose descriptor will be passed to a ++ * Node within a (DSP_MSG)message ++ * Parameters: ++ * hNode: The node handle. ++ * uSize: The size of the buffer to be allocated. ++ * pAttr: Pointer to a DSP_BUFFERATTR structure. ++ * pBuffer: Location to store the address of the allocated ++ * buffer on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid node handle. ++ * DSP_EMEMORY: Insufficent memory. ++ * DSP_EFAIL: General Failure. ++ * DSP_ESIZE: Invalid Size. ++ * Requires: ++ * NODE_Init(void) called. ++ * pBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_AllocMsgBuf(struct NODE_OBJECT *hNode, ++ u32 uSize, ++ OPTIONAL struct DSP_BUFFERATTR ++ *pAttr, ++ OUT u8 **pBuffer); ++ ++/* ++ * ======== NODE_ChangePriority ======== ++ * Purpose: ++ * Change the priority of an allocated node. ++ * Parameters: ++ * hNode: Node handle returned from NODE_Allocate. ++ * nPriority: New priority level to set node's priority to. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ERANGE: nPriority is out of range. ++ * DSP_ENODETYPE: The specified node is not a task node. ++ * DSP_EWRONGSTATE: Node is not in the NODE_ALLOCATED, NODE_PAUSED, ++ * or NODE_RUNNING state. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_ERESTART: A critical error has occurred and the DSP is ++ * being restarted. ++ * DSP_EFAIL: Unable to change node's runtime priority level. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ * DSP_SOK && (Node's current priority == nPriority) ++ */ ++ extern DSP_STATUS NODE_ChangePriority(struct NODE_OBJECT *hNode, ++ s32 nPriority); ++ ++/* ++ * ======== NODE_CloseOrphans ======== ++ * Purpose: ++ * Delete all nodes whose owning processor is being destroyed. ++ * Parameters: ++ * hNodeMgr: Node manager object. ++ * hProc: Handle to processor object being destroyed. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Unable to delete all nodes belonging to hProc. ++ * Requires: ++ * Valid hNodeMgr. ++ * hProc != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_CloseOrphans(struct NODE_MGR *hNodeMgr, ++ struct PROC_OBJECT *hProc); ++ ++/* ++ * ======== NODE_Connect ======== ++ * Purpose: ++ * Connect two nodes on the DSP, or a node on the DSP to the GPP. In the ++ * case that the connnection is being made between a node on the DSP and ++ * the GPP, one of the node handles (either hNode1 or hNode2) must be ++ * the constant NODE_HGPPNODE. ++ * Parameters: ++ * hNode1: Handle of first node to connect to second node. If ++ * this is a connection from the GPP to hNode2, hNode1 ++ * must be the constant NODE_HGPPNODE. Otherwise, hNode1 ++ * must be a node handle returned from a successful call ++ * to Node_Allocate(). ++ * hNode2: Handle of second node. Must be either NODE_HGPPNODE ++ * if this is a connection from DSP node to GPP, or a ++ * node handle returned from a successful call to ++ * NODE_Allocate(). ++ * uStream1: Output stream index on first node, to be connected ++ * to second node's input stream. Value must range from ++ * 0 <= uStream1 < number of output streams. ++ * uStream2: Input stream index on second node. Value must range ++ * from 0 <= uStream2 < number of input streams. ++ * pAttrs: Stream attributes (NULL ==> use defaults). ++ * pConnParam: A pointer to a DSP_CBDATA structure that defines ++ * connection parameter for device nodes to pass to DSP ++ * side. ++ * If the value of this parameter is NULL, then this API ++ * behaves like DSPNode_Connect. This parameter will have ++ * length of the string and the null terminated string in ++ * DSP_CBDATA struct. This can be extended in future tp ++ * pass binary data. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode1 or hNode2. ++ * DSP_EMEMORY: Insufficient host memory. ++ * DSP_EVALUE: A stream index parameter is invalid. ++ * DSP_EALREADYCONNECTED: A connection already exists for one of the ++ * indices uStream1 or uStream2. ++ * DSP_EWRONGSTATE: Either hNode1 or hNode2 is not in the ++ * NODE_ALLOCATED state. ++ * DSP_ENOMORECONNECTIONS: No more connections available. ++ * DSP_EFAIL: Attempt to make an illegal connection (eg, ++ * Device node to device node, or device node to ++ * GPP), the two nodes are on different DSPs. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_Connect(struct NODE_OBJECT *hNode1, ++ u32 uStream1, ++ struct NODE_OBJECT *hNode2, ++ u32 uStream2, ++ OPTIONAL IN struct DSP_STRMATTR *pAttrs, ++ OPTIONAL IN struct DSP_CBDATA ++ *pConnParam); ++ ++/* ++ * ======== NODE_Create ======== ++ * Purpose: ++ * Create a node on the DSP by remotely calling the node's create ++ * function. If necessary, load code that contains the node's create ++ * function. ++ * Parameters: ++ * hNode: Node handle returned from NODE_Allocate(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ESYMBOL: Create function not found in the COFF file. ++ * DSP_EWRONGSTATE: Node is not in the NODE_ALLOCATED state. ++ * DSP_EMEMORY: Memory allocation failure on the DSP. ++ * DSP_ETASK: Unable to create node's task or process on the DSP. ++ * DSP_ESTREAM: Stream creation failure on the DSP. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_EUSER1-16: A user-defined failure occurred on the DSP. ++ * DSP_EFAIL: A failure occurred, unable to create node. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_Create(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== NODE_CreateMgr ======== ++ * Purpose: ++ * Create a NODE Manager object. This object handles the creation, ++ * deletion, and execution of nodes on the DSP target. The NODE Manager ++ * also maintains a pipe map of used and available node connections. ++ * Each DEV object should have exactly one NODE Manager object. ++ * ++ * Parameters: ++ * phNodeMgr: Location to store node manager handle on output. ++ * hDevObject: Device for this processor. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * NODE_Init(void) called. ++ * phNodeMgr != NULL. ++ * hDevObject != NULL. ++ * Ensures: ++ * DSP_SOK: Valide *phNodeMgr. ++ * error: *phNodeMgr == NULL. ++ */ ++ extern DSP_STATUS NODE_CreateMgr(OUT struct NODE_MGR **phNodeMgr, ++ struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== NODE_Delete ======== ++ * Purpose: ++ * Delete resources allocated in NODE_Allocate(). If the node was ++ * created, delete the node on the DSP by remotely calling the node's ++ * delete function. Loads the node's delete function if necessary. ++ * GPP side resources are freed after node's delete function returns. ++ * Parameters: ++ * hNode: Node handle returned from NODE_Allocate(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_EDELETE: A deletion failure occurred. ++ * DSP_EUSER1-16: Node specific failure occurred on the DSP. ++ * DSP_EFAIL: A failure occurred in deleting the node. ++ * DSP_ESYMBOL: Delete function not found in the COFF file. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ * DSP_SOK: hNode is invalid. ++ */ ++ extern DSP_STATUS NODE_Delete(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== NODE_DeleteMgr ======== ++ * Purpose: ++ * Delete the NODE Manager. ++ * Parameters: ++ * hNodeMgr: Node manager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * Requires: ++ * NODE_Init(void) called. ++ * Valid hNodeMgr. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_DeleteMgr(struct NODE_MGR *hNodeMgr); ++ ++/* ++ * ======== NODE_EnumNodes ======== ++ * Purpose: ++ * Enumerate the nodes currently allocated for the DSP. ++ * Parameters: ++ * hNodeMgr: Node manager returned from NODE_CreateMgr(). ++ * aNodeTab: Array to copy node handles into. ++ * uNodeTabSize: Number of handles that can be written to aNodeTab. ++ * puNumNodes: Location where number of node handles written to ++ * aNodeTab will be written. ++ * puAllocated: Location to write total number of allocated nodes. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ESIZE: aNodeTab is too small to hold all node handles. ++ * Requires: ++ * Valid hNodeMgr. ++ * aNodeTab != NULL || uNodeTabSize == 0. ++ * puNumNodes != NULL. ++ * puAllocated != NULL. ++ * Ensures: ++ * - (DSP_ESIZE && *puNumNodes == 0) ++ * - || (DSP_SOK && *puNumNodes <= uNodeTabSize) && ++ * (*puAllocated == *puNumNodes) ++ */ ++ extern DSP_STATUS NODE_EnumNodes(struct NODE_MGR *hNodeMgr, ++ IN DSP_HNODE *aNodeTab, ++ u32 uNodeTabSize, ++ OUT u32 *puNumNodes, ++ OUT u32 *puAllocated); ++ ++/* ++ * ======== NODE_Exit ======== ++ * Purpose: ++ * Discontinue usage of NODE module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * NODE_Init(void) successfully called before. ++ * Ensures: ++ * Any resources acquired in NODE_Init(void) will be freed when last NODE ++ * client calls NODE_Exit(void). ++ */ ++ extern void NODE_Exit(void); ++ ++/* ++ * ======== NODE_FreeMsgBuf ======== ++ * Purpose: ++ * Free a message buffer previously allocated with NODE_AllocMsgBuf. ++ * Parameters: ++ * hNode: The node handle. ++ * pBuffer: (Address) Buffer allocated by NODE_AllocMsgBuf. ++ * pAttr: Same buffer attributes passed to NODE_AllocMsgBuf. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid node handle. ++ * DSP_EFAIL: Failure to free the buffer. ++ * Requires: ++ * NODE_Init(void) called. ++ * pBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_FreeMsgBuf(struct NODE_OBJECT *hNode, ++ IN u8 *pBuffer, ++ OPTIONAL struct DSP_BUFFERATTR ++ *pAttr); ++ ++/* ++ * ======== NODE_GetAttr ======== ++ * Purpose: ++ * Copy the current attributes of the specified node into a DSP_NODEATTR ++ * structure. ++ * Parameters: ++ * hNode: Node object allocated from NODE_Allocate(). ++ * pAttr: Pointer to DSP_NODEATTR structure to copy node's ++ * attributes. ++ * uAttrSize: Size of pAttr. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * Requires: ++ * NODE_Init(void) called. ++ * pAttr != NULL. ++ * Ensures: ++ * DSP_SOK: *pAttrs contains the node's current attributes. ++ */ ++ extern DSP_STATUS NODE_GetAttr(struct NODE_OBJECT *hNode, ++ OUT struct DSP_NODEATTR *pAttr, ++ u32 uAttrSize); ++ ++/* ++ * ======== NODE_GetMessage ======== ++ * Purpose: ++ * Retrieve a message from a node on the DSP. The node must be either a ++ * message node, task node, or XDAIS socket node. ++ * If a message is not available, this function will block until a ++ * message is available, or the node's timeout value is reached. ++ * Parameters: ++ * hNode: Node handle returned from NODE_Allocate(). ++ * pMessage: Pointer to DSP_MSG structure to copy the ++ * message into. ++ * uTimeout: Timeout in milliseconds to wait for message. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ENODETYPE: Cannot retrieve messages from this type of node. ++ * DSP_ETIMEOUT: Timeout occurred and no message is available. ++ * DSP_EFAIL: Error occurred while trying to retrieve a message. ++ * Requires: ++ * NODE_Init(void) called. ++ * pMessage != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_GetMessage(struct NODE_OBJECT *hNode, ++ OUT struct DSP_MSG *pMessage, ++ u32 uTimeout); ++ ++/* ++ * ======== NODE_GetNldrObj ======== ++ * Purpose: ++ * Retrieve the Nldr manager ++ * Parameters: ++ * hNodeMgr: Node Manager ++ * phNldrObj: Pointer to a Nldr manager handle ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_GetNldrObj(struct NODE_MGR *hNodeMgr, ++ OUT struct NLDR_OBJECT **phNldrObj); ++ ++/* ++ * ======== NODE_Init ======== ++ * Purpose: ++ * Initialize the NODE module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Ensures: ++ */ ++ extern bool NODE_Init(void); ++ ++/* ++ * ======== NODE_OnExit ======== ++ * Purpose: ++ * Gets called when RMS_EXIT is received for a node. PROC needs to pass ++ * this function as a parameter to MSG_Create(). This function then gets ++ * called by the mini-driver when an exit message for a node is received. ++ * Parameters: ++ * hNode: Handle of the node that the exit message is for. ++ * nStatus: Return status of the node's execute phase. ++ * Returns: ++ * Ensures: ++ */ ++ void NODE_OnExit(struct NODE_OBJECT *hNode, s32 nStatus); ++ ++/* ++ * ======== NODE_Pause ======== ++ * Purpose: ++ * Suspend execution of a node currently running on the DSP. ++ * Parameters: ++ * hNode: Node object representing a node currently ++ * running on the DSP. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ENODETYPE: Node is not a task or socket node. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_EWRONGSTSATE: Node is not in NODE_RUNNING state. ++ * DSP_EFAIL: Failed to pause node. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_Pause(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== NODE_PutMessage ======== ++ * Purpose: ++ * Send a message to a message node, task node, or XDAIS socket node. ++ * This function will block until the message stream can accommodate ++ * the message, or a timeout occurs. The message will be copied, so Msg ++ * can be re-used immediately after return. ++ * Parameters: ++ * hNode: Node handle returned by NODE_Allocate(). ++ * pMsg: Location of message to be sent to the node. ++ * uTimeout: Timeout in msecs to wait. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ENODETYPE: Messages can't be sent to this type of node. ++ * DSP_ETIMEOUT: Timeout occurred before message could be set. ++ * DSP_EWRONGSTATE: Node is in invalid state for sending messages. ++ * DSP_EFAIL: Unable to send message. ++ * Requires: ++ * NODE_Init(void) called. ++ * pMsg != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_PutMessage(struct NODE_OBJECT *hNode, ++ IN CONST struct DSP_MSG *pMsg, ++ u32 uTimeout); ++ ++/* ++ * ======== NODE_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified on specific events for this node. ++ * Parameters: ++ * hNode: Node handle returned by NODE_Allocate(). ++ * uEventMask: Mask of types of events to be notified about. ++ * uNotifyType: Type of notification to be sent. ++ * hNotification: Handle to be used for notification. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * DSP_EVALUE: uEventMask is invalid. ++ * DSP_ENOTIMPL: Notification type specified by uNotifyType is not ++ * supported. ++ * Requires: ++ * NODE_Init(void) called. ++ * hNotification != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_RegisterNotify(struct NODE_OBJECT *hNode, ++ u32 uEventMask, u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++/* ++ * ======== NODE_Run ======== ++ * Purpose: ++ * Start execution of a node's execute phase, or resume execution of ++ * a node that has been suspended (via NODE_Pause()) on the DSP. Load ++ * the node's execute function if necessary. ++ * Parameters: ++ * hNode: Node object representing a node currently ++ * running on the DSP. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ENODETYPE: hNode doesn't represent a message, task or dais ++ * socket node. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_EWRONGSTSATE: Node is not in NODE_PAUSED or NODE_CREATED state. ++ * DSP_EFAIL: Unable to start or resume execution. ++ * DSP_ESYMBOL: Execute function not found in the COFF file. ++ * Requires: ++ * NODE_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_Run(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== NODE_Terminate ======== ++ * Purpose: ++ * Signal a node running on the DSP that it should exit its execute ++ * phase function. ++ * Parameters: ++ * hNode: Node object representing a node currently ++ * running on the DSP. ++ * pStatus: Location to store execute-phase function return ++ * value (DSP_EUSER1-16). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ETIMEOUT: A timeout occurred before the DSP responded. ++ * DSP_ENODETYPE: Type of node specified cannot be terminated. ++ * DSP_EWRONGSTATE: Operation not valid for the current node state. ++ * DSP_EFAIL: Unable to terminate the node. ++ * Requires: ++ * NODE_Init(void) called. ++ * pStatus != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_Terminate(struct NODE_OBJECT *hNode, ++ OUT DSP_STATUS *pStatus); ++ ++ ++ ++/* ++ * ======== NODE_GetUUIDProps ======== ++ * Purpose: ++ * Fetch Node properties given the UUID ++ * Parameters: ++ * ++ */ ++ extern DSP_STATUS NODE_GetUUIDProps(DSP_HPROCESSOR hProcessor, ++ IN CONST struct DSP_UUID *pNodeId, ++ OUT struct DSP_NDBPROPS ++ *pNodeProps); ++ ++#endif /* NODE_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/nodedefs.h b/arch/arm/plat-omap/include/dspbridge/nodedefs.h +new file mode 100644 +index 0000000..cdc0c4b +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/nodedefs.h +@@ -0,0 +1,40 @@ ++/* ++ * nodedefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== nodedefs.h ======== ++ * Description: ++ * Global NODE constants and types, shared by PROCESSOR, NODE, and DISP. ++ * ++ *! Revision History ++ *! ================ ++ *! 23-Apr-2001 jeh Removed NODE_MGRATTRS. ++ *! 21-Sep-2000 jeh Removed NODE_TYPE enum. ++ *! 17-Jul-2000 jeh Changed order of node types to match rms_sh.h. ++ *! 20-Jun-2000 jeh Created. ++ */ ++ ++#ifndef NODEDEFS_ ++#define NODEDEFS_ ++ ++#define NODE_SUSPENDEDPRI -1 ++ ++/* NODE Objects: */ ++ struct NODE_MGR; ++ struct NODE_OBJECT; ++ ++#endif /* NODEDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/nodepriv.h b/arch/arm/plat-omap/include/dspbridge/nodepriv.h +new file mode 100644 +index 0000000..d28b29b +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/nodepriv.h +@@ -0,0 +1,202 @@ ++/* ++ * nodepriv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== nodepriv.h ======== ++ * Description: ++ * Private node header shared by NODE and DISP. ++ * ++ * Public Functions: ++ * NODE_GetChannelId ++ * NODE_GetStrmMgr ++ * NODE_GetTimeout ++ * NODE_GetType ++ * NODE_GetLoadType ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Nov-2002 map Added NODE_GetLoadType ++ *! 13-Feb-2002 jeh Added uSysStackSize to NODE_TASKARGS. ++ *! 23-Apr-2001 jeh Removed unused typedefs, defines. ++ *! 10-Oct-2000 jeh Added alignment to NODE_STRMDEF. ++ *! 20-Jun-2000 jeh Created. ++ */ ++ ++#ifndef NODEPRIV_ ++#define NODEPRIV_ ++ ++#include <dspbridge/strmdefs.h> ++#include <dspbridge/nodedefs.h> ++#include <dspbridge/nldrdefs.h> ++ ++/* DSP address of node environment structure */ ++ typedef u32 NODE_ENV; ++ ++/* ++ * Node create structures ++ */ ++ ++/* Message node */ ++ struct NODE_MSGARGS { ++ u32 uMaxMessages; /* Max # of simultaneous messages for node */ ++ u32 uSegid; /* Segment for allocating message buffers */ ++ u32 uNotifyType; /* Notify type (SEM_post, SWI_post, etc.) */ ++ u32 uArgLength; /* Length in 32-bit words of arg data block */ ++ u8 *pData; /* Argument data for node */ ++ } ; ++ ++ struct NODE_STRMDEF { ++ u32 uBufsize; /* Size of buffers for SIO stream */ ++ u32 uNumBufs; /* max # of buffers in SIO stream at once */ ++ u32 uSegid; /* Memory segment id to allocate buffers */ ++ u32 uTimeout; /* Timeout for blocking SIO calls */ ++ u32 uAlignment; /* Buffer alignment */ ++ char *szDevice; /* Device name for stream */ ++ } ; ++ ++/* Task node */ ++ struct NODE_TASKARGS { ++ struct NODE_MSGARGS msgArgs; ++ s32 nPriority; ++ u32 uStackSize; ++ u32 uSysStackSize; ++ u32 uStackSeg; ++ u32 uDSPHeapResAddr; /* DSP virtual heap address */ ++ u32 uDSPHeapAddr; /* DSP virtual heap address */ ++ u32 uHeapSize; /* Heap size */ ++ u32 uGPPHeapAddr; /* GPP virtual heap address */ ++ u32 uProfileID; /* Profile ID */ ++ u32 uNumInputs; ++ u32 uNumOutputs; ++ u32 ulDaisArg; /* Address of iAlg object */ ++ struct NODE_STRMDEF *strmInDef; ++ struct NODE_STRMDEF *strmOutDef; ++ } ; ++ ++/* ++ * ======== NODE_CREATEARGS ======== ++ */ ++ struct NODE_CREATEARGS { ++ union { ++ struct NODE_MSGARGS msgArgs; ++ struct NODE_TASKARGS taskArgs; ++ } asa; ++ } ; ++ ++/* ++ * ======== NODE_GetChannelId ======== ++ * Purpose: ++ * Get the channel index reserved for a stream connection between the ++ * host and a node. This index is reserved when NODE_Connect() is called ++ * to connect the node with the host. This index should be passed to ++ * the CHNL_Open function when the stream is actually opened. ++ * Parameters: ++ * hNode: Node object allocated from NODE_Allocate(). ++ * uDir: Input (DSP_TONODE) or output (DSP_FROMNODE). ++ * uIndex: Stream index. ++ * pulId: Location to store channel index. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_ENODETYPE: Not a task or DAIS socket node. ++ * DSP_EVALUE: The node's stream corresponding to uIndex and uDir ++ * is not a stream to or from the host. ++ * Requires: ++ * NODE_Init(void) called. ++ * Valid uDir. ++ * pulId != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_GetChannelId(struct NODE_OBJECT *hNode, ++ u32 uDir, ++ u32 uIndex, OUT u32 *pulId); ++ ++/* ++ * ======== NODE_GetStrmMgr ======== ++ * Purpose: ++ * Get the STRM manager for a node. ++ * Parameters: ++ * hNode: Node allocated with NODE_Allocate(). ++ * phStrmMgr: Location to store STRM manager on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * Requires: ++ * phStrmMgr != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS NODE_GetStrmMgr(struct NODE_OBJECT *hNode, ++ struct STRM_MGR **phStrmMgr); ++ ++/* ++ * ======== NODE_GetTimeout ======== ++ * Purpose: ++ * Get the timeout value of a node. ++ * Parameters: ++ * hNode: Node allocated with NODE_Allocate(), or DSP_HGPPNODE. ++ * Returns: ++ * Node's timeout value. ++ * Requires: ++ * Valid hNode. ++ * Ensures: ++ */ ++ extern u32 NODE_GetTimeout(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== NODE_GetType ======== ++ * Purpose: ++ * Get the type (device, message, task, or XDAIS socket) of a node. ++ * Parameters: ++ * hNode: Node allocated with NODE_Allocate(), or DSP_HGPPNODE. ++ * Returns: ++ * Node type: NODE_DEVICE, NODE_TASK, NODE_XDAIS, or NODE_GPP. ++ * Requires: ++ * Valid hNode. ++ * Ensures: ++ */ ++ extern enum NODE_TYPE NODE_GetType(struct NODE_OBJECT *hNode); ++ ++/* ++ * ======== GetNodeInfo ======== ++ * Purpose: ++ * Get node information without holding semaphore. ++ * Parameters: ++ * hNode: Node allocated with NODE_Allocate(), or DSP_HGPPNODE. ++ * Returns: ++ * Node info: priority, device owner, no. of streams, execution state ++ * NDB properties. ++ * Requires: ++ * Valid hNode. ++ * Ensures: ++ */ ++ extern void GetNodeInfo(struct NODE_OBJECT *hNode, ++ struct DSP_NODEINFO *pNodeInfo); ++ ++/* ++ * ======== NODE_GetLoadType ======== ++ * Purpose: ++ * Get the load type (dynamic, overlay, static) of a node. ++ * Parameters: ++ * hNode: Node allocated with NODE_Allocate(), or DSP_HGPPNODE. ++ * Returns: ++ * Node type: NLDR_DYNAMICLOAD, NLDR_OVLYLOAD, NLDR_STATICLOAD ++ * Requires: ++ * Valid hNode. ++ * Ensures: ++ */ ++ extern enum NLDR_LOADTYPE NODE_GetLoadType(struct NODE_OBJECT *hNode); ++ ++#endif /* NODEPRIV_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/ntfy.h b/arch/arm/plat-omap/include/dspbridge/ntfy.h +new file mode 100644 +index 0000000..5a0992a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/ntfy.h +@@ -0,0 +1,146 @@ ++/* ++ * ntfy.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== ntfy.h ======== ++ * Purpose: ++ * Manage lists of notification events. ++ * ++ * Public Functions: ++ * NTFY_Create ++ * NTFY_Delete ++ * NTFY_Exit ++ * NTFY_Init ++ * NTFY_Notify ++ * NTFY_Register ++ * ++ *! Revision History: ++ *! ================= ++ *! 05-Nov-2001 kc: Updated NTFY_Register. ++ *! 07-Sep-2000 jeh Created. ++ */ ++ ++#ifndef NTFY_ ++#define NTFY_ ++ ++ struct NTFY_OBJECT; ++ ++/* ++ * ======== NTFY_Create ======== ++ * Purpose: ++ * Create an empty list of notifications. ++ * Parameters: ++ * phNtfy: Location to store handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * Requires: ++ * NTFY_Init(void) called. ++ * phNtfy != NULL. ++ * Ensures: ++ * DSP_SUCCEEDED(status) <==> IsValid(*phNtfy). ++ */ ++ extern DSP_STATUS NTFY_Create(OUT struct NTFY_OBJECT **phNtfy); ++ ++/* ++ * ======== NTFY_Delete ======== ++ * Purpose: ++ * Free resources allocated in NTFY_Create. ++ * Parameters: ++ * hNtfy: Handle returned from NTFY_Create(). ++ * Returns: ++ * Requires: ++ * NTFY_Init(void) called. ++ * IsValid(hNtfy). ++ * Ensures: ++ */ ++ extern void NTFY_Delete(IN struct NTFY_OBJECT *hNtfy); ++ ++/* ++ * ======== NTFY_Exit ======== ++ * Purpose: ++ * Discontinue usage of NTFY module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * NTFY_Init(void) successfully called before. ++ * Ensures: ++ */ ++ extern void NTFY_Exit(void); ++ ++/* ++ * ======== NTFY_Init ======== ++ * Purpose: ++ * Initialize the NTFY module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Ensures: ++ */ ++ extern bool NTFY_Init(void); ++ ++/* ++ * ======== NTFY_Notify ======== ++ * Purpose: ++ * Execute notify function (signal event or post message) for every ++ * element in the notification list that is to be notified about the ++ * event specified in uEventMask. ++ * Parameters: ++ * hNtfy: Handle returned from NTFY_Create(). ++ * uEventMask: The type of event that has occurred. ++ * Returns: ++ * Requires: ++ * NTFY_Init(void) called. ++ * IsValid(hNtfy). ++ * Ensures: ++ */ ++ extern void NTFY_Notify(IN struct NTFY_OBJECT *hNtfy, ++ IN u32 uEventMask); ++ ++/* ++ * ======== NTFY_Register ======== ++ * Purpose: ++ * Add a notification element to the list. If the notification is already ++ * registered, and uEventMask != 0, the notification will get posted for ++ * events specified in the new event mask. If the notification is already ++ * registered and uEventMask == 0, the notification will be unregistered. ++ * Parameters: ++ * hNtfy: Handle returned from NTFY_Create(). ++ * hNotification: Handle to a DSP_NOTIFICATION object. ++ * uEventMask: Events to be notified about. ++ * uNotifyType: Type of notification: DSP_SIGNALEVENT. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory. ++ * DSP_EVALUE: uEventMask is 0 and hNotification was not ++ * previously registered. ++ * DSP_EHANDLE: NULL hNotification, hNotification event name ++ * too long, or hNotification event name NULL. ++ * Requires: ++ * NTFY_Init(void) called. ++ * IsValid(hNtfy). ++ * hNotification != NULL. ++ * uNotifyType is DSP_SIGNALEVENT ++ * Ensures: ++ */ ++ extern DSP_STATUS NTFY_Register(IN struct NTFY_OBJECT *hNtfy, ++ IN struct DSP_NOTIFICATION ++ *hNotification, ++ IN u32 uEventMask, ++ IN u32 uNotifyType); ++ ++#endif /* NTFY_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/proc.h b/arch/arm/plat-omap/include/dspbridge/proc.h +new file mode 100644 +index 0000000..486652e +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/proc.h +@@ -0,0 +1,648 @@ ++/* ++ * proc.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== proc.h ======== ++ * Description: ++ * This is the Class driver RM module interface. ++ * ++ * Public Functions: ++ * PROC_Attach ++ * PROC_Create ++ * PROC_Ctrl (OEM-function) ++ * PROC_Destroy ++ * PROC_Detach ++ * PROC_EnumNodes ++ * PROC_Exit ++ * PROC_FlushMemory ++ * PROC_GetDevObject (OEM-function) ++ * PROC_GetResourceInfo ++ * PROC_GetState ++ * PROC_GetProcessorId ++ * PROC_GetTrace (OEM-function) ++ * PROC_Init ++ * PROC_Load (OEM-function) ++ * PROC_Map ++ * PROC_NotifyAllclients ++ * PROC_NotifyClients (OEM-function) ++ * PROC_RegisterNotify ++ * PROC_ReserveMemory ++ * PROC_Start (OEM-function) ++ * PROC_UnMap ++ * PROC_UnReserveMemory ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping APIs ++ *! 09-Feb-2003 vp: Added PROC_GetProcessorID function ++ *! 29-Nov-2000 rr: Incorporated code review changes. ++ *! 28-Sep-2000 rr: Updated to Version 0.9. ++ *! 10-Aug-2000 rr: PROC_NotifyClients, PROC_GetProcessorHandle Added ++ *! 27-Jul-2000 rr: Updated to ver 0.8 of DSPAPI(types). GetTrace added. ++ *! 27-Jun-2000 rr: Created from dspapi.h ++ */ ++ ++#ifndef PROC_ ++#define PROC_ ++ ++#include <dspbridge/cfgdefs.h> ++#include <dspbridge/devdefs.h> ++ ++/* ++ * ======== PROC_Attach ======== ++ * Purpose: ++ * Prepare for communication with a particular DSP processor, and return ++ * a handle to the processor object. The PROC Object gets created ++ * Parameters: ++ * uProcessor : The processor index (zero-based). ++ * hMgrObject : Handle to the Manager Object ++ * pAttrIn : Ptr to the DSP_PROCESSORATTRIN structure. ++ * A NULL value means use default values. ++ * phProcessor : Ptr to location to store processor handle. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EFAIL : General failure. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_SALREADYATTACHED: Success; Processor already attached. ++ * Requires: ++ * phProcessor != NULL. ++ * PROC Initialized. ++ * Ensures: ++ * DSP_EFAIL, and *phProcessor == NULL, OR ++ * Success and *phProcessor is a Valid Processor handle OR ++ * DSP_SALREADYATTACHED and *phProcessor is a Valid Processor. ++ * Details: ++ * When pAttrIn is NULL, the default timeout value is 10 seconds. ++ */ ++ extern DSP_STATUS PROC_Attach(u32 uProcessor, ++ OPTIONAL CONST struct DSP_PROCESSORATTRIN ++ *pAttrIn, ++ OUT DSP_HPROCESSOR *phProcessor); ++ ++/* ++ * ======== PROC_AutoStart ========= ++ * Purpose: ++ * A Particular device gets loaded with the default image ++ * if the AutoStart flag is set. ++ * Parameters: ++ * hDevObject : Handle to the Device ++ * Returns: ++ * DSP_SOK : On Successful Loading ++ * DSP_EFILE : No DSP exec file found. ++ * DSP_EFAIL : General Failure ++ * Requires: ++ * hDevObject != NULL. ++ * hDevNode != NULL. ++ * PROC Initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS PROC_AutoStart(struct CFG_DEVNODE *hDevNode, ++ struct DEV_OBJECT *hDevObject); ++ ++/* ++ * ======== PROC_Ctrl ======== ++ * Purpose: ++ * Pass control information to the GPP device driver managing the DSP ++ * processor. This will be an OEM-only function, and not part of the ++ * 'Bridge application developer's API. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * dwCmd : Private driver IOCTL cmd ID. ++ * pArgs : Ptr to an driver defined argument structure. ++ * Returns: ++ * DSP_SOK : SUCCESS ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_ETIMEOUT: A Timeout Occured before the Control information ++ * could be sent. ++ * DSP_EACCESSDENIED: Client does not have the access rights required ++ * to call this function. ++ * DSP_ERESTART: A Critical error has occured and the DSP is being ++ * restarted. ++ * DSP_EFAIL : General Failure. ++ * Requires: ++ * PROC Initialized. ++ * Ensures ++ * Details: ++ * This function Calls WMD_BRD_Ioctl. ++ */ ++ extern DSP_STATUS PROC_Ctrl(DSP_HPROCESSOR hProcessor, ++ u32 dwCmd, IN struct DSP_CBDATA *pArgs); ++ ++/* ++ * ======== PROC_Detach ======== ++ * Purpose: ++ * Close a DSP processor and de-allocate all (GPP) resources reserved ++ * for it. The Processor Object is deleted. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : InValid Handle. ++ * DSP_EFAIL : General failure. ++ * Requires: ++ * PROC Initialized. ++ * Ensures: ++ * PROC Object is destroyed. ++ */ ++ extern DSP_STATUS PROC_Detach(DSP_HPROCESSOR hProcessor); ++ ++/* ++ * ======== PROC_EnumNodes ======== ++ * Purpose: ++ * Enumerate the nodes currently allocated on a processor. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * aNodeTab : The first Location of an array allocated for node ++ * handles. ++ * uNodeTabSize: The number of (DSP_HNODE) handles that can be held ++ * to the memory the client has allocated for aNodeTab ++ * puNumNodes : Location where DSPProcessor_EnumNodes will return ++ * the number of valid handles written to aNodeTab ++ * puAllocated : Location where DSPProcessor_EnumNodes will return ++ * the number of nodes that are allocated on the DSP. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_ESIZE : The amount of memory allocated for aNodeTab is ++ * insufficent. That is the number of nodes actually ++ * allocated on the DSP is greater than the value ++ * specified for uNodeTabSize. ++ * DSP_EFAIL : Unable to get Resource Information. ++ * Details: ++ * Requires ++ * puNumNodes is not NULL. ++ * puAllocated is not NULL. ++ * aNodeTab is not NULL. ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_EnumNodes(DSP_HPROCESSOR hProcessor, ++ IN DSP_HNODE *aNodeTab, ++ IN u32 uNodeTabSize, ++ OUT u32 *puNumNodes, ++ OUT u32 *puAllocated); ++ ++/* ++ * ======== PROC_GetResourceInfo ======== ++ * Purpose: ++ * Enumerate the resources currently available on a processor. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * uResourceType: Type of resource . ++ * pResourceInfo: Ptr to the DSP_RESOURCEINFO structure. ++ * uResourceInfoSize: Size of the structure. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EWRONGSTATE: The processor is not in the PROC_RUNNING state. ++ * DSP_ETIMEOUT: A timeout occured before the DSP responded to the ++ * querry. ++ * DSP_ERESTART: A Critical error has occured and the DSP is being ++ * restarted. ++ * DSP_EFAIL : Unable to get Resource Information ++ * Requires: ++ * pResourceInfo is not NULL. ++ * Parameter uResourceType is Valid.[TBD] ++ * uResourceInfoSize is >= sizeof DSP_RESOURCEINFO struct. ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ * This function currently returns ++ * DSP_ENOTIMPL, and does not write any data to the pResourceInfo struct. ++ */ ++ extern DSP_STATUS PROC_GetResourceInfo(DSP_HPROCESSOR hProcessor, ++ u32 uResourceType, ++ OUT struct DSP_RESOURCEINFO * ++ pResourceInfo, ++ u32 uResourceInfoSize); ++ ++/* ++ * ======== PROC_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * PROC is initialized. ++ * Ensures: ++ * When reference count == 0, PROC's private resources are freed. ++ */ ++ extern void PROC_Exit(void); ++ ++/* ++ * ======== PROC_GetDevObject ========= ++ * Purpose: ++ * Returns the DEV Hanlde for a given Processor handle ++ * Parameters: ++ * hProcessor : Processor Handle ++ * phDevObject : Location to store the DEV Handle. ++ * Returns: ++ * DSP_SOK : Success; *phDevObject has Dev handle ++ * DSP_EFAIL : Failure; *phDevObject is zero. ++ * Requires: ++ * phDevObject is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * DSP_SOK : *phDevObject is not NULL ++ * DSP_EFAIL : *phDevObject is NULL. ++ */ ++ extern DSP_STATUS PROC_GetDevObject(DSP_HPROCESSOR hProcessor, ++ struct DEV_OBJECT **phDevObject); ++ ++/* ++ * ======== PROC_Init ======== ++ * Purpose: ++ * Initialize PROC's private state, keeping a reference count on each ++ * call. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * TRUE: A requirement for the other public PROC functions. ++ */ ++ extern bool PROC_Init(void); ++ ++/* ++ * ======== PROC_GetState ======== ++ * Purpose: ++ * Report the state of the specified DSP processor. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pProcStatus : Ptr to location to store the DSP_PROCESSORSTATE ++ * structure. ++ * uStateInfoSize: Size of DSP_PROCESSORSTATE. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure while querying processor state. ++ * Requires: ++ * pProcStatus is not NULL ++ * uStateInfoSize is >= than the size of DSP_PROCESSORSTATE structure. ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_GetState(DSP_HPROCESSOR hProcessor, ++ OUT struct DSP_PROCESSORSTATE ++ *pProcStatus, ++ u32 uStateInfoSize); ++ ++/* ++ * ======== PROC_GetProcessorID ======== ++ * Purpose: ++ * Report the state of the specified DSP processor. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * procID : Processor ID ++ * ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure while querying processor state. ++ * Requires: ++ * pProcStatus is not NULL ++ * uStateInfoSize is >= than the size of DSP_PROCESSORSTATE structure. ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_GetProcessorId(DSP_HPROCESSOR hProcessor, ++ u32 *procID); ++ ++/* ++ * ======== PROC_GetTrace ======== ++ * Purpose: ++ * Retrieve the trace buffer from the specified DSP processor. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pBuf : Ptr to buffer to hold trace output. ++ * uMaxSize : Maximum size of the output buffer. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure while retireving processor trace ++ * Buffer. ++ * Requires: ++ * pBuf is not NULL ++ * uMaxSize is > 0. ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_GetTrace(DSP_HPROCESSOR hProcessor, u8 *pBuf, ++ u32 uMaxSize); ++ ++/* ++ * ======== PROC_Load ======== ++ * Purpose: ++ * Reset a processor and load a new base program image. ++ * This will be an OEM-only function. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * iArgc : The number of Arguments(strings)in the aArgV[] ++ * aArgv : An Array of Arguments(Unicode Strings) ++ * aEnvp : An Array of Environment settings(Unicode Strings) ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EFILE : The DSP Execuetable was not found. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_ECORRUTFILE: Unable to Parse the DSP Execuetable ++ * DSP_EATTACHED: Abort because a GPP Client is attached to the ++ * specified Processor ++ * DSP_EACCESSDENIED: Client does not have the required access rights ++ * to reset and load the Processor ++ * DSP_EFAIL : Unable to Load the Processor ++ * Requires: ++ * aArgv is not NULL ++ * iArgc is > 0 ++ * PROC Initialized. ++ * Ensures: ++ * Success and ProcState == PROC_LOADED ++ * or DSP_FAILED status. ++ * Details: ++ * Does not implement access rights to control which GPP application ++ * can load the processor. ++ */ ++ extern DSP_STATUS PROC_Load(DSP_HPROCESSOR hProcessor, ++ IN CONST s32 iArgc, IN CONST char **aArgv, ++ IN CONST char **aEnvp); ++ ++/* ++ * ======== PROC_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified of specific processor events ++ * Parameters: ++ * hProcessor : The processor handle. ++ * uEventMask : Mask of types of events to be notified about. ++ * uNotifyType : Type of notification to be sent. ++ * hNotification: Handle to be used for notification. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle or hNotification. ++ * DSP_EVALUE : Parameter uEventMask is Invalid ++ * DSP_ENOTIMP : The notification type specified in uNotifyMask ++ * is not supported. ++ * DSP_EFAIL : Unable to register for notification. ++ * Requires: ++ * hNotification is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_RegisterNotify(DSP_HPROCESSOR hProcessor, ++ u32 uEventMask, u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++/* ++ * ======== PROC_NotifyClients ======== ++ * Purpose: ++ * Notify the Processor Clients ++ * Parameters: ++ * hProc : The processor handle. ++ * uEvents : Event to be notified about. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : Failure to Set or Reset the Event ++ * Requires: ++ * uEvents is Supported or Valid type of Event ++ * hProc is a valid handle ++ * PROC Initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS PROC_NotifyClients(DSP_HPROCESSOR hProc, ++ u32 uEvents); ++ ++/* ++ * ======== PROC_NotifyAllClients ======== ++ * Purpose: ++ * Notify the Processor Clients ++ * Parameters: ++ * hProc : The processor handle. ++ * uEvents : Event to be notified about. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : Failure to Set or Reset the Event ++ * Requires: ++ * uEvents is Supported or Valid type of Event ++ * hProc is a valid handle ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ * NODE And STRM would use this function to notify their clients ++ * about the state changes in NODE or STRM. ++ */ ++ extern DSP_STATUS PROC_NotifyAllClients(DSP_HPROCESSOR hProc, ++ u32 uEvents); ++ ++/* ++ * ======== PROC_Start ======== ++ * Purpose: ++ * Start a processor running. ++ * Processor must be in PROC_LOADED state. ++ * This will be an OEM-only function, and not part of the 'Bridge ++ * application developer's API. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EWRONGSTATE: Processor is not in PROC_LOADED state. ++ * DSP_EFAIL : Unable to start the processor. ++ * Requires: ++ * PROC Initialized. ++ * Ensures: ++ * Success and ProcState == PROC_RUNNING or DSP_FAILED status. ++ * Details: ++ */ ++ extern DSP_STATUS PROC_Start(DSP_HPROCESSOR hProcessor); ++ ++/* ++ * ======== PROC_Stop ======== ++ * Purpose: ++ * Start a processor running. ++ * Processor must be in PROC_LOADED state. ++ * This will be an OEM-only function, and not part of the 'Bridge ++ * application developer's API. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EWRONGSTATE: Processor is not in PROC_LOADED state. ++ * DSP_EFAIL : Unable to start the processor. ++ * Requires: ++ * PROC Initialized. ++ * Ensures: ++ * Success and ProcState == PROC_RUNNING or DSP_FAILED status. ++ * Details: ++ */ ++ extern DSP_STATUS PROC_Stop(DSP_HPROCESSOR hProcessor); ++ ++/* ++ * ======== PROC_FlushMemory ======== ++ * Purpose: ++ * Flushes a buffer from the MPU data cache. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pMpuAddr : Buffer start address ++ * ulSize : Buffer size ++ * ulFlags : Reserved. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * Requires: ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ * All the arguments are currently ignored. ++ */ ++ extern DSP_STATUS PROC_FlushMemory(DSP_HPROCESSOR hProcessor, ++ void *pMpuAddr, ++ u32 ulSize, u32 ulFlags); ++ ++ ++/* ++ * ======== PROC_InvalidateMemory ======== ++ * Purpose: ++ * Invalidates a buffer from the MPU data cache. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pMpuAddr : Buffer start address ++ * ulSize : Buffer size ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * Requires: ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ * All the arguments are currently ignored. ++ */ ++ extern DSP_STATUS PROC_InvalidateMemory(DSP_HPROCESSOR hProcessor, ++ void *pMpuAddr, ++ u32 ulSize); ++ ++/* ++ * ======== PROC_Map ======== ++ * Purpose: ++ * Maps a MPU buffer to DSP address space. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pMpuAddr : Starting address of the memory region to map. ++ * ulSize : Size of the memory region to map. ++ * pReqAddr : Requested DSP start address. Offset-adjusted actual ++ * mapped address is in the last argument. ++ * ppMapAddr : Ptr to DSP side mapped u8 address. ++ * ulMapAttr : Optional endianness attributes, virt to phys flag. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * DSP_EMEMORY : MPU side memory allocation error. ++ * DSP_ENOTFOUND : Cannot find a reserved region starting with this ++ * : address. ++ * Requires: ++ * pMpuAddr is not NULL ++ * ulSize is not zero ++ * ppMapAddr is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_Map(DSP_HPROCESSOR hProcessor, ++ void *pMpuAddr, ++ u32 ulSize, ++ void *pReqAddr, ++ void **ppMapAddr, u32 ulMapAttr); ++ ++/* ++ * ======== PROC_ReserveMemory ======== ++ * Purpose: ++ * Reserve a virtually contiguous region of DSP address space. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * ulSize : Size of the address space to reserve. ++ * ppRsvAddr : Ptr to DSP side reserved u8 address. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * DSP_EMEMORY : Cannot reserve chunk of this size. ++ * Requires: ++ * ppRsvAddr is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_ReserveMemory(DSP_HPROCESSOR hProcessor, ++ u32 ulSize, void **ppRsvAddr); ++ ++/* ++ * ======== PROC_UnMap ======== ++ * Purpose: ++ * Removes a MPU buffer mapping from the DSP address space. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pMapAddr : Starting address of the mapped memory region. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * DSP_ENOTFOUND : Cannot find a mapped region starting with this ++ * : address. ++ * Requires: ++ * pMapAddr is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_UnMap(DSP_HPROCESSOR hProcessor, void *pMapAddr); ++ ++/* ++ * ======== PROC_UnReserveMemory ======== ++ * Purpose: ++ * Frees a previously reserved region of DSP address space. ++ * Parameters: ++ * hProcessor : The processor handle. ++ * pRsvAddr : Ptr to DSP side reservedBYTE address. ++ * Returns: ++ * DSP_SOK : Success. ++ * DSP_EHANDLE : Invalid processor handle. ++ * DSP_EFAIL : General failure. ++ * DSP_ENOTFOUND : Cannot find a reserved region starting with this ++ * : address. ++ * Requires: ++ * pRsvAddr is not NULL ++ * PROC Initialized. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS PROC_UnReserveMemory(DSP_HPROCESSOR hProcessor, ++ void *pRsvAddr); ++ ++#endif /* PROC_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/procpriv.h b/arch/arm/plat-omap/include/dspbridge/procpriv.h +new file mode 100644 +index 0000000..21d4b3e +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/procpriv.h +@@ -0,0 +1,35 @@ ++/* ++ * procpriv.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== procpriv.h ======== ++ * Description: ++ * Global PROC constants and types, shared by PROC, MGR, and WCD. ++ * ++ *! Revision History: ++ *! ================ ++ *! 05-July-2000 rr: Created ++ */ ++ ++#ifndef PROCPRIV_ ++#define PROCPRIV_ ++ ++/* RM PROC Object */ ++ struct PROC_OBJECT; ++ ++#endif /* PROCPRIV_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/pwr.h b/arch/arm/plat-omap/include/dspbridge/pwr.h +new file mode 100644 +index 0000000..a6645ca +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/pwr.h +@@ -0,0 +1,129 @@ ++/* ++ * pwr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== pwr.h ======== ++ * ++ * Public Functions: ++ * ++ * PWR_SleepDSP ++ * PWR_WakeDSP ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 06-Jun-2002 sg Replaced dspdefs.h with includes of dbdefs.h and errbase.h. ++ *! 13-May-2002 sg Added DSP_SAREADYASLEEP and DSP_SALREADYAWAKE. ++ *! 09-May-2002 sg Updated, added timeouts. ++ *! 02-May-2002 sg Initial. ++ */ ++ ++#ifndef PWR_ ++#define PWR_ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++#include <dspbridge/pwr_sh.h> ++ ++/* ++ * ======== PWR_SleepDSP ======== ++ * Signal the DSP to go to sleep. ++ * ++ * Parameters: ++ * sleepCode: New sleep state for DSP. (Initially, valid codes ++ * are PWR_DEEPSLEEP or PWR_EMERGENCYDEEPSLEEP; both of ++ * these codes will simply put the DSP in deep sleep.) ++ * ++ * timeout: Maximum time (msec) that PWR should wait for ++ * confirmation that the DSP sleep state has been ++ * reached. If PWR should simply send the command to ++ * the DSP to go to sleep and then return (i.e., ++ * asynchrounous sleep), the timeout should be ++ * specified as zero. ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_SALREADYASLEEP: Success, but the DSP was already asleep. ++ * DSP_EINVALIDARG: The specified sleepCode is not supported. ++ * DSP_ETIMEOUT: A timeout occured while waiting for DSP sleep ++ * confirmation. ++ * DSP_EFAIL: General failure, unable to send sleep command to ++ * the DSP. ++ */ ++ extern DSP_STATUS PWR_SleepDSP(IN CONST u32 sleepCode, ++ IN CONST u32 timeout); ++ ++/* ++ * ======== PWR_WakeDSP ======== ++ * Signal the DSP to wake from sleep. ++ * ++ * Parameters: ++ * timeout: Maximum time (msec) that PWR should wait for ++ * confirmation that the DSP is awake. If PWR should ++ * simply send a command to the DSP to wake and then ++ * return (i.e., asynchrounous wake), timeout should ++ * be specified as zero. ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_SALREADYAWAKE: Success, but the DSP was already awake. ++ * DSP_ETIMEOUT: A timeout occured while waiting for wake ++ * confirmation. ++ * DSP_EFAIL: General failure, unable to send wake command to ++ * the DSP. ++ */ ++ extern DSP_STATUS PWR_WakeDSP(IN CONST u32 timeout); ++ ++/* ++ * ======== PWR_PM_PreScale ======== ++ * Prescale notification to DSP. ++ * ++ * Parameters: ++ * voltage_domain: The voltage domain for which notification is sent ++ * level: The level of voltage domain ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_SALREADYAWAKE: Success, but the DSP was already awake. ++ * DSP_ETIMEOUT: A timeout occured while waiting for wake ++ * confirmation. ++ * DSP_EFAIL: General failure, unable to send wake command to ++ * the DSP. ++ */ ++ extern DSP_STATUS PWR_PM_PreScale(IN u16 voltage_domain, u32 level); ++ ++/* ++ * ======== PWR_PM_PostScale ======== ++ * PostScale notification to DSP. ++ * ++ * Parameters: ++ * voltage_domain: The voltage domain for which notification is sent ++ * level: The level of voltage domain ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_SALREADYAWAKE: Success, but the DSP was already awake. ++ * DSP_ETIMEOUT: A timeout occured while waiting for wake ++ * confirmation. ++ * DSP_EFAIL: General failure, unable to send wake command to ++ * the DSP. ++ */ ++ extern DSP_STATUS PWR_PM_PostScale(IN u16 voltage_domain, ++ u32 level); ++ ++#endif /* PWR_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/pwr_sh.h b/arch/arm/plat-omap/include/dspbridge/pwr_sh.h +new file mode 100644 +index 0000000..40f1b84 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/pwr_sh.h +@@ -0,0 +1,41 @@ ++/* ++ * pwr_sh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== pwr_sh.h ======== ++ * ++ * Power Manager shared definitions (used on both GPP and DSP sides). ++ * ++ *! Revision History ++ *! ================ ++ *! 17-Apr-2002 sg: Initial. ++ */ ++ ++#ifndef PWR_SH_ ++#define PWR_SH_ ++ ++#include <dspbridge/mbx_sh.h> ++ ++/* valid sleep command codes that can be sent by GPP via mailbox: */ ++#define PWR_DEEPSLEEP MBX_PM_DSPIDLE ++#define PWR_EMERGENCYDEEPSLEEP MBX_PM_EMERGENCYSLEEP ++#define PWR_SLEEPUNTILRESTART MBX_PM_SLEEPUNTILRESTART ++#define PWR_WAKEUP MBX_PM_DSPWAKEUP ++#define PWR_AUTOENABLE MBX_PM_PWRENABLE ++#define PWR_AUTODISABLE MBX_PM_PWRDISABLE ++#define PWR_RETENTION MBX_PM_DSPRETN ++ ++#endif /* PWR_SH_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/reg.h b/arch/arm/plat-omap/include/dspbridge/reg.h +new file mode 100644 +index 0000000..5b34952 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/reg.h +@@ -0,0 +1,257 @@ ++/* ++ * reg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== reg.h ======== ++ * Purpose: ++ * Provide registry functions. ++ * ++ * Public Functions: ++ * REG_DeleteValue ++ * REG_EnumKey ++ * REG_EnumValue ++ * REG_Exit ++ * REG_GetValue ++ * REG_Init ++ * REG_SetValue ++ * ++ *! Revision History: ++ *! ================= ++ *! 30-Oct-2000 kc: Updated REG_SetValue & REG_GetValue; renamed ++ *! REG_DeleteEntry to REG_DeleteValue. ++ *! 29-Sep-2000 kc: Updated a REG functions for code review. ++ *! 12-Aug-2000 kc: Renamed REG_EnumValue to REG_EnumKey. Re-implemented ++ *! REG_EnumValue. ++ *! 03-Feb-2000 rr: REG_EnumValue Fxn Added ++ *! 13-Dec-1999 rr: windows.h removed ++ *! 02-Dec-1999 rr: windows.h included for retail build ++ *! 22-Nov-1999 kc: Changes from code review. ++ *! 29-Dec-1997 cr: Changes from code review. ++ *! 27-Oct-1997 cr: Added REG_DeleteValue. ++ *! 20-Oct-1997 cr: Added ability to pass bValue = NULL to REG_GetValue ++ *! and return size of reg entry in pdwValueSize. ++ *! 29-Sep-1997 cr: Added REG_SetValue ++ *! 29-Aug-1997 cr: Created. ++ */ ++ ++#ifndef _REG_H ++#define _REG_H ++ ++#include <linux/types.h> ++ ++/* ------------------------- Defines, Data Structures, Typedefs for Linux */ ++#ifndef UNDER_CE ++ ++#ifndef REG_SZ ++#define REG_SZ 1 ++#endif ++ ++#ifndef REG_BINARY ++#define REG_BINARY 3 ++#endif ++ ++#ifndef REG_DWORD ++#define REG_DWORD 4 ++#endif ++ ++#endif /* UNDER_CE */ ++ ++#define REG_MAXREGPATHLENGTH 255 ++ ++/* ++ * ======== REG_DeleteValue ======== ++ * Purpose: ++ * Deletes a registry entry. NOTE: A registry entry is not the same as ++ * a registry key. ++ * Parameters: ++ * phKey: Currently reserved; must be NULL. ++ * pstrSubkey: Path to key to open. ++ * pstrValue: Name of entry to delete. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * - REG initialized. ++ * - pstrSubkey & pstrValue are non-NULL values. ++ * - phKey is NULL. ++ * - length of pstrSubkey < REG_MAXREGPATHLENGTH. ++ * - length of pstrValue < REG_MAXREGPATHLENGTH. ++ * Ensures: ++ * Details: ++ */ ++ extern DSP_STATUS REG_DeleteValue(OPTIONAL IN HANDLE *phKey, ++ IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue); ++ ++/* ++ * ======== REG_EnumKey ======== ++ * Purpose: ++ * Enumerates subkeys of the specified path to the registry key ++ * Retrieves the name of the subkey(given the index) and ++ * appends with the orignal path to form the full path. ++ * Parameters: ++ * phKey: Currently reserved; must be NULL. ++ * pstrKey The name of the registry key to be enumerated. ++ * dwIndex Specifies the index of the subkey to retrieve. ++ * pstrSubkey: Pointer to buffer that receives full path name of the ++ * specified key + the sub-key ++ * pdwValueSize: Specifies bytes of memory pstrSubkey points to on input, ++ * on output, specifies actual memory bytes written into. ++ * If there is no sub key,pdwValueSize returns NULL. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * - REG initialized. ++ * - pstrKey is non-NULL value. ++ * - pdwValueSize is a valid pointer. ++ * - phKey is NULL. ++ * - length of pstrKey < REG_MAXREGPATHLENGTH. ++ * Ensures: ++ * - strlen(pstrSubkey) is > strlen(pstrKey) && ++ * - strlen(pstrSubkey) is < REG_MAXREGPATHLENGTH ++ */ ++ extern DSP_STATUS REG_EnumKey(OPTIONAL IN HANDLE *phKey, ++ IN u32 dwIndex, IN CONST char *pstrKey, ++ IN OUT char *pstrSubkey, ++ IN OUT u32 *pdwValueSize); ++ ++/* ++ * ======== REG_EnumValue ======== ++ * Purpose: ++ * Enumerates values of a specified key. Retrieves each value name and ++ * the data associated with the value. ++ * Parameters: ++ * phKey: Currently reserved; must be NULL. ++ * dwIndex: Specifies the index of the value to retrieve. ++ * pstrKey: The name of the registry key to be enumerated. ++ * pstrValue: Pointer to buffer that receives the name of the value. ++ * pdwValueSize: Specifies bytes of memory pstrValue points to on input, ++ * On output, specifies actual memory bytes written into. ++ * If there is no value, pdwValueSize returns NULL ++ * pstrData: Pointer to buffer that receives the data of a value. ++ * pdwDataSize: Specifies bytes of memory in pstrData on input and ++ * bytes of memory written into pstrData on output. ++ * If there is no data, pdwDataSize returns NULL. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * REG initialized. ++ * phKey is NULL. ++ * pstrKey is a non-NULL value. ++ * pstrValue, pstrData, pdwValueSize and pdwDataSize are valid pointers. ++ * Length of pstrKey is less than REG_MAXREGPATHLENGTH. ++ * Ensures: ++ */ ++ extern DSP_STATUS REG_EnumValue(IN HANDLE *phKey, ++ IN u32 dwIndex, ++ IN CONST char *pstrKey, ++ IN OUT char *pstrValue, ++ IN OUT u32 *pdwValueSize, ++ IN OUT char *pstrData, ++ IN OUT u32 *pdwDataSize); ++ ++/* ++ * ======== REG_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * REG initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void REG_Exit(void); ++ ++/* ++ * ======== REG_GetValue ======== ++ * Purpose: ++ * Retrieve a value from the registry. ++ * Parameters: ++ * phKey: Currently reserved; must be NULL. ++ * pstrSubkey: Path to key to open. ++ * pstrEntry: Name of entry to retrieve. ++ * pbValue: Upon return, points to retrieved value. ++ * pdwValueSize: Specifies bytes of memory pbValue points to on input, ++ * on output, specifies actual memory bytes written into. ++ * If pbValue is NULL, pdwValueSize reports the size of ++ * the entry in pstrEntry. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * - REG initialized. ++ * - pstrSubkey & pstrEntry are non-NULL values. ++ * - pbValue is a valid pointer. ++ * - phKey is NULL. ++ * - length of pstrSubkey < REG_MAXREGPATHLENGTH. ++ * - length of pstrEntry < REG_MAXREGPATHLENGTH. ++ * Ensures: ++ */ ++ extern DSP_STATUS REG_GetValue(OPTIONAL IN HANDLE *phKey, ++ IN CONST char *pstrSubkey, ++ IN CONST char *pstrEntry, ++ OUT u8 *pbValue, ++ IN OUT u32 *pdwValueSize); ++ ++/* ++ * ======== REG_Init ======== ++ * Purpose: ++ * Initializes private state of REG module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * REG initialized. ++ */ ++ extern bool REG_Init(void); ++ ++/* ++ * ======== REG_SetValue ======== ++ * Purpose: ++ * Set a value in the registry. ++ * Parameters: ++ * phKey: Handle to open reg key, or NULL if pSubkey is full path. ++ * pstrSubkey: Path to key to open, could be based on phKey. ++ * pstrEntry: Name of entry to set. ++ * dwType: Data type of new registry value. ++ * pbValue: Points to buffer containing new data. ++ * dwValueSize: Specifies bytes of memory bValue points to. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * - REG initialized. ++ * - pstrSubkey & pstrEntry are non-NULL values. ++ * - pbValue is a valid pointer. ++ * - phKey is NULL. ++ * - dwValuSize > 0. ++ * - length of pstrSubkey < REG_MAXREGPATHLENGTH. ++ * - length of pstrEntry < REG_MAXREGPATHLENGTH. ++ * Ensures: ++ */ ++ extern DSP_STATUS REG_SetValue(OPTIONAL IN HANDLE *phKey, ++ IN CONST char *pstrSubKey, ++ IN CONST char *pstrEntry, ++ IN CONST u32 dwType, ++ IN u8 *pbValue, IN u32 dwValueSize); ++ ++#endif /* _REG_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/resourcecleanup.h b/arch/arm/plat-omap/include/dspbridge/resourcecleanup.h +new file mode 100644 +index 0000000..b43fa16 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/resourcecleanup.h +@@ -0,0 +1,88 @@ ++/* ++ * resourcecleanup.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef RES_CLEANUP_DISABLE ++ ++#include <dspbridge/nodepriv.h> ++#include <dspbridge/drv.h> ++ ++ ++extern DSP_STATUS DRV_GetProcCtxtList(struct PROCESS_CONTEXT **pPctxt, ++ struct DRV_OBJECT *hDrvObject); ++ ++extern DSP_STATUS DRV_InsertProcContext(struct DRV_OBJECT *hDrVObject, ++ HANDLE hPCtxt); ++ ++extern DSP_STATUS DRV_RemoveAllDMMResElements(HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_RemoveAllNodeResElements(HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_ProcUpdatestate(HANDLE pCtxt, ++ enum GPP_PROC_RES_STATE resState); ++ ++extern DSP_STATUS DRV_ProcSetPID(HANDLE pCtxt, s32 hProcess); ++ ++extern DSP_STATUS DRV_GetProcContext(u32 phProcess, ++ struct DRV_OBJECT *hDrvObject, ++ HANDLE hPCtxt, DSP_HNODE hNode, ++ u32 pMapAddr); ++ ++extern DSP_STATUS DRV_RemoveAllResources(HANDLE pPctxt); ++ ++extern DSP_STATUS DRV_RemoveProcContext(struct DRV_OBJECT *hDRVObject, ++ HANDLE hPCtxt, HANDLE hProcess); ++ ++extern DSP_STATUS DRV_GetNodeResElement(HANDLE hNode, HANDLE nodeRes, ++ HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_InsertNodeResElement(HANDLE hNode, HANDLE nodeRes, ++ HANDLE pCtxt); ++ ++extern void DRV_ProcNodeUpdateHeapStatus(HANDLE hNodeRes, s32 status); ++ ++extern DSP_STATUS DRV_RemoveNodeResElement(HANDLE nodeRes, HANDLE status); ++ ++extern void DRV_ProcNodeUpdateStatus(HANDLE hNodeRes, s32 status); ++ ++extern DSP_STATUS DRV_UpdateDMMResElement(HANDLE dmmRes, u32 pMpuAddr, ++ u32 ulSize, u32 pReqAddr, ++ u32 ppMapAddr, HANDLE hProcesso); ++ ++extern DSP_STATUS DRV_InsertDMMResElement(HANDLE dmmRes, HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_GetDMMResElement(u32 pMapAddr, HANDLE dmmRes, ++ HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_RemoveDMMResElement(HANDLE dmmRes, HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_ProcUpdateSTRMRes(u32 uNumBufs, HANDLE STRMRes, ++ HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_ProcInsertSTRMResElement(HANDLE hStrm, HANDLE STRMRes, ++ HANDLE pPctxt); ++ ++extern DSP_STATUS DRV_GetSTRMResElement(HANDLE hStrm, HANDLE STRMRes, ++ HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_ProcRemoveSTRMResElement(HANDLE STRMRes, HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_RemoveAllSTRMResElements(HANDLE pCtxt); ++ ++extern DSP_STATUS DRV_ProcDisplayResInfo(u8 *pBuf, u32 *pSize); ++ ++extern enum NODE_STATE NODE_GetState(HANDLE hNode); ++ ++#endif +diff --git a/arch/arm/plat-omap/include/dspbridge/rmm.h b/arch/arm/plat-omap/include/dspbridge/rmm.h +new file mode 100644 +index 0000000..5b14b8f +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/rmm.h +@@ -0,0 +1,199 @@ ++/* ++ * rmm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== rmm.h ======== ++ * ++ * This memory manager provides general heap management and arbitrary ++ * alignment for any number of memory segments, and management of overlay ++ * memory. ++ * ++ * Public functions: ++ * RMM_alloc ++ * RMM_create ++ * RMM_delete ++ * RMM_exit ++ * RMM_free ++ * RMM_init ++ * ++ *! Revision History ++ *! ================ ++ *! 25-Jun-2002 jeh Added RMM_Addr. Removed RMM_reserve, RMM_stat. ++ *! 15-Oct-2001 jeh Based on rm.h in gen tree. ++ */ ++ ++#ifndef RMM_ ++#define RMM_ ++ ++/* ++ * ======== RMM_Addr ======== ++ * DSP address + segid ++ */ ++struct RMM_Addr { ++ u32 addr; ++ s32 segid; ++} ; ++ ++/* ++ * ======== RMM_Segment ======== ++ * Memory segment on the DSP available for remote allocations. ++ */ ++struct RMM_Segment { ++ u32 base; /* Base of the segment */ ++ u32 length; /* Size of the segment (target MAUs) */ ++ s32 space; /* Code or data */ ++ u32 number; /* Number of Allocated Blocks */ ++} ; ++ ++/* ++ * ======== RMM_Target ======== ++ */ ++struct RMM_TargetObj; ++ ++/* ++ * ======== RMM_alloc ======== ++ * ++ * RMM_alloc is used to remotely allocate or reserve memory on the DSP. ++ * ++ * Parameters: ++ * target - Target returned from RMM_create(). ++ * segid - Memory segment to allocate from. ++ * size - Size (target MAUS) to allocate. ++ * align - alignment. ++ * dspAddr - If reserve is FALSE, the location to store allocated ++ * address on output, otherwise, the DSP address to ++ * reserve. ++ * reserve - If TRUE, reserve the memory specified by dspAddr. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation on GPP failed. ++ * DSP_EOVERLAYMEMORY: Cannot "allocate" overlay memory because it's ++ * already in use. ++ * Requires: ++ * RMM initialized. ++ * Valid target. ++ * dspAddr != NULL. ++ * size > 0 ++ * reserve || target->numSegs > 0. ++ * Ensures: ++ */ ++extern DSP_STATUS RMM_alloc(struct RMM_TargetObj *target, u32 segid, u32 size, ++ u32 align, u32 *dspAdr, bool reserve); ++ ++/* ++ * ======== RMM_create ======== ++ * Create a target object with memory segments for remote allocation. If ++ * segTab == NULL or numSegs == 0, memory can only be reserved through ++ * RMM_alloc(). ++ * ++ * Parameters: ++ * pTarget: - Location to store target on output. ++ * segTab: - Table of memory segments. ++ * numSegs: - Number of memory segments. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failed. ++ * Requires: ++ * RMM initialized. ++ * pTarget != NULL. ++ * numSegs == 0 || segTab != NULL. ++ * Ensures: ++ * Success: Valid *pTarget. ++ * Failure: *pTarget == NULL. ++ */ ++extern DSP_STATUS RMM_create(struct RMM_TargetObj **pTarget, ++ struct RMM_Segment segTab[], u32 numSegs); ++ ++/* ++ * ======== RMM_delete ======== ++ * Delete target allocated in RMM_create(). ++ * ++ * Parameters: ++ * target - Target returned from RMM_create(). ++ * Returns: ++ * Requires: ++ * RMM initialized. ++ * Valid target. ++ * Ensures: ++ */ ++extern void RMM_delete(struct RMM_TargetObj *target); ++ ++/* ++ * ======== RMM_exit ======== ++ * Exit the RMM module ++ * ++ * Parameters: ++ * Returns: ++ * Requires: ++ * RMM_init successfully called. ++ * Ensures: ++ */ ++extern void RMM_exit(void); ++ ++/* ++ * ======== RMM_free ======== ++ * Free or unreserve memory allocated through RMM_alloc(). ++ * ++ * Parameters: ++ * target: - Target returned from RMM_create(). ++ * segid: - Segment of memory to free. ++ * dspAddr: - Address to free or unreserve. ++ * size: - Size of memory to free or unreserve. ++ * reserved: - TRUE if memory was reserved only, otherwise FALSE. ++ * Returns: ++ * Requires: ++ * RMM initialized. ++ * Valid target. ++ * reserved || segid < target->numSegs. ++ * reserve || [dspAddr, dspAddr + size] is a valid memory range. ++ * Ensures: ++ */ ++extern bool RMM_free(struct RMM_TargetObj *target, u32 segid, u32 dspAddr, ++ u32 size, bool reserved); ++ ++/* ++ * ======== RMM_init ======== ++ * Initialize the RMM module ++ * ++ * Parameters: ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Failure. ++ * Requires: ++ * Ensures: ++ */ ++extern bool RMM_init(void); ++ ++/* ++ * ======== RMM_stat ======== ++ * Obtain memory segment status ++ * ++ * Parameters: ++ * segid: Segment ID of the dynamic loading segment. ++ * pMemStatBuf: Pointer to allocated buffer into which memory stats are ++ * placed. ++ * Returns: ++ * TRUE: Success. ++ * FALSE: Failure. ++ * Requires: ++ * segid < target->numSegs ++ * Ensures: ++ */ ++extern bool RMM_stat(struct RMM_TargetObj *target, enum DSP_MEMTYPE segid, ++ struct DSP_MEMSTAT *pMemStatBuf); ++ ++#endif /* RMM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/rms_sh.h b/arch/arm/plat-omap/include/dspbridge/rms_sh.h +new file mode 100644 +index 0000000..5d4b49a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/rms_sh.h +@@ -0,0 +1,125 @@ ++/* ++ * rms_sh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== rms_sh.h ======== ++ * ++ * DSP/BIOS Bridge Resource Manager Server shared definitions (used on both ++ * GPP and DSP sides). ++ * ++ *! Revision History ++ *! ================ ++ *! 24-Mar-2003 vp Merged updates required for CCS2.2 transition. ++ *! 24-Feb-2003 kc Rearranged order of node types to temporarily support ++ *! legacy message node code ++ *! 23-Nov-2002 gp Converted tabs -> spaces, to fix formatting. ++ *! 13-Feb-2002 jeh Added sysstacksize element to RMS_MoreTaskArgs. ++ *! 11-Dec-2000 sg Added 'misc' element to RMS_MoreTaskArgs. ++ *! 04-Dec-2000 ag Added RMS_BUFDESC command code. ++ *! C/R code value changed to allow ORing of system/user codes. ++ *! 10-Oct-2000 sg Added 'align' field to RMS_StrmDef. ++ *! 09-Oct-2000 sg Moved pre-defined message codes here from rmsdefs.h. ++ *! 02-Oct-2000 sg Changed ticks to msec. ++ *! 24-Aug-2000 sg Moved definitions that will be exposed to app developers ++ *! to a separate file, rmsdefs.h. ++ *! 10-Aug-2000 sg Added RMS_COMMANDBUFSIZE and RMS_RESPONSEBUFSIZE; added ++ *! pre-defined command/response codes; more comments. ++ *! 09-Aug-2000 sg Added RMS_ETASK. ++ *! 08-Aug-2000 jeh Define RMS_WORD for GPP, rename DSP_MSG to RMS_DSPMSG. ++ *! Added RMS_MsgArgs, RMS_MoreTaskArgs. ++ *! 25-Jul-2000 sg: Changed SIO to STRM. ++ *! 30-Jun-2000 sg: Initial. ++ */ ++ ++#ifndef RMS_SH_ ++#define RMS_SH_ ++ ++#include <dspbridge/rmstypes.h> ++ ++/* Node Types: */ ++#define RMS_TASK 1 /* Task node */ ++#define RMS_DAIS 2 /* xDAIS socket node */ ++#define RMS_MSG 3 /* Message node */ ++ ++/* Memory Types: */ ++#define RMS_CODE 0 /* Program space */ ++#define RMS_DATA 1 /* Data space */ ++#define RMS_IO 2 /* I/O space */ ++ ++/* RM Server Command and Response Buffer Sizes: */ ++#define RMS_COMMANDBUFSIZE 256 /* Size of command buffer */ ++#define RMS_RESPONSEBUFSIZE 16 /* Size of response buffer */ ++ ++/* Pre-Defined Command/Response Codes: */ ++#define RMS_EXIT 0x80000000 /* GPP->Node: shutdown */ ++#define RMS_EXITACK 0x40000000 /* Node->GPP: ack shutdown */ ++#define RMS_BUFDESC 0x20000000 /* Arg1 SM buf, Arg2 is SM size */ ++#define RMS_KILLTASK 0x10000000 /* GPP->Node: Kill Task */ ++#define RMS_USER 0x0 /* Start of user-defined msg codes */ ++#define RMS_MAXUSERCODES 0xfff /* Maximum user defined C/R Codes */ ++ ++ ++/* RM Server RPC Command Structure: */ ++ struct RMS_Command { ++ RMS_WORD fxn; /* Server function address */ ++ RMS_WORD arg1; /* First argument */ ++ RMS_WORD arg2; /* Second argument */ ++ RMS_WORD data; /* Function-specific data array */ ++ } ; ++ ++/* ++ * The RMS_StrmDef structure defines the parameters for both input and output ++ * streams, and is passed to a node's create function. ++ */ ++ struct RMS_StrmDef { ++ RMS_WORD bufsize; /* Buffer size (in DSP words) */ ++ RMS_WORD nbufs; /* Max number of bufs in stream */ ++ RMS_WORD segid; /* Segment to allocate buffers */ ++ RMS_WORD align; /* Alignment for allocated buffers */ ++ RMS_WORD timeout; /* Timeout (msec) for blocking calls */ ++ RMS_CHAR name[1]; /* Device Name (terminated by '\0') */ ++ } ; ++ ++/* Message node create args structure: */ ++ struct RMS_MsgArgs { ++ RMS_WORD maxMessages; /* Max # simultaneous msgs to node */ ++ RMS_WORD segid; /* Mem segment for NODE_allocMsgBuf */ ++ RMS_WORD notifyType; /* Type of message notification */ ++ RMS_WORD argLength; /* Length (in DSP chars) of arg data */ ++ RMS_WORD argData; /* Arg data for node */ ++ } ; ++ ++/* Partial task create args structure */ ++ struct RMS_MoreTaskArgs { ++ RMS_WORD priority; /* Task's runtime priority level */ ++ RMS_WORD stackSize; /* Task's stack size */ ++ RMS_WORD sysstackSize; /* Task's system stack size (55x) */ ++ RMS_WORD stackSeg; /* Memory segment for task's stack */ ++ RMS_WORD heapAddr; /* base address of the node memory heap in ++ * external memory (DSP virtual address) */ ++ RMS_WORD heapSize; /* size in MAUs of the node memory heap in ++ * external memory */ ++ RMS_WORD misc; /* Misc field. Not used for 'normal' ++ * task nodes; for xDAIS socket nodes ++ * specifies the IALG_Fxn pointer. ++ */ ++ /* # input STRM definition structures */ ++ RMS_WORD numInputStreams; ++ } ; ++ ++#endif /* RMS_SH_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/rmstypes.h b/arch/arm/plat-omap/include/dspbridge/rmstypes.h +new file mode 100644 +index 0000000..13d752e +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/rmstypes.h +@@ -0,0 +1,40 @@ ++/* ++ * rmstypes.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== rmstypes.h ======== ++ * ++ * DSP/BIOS Bridge Resource Manager Server shared data type definitions. ++ * ++ *! Revision History ++ *! ================ ++ *! 06-Oct-2000 sg Added LgFxn type. ++ *! 05-Oct-2000 sg Changed RMS_STATUS to LgUns. ++ *! 31-Aug-2000 sg Added RMS_DSPMSG. ++ *! 25-Aug-2000 sg Initial. ++ */ ++ ++#ifndef RMSTYPES_ ++#define RMSTYPES_ ++#include <linux/types.h> ++/* ++ * DSP-side definitions. ++ */ ++#include <dspbridge/std.h> ++typedef u32 RMS_WORD; ++typedef char RMS_CHAR; ++ ++#endif /* RMSTYPES_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/services.h b/arch/arm/plat-omap/include/dspbridge/services.h +new file mode 100644 +index 0000000..35bab0d +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/services.h +@@ -0,0 +1,63 @@ ++/* ++ * services.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== services.h ======== ++ * Purpose: ++ * Provide loading and unloading of SERVICES modules. ++ * ++ * Public Functions: ++ * SERVICES_Exit(void) ++ * SERVICES_Init(void) ++ * ++ *! Revision History: ++ *! ================ ++ *! 01-Feb-2000 kc: Created. ++ */ ++ ++#ifndef SERVICES_ ++#define SERVICES_ ++ ++#include <dspbridge/host_os.h> ++/* ++ * ======== SERVICES_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * SERVICES initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void SERVICES_Exit(void); ++ ++/* ++ * ======== SERVICES_Init ======== ++ * Purpose: ++ * Initializes SERVICES modules. ++ * Parameters: ++ * Returns: ++ * TRUE if all modules initialized; otherwise FALSE. ++ * Requires: ++ * Ensures: ++ * SERVICES modules initialized. ++ */ ++ extern bool SERVICES_Init(void); ++ ++#endif /* SERVICES_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/std.h b/arch/arm/plat-omap/include/dspbridge/std.h +new file mode 100644 +index 0000000..ec849f4 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/std.h +@@ -0,0 +1,143 @@ ++/* ++ * std.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== std.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 16-Feb-2004 vp GNU compiler 3.x defines inline keyword. Added ++ *! appropriate macros not to redefine inline keyword in ++ *! this file. ++ *! 24-Oct-2002 ashu defined _TI_ and _FIXED_ symbols for 28x. ++ *! 24-Oct-2002 ashu defined _TI_ for 24x. ++ *! 01-Mar-2002 kln changed LARGE_MODEL and Arg definition for 28x ++ *! 01-Feb-2002 kln added definitions for 28x ++ *! 08-Dec-2000 kw: added 'ArgToInt' and 'ArgToPtr' macros ++ *! 30-Nov-2000 mf: Added _64_, _6x_; removed _7d_ ++ *! 30-May-2000 srid: Added __TMS320C55X__ for 55x; Arg is void * for 55 . ++ *! 18-Jun-1999 dr: Added '_TI_', fixed __inline for SUN4, added inline ++ *! 10-Feb-1999 rt: Added '55' support, changed 54's symbol to _TMS320C5XX ++ *! 29-Aug-1998 mf: fixed typo, removed obsolete targets ++ *! 08-Jun-1998 mf: _67_ is synonym for _7d_ ++ *! 10-Oct-1997 rt; added _7d_ for Raytheon C7DSP triggered by _TMS320C6700 ++ *! 04-Aug-1997 cc: added _29_ for _TMS320C2XX ++ *! 11-Jul-1997 dlr: _5t_, and STD_SPOXTASK keyword for Tasking ++ *! 12-Jun-1997 mf: _TMS320C60 -> _TMS320C6200 ++ *! 13-Feb-1997 mf: _62_, with 32-bit LgInt ++ *! 26-Nov-1996 kw: merged bios-c00's and wsx-a27's <dspbridge/std.h> changes ++ *! *and* revision history ++ *! 12-Sep-1996 kw: added C54x #ifdef's ++ *! 21-Aug-1996 mf: removed #define main smain for _21_ ++ *! 14-May-1996 gp: def'd out INT, FLOAT, and COMPLEX defines for WSX. ++ *! 11-Apr-1996 kw: define _W32_ based on _WIN32 (defined by MS compiler) ++ *! 07-Mar-1996 mg: added Win32 support ++ *! 06-Sep-1995 dh: added _77_ dynamic stack support via fxns77.h ++ *! 27-Jun-1995 dh: added _77_ support ++ *! 16-Mar-1995 mf: for _21_: #define main smain ++ *! 01-Mar-1995 mf: set _20_ and _60_ (as well as _21_ for both) ++ *! 22-Feb-1995 mf: Float is float for _SUN_ and _80_ ++ *! 22-Dec-1994 mf: Added _80_ definition, for PP or MP. ++ *! 09-Dec-1994 mf: Added _53_ definition. ++ *! Added definitions of _30_, etc. ++ *! 23-Aug-1994 dh removed _21_ special case (kw) ++ *! 17-Aug-1994 dh added _51_ support ++ *! 03-Aug-1994 kw updated _80_ support ++ *! 30-Jun-1994 kw added _80_ support ++ *! 05-Apr-1994 kw: Added _SUN_ to _FLOAT_ definition ++ *! 01-Mar-1994 kw: Made Bool an int (was u16) for _56_ (more efficient). ++ *! Added _53_ support. ++ */ ++ ++#ifndef STD_ ++#define STD_ ++ ++#include <linux/types.h> ++ ++/* ++ * ======== _TI_ ======== ++ * _TI_ is defined for all TI targets ++ */ ++#if defined(_29_) || defined(_30_) || defined(_40_) || defined(_50_) || \ ++ defined(_54_) || defined(_55_) || defined(_6x_) || defined(_80_) || \ ++ defined(_28_) || defined(_24_) ++#define _TI_ 1 ++#endif ++ ++/* ++ * ======== _FLOAT_ ======== ++ * _FLOAT_ is defined for all targets that natively support floating point ++ */ ++#if defined(_SUN_) || defined(_30_) || defined(_40_) || defined(_67_) || \ ++ defined(_80_) ++#define _FLOAT_ 1 ++#endif ++ ++/* ++ * ======== _FIXED_ ======== ++ * _FIXED_ is defined for all fixed point target architectures ++ */ ++#if defined(_29_) || defined(_50_) || defined(_54_) || defined(_55_) || \ ++ defined(_62_) || defined(_64_) || defined(_28_) ++#define _FIXED_ 1 ++#endif ++ ++/* ++ * ======== _TARGET_ ======== ++ * _TARGET_ is defined for all target architectures (as opposed to ++ * host-side software) ++ */ ++#if defined(_FIXED_) || defined(_FLOAT_) ++#define _TARGET_ 1 ++#endif ++ ++/* ++ * 8, 16, 32-bit type definitions ++ * ++ * Sm* - 8-bit type ++ * Md* - 16-bit type ++ * Lg* - 32-bit type ++ * ++ * *s32 - signed type ++ * *u32 - unsigned type ++ * *Bits - unsigned type (bit-maps) ++ */ ++ ++/* ++ * Aliases for standard C types ++ */ ++ ++typedef s32(*Fxn) (void); /* generic function type */ ++ ++#ifndef NULL ++#define NULL 0 ++#endif ++ ++ ++/* ++ * These macros are used to cast 'Arg' types to 's32' or 'Ptr'. ++ * These macros were added for the 55x since Arg is not the same ++ * size as s32 and Ptr in 55x large model. ++ */ ++#if defined(_28l_) || defined(_55l_) ++#define ArgToInt(A) ((s32)((long)(A) & 0xffff)) ++#define ArgToPtr(A) ((Ptr)(A)) ++#else ++#define ArgToInt(A) ((s32)(A)) ++#define ArgToPtr(A) ((Ptr)(A)) ++#endif ++ ++#endif /* STD_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/strm.h b/arch/arm/plat-omap/include/dspbridge/strm.h +new file mode 100644 +index 0000000..5825615 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/strm.h +@@ -0,0 +1,441 @@ ++/* ++ * strm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== strm.h ======== ++ * Description: ++ * DSPBridge Stream Manager. ++ * ++ * Public Functions: ++ * STRM_AllocateBuffer ++ * STRM_Close ++ * STRM_Create ++ * STRM_Delete ++ * STRM_Exit ++ * STRM_FreeBuffer ++ * STRM_GetEventHandle ++ * STRM_GetInfo ++ * STRM_Idle ++ * STRM_Init ++ * STRM_Issue ++ * STRM_Open ++ * STRM_PrepareBuffer ++ * STRM_Reclaim ++ * STRM_RegisterNotify ++ * STRM_Select ++ * STRM_UnprepareBuffer ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================= ++ *! 15-Nov-2001 ag Changed DSP_STREAMINFO to STRM_INFO in STRM_GetInfo(). ++ *! Added DSP_ESIZE error to STRM_AllocateBuffer(). ++ *! 07-Jun-2001 sg Made DSPStream_AllocateBuffer fxn name plural. ++ *! 10-May-2001 jeh Code review cleanup. ++ *! 13-Feb-2001 kc DSP/BIOS Bridge name updates. ++ *! 06-Feb-2001 kc Updated DBC_Ensure for STRM_Select(). ++ *! 23-Oct-2000 jeh Allow NULL STRM_ATTRS passed to STRM_Open(). ++ *! 25-Sep-2000 jeh Created. ++ */ ++ ++#ifndef STRM_ ++#define STRM_ ++ ++#include <dspbridge/dev.h> ++ ++#include <dspbridge/strmdefs.h> ++ ++/* ++ * ======== STRM_AllocateBuffer ======== ++ * Purpose: ++ * Allocate data buffer(s) for use with a stream. ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * uSize: Size (GPP bytes) of the buffer(s). ++ * uNumBufs: Number of buffers to allocate. ++ * apBuffer: Array to hold buffer addresses. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_EMEMORY: Insufficient memory. ++ * DSP_EFAIL: Failure occurred, unable to allocate buffers. ++ * DSP_ESIZE: uSize must be > 0 bytes. ++ * Requires: ++ * STRM_Init(void) called. ++ * apBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_AllocateBuffer(struct STRM_OBJECT *hStrm, ++ u32 uSize, ++ OUT u8 **apBuffer, ++ u32 uNumBufs); ++ ++/* ++ * ======== STRM_Close ======== ++ * Purpose: ++ * Close a stream opened with STRM_Open(). ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_EPENDING: Some data buffers issued to the stream have not ++ * been reclaimed. ++ * DSP_EFAIL: Failure to close stream. ++ * Requires: ++ * STRM_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_Close(struct STRM_OBJECT *hStrm); ++ ++/* ++ * ======== STRM_Create ======== ++ * Purpose: ++ * Create a STRM manager object. This object holds information about the ++ * device needed to open streams. ++ * Parameters: ++ * phStrmMgr: Location to store handle to STRM manager object on ++ * output. ++ * hDev: Device for this processor. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * DSP_EFAIL: General failure. ++ * Requires: ++ * STRM_Init(void) called. ++ * phStrmMgr != NULL. ++ * hDev != NULL. ++ * Ensures: ++ * DSP_SOK: Valid *phStrmMgr. ++ * error: *phStrmMgr == NULL. ++ */ ++ extern DSP_STATUS STRM_Create(OUT struct STRM_MGR **phStrmMgr, ++ struct DEV_OBJECT *hDev); ++ ++/* ++ * ======== STRM_Delete ======== ++ * Purpose: ++ * Delete the STRM Object. ++ * Parameters: ++ * hStrmMgr: Handle to STRM manager object from STRM_Create. ++ * Returns: ++ * Requires: ++ * STRM_Init(void) called. ++ * Valid hStrmMgr. ++ * Ensures: ++ * hStrmMgr is not valid. ++ */ ++ extern void STRM_Delete(struct STRM_MGR *hStrmMgr); ++ ++/* ++ * ======== STRM_Exit ======== ++ * Purpose: ++ * Discontinue usage of STRM module. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * STRM_Init(void) successfully called before. ++ * Ensures: ++ */ ++ extern void STRM_Exit(void); ++ ++/* ++ * ======== STRM_FreeBuffer ======== ++ * Purpose: ++ * Free buffer(s) allocated with STRM_AllocateBuffer. ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * apBuffer: Array containing buffer addresses. ++ * uNumBufs: Number of buffers to be freed. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid stream handle. ++ * DSP_EFAIL: Failure occurred, unable to free buffers. ++ * Requires: ++ * STRM_Init(void) called. ++ * apBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_FreeBuffer(struct STRM_OBJECT *hStrm, ++ u8 **apBuffer, u32 uNumBufs); ++ ++/* ++ * ======== STRM_GetEventHandle ======== ++ * Purpose: ++ * Get stream's user event handle. This function is used when closing ++ * a stream, so the event can be closed. ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * phEvent: Location to store event handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * Requires: ++ * STRM_Init(void) called. ++ * phEvent != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_GetEventHandle(struct STRM_OBJECT *hStrm, ++ OUT HANDLE *phEvent); ++ ++/* ++ * ======== STRM_GetInfo ======== ++ * Purpose: ++ * Get information about a stream. User's DSP_STREAMINFO is contained ++ * in STRM_INFO struct. STRM_INFO also contains Bridge private info. ++ * Parameters: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * pStreamInfo: Location to store stream info on output. ++ * uSteamInfoSize: Size of user's DSP_STREAMINFO structure. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_ESIZE: uStreamInfoSize < sizeof(DSP_STREAMINFO). ++ * DSP_EFAIL: Unable to get stream info. ++ * Requires: ++ * STRM_Init(void) called. ++ * pStreamInfo != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_GetInfo(struct STRM_OBJECT *hStrm, ++ OUT struct STRM_INFO *pStreamInfo, ++ u32 uStreamInfoSize); ++ ++/* ++ * ======== STRM_Idle ======== ++ * Purpose: ++ * Idle a stream and optionally flush output data buffers. ++ * If this is an output stream and fFlush is TRUE, all data currently ++ * enqueued will be discarded. ++ * If this is an output stream and fFlush is FALSE, this function ++ * will block until all currently buffered data is output, or the timeout ++ * specified has been reached. ++ * After a successful call to STRM_Idle(), all buffers can immediately ++ * be reclaimed. ++ * Parameters: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * fFlush: If TRUE, discard output buffers. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_ETIMEOUT: A timeout occurred before the stream could be idled. ++ * DSP_ERESTART: A critical error occurred, DSP is being restarted. ++ * DSP_EFAIL: Unable to idle stream. ++ * Requires: ++ * STRM_Init(void) called. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_Idle(struct STRM_OBJECT *hStrm, bool fFlush); ++ ++/* ++ * ======== STRM_Init ======== ++ * Purpose: ++ * Initialize the STRM module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialization succeeded, FALSE otherwise. ++ * Requires: ++ * Ensures: ++ */ ++ extern bool STRM_Init(void); ++ ++/* ++ * ======== STRM_Issue ======== ++ * Purpose: ++ * Send a buffer of data to a stream. ++ * Parameters: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * pBuf: Pointer to buffer of data to be sent to the stream. ++ * ulBytes: Number of bytes of data in the buffer. ++ * ulBufSize: Actual buffer size in bytes. ++ * dwArg: A user argument that travels with the buffer. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_ESTREAMFULL: The stream is full. ++ * DSP_EFAIL: Failure occurred, unable to issue buffer. ++ * Requires: ++ * STRM_Init(void) called. ++ * pBuf != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_Issue(struct STRM_OBJECT *hStrm, IN u8 *pBuf, ++ u32 ulBytes, u32 ulBufSize, ++ IN u32 dwArg); ++ ++/* ++ * ======== STRM_Open ======== ++ * Purpose: ++ * Open a stream for sending/receiving data buffers to/from a task of ++ * DAIS socket node on the DSP. ++ * Parameters: ++ * hNode: Node handle returned from NODE_Allocate(). ++ * uDir: DSP_TONODE or DSP_FROMNODE. ++ * uIndex: Stream index. ++ * pAttr: Pointer to structure containing attributes to be ++ * applied to stream. Cannot be NULL. ++ * phStrm: Location to store stream handle on output. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hNode. ++ * DSP_EDIRECTION: Invalid uDir. ++ * DSP_EVALUE: Invalid uIndex. ++ * DSP_ENODETYPE: hNode is not a task or DAIS socket node. ++ * DSP_EFAIL: Unable to open stream. ++ * Requires: ++ * STRM_Init(void) called. ++ * phStrm != NULL. ++ * pAttr != NULL. ++ * Ensures: ++ * DSP_SOK: *phStrm is valid. ++ * error: *phStrm == NULL. ++ */ ++ extern DSP_STATUS STRM_Open(struct NODE_OBJECT *hNode, u32 uDir, ++ u32 uIndex, IN struct STRM_ATTR *pAttr, ++ OUT struct STRM_OBJECT **phStrm); ++ ++/* ++ * ======== STRM_PrepareBuffer ======== ++ * Purpose: ++ * Prepare a data buffer not allocated by DSPStream_AllocateBuffers() ++ * for use with a stream. ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * uSize: Size (GPP bytes) of the buffer. ++ * pBuffer: Buffer address. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_EFAIL: Failure occurred, unable to prepare buffer. ++ * Requires: ++ * STRM_Init(void) called. ++ * pBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_PrepareBuffer(struct STRM_OBJECT *hStrm, ++ u32 uSize, ++ u8 *pBuffer); ++ ++/* ++ * ======== STRM_Reclaim ======== ++ * Purpose: ++ * Request a buffer back from a stream. ++ * Parameters: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * pBufPtr: Location to store pointer to reclaimed buffer. ++ * pulBytes: Location where number of bytes of data in the ++ * buffer will be written. ++ * pulBufSize: Location where actual buffer size will be written. ++ * pdwArg: Location where user argument that travels with ++ * the buffer will be written. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_ETIMEOUT: A timeout occurred before a buffer could be ++ * retrieved. ++ * DSP_EFAIL: Failure occurred, unable to reclaim buffer. ++ * Requires: ++ * STRM_Init(void) called. ++ * pBufPtr != NULL. ++ * pulBytes != NULL. ++ * pdwArg != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_Reclaim(struct STRM_OBJECT *hStrm, ++ OUT u8 **pBufPtr, u32 *pulBytes, ++ u32 *pulBufSize, u32 *pdwArg); ++ ++/* ++ * ======== STRM_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified on specific events for this stream. ++ * Parameters: ++ * hStrm: Stream handle returned by STRM_Open(). ++ * uEventMask: Mask of types of events to be notified about. ++ * uNotifyType: Type of notification to be sent. ++ * hNotification: Handle to be used for notification. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_EMEMORY: Insufficient memory on GPP. ++ * DSP_EVALUE: uEventMask is invalid. ++ * DSP_ENOTIMPL: Notification type specified by uNotifyType is not ++ * supported. ++ * Requires: ++ * STRM_Init(void) called. ++ * hNotification != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_RegisterNotify(struct STRM_OBJECT *hStrm, ++ u32 uEventMask, u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++/* ++ * ======== STRM_Select ======== ++ * Purpose: ++ * Select a ready stream. ++ * Parameters: ++ * aStrmTab: Array of stream handles returned from STRM_Open(). ++ * nStrms: Number of stream handles in array. ++ * pMask: Location to store mask of ready streams on output. ++ * uTimeout: Timeout value (milliseconds). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ERANGE: nStrms out of range. ++ ++ * DSP_EHANDLE: Invalid stream handle in array. ++ * DSP_ETIMEOUT: A timeout occurred before a stream became ready. ++ * DSP_EFAIL: Failure occurred, unable to select a stream. ++ * Requires: ++ * STRM_Init(void) called. ++ * aStrmTab != NULL. ++ * nStrms > 0. ++ * pMask != NULL. ++ * Ensures: ++ * DSP_SOK: *pMask != 0 || uTimeout == 0. ++ * Error: *pMask == 0. ++ */ ++ extern DSP_STATUS STRM_Select(IN struct STRM_OBJECT **aStrmTab, ++ u32 nStrms, ++ OUT u32 *pMask, u32 uTimeout); ++ ++/* ++ * ======== STRM_UnprepareBuffer ======== ++ * Purpose: ++ * Unprepare a data buffer that was previously prepared for a stream ++ * with DSPStream_PrepareBuffer(), and that will no longer be used with ++ * the stream. ++ * Parameter: ++ * hStrm: Stream handle returned from STRM_Open(). ++ * uSize: Size (GPP bytes) of the buffer. ++ * pBuffer: Buffer address. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hStrm. ++ * DSP_EFAIL: Failure occurred, unable to unprepare buffer. ++ * Requires: ++ * STRM_Init(void) called. ++ * pBuffer != NULL. ++ * Ensures: ++ */ ++ extern DSP_STATUS STRM_UnprepareBuffer(struct STRM_OBJECT *hStrm, ++ u32 uSize, ++ u8 *pBuffer); ++ ++#endif /* STRM_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/strmdefs.h b/arch/arm/plat-omap/include/dspbridge/strmdefs.h +new file mode 100644 +index 0000000..44d217a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/strmdefs.h +@@ -0,0 +1,57 @@ ++/* ++ * strmdefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== strmdefs.h ======== ++ * Purpose: ++ * Global STRM constants and types. ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Nov-2001 ag Added STRM_INFO.. ++ *! 25-Sep-2000 jeh Created. ++ */ ++ ++#ifndef STRMDEFS_ ++#define STRMDEFS_ ++ ++#define STRM_MAXEVTNAMELEN 32 ++ ++ struct STRM_MGR; ++ ++ struct STRM_OBJECT; ++ ++ struct STRM_ATTR { ++ HANDLE hUserEvent; ++ char *pstrEventName; ++ void *pVirtBase; /* Process virtual base address of ++ * mapped SM */ ++ u32 ulVirtSize; /* Size of virtual space in bytes */ ++ struct DSP_STREAMATTRIN *pStreamAttrIn; ++ } ; ++ ++ struct STRM_INFO { ++ enum DSP_STRMMODE lMode; /* transport mode of ++ * stream(DMA, ZEROCOPY..) */ ++ u32 uSegment; /* Segment strm allocs from. 0 is local mem */ ++ void *pVirtBase; /* " " Stream'process virt base */ ++ struct DSP_STREAMINFO *pUser; /* User's stream information ++ * returned */ ++ } ; ++ ++#endif /* STRMDEFS_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/sync.h b/arch/arm/plat-omap/include/dspbridge/sync.h +new file mode 100644 +index 0000000..fa3ff8d +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/sync.h +@@ -0,0 +1,340 @@ ++/* ++ * sync.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== sync.h ======== ++ * Purpose: ++ * Provide synchronization services. ++ * ++ * Public Functions: ++ * SYNC_CloseEvent ++ * SYNC_DeleteCS ++ * SYNC_EnterCS ++ * SYNC_Exit ++ * SYNC_Init ++ * SYNC_InitializeCS ++ * SYNC_LeaveCS ++ * SYNC_OpenEvent ++ * SYNC_PostMessage ++ * SYNC_ResetEvent ++ * SYNC_SetEvent ++ * SYNC_WaitOnEvent ++ * SYNC_WaitOnMultipleEvents ++ * ++ *! Revision History: ++ *! ================ ++ *! 05-Oct-2000 jeh Added SYNC_WaitOnMultipleEvents(). ++ *! 01-Dec-1999 ag: Added #define SYNC_MAXNAMELENGTH. ++ *! 04-Nov-1999 kc: Added critical section functions and objects to SYNC. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 24-Sep-1999 kc: Added WinCE notes. ++ *! 20-Oct-1997 gp: Removed unused SYNC_ critical section and must complete fxns ++ *! Added SYNC_HOBJECT, SYNC_ATTRS, and object validation, and ++ *! merged SYNC_DestroyEvent into SYNC_CloseEvent, and merged ++ *! SYNC_CreateEvent into SYNC_OpenEvent. ++ *! 07-Oct-1997 gp: Added SYNC_Create/DestroyEvent (for NT testing). ++ *! 06-Oct-1997 gp: Added SYNC_OpenEvent. ++ *! 03-Jun-1997 gp: Added SYNC_{Begin|End}CritSection() functions. ++ *! 03-Jan-1997 gp: Added SYNC_INFINITE define. ++ *! 05-Aug-1996 gp: Created. ++ */ ++ ++#ifndef _SYNC_H ++#define _SYNC_H ++ ++#define SIGNATURECS 0x53435953 /* "SYCS" (in reverse) */ ++#define SIGNATUREDPCCS 0x53445953 /* "SYDS" (in reverse) */ ++ ++/* Special timeout value indicating an infinite wait: */ ++#define SYNC_INFINITE 0xffffffff ++ ++/* Maximum string length of a named event */ ++#define SYNC_MAXNAMELENGTH 32 ++ ++/* Generic SYNC object: */ ++ struct SYNC_OBJECT; ++ ++/* Generic SYNC CS object: */ ++struct SYNC_CSOBJECT { ++ u32 dwSignature; /* used for object validation */ ++ struct semaphore sem; ++} ; ++ ++/* SYNC object attributes: */ ++ struct SYNC_ATTRS { ++ HANDLE hUserEvent; /* Platform's User Mode synch. object. */ ++ HANDLE hKernelEvent; /* Platform's Kernel Mode sync. object. */ ++ u32 dwReserved1; /* For future expansion. */ ++ u32 dwReserved2; /* For future expansion. */ ++ } ; ++ ++/* ++ * ======== SYNC_CloseEvent ======== ++ * Purpose: ++ * Close this event handle, freeing resources allocated in SYNC_OpenEvent ++ * if necessary. ++ * Parameters: ++ * hEvent: Handle to a synchronization event, created/opened in ++ * SYNC_OpenEvent. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EFAIL: Failed to close event handle. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * SYNC initialized. ++ * Ensures: ++ * Any subsequent usage of hEvent would be invalid. ++ */ ++ extern DSP_STATUS SYNC_CloseEvent(IN struct SYNC_OBJECT *hEvent); ++ ++/* ++ * ======== SYNC_DeleteCS ======== ++ * Purpose: ++ * Delete a critical section. ++ * Parameters: ++ * hCSObj: critical section handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_DeleteCS(IN struct SYNC_CSOBJECT *hCSObj); ++ ++/* ++ * ======== SYNC_EnterCS ======== ++ * Purpose: ++ * Enter the critical section. ++ * Parameters: ++ * hCSObj: critical section handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_EnterCS(IN struct SYNC_CSOBJECT *hCSObj); ++ ++/* ++ * ======== SYNC_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * SYNC initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern void SYNC_Exit(void); ++ ++/* ++ * ======== SYNC_Init ======== ++ * Purpose: ++ * Initializes private state of SYNC module. ++ * Parameters: ++ * Returns: ++ * TRUE if initialized; FALSE if error occured. ++ * Requires: ++ * Ensures: ++ * SYNC initialized. ++ */ ++ extern bool SYNC_Init(void); ++ ++/* ++ * ======== SYNC_InitializeCS ======== ++ * Purpose: ++ * Initialize the critical section. ++ * Parameters: ++ * hCSObj: critical section handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Out of memory. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_InitializeCS(OUT struct SYNC_CSOBJECT **phCSObj); ++ ++/* ++ * ======== SYNC_InitializeDPCCS ======== ++ * Purpose: ++ * Initialize the critical section between process context and DPC. ++ * Parameters: ++ * hCSObj: critical section handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Out of memory. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_InitializeDPCCS(OUT struct SYNC_CSOBJECT ++ **phCSObj); ++ ++/* ++ * ======== SYNC_LeaveCS ======== ++ * Purpose: ++ * Leave the critical section. ++ * Parameters: ++ * hCSObj: critical section handle. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_LeaveCS(IN struct SYNC_CSOBJECT *hCSObj); ++ ++/* ++ * ======== SYNC_OpenEvent ======== ++ * Purpose: ++ * Create/open and initialize an event object for thread synchronization, ++ * which is initially in the non-signalled state. ++ * Parameters: ++ * phEvent: Pointer to location to receive the event object handle. ++ * pAttrs: Pointer to SYNC_ATTRS object containing initial SYNC ++ * SYNC_OBJECT attributes. If this pointer is NULL, then ++ * SYNC_OpenEvent will create and manage an OS specific ++ * syncronization object. ++ * pAttrs->hUserEvent: Platform's User Mode synchronization object. ++ * ++ * The behaviour of the SYNC methods depend on the value of ++ * the hUserEvent attr: ++ * ++ * 1. (hUserEvent == NULL): ++ * A user mode event is created. ++ * 2. (hUserEvent != NULL): ++ * A user mode event is supplied by the caller of SYNC_OpenEvent(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Unable to create user mode event. ++ * DSP_EMEMORY: Insufficient memory. ++ * DSP_EINVALIDARG SYNC_ATTRS values are invalid. ++ * Requires: ++ * - SYNC initialized. ++ * - phEvent != NULL. ++ * Ensures: ++ * If function succeeded, pEvent->hEvent must be a valid event handle. ++ */ ++ extern DSP_STATUS SYNC_OpenEvent(OUT struct SYNC_OBJECT **phEvent, ++ IN OPTIONAL struct SYNC_ATTRS ++ *pAttrs); ++ ++/* ++ * ========= SYNC_PostMessage ======== ++ * Purpose: ++ * To post a windows message ++ * Parameters: ++ * hWindow: Handle to the window ++ * uMsg: Message to be posted ++ * Returns: ++ * DSP_SOK: Success ++ * DSP_EFAIL: Post message failed ++ * DSP_EHANDLE: Invalid Window handle ++ * Requires: ++ * SYNC initialized ++ * Ensures ++ */ ++ extern DSP_STATUS SYNC_PostMessage(IN HANDLE hWindow, IN u32 uMsg); ++ ++/* ++ * ======== SYNC_ResetEvent ======== ++ * Purpose: ++ * Reset a syncronization event object state to non-signalled. ++ * Parameters: ++ * hEvent: Handle to a sync event. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EFAIL: Failed to reset event. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * SYNC initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_ResetEvent(IN struct SYNC_OBJECT *hEvent); ++ ++/* ++ * ======== SYNC_SetEvent ======== ++ * Purpose: ++ * Signal the event. Will unblock one waiting thread. ++ * Parameters: ++ * hEvent: Handle to an event object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Failed to signal event. ++ * DSP_EHANDLE: Invalid handle. ++ * Requires: ++ * SYNC initialized. ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_SetEvent(IN struct SYNC_OBJECT *hEvent); ++ ++/* ++ * ======== SYNC_WaitOnEvent ======== ++ * Purpose: ++ * Wait for an event to be signalled, up to the specified timeout. ++ * Parameters: ++ * hEvent: Handle to an event object. ++ * dwTimeOut: The time-out interval, in milliseconds. ++ * The function returns if the interval elapses, even if ++ * the object's state is nonsignaled. ++ * If zero, the function tests the object's state and ++ * returns immediately. ++ * If SYNC_INFINITE, the function's time-out interval ++ * never elapses. ++ * Returns: ++ * DSP_SOK: The object was signalled. ++ * DSP_EHANDLE: Invalid handle. ++ * SYNC_E_FAIL: Wait failed, possibly because the process terminated. ++ * SYNC_E_TIMEOUT: Timeout expired while waiting for event to be signalled. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_WaitOnEvent(IN struct SYNC_OBJECT *hEvent, ++ IN u32 dwTimeOut); ++ ++/* ++ * ======== SYNC_WaitOnMultipleEvents ======== ++ * Purpose: ++ * Wait for any of an array of events to be signalled, up to the ++ * specified timeout. ++ * Note: dwTimeOut must be SYNC_INFINITE to signal infinite wait. ++ * Parameters: ++ * hSyncEvents: Array of handles to event objects. ++ * uCount: Number of event handles. ++ * dwTimeOut: The time-out interval, in milliseconds. ++ * The function returns if the interval elapses, even if ++ * no event is signalled. ++ * If zero, the function tests the object's state and ++ * returns immediately. ++ * If SYNC_INFINITE, the function's time-out interval ++ * never elapses. ++ * puIndex: Location to store index of event that was signalled. ++ * Returns: ++ * DSP_SOK: The object was signalled. ++ * SYNC_E_FAIL: Wait failed, possibly because the process terminated. ++ * SYNC_E_TIMEOUT: Timeout expired before event was signalled. ++ * DSP_EMEMORY: Memory allocation failed. ++ * Requires: ++ * Ensures: ++ */ ++ extern DSP_STATUS SYNC_WaitOnMultipleEvents(IN struct SYNC_OBJECT ++ **hSyncEvents, ++ IN u32 uCount, ++ IN u32 dwTimeout, ++ OUT u32 *puIndex); ++ ++#endif /* _SYNC_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/util.h b/arch/arm/plat-omap/include/dspbridge/util.h +new file mode 100644 +index 0000000..e6815ca +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/util.h +@@ -0,0 +1,122 @@ ++/* ++ * util.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== util.h ======== ++ * Purpose: ++ * Provide general purpose utility functions. ++ * ++ * Public Functions: ++ * UTIL_CDTestDll ++ * UTIL_CmdLineToArgs ++ * UTIL_Exit ++ * UTIL_GetSysInfo ++ * UTIL_Init ++ */ ++ ++#ifndef _UTIL_H ++#define _UTIL_H ++ ++#include <linux/delay.h> ++#include <linux/sched.h> ++ ++#include <dspbridge/utildefs.h> ++ ++/* ++ * ======== UTIL_CDTestDll ======== ++ * Purpose: ++ * Provides test entry point in class driver context. ++ * Parameters: ++ * cArgc: test module command line input count. ++ * ppArgv: test module command line args. ++ * Returns: ++ * 0 if successful, a negative value otherwise. ++ * Requires: ++ * UTIL initialized. ++ * Ensures: ++ */ ++ extern u32 UTIL_CDTestDll(IN s32 cArgc, IN char **ppArgv); ++ ++/* ++ * ======== UTIL_CmdLineToArgs ======== ++ * Purpose: ++ * This function re-creates C-style cmd line argc & argv from WinMain() ++ * cmd line args. ++ * Parameters: ++ * s8 *pszProgName - The name of the program currently being executed. ++ * s8 *argv[] - The argument vector. ++ * s8 *pCmdLine - The pointer to the command line. ++ * bool fHasProgName - Indicats whether a program name is supplied. ++ * Returns: ++ * Returns the number of arguments found. ++ * Requires: ++ * UTIL initialized. ++ * Ensures: ++ */ ++ extern s32 UTIL_CmdLineToArgs(IN char *pszProgName, ++ IN char *argv[UTIL_MAXARGVS], ++ IN char *pCmdLine, IN bool fHasProgName); ++ ++/* ++ * ======== UTIL_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ * Parameters: ++ * Returns: ++ * Requires: ++ * UTIL initialized. ++ * Ensures: ++ * Resources used by module are freed when cRef reaches zero. ++ */ ++ extern inline void UTIL_Exit(void) ++ { ++ } ++/* ++ * ======== UTIL_GetSysInfo ======== ++ * Purpose: ++ * This function return platform specific system information. ++ * ++ * Parameters: ++ * pSysInfo - address to store the system information. ++ * Returns: ++ * DSP_SOK ++ * S_FAIL ++ * Requires: ++ * UTIL initialized. ++ * pSysInfo != NULL ++ * Ensures: ++ */ ++ extern DSP_STATUS UTIL_GetSysInfo(OUT struct UTIL_SYSINFO *pSysInfo); ++ ++/* ++ * ======== UTIL_Init ======== ++ * Purpose: ++ * Initializes private state of UTIL module. ++ * Parameters: ++ * Returns: ++ * TRUE if success, else FALSE. ++ * Requires: ++ * Ensures: ++ * UTIL initialized. ++ */ ++ extern inline bool UTIL_Init(void) ++ { ++ return true; ++ } ++ ++#endif /* _UTIL_H */ +diff --git a/arch/arm/plat-omap/include/dspbridge/utildefs.h b/arch/arm/plat-omap/include/dspbridge/utildefs.h +new file mode 100644 +index 0000000..bd53a5a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/utildefs.h +@@ -0,0 +1,51 @@ ++/* ++ * utildefs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== utildefs.h ======== ++ * Purpose: ++ * Global UTIL constants and types, shared between WCD and DSPSYS. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 kc Removed wIOPort* entries from UTIL_HOSTCONFIG. ++ *! 12-Aug-2000 ag Added UTIL_SYSINFO typedef. ++ *! 08-Oct-1999 rr Adopted for WinCE where test fxns will be added in util.h ++ *! 26-Dec-1996 cr Created. ++ */ ++ ++#ifndef UTILDEFS_ ++#define UTILDEFS_ ++ ++/* constants taken from configmg.h */ ++#define UTIL_MAXMEMREGS 9 ++#define UTIL_MAXIOPORTS 20 ++#define UTIL_MAXIRQS 7 ++#define UTIL_MAXDMACHNLS 7 ++ ++/* misc. constants */ ++#define UTIL_MAXARGVS 10 ++ ++/* Platform specific important info */ ++ struct UTIL_SYSINFO { ++ /* Granularity of page protection; usually 1k or 4k */ ++ u32 dwPageSize; ++ u32 dwAllocationGranularity; /* VM granularity, usually 64K */ ++ u32 dwNumberOfProcessors; /* Used as sanity check */ ++ } ; ++ ++#endif /* UTILDEFS_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/uuidutil.h b/arch/arm/plat-omap/include/dspbridge/uuidutil.h +new file mode 100644 +index 0000000..af4aaec +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/uuidutil.h +@@ -0,0 +1,74 @@ ++/* ++ * uuidutil.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== uuidutil.h ======== ++ * Description: ++ * This file contains the specification of UUID helper functions. ++ * ++ *! Revision History ++ *! ================ ++ *! 09-Nov-2000 kc: Modified description of UUID utility functions. ++ *! 29-Sep-2000 kc: Appended "UUID_" prefix to UUID helper functions. ++ *! 10-Aug-2000 kc: Created. ++ *! ++ */ ++ ++#ifndef UUIDUTIL_ ++#define UUIDUTIL_ ++ ++#define MAXUUIDLEN 37 ++ ++/* ++ * ======== UUID_UuidToString ======== ++ * Purpose: ++ * Converts a DSP_UUID to an ANSI string. ++ * Parameters: ++ * pUuid: Pointer to a DSP_UUID object. ++ * pszUuid: Pointer to a buffer to receive a NULL-terminated UUID ++ * string. ++ * size: Maximum size of the pszUuid string. ++ * Returns: ++ * Requires: ++ * pUuid & pszUuid are non-NULL values. ++ * Ensures: ++ * Lenghth of pszUuid is less than MAXUUIDLEN. ++ * Details: ++ * UUID string limit currently set at MAXUUIDLEN. ++ */ ++ void UUID_UuidToString(IN struct DSP_UUID *pUuid, OUT char *pszUuid, ++ s32 size); ++ ++/* ++ * ======== UUID_UuidFromString ======== ++ * Purpose: ++ * Converts an ANSI string to a DSP_UUID. ++ * Parameters: ++ * pszUuid: Pointer to a string that represents a DSP_UUID object. ++ * pUuid: Pointer to a DSP_UUID object. ++ * Returns: ++ * Requires: ++ * pUuid & pszUuid are non-NULL values. ++ * Ensures: ++ * Details: ++ * We assume the string representation of a UUID has the following format: ++ * "12345678_1234_1234_1234_123456789abc". ++ */ ++ extern void UUID_UuidFromString(IN char *pszUuid, ++ OUT struct DSP_UUID *pUuid); ++ ++#endif /* UUIDUTIL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wcd.h b/arch/arm/plat-omap/include/dspbridge/wcd.h +new file mode 100644 +index 0000000..5a7d47a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wcd.h +@@ -0,0 +1,61 @@ ++/* ++ * wcd.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wcd.h ======== ++ * Description: ++ * 'Bridge class driver library functions, object definitions, and ++ * return error/status codes. To be included by 'Bridge mini drivers. ++ * ++ * Public Functions: ++ * See mem.h and dbg.h. ++ * ++ * Notes: ++ * 'Bridge Class Driver services exported to WMD's are initialized by the ++ * WCD on behalf of the WMD. WMD's must not call module Init/Exit ++ * functions. ++ * ++ * To ensure WMD binary compatibility across different platforms, ++ * for the same processor, a WMD must restrict its usage of system ++ * services to those exported by the 'Bridge class library. ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Jun-2000 jeh Added dev.h ++ *! 01-Nov-1999 ag: #WINCE# WCD_MAJOR_VERSION=8 & WCD_MINOR_VERSION=0 to match ++ *! dll stamps. ++ *! 0.80 - 0.89 Alpha, 0.90 - 0.99 Beta, 1.00 - 1.10 FCS. ++ *! 17-Sep-1997 gp: Changed size of CFG_HOSTRES structure; and ISR_Install API; ++ *! Changed WCD_MINOR_VERSION 3 -> 4. ++ *! 15-Sep-1997 gp: Moved WCD_(Un)registerMinidriver to drv. ++ *! 25-Jul-1997 cr: Added WCD_UnregisterMinidriver. ++ *! 22-Jul-1997 cr: Added WCD_RegisterMinidriver, WCD_MINOR_VERSION 2 -> 3. ++ *! 12-Nov-1996 gp: Defined port io macros. ++ *! 07-Nov-1996 gp: Updated for code review. ++ *! 16-Jul-1996 gp: Added CHNL fxns; updated WCD lib version to 2. ++ *! 10-May-1996 gp: Separated WMD def.s' into wmd.h. ++ *! 03-May-1996 gp: Created. ++ */ ++ ++#ifndef WCD_ ++#define WCD_ ++ ++/* This WCD Library Version: */ ++#define WCD_MAJOR_VERSION (u32)8 /* .8x - Alpha, .9x - Beta, 1.x FCS */ ++#define WCD_MINOR_VERSION (u32)0 ++ ++#endif /* WCD_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wcdioctl.h b/arch/arm/plat-omap/include/dspbridge/wcdioctl.h +new file mode 100644 +index 0000000..04b13ab +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wcdioctl.h +@@ -0,0 +1,519 @@ ++/* ++ * wcdioctl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wcdioctl.h ======== ++ * Purpose: ++ * Contains structures and commands that are used for interaction ++ * between the DDSP API and class driver. ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping structs & offsets ++ *! 15-Oct-2002 kc Updated definitions for private PERF module. ++ *! 16-Aug-2002 map Added ARGS_MGR_REGISTEROBJECT & ARGS_MGR_UNREGISTEROBJECT ++ *! Added CMD_MGR_REGISTEROBJECT_OFFSET & ++ *! CMD_MGR_UNREGISTEROBJECT_OFFSET ++ *! 15-Jan-2002 ag Added actaul bufSize to ARGS_STRM_[RECLAIM][ISSUE]. ++ *! 15-Nov-2001 ag change to STRMINFO in ARGS_STRM_GETINFO. ++ *! 11-Sep-2001 ag ARGS_CMM_GETHANDLE defn uses DSP_HPROCESSOR. ++ *! 23-Apr-2001 jeh Added pStatus to NODE_TERMINATE args. ++ *! 13-Feb-2001 kc DSP/BIOS Bridge name updates. ++ *! 22-Nov-2000 kc: Added CMD_MGR_GETPERF_DATA_OFFSET for acquiring PERF stats. ++ *! 27-Oct-2000 jeh Added timeouts to NODE_GETMESSAGE, NODE_PUTMESSAGE args. ++ *! Removed NODE_GETMESSAGESTRM args. ++ *! 11-Oct-2000 ag: Added SM mgr(CMM) args. ++ *! 27-Sep-2000 jeh Removed struct DSP_BUFFERATTR param from ++ *! ARGS_STRM_ALLOCATEBUFFER. ++ *! 25-Sep-2000 rr: Updated to Version 0.9 ++ *! 07-Sep-2000 jeh Changed HANDLE to DSP_HNOTIFICATION in RegisterNotify args. ++ *! Added DSP_STRMATTR to DSPNode_Connect args. ++ *! 04-Aug-2000 rr: MEM and UTIL added to RM. ++ *! 27-Jul-2000 rr: NODE, MGR,STRM and PROC added ++ *! 27-Jun-2000 rr: Modifed to Use either PM or DSP/BIOS Bridge ++ *! IFDEF to build for PM or DSP/BIOS Bridge ++ *! 28-Jan-2000 rr: NT_CMD_FROM_OFFSET moved out to dsptrap.h ++ *! 24-Jan-2000 rr: Merged with Scott's code. ++ *! 21-Jan-2000 sg: In ARGS_CHNL_GETMODE changed mode to be u32 to be ++ *! consistent with chnldefs.h. ++ *! 11-Jan-2000 rr: CMD_CFG_GETCDVERSION_OFFSET added. ++ *! 12-Nov-1999 rr: CMD_BRD_MONITOR_OFFSET added ++ *! 09-Nov-1999 kc: Added MEMRY and enabled CMD_BRD_IOCTL_OFFSET. ++ *! 05-Nov-1999 ag: Added CHNL. ++ *! 02-Nov-1999 kc: Removed field from ARGS_UTIL_TESTDLL. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 08-Oct-1999 rr: Util control offsets added. ++ *! 13-Sep-1999 kc: Added ARGS_UTIL_TESTDLL for PM test infrastructure. ++ *! 19-Aug-1999 rr: Created from WSX. Minimal Implementaion of BRD_Start and BRD ++ *! and BRD_Stop. IOCTL Offsets and CTRL Code. ++ */ ++ ++#ifndef WCDIOCTL_ ++#define WCDIOCTL_ ++ ++#include <dspbridge/mem.h> ++#include <dspbridge/cmm.h> ++#include <dspbridge/strmdefs.h> ++#include <dspbridge/dbdcd.h> ++ ++union Trapped_Args { ++ ++ /* MGR Module */ ++ struct { ++ u32 uNode; ++ struct DSP_NDBPROPS __user *pNDBProps; ++ u32 uNDBPropsSize; ++ u32 __user *puNumNodes; ++ } ARGS_MGR_ENUMNODE_INFO; ++ ++ struct { ++ u32 uProcessor; ++ struct DSP_PROCESSORINFO __user *pProcessorInfo; ++ u32 uProcessorInfoSize; ++ u32 __user *puNumProcs; ++ } ARGS_MGR_ENUMPROC_INFO; ++ ++ struct { ++ struct DSP_UUID *pUuid; ++ enum DSP_DCDOBJTYPE objType; ++ char *pszPathName; ++ } ARGS_MGR_REGISTEROBJECT; ++ ++ struct { ++ struct DSP_UUID *pUuid; ++ enum DSP_DCDOBJTYPE objType; ++ } ARGS_MGR_UNREGISTEROBJECT; ++ ++ struct { ++ struct DSP_NOTIFICATION __user*__user *aNotifications; ++ u32 uCount; ++ u32 __user *puIndex; ++ u32 uTimeout; ++ } ARGS_MGR_WAIT; ++ ++ /* PROC Module */ ++ struct { ++ u32 uProcessor; ++ struct DSP_PROCESSORATTRIN __user *pAttrIn; ++ DSP_HPROCESSOR __user *phProcessor; ++ } ARGS_PROC_ATTACH; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 dwCmd; ++ struct DSP_CBDATA __user *pArgs; ++ } ARGS_PROC_CTRL; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ } ARGS_PROC_DETACH; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ DSP_HNODE __user *aNodeTab; ++ u32 uNodeTabSize; ++ u32 __user *puNumNodes; ++ u32 __user *puAllocated; ++ } ARGS_PROC_ENUMNODE_INFO; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 uResourceType; ++ struct DSP_RESOURCEINFO *pResourceInfo; ++ u32 uResourceInfoSize; ++ } ARGS_PROC_ENUMRESOURCES; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ struct DSP_PROCESSORSTATE __user *pProcStatus; ++ u32 uStateInfoSize; ++ } ARGS_PROC_GETSTATE; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u8 __user *pBuf; ++ ++ #ifndef RES_CLEANUP_DISABLE ++ u8 __user *pSize; ++ #endif ++ u32 uMaxSize; ++ } ARGS_PROC_GETTRACE; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ s32 iArgc; ++ char __user*__user *aArgv; ++ char *__user *aEnvp; ++ } ARGS_PROC_LOAD; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 uEventMask; ++ u32 uNotifyType; ++ struct DSP_NOTIFICATION __user *hNotification; ++ } ARGS_PROC_REGISTER_NOTIFY; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ } ARGS_PROC_START; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 ulSize; ++ void *__user *ppRsvAddr; ++ } ARGS_PROC_RSVMEM; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 ulSize; ++ void *pRsvAddr; ++ } ARGS_PROC_UNRSVMEM; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ void *pMpuAddr; ++ u32 ulSize; ++ void *pReqAddr; ++ void *__user *ppMapAddr; ++ u32 ulMapAttr; ++ } ARGS_PROC_MAPMEM; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ u32 ulSize; ++ void *pMapAddr; ++ } ARGS_PROC_UNMAPMEM; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ void *pMpuAddr; ++ u32 ulSize; ++ u32 ulFlags; ++ } ARGS_PROC_FLUSHMEMORY; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ } ARGS_PROC_STOP; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ void *pMpuAddr; ++ u32 ulSize; ++ } ARGS_PROC_INVALIDATEMEMORY; ++ ++ ++ /* NODE Module */ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ struct DSP_UUID __user *pNodeID; ++ struct DSP_CBDATA __user *pArgs; ++ struct DSP_NODEATTRIN __user *pAttrIn; ++ DSP_HNODE __user *phNode; ++ } ARGS_NODE_ALLOCATE; ++ ++ struct { ++ DSP_HNODE hNode; ++ u32 uSize; ++ struct DSP_BUFFERATTR __user *pAttr; ++ u8 *__user *pBuffer; ++ } ARGS_NODE_ALLOCMSGBUF; ++ ++ struct { ++ DSP_HNODE hNode; ++ s32 iPriority; ++ } ARGS_NODE_CHANGEPRIORITY; ++ ++ struct { ++ DSP_HNODE hNode; ++ u32 uStream; ++ DSP_HNODE hOtherNode; ++ u32 uOtherStream; ++ struct DSP_STRMATTR __user *pAttrs; ++ struct DSP_CBDATA __user *pConnParam; ++ } ARGS_NODE_CONNECT; ++ ++ struct { ++ DSP_HNODE hNode; ++ } ARGS_NODE_CREATE; ++ ++ struct { ++ DSP_HNODE hNode; ++ } ARGS_NODE_DELETE; ++ ++ struct { ++ DSP_HNODE hNode; ++ struct DSP_BUFFERATTR __user *pAttr; ++ u8 *pBuffer; ++ } ARGS_NODE_FREEMSGBUF; ++ ++ struct { ++ DSP_HNODE hNode; ++ struct DSP_NODEATTR __user *pAttr; ++ u32 uAttrSize; ++ } ARGS_NODE_GETATTR; ++ ++ struct { ++ DSP_HNODE hNode; ++ struct DSP_MSG __user *pMessage; ++ u32 uTimeout; ++ } ARGS_NODE_GETMESSAGE; ++ ++ struct { ++ DSP_HNODE hNode; ++ } ARGS_NODE_PAUSE; ++ ++ struct { ++ DSP_HNODE hNode; ++ struct DSP_MSG __user *pMessage; ++ u32 uTimeout; ++ } ARGS_NODE_PUTMESSAGE; ++ ++ struct { ++ DSP_HNODE hNode; ++ u32 uEventMask; ++ u32 uNotifyType; ++ struct DSP_NOTIFICATION __user *hNotification; ++ } ARGS_NODE_REGISTERNOTIFY; ++ ++ struct { ++ DSP_HNODE hNode; ++ } ARGS_NODE_RUN; ++ ++ struct { ++ DSP_HNODE hNode; ++ DSP_STATUS __user *pStatus; ++ } ARGS_NODE_TERMINATE; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ struct DSP_UUID __user *pNodeID; ++ struct DSP_NDBPROPS __user *pNodeProps; ++ } ARGS_NODE_GETUUIDPROPS; ++ ++ /* STRM module */ ++ ++ struct { ++ DSP_HSTREAM hStream; ++ u32 uSize; ++ u8 *__user *apBuffer; ++ u32 uNumBufs; ++ } ARGS_STRM_ALLOCATEBUFFER; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ } ARGS_STRM_CLOSE; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ u8 *__user *apBuffer; ++ u32 uNumBufs; ++ } ARGS_STRM_FREEBUFFER; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ HANDLE *phEvent; ++ } ARGS_STRM_GETEVENTHANDLE; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ struct STRM_INFO __user *pStreamInfo; ++ u32 uStreamInfoSize; ++ } ARGS_STRM_GETINFO; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ bool bFlush; ++ } ARGS_STRM_IDLE; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ u8 *pBuffer; ++ u32 dwBytes; ++ u32 dwBufSize; ++ u32 dwArg; ++ } ARGS_STRM_ISSUE; ++ ++ struct { ++ DSP_HNODE hNode; ++ u32 uDirection; ++ u32 uIndex; ++ struct STRM_ATTR __user *pAttrIn; ++ DSP_HSTREAM __user *phStream; ++ } ARGS_STRM_OPEN; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ u8 *__user *pBufPtr; ++ u32 __user *pBytes; ++ u32 __user *pBufSize; ++ u32 __user *pdwArg; ++ } ARGS_STRM_RECLAIM; ++ ++ struct { ++ DSP_HSTREAM hStream; ++ u32 uEventMask; ++ u32 uNotifyType; ++ struct DSP_NOTIFICATION __user *hNotification; ++ } ARGS_STRM_REGISTERNOTIFY; ++ ++ struct { ++ DSP_HSTREAM __user *aStreamTab; ++ u32 nStreams; ++ u32 __user *pMask; ++ u32 uTimeout; ++ } ARGS_STRM_SELECT; ++ ++ /* CMM Module */ ++ struct { ++ struct CMM_OBJECT *hCmmMgr; ++ u32 uSize; ++ struct CMM_ATTRS *pAttrs; ++ OUT void **ppBufVA; ++ } ARGS_CMM_ALLOCBUF; ++ ++ struct { ++ struct CMM_OBJECT *hCmmMgr; ++ void *pBufPA; ++ u32 ulSegId; ++ } ARGS_CMM_FREEBUF; ++ ++ struct { ++ DSP_HPROCESSOR hProcessor; ++ struct CMM_OBJECT *__user *phCmmMgr; ++ } ARGS_CMM_GETHANDLE; ++ ++ struct { ++ struct CMM_OBJECT *hCmmMgr; ++ struct CMM_INFO __user *pCmmInfo; ++ } ARGS_CMM_GETINFO; ++ ++ /* MEM Module */ ++ struct { ++ u32 cBytes; ++ enum MEM_POOLATTRS type; ++ void *pMem; ++ } ARGS_MEM_ALLOC; ++ ++ struct { ++ u32 cBytes; ++ enum MEM_POOLATTRS type; ++ void *pMem; ++ } ARGS_MEM_CALLOC; ++ ++ struct { ++ void *pMem; ++ } ARGS_MEM_FREE; ++ ++ struct { ++ void *pBuffer; ++ u32 cSize; ++ void *pLockedBuffer; ++ } ARGS_MEM_PAGELOCK; ++ ++ struct { ++ void *pBuffer; ++ u32 cSize; ++ } ARGS_MEM_PAGEUNLOCK; ++ ++ /* UTIL module */ ++ struct { ++ s32 cArgc; ++ char **ppArgv; ++ } ARGS_UTIL_TESTDLL; ++} ; ++ ++#define CMD_BASE 1 ++ ++/* MGR module offsets */ ++#define CMD_MGR_BASE_OFFSET CMD_BASE ++#define CMD_MGR_ENUMNODE_INFO_OFFSET (CMD_MGR_BASE_OFFSET + 0) ++#define CMD_MGR_ENUMPROC_INFO_OFFSET (CMD_MGR_BASE_OFFSET + 1) ++#define CMD_MGR_REGISTEROBJECT_OFFSET (CMD_MGR_BASE_OFFSET + 2) ++#define CMD_MGR_UNREGISTEROBJECT_OFFSET (CMD_MGR_BASE_OFFSET + 3) ++#define CMD_MGR_WAIT_OFFSET (CMD_MGR_BASE_OFFSET + 4) ++ ++#ifndef RES_CLEANUP_DISABLE ++#define CMD_MGR_RESOUCES_OFFSET (CMD_MGR_BASE_OFFSET + 5) ++#define CMD_MGR_END_OFFSET CMD_MGR_RESOUCES_OFFSET ++#else ++#define CMD_MGR_END_OFFSET CMD_MGR_WAIT_OFFSET ++#endif ++ ++#define CMD_PROC_BASE_OFFSET (CMD_MGR_END_OFFSET + 1) ++#define CMD_PROC_ATTACH_OFFSET (CMD_PROC_BASE_OFFSET + 0) ++#define CMD_PROC_CTRL_OFFSET (CMD_PROC_BASE_OFFSET + 1) ++#define CMD_PROC_DETACH_OFFSET (CMD_PROC_BASE_OFFSET + 2) ++#define CMD_PROC_ENUMNODE_OFFSET (CMD_PROC_BASE_OFFSET + 3) ++#define CMD_PROC_ENUMRESOURCES_OFFSET (CMD_PROC_BASE_OFFSET + 4) ++#define CMD_PROC_GETSTATE_OFFSET (CMD_PROC_BASE_OFFSET + 5) ++#define CMD_PROC_GETTRACE_OFFSET (CMD_PROC_BASE_OFFSET + 6) ++#define CMD_PROC_LOAD_OFFSET (CMD_PROC_BASE_OFFSET + 7) ++#define CMD_PROC_REGISTERNOTIFY_OFFSET (CMD_PROC_BASE_OFFSET + 8) ++#define CMD_PROC_START_OFFSET (CMD_PROC_BASE_OFFSET + 9) ++#define CMD_PROC_RSVMEM_OFFSET (CMD_PROC_BASE_OFFSET + 10) ++#define CMD_PROC_UNRSVMEM_OFFSET (CMD_PROC_BASE_OFFSET + 11) ++#define CMD_PROC_MAPMEM_OFFSET (CMD_PROC_BASE_OFFSET + 12) ++#define CMD_PROC_UNMAPMEM_OFFSET (CMD_PROC_BASE_OFFSET + 13) ++#define CMD_PROC_FLUSHMEMORY_OFFSET (CMD_PROC_BASE_OFFSET + 14) ++#define CMD_PROC_STOP_OFFSET (CMD_PROC_BASE_OFFSET + 15) ++#define CMD_PROC_INVALIDATEMEMORY_OFFSET (CMD_PROC_BASE_OFFSET + 16) ++#define CMD_PROC_END_OFFSET CMD_PROC_INVALIDATEMEMORY_OFFSET ++ ++ ++#define CMD_NODE_BASE_OFFSET (CMD_PROC_END_OFFSET + 1) ++#define CMD_NODE_ALLOCATE_OFFSET (CMD_NODE_BASE_OFFSET + 0) ++#define CMD_NODE_ALLOCMSGBUF_OFFSET (CMD_NODE_BASE_OFFSET + 1) ++#define CMD_NODE_CHANGEPRIORITY_OFFSET (CMD_NODE_BASE_OFFSET + 2) ++#define CMD_NODE_CONNECT_OFFSET (CMD_NODE_BASE_OFFSET + 3) ++#define CMD_NODE_CREATE_OFFSET (CMD_NODE_BASE_OFFSET + 4) ++#define CMD_NODE_DELETE_OFFSET (CMD_NODE_BASE_OFFSET + 5) ++#define CMD_NODE_FREEMSGBUF_OFFSET (CMD_NODE_BASE_OFFSET + 6) ++#define CMD_NODE_GETATTR_OFFSET (CMD_NODE_BASE_OFFSET + 7) ++#define CMD_NODE_GETMESSAGE_OFFSET (CMD_NODE_BASE_OFFSET + 8) ++#define CMD_NODE_PAUSE_OFFSET (CMD_NODE_BASE_OFFSET + 9) ++#define CMD_NODE_PUTMESSAGE_OFFSET (CMD_NODE_BASE_OFFSET + 10) ++#define CMD_NODE_REGISTERNOTIFY_OFFSET (CMD_NODE_BASE_OFFSET + 11) ++#define CMD_NODE_RUN_OFFSET (CMD_NODE_BASE_OFFSET + 12) ++#define CMD_NODE_TERMINATE_OFFSET (CMD_NODE_BASE_OFFSET + 13) ++#define CMD_NODE_GETUUIDPROPS_OFFSET (CMD_NODE_BASE_OFFSET + 14) ++#define CMD_NODE_END_OFFSET CMD_NODE_GETUUIDPROPS_OFFSET ++ ++#define CMD_STRM_BASE_OFFSET (CMD_NODE_END_OFFSET + 1) ++#define CMD_STRM_ALLOCATEBUFFER_OFFSET (CMD_STRM_BASE_OFFSET + 0) ++#define CMD_STRM_CLOSE_OFFSET (CMD_STRM_BASE_OFFSET + 1) ++#define CMD_STRM_FREEBUFFER_OFFSET (CMD_STRM_BASE_OFFSET + 2) ++#define CMD_STRM_GETEVENTHANDLE_OFFSET (CMD_STRM_BASE_OFFSET + 3) ++#define CMD_STRM_GETINFO_OFFSET (CMD_STRM_BASE_OFFSET + 4) ++#define CMD_STRM_IDLE_OFFSET (CMD_STRM_BASE_OFFSET + 5) ++#define CMD_STRM_ISSUE_OFFSET (CMD_STRM_BASE_OFFSET + 6) ++#define CMD_STRM_OPEN_OFFSET (CMD_STRM_BASE_OFFSET + 7) ++#define CMD_STRM_RECLAIM_OFFSET (CMD_STRM_BASE_OFFSET + 8) ++#define CMD_STRM_REGISTERNOTIFY_OFFSET (CMD_STRM_BASE_OFFSET + 9) ++#define CMD_STRM_SELECT_OFFSET (CMD_STRM_BASE_OFFSET + 10) ++#define CMD_STRM_END_OFFSET CMD_STRM_SELECT_OFFSET ++ ++/* Communication Memory Manager (UCMM) */ ++#define CMD_CMM_BASE_OFFSET (CMD_STRM_END_OFFSET + 1) ++#define CMD_CMM_ALLOCBUF_OFFSET (CMD_CMM_BASE_OFFSET + 0) ++#define CMD_CMM_FREEBUF_OFFSET (CMD_CMM_BASE_OFFSET + 1) ++#define CMD_CMM_GETHANDLE_OFFSET (CMD_CMM_BASE_OFFSET + 2) ++#define CMD_CMM_GETINFO_OFFSET (CMD_CMM_BASE_OFFSET + 3) ++#define CMD_CMM_END_OFFSET CMD_CMM_GETINFO_OFFSET ++ ++#define CMD_BASE_END_OFFSET CMD_CMM_END_OFFSET ++#endif /* WCDIOCTL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmd.h b/arch/arm/plat-omap/include/dspbridge/wmd.h +new file mode 100644 +index 0000000..f584038 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmd.h +@@ -0,0 +1,1193 @@ ++/* ++ * wmd.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmd.h ======== ++ * Purpose: ++ * 'Bridge mini driver entry point and interface function declarations. ++ * ++ * Public Functions: ++ * WMD_DRV_Entry ++ * ++ * Notes: ++ * The 'Bridge class driver obtains it's function interface to ++ * the 'Bridge mini driver via a call to WMD_DRV_Entry(). ++ * ++ * 'Bridge Class Driver services exported to WMD's are initialized by the ++ * WCD on behalf of the WMD. ++ * ++ * WMD function DBC Requires and Ensures are also made by the WCD on ++ * behalf of the WMD, to simplify the WMD code. ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping APIs - WMD_BRD_MemMap/UnMap ++ *! 01-Mar-2004 vp Added filename argument to WMD_DRV_Entry function. ++ *! 29-Aug-2002 map Added WMD_BRD_MemWrite() ++ *! 26-Aug-2002 map Added WMD_BRD_MemCopy() ++ *! 07-Jan-2002 ag Added cBufSize to WMD_CHNL_AddIOReq(). ++ *! 05-Nov-2001 kc: Added error handling DEH functions. ++ *! 06-Dec-2000 jeh Added uEventMask to WMD_MSG_RegisterNotify(). ++ *! 17-Nov-2000 jeh Added WMD_MSG and WMD_IO definitions. ++ *! 01-Nov-2000 jeh Added more error codes to WMD_CHNL_RegisterNotify(). ++ *! 13-Oct-2000 jeh Added dwArg to WMD_CHNL_AddIOReq(), added WMD_CHNL_IDLE ++ *! and WMD_CHNL_RegisterNotify for DSPStream support. ++ *! 17-Jan-2000 rr: WMD_BRD_SETSTATE Added. ++ *! 30-Jul-1997 gp: Split wmd IOCTL space into reserved and private. ++ *! 07-Nov-1996 gp: Updated for code review. ++ *! 18-Oct-1996 gp: Added WMD_E_HARDWARE return code from WMD_BRD_Monitor. ++ *! 09-Sep-1996 gp: Subtly altered the semantics of WMD_CHNL_GetInfo(). ++ *! 02-Aug-1996 gp: Ensured on BRD_Start that interrupts to the PC are enabled. ++ *! 11-Jul-1996 gp: Added CHNL interface. Note stronger DBC_Require conditions. ++ *! 29-May-1996 gp: Removed WCD_ prefix from functions imported from WCD.LIB. ++ *! 29-May-1996 gp: Made OUT param first in WMD_DEV_Create(). ++ *! 09-May-1996 gp: Created. ++ */ ++ ++#ifndef WMD_ ++#define WMD_ ++ ++#include <dspbridge/brddefs.h> ++#include <dspbridge/cfgdefs.h> ++#include <dspbridge/chnlpriv.h> ++#include <dspbridge/dehdefs.h> ++#include <dspbridge/devdefs.h> ++#include <dspbridge/iodefs.h> ++#include <dspbridge/msgdefs.h> ++ ++/* ++ * Any IOCTLS at or above this value are reserved for standard WMD ++ * interfaces. ++ */ ++#define WMD_RESERVEDIOCTLBASE 0x8000 ++ ++/* Handle to mini-driver's private device context. */ ++ struct WMD_DEV_CONTEXT; ++ ++/*---------------------------------------------------------------------------*/ ++/* 'Bridge MINI DRIVER FUNCTION TYPES */ ++/*---------------------------------------------------------------------------*/ ++ ++/* ++ * ======== WMD_BRD_Monitor ======== ++ * Purpose: ++ * Bring the board to the BRD_IDLE (monitor) state. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device context. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_HARDWARE: A test of hardware assumptions/integrity failed. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL ++ * Ensures: ++ * DSP_SOK: Board is in BRD_IDLE state; ++ * else: Board state is indeterminate. ++ */ ++ typedef DSP_STATUS( ++ *WMD_BRD_MONITOR) (struct WMD_DEV_CONTEXT ++ *hDevContext); ++ ++/* ++ * ======== WMD_BRD_SETSTATE ======== ++ * Purpose: ++ * Sets the Mini driver state ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * ulBrdState: Board state ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * ulBrdState <= BRD_LASTSTATE. ++ * Ensures: ++ * ulBrdState <= BRD_LASTSTATE. ++ * Update the Board state to the specified state. ++ */ ++ typedef DSP_STATUS( ++ *WMD_BRD_SETSTATE) (struct WMD_DEV_CONTEXT ++ *hDevContext, u32 ulBrdState); ++ ++/* ++ * ======== WMD_BRD_Start ======== ++ * Purpose: ++ * Bring board to the BRD_RUNNING (start) state. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device context. ++ * dwDSPAddr: DSP address at which to start execution. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL ++ * Board is in monitor (BRD_IDLE) state. ++ * Ensures: ++ * DSP_SOK: Board is in BRD_RUNNING state. ++ * Interrupts to the PC are enabled. ++ * else: Board state is indeterminate. ++ */ ++ typedef DSP_STATUS(*WMD_BRD_START) (struct WMD_DEV_CONTEXT ++ *hDevContext, u32 dwDSPAddr); ++ ++/* ++ * ======== WMD_BRD_MemCopy ======== ++ * Purpose: ++ * Copy memory from one DSP address to another ++ * Parameters: ++ * pDevContext: Pointer to context handle ++ * ulDspDestAddr: DSP address to copy to ++ * ulDspSrcAddr: DSP address to copy from ++ * ulNumBytes: Number of bytes to copy ++ * ulMemType: What section of memory to copy to ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * pDevContext != NULL ++ * Ensures: ++ * DSP_SOK: Board is in BRD_RUNNING state. ++ * Interrupts to the PC are enabled. ++ * else: Board state is indeterminate. ++ */ ++ typedef DSP_STATUS(*WMD_BRD_MEMCOPY) (struct WMD_DEV_CONTEXT ++ *hDevContext, ++ u32 ulDspDestAddr, ++ u32 ulDspSrcAddr, ++ u32 ulNumBytes, u32 ulMemType); ++/* ++ * ======== WMD_BRD_MemWrite ======== ++ * Purpose: ++ * Write a block of host memory into a DSP address, into a given memory ++ * space. Unlike WMD_BRD_Write, this API does reset the DSP ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * dwDSPAddr: Address on DSP board (Destination). ++ * pHostBuf: Pointer to host buffer (Source). ++ * ulNumBytes: Number of bytes to transfer. ++ * ulMemType: Memory space on DSP to which to transfer. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * pHostBuf != NULL. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_BRD_MEMWRITE) (struct WMD_DEV_CONTEXT ++ *hDevContext, ++ IN u8 *pHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes, ++ u32 ulMemType); ++ ++/* ++ * ======== WMD_BRD_MemMap ======== ++ * Purpose: ++ * Map a MPU memory region to a DSP/IVA memory space ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * ulMpuAddr: MPU memory region start address. ++ * ulVirtAddr: DSP/IVA memory region u8 address. ++ * ulNumBytes: Number of bytes to map. ++ * mapAttrs: Mapping attributes (e.g. endianness). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_BRD_MEMMAP) (struct WMD_DEV_CONTEXT ++ *hDevContext, u32 ulMpuAddr, ++ u32 ulVirtAddr, u32 ulNumBytes, ++ u32 ulMapAttrs); ++ ++/* ++ * ======== WMD_BRD_MemUnMap ======== ++ * Purpose: ++ * UnMap an MPU memory region from DSP/IVA memory space ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * ulVirtAddr: DSP/IVA memory region u8 address. ++ * ulNumBytes: Number of bytes to unmap. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_BRD_MEMUNMAP) (struct WMD_DEV_CONTEXT ++ *hDevContext, ++ u32 ulVirtAddr, ++ u32 ulNumBytes); ++ ++/* ++ * ======== WMD_BRD_Stop ======== ++ * Purpose: ++ * Bring board to the BRD_STOPPED state. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device context. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL ++ * Ensures: ++ * DSP_SOK: Board is in BRD_STOPPED (stop) state; ++ * Interrupts to the PC are disabled. ++ * else: Board state is indeterminate. ++ */ ++ typedef DSP_STATUS(*WMD_BRD_STOP) (struct WMD_DEV_CONTEXT ++ *hDevContext); ++ ++/* ++ * ======== WMD_BRD_Status ======== ++ * Purpose: ++ * Report the current state of the board. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device context. ++ * pdwState: Ptr to BRD status variable. ++ * Returns: ++ * DSP_SOK: ++ * Requires: ++ * pdwState != NULL; ++ * hDevContext != NULL ++ * Ensures: ++ * *pdwState is one of {BRD_STOPPED, BRD_IDLE, BRD_RUNNING, BRD_UNKNOWN}; ++ */ ++ typedef DSP_STATUS(* ++ WMD_BRD_STATUS) (struct WMD_DEV_CONTEXT *hDevContext, ++ OUT BRD_STATUS * pdwState); ++ ++/* ++ * ======== WMD_BRD_Read ======== ++ * Purpose: ++ * Read a block of DSP memory, from a given memory space, into a host ++ * buffer. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * pHostBuf: Pointer to host buffer (Destination). ++ * dwDSPAddr: Address on DSP board (Source). ++ * ulNumBytes: Number of bytes to transfer. ++ * ulMemType: Memory space on DSP from which to transfer. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * pHostBuf != NULL. ++ * Ensures: ++ * Will not write more than ulNumBytes bytes into pHostBuf. ++ */ ++typedef DSP_STATUS(*WMD_BRD_READ) (struct WMD_DEV_CONTEXT *hDevContext, ++ OUT u8 *pHostBuf, ++ u32 dwDSPAddr, ++ u32 ulNumBytes, ++ u32 ulMemType); ++ ++/* ++ * ======== WMD_BRD_Write ======== ++ * Purpose: ++ * Write a block of host memory into a DSP address, into a given memory ++ * space. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * dwDSPAddr: Address on DSP board (Destination). ++ * pHostBuf: Pointer to host buffer (Source). ++ * ulNumBytes: Number of bytes to transfer. ++ * ulMemType: Memory space on DSP to which to transfer. ++ * Returns: ++ * DSP_SOK: Success. ++ * WMD_E_TIMEOUT: Timeout occured waiting for a response from hardware. ++ * DSP_EFAIL: Other, unspecified error. ++ * Requires: ++ * hDevContext != NULL; ++ * pHostBuf != NULL. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*WMD_BRD_WRITE)(struct WMD_DEV_CONTEXT *hDevContext, ++ IN u8 *pHostBuf, ++ u32 dwDSPAddr, ++ u32 ulNumBytes, ++ u32 ulMemType); ++ ++/* ++ * ======== WMD_CHNL_Create ======== ++ * Purpose: ++ * Create a channel manager object, responsible for opening new channels ++ * and closing old ones for a given 'Bridge board. ++ * Parameters: ++ * phChnlMgr: Location to store a channel manager object on output. ++ * hDevObject: Handle to a device object. ++ * pMgrAttrs: Channel manager attributes. ++ * pMgrAttrs->cChannels: Max channels ++ * pMgrAttrs->bIRQ: Channel's I/O IRQ number. ++ * pMgrAttrs->fShared: TRUE if the IRQ is shareable. ++ * pMgrAttrs->uWordSize: DSP Word size in equivalent PC bytes.. ++ * pMgrAttrs->dwSMBase: Base physical address of shared memory, if any. ++ * pMgrAttrs->uSMLength: Bytes of shared memory block. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * CHNL_E_ISR: Unable to plug ISR for given IRQ. ++ * CHNL_E_NOMEMMAP: Couldn't map physical address to a virtual one. ++ * Requires: ++ * phChnlMgr != NULL. ++ * pMgrAttrs != NULL ++ * pMgrAttrs field are all valid: ++ * 0 < cChannels <= CHNL_MAXCHANNELS. ++ * bIRQ <= 15. ++ * uWordSize > 0. ++ * IsValidHandle(hDevObject) ++ * No channel manager exists for this board. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_CREATE)(OUT struct CHNL_MGR ++ **phChnlMgr, ++ struct DEV_OBJECT ++ *hDevObject, ++ IN CONST struct ++ CHNL_MGRATTRS *pMgrAttrs); ++ ++/* ++ * ======== WMD_CHNL_Destroy ======== ++ * Purpose: ++ * Close all open channels, and destroy the channel manager. ++ * Parameters: ++ * hChnlMgr: Channel manager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: hChnlMgr was invalid. ++ * Requires: ++ * Ensures: ++ * DSP_SOK: Cancels I/O on each open channel. Closes each open channel. ++ * CHNL_Create may subsequently be called for the same device. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_DESTROY) (struct CHNL_MGR ++ *hChnlMgr); ++/* ++ * ======== WMD_DEH_Notify ======== ++ * Purpose: ++ * When notified of DSP error, take appropriate action. ++ * Parameters: ++ * hDehMgr: Handle to DEH manager object. ++ * ulEventMask: Indicate the type of exception ++ * dwErrInfo: Error information ++ * Returns: ++ * ++ * Requires: ++ * hDehMgr != NULL; ++ * ulEventMask with a valid exception ++ * Ensures: ++ */ ++ typedef void (*WMD_DEH_NOTIFY)(struct DEH_MGR *hDehMgr, ++ u32 ulEventMask, u32 dwErrInfo); ++ ++ ++/* ++ * ======== WMD_CHNL_Open ======== ++ * Purpose: ++ * Open a new half-duplex channel to the DSP board. ++ * Parameters: ++ * phChnl: Location to store a channel object handle. ++ * hChnlMgr: Handle to channel manager, as returned by CHNL_GetMgr(). ++ * uMode: One of {CHNL_MODETODSP, CHNL_MODEFROMDSP} specifies ++ * direction of data transfer. ++ * uChnlId: If CHNL_PICKFREE is specified, the channel manager will ++ * select a free channel id (default); ++ * otherwise this field specifies the id of the channel. ++ * pAttrs: Channel attributes. Attribute fields are as follows: ++ * pAttrs->uIOReqs: Specifies the maximum number of I/O requests which can ++ * be pending at any given time. All request packets are ++ * preallocated when the channel is opened. ++ * pAttrs->hEvent: This field allows the user to supply an auto reset ++ * event object for channel I/O completion notifications. ++ * It is the responsibility of the user to destroy this ++ * object AFTER closing the channel. ++ * This channel event object can be retrieved using ++ * CHNL_GetEventHandle(). ++ * pAttrs->hReserved: The kernel mode handle of this event object. ++ * ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: hChnlMgr is invalid. ++ * DSP_EMEMORY: Insufficient memory for requested resources. ++ * DSP_EINVALIDARG: Invalid number of IOReqs. ++ * CHNL_E_OUTOFSTREAMS: No free channels available. ++ * CHNL_E_BADCHANID: Channel ID is out of range. ++ * CHNL_E_CHANBUSY: Channel is in use. ++ * CHNL_E_NOIORPS: No free IO request packets available for ++ * queuing. ++ * Requires: ++ * phChnl != NULL. ++ * pAttrs != NULL. ++ * pAttrs->hEvent is a valid event handle. ++ * pAttrs->hReserved is the kernel mode handle for pAttrs->hEvent. ++ * Ensures: ++ * DSP_SOK: *phChnl is a valid channel. ++ * else: *phChnl is set to NULL if (phChnl != NULL); ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_OPEN) (OUT struct CHNL_OBJECT ++ **phChnl, ++ struct CHNL_MGR *hChnlMgr, ++ CHNL_MODE uMode, ++ u32 uChnlId, ++ CONST IN OPTIONAL struct ++ CHNL_ATTRS *pAttrs); ++ ++/* ++ * ======== WMD_CHNL_Close ======== ++ * Purpose: ++ * Ensures all pending I/O on this channel is cancelled, discards all ++ * queued I/O completion notifications, then frees the resources allocated ++ * for this channel, and makes the corresponding logical channel id ++ * available for subsequent use. ++ * Parameters: ++ * hChnl: Handle to a channel object. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * Requires: ++ * No thread must be blocked on this channel's I/O completion event. ++ * Ensures: ++ * DSP_SOK: hChnl is no longer valid. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_CLOSE) (struct CHNL_OBJECT *hChnl); ++ ++/* ++ * ======== WMD_CHNL_AddIOReq ======== ++ * Purpose: ++ * Enqueue an I/O request for data transfer on a channel to the DSP. ++ * The direction (mode) is specified in the channel object. Note the DSP ++ * address is specified for channels opened in direct I/O mode. ++ * Parameters: ++ * hChnl: Channel object handle. ++ * pHostBuf: Host buffer address source. ++ * cBytes: Number of PC bytes to transfer. A zero value indicates ++ * that this buffer is the last in the output channel. ++ * A zero value is invalid for an input channel. ++ *! cBufSize: Actual buffer size in host bytes. ++ * dwDspAddr: DSP address for transfer. (Currently ignored). ++ * dwArg: A user argument that travels with the buffer. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * DSP_EPOINTER: pHostBuf is invalid. ++ * CHNL_E_NOEOS: User cannot mark EOS on an input channel. ++ * CHNL_E_CANCELLED: I/O has been cancelled on this channel. No further ++ * I/O is allowed. ++ * CHNL_E_EOS: End of stream was already marked on a previous ++ * IORequest on this channel. No further I/O is expected. ++ * CHNL_E_BUFSIZE: Buffer submitted to this output channel is larger than ++ * the size of the physical shared memory output window. ++ * Requires: ++ * Ensures: ++ * DSP_SOK: The buffer will be transferred if the channel is ready; ++ * otherwise, will be queued for transfer when the channel becomes ++ * ready. In any case, notifications of I/O completion are ++ * asynchronous. ++ * If cBytes is 0 for an output channel, subsequent CHNL_AddIOReq's ++ * on this channel will fail with error code CHNL_E_EOS. The ++ * corresponding IOC for this I/O request will have its status flag ++ * set to CHNL_IOCSTATEOS. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_ADDIOREQ) (struct CHNL_OBJECT ++ *hChnl, ++ void *pHostBuf, ++ u32 cBytes, ++ u32 cBufSize, ++ OPTIONAL u32 dwDspAddr, ++ u32 dwArg); ++ ++/* ++ * ======== WMD_CHNL_GetIOC ======== ++ * Purpose: ++ * Dequeue an I/O completion record, which contains information about the ++ * completed I/O request. ++ * Parameters: ++ * hChnl: Channel object handle. ++ * dwTimeOut: A value of CHNL_IOCNOWAIT will simply dequeue the ++ * first available IOC. ++ * pIOC: On output, contains host buffer address, bytes ++ * transferred, and status of I/O completion. ++ * pIOC->status: See chnldefs.h. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hChnl. ++ * DSP_EPOINTER: pIOC is invalid. ++ * CHNL_E_NOIOC: CHNL_IOCNOWAIT was specified as the dwTimeOut parameter ++ * yet no I/O completions were queued. ++ * Requires: ++ * dwTimeOut == CHNL_IOCNOWAIT. ++ * Ensures: ++ * DSP_SOK: if there are any remaining IOC's queued before this call ++ * returns, the channel event object will be left in a signalled ++ * state. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_GETIOC) (struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut, ++ OUT struct CHNL_IOC *pIOC); ++ ++/* ++ * ======== WMD_CHNL_CancelIO ======== ++ * Purpose: ++ * Return all I/O requests to the client which have not yet been ++ * transferred. The channel's I/O completion object is ++ * signalled, and all the I/O requests are queued as IOC's, with the ++ * status field set to CHNL_IOCSTATCANCEL. ++ * This call is typically used in abort situations, and is a prelude to ++ * CHNL_Close(); ++ * Parameters: ++ * hChnl: Channel object handle. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * Requires: ++ * Ensures: ++ * Subsequent I/O requests to this channel will not be accepted. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_CANCELIO) (struct CHNL_OBJECT ++ *hChnl); ++ ++/* ++ * ======== WMD_CHNL_FlushIO ======== ++ * Purpose: ++ * For an output stream (to the DSP), indicates if any IO requests are in ++ * the output request queue. For input streams (from the DSP), will ++ * cancel all pending IO requests. ++ * Parameters: ++ * hChnl: Channel object handle. ++ * dwTimeOut: Timeout value for flush operation. ++ * Returns: ++ * DSP_SOK: Success; ++ * S_CHNLIOREQUEST: Returned if any IORequests are in the output queue. ++ * DSP_EHANDLE: Invalid hChnl. ++ * Requires: ++ * Ensures: ++ * DSP_SOK: No I/O requests will be pending on this channel. ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_FLUSHIO) (struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut); ++ ++/* ++ * ======== WMD_CHNL_GetInfo ======== ++ * Purpose: ++ * Retrieve information related to a channel. ++ * Parameters: ++ * hChnl: Handle to a valid channel object, or NULL. ++ * pInfo: Location to store channel info. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * DSP_EPOINTER: pInfo == NULL. ++ * Requires: ++ * Ensures: ++ * DSP_SOK: pInfo points to a filled in CHNL_INFO struct, ++ * if (pInfo != NULL). ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_GETINFO) (struct CHNL_OBJECT *hChnl, ++ OUT struct CHNL_INFO ++ *pChnlInfo); ++ ++/* ++ * ======== WMD_CHNL_GetMgrInfo ======== ++ * Purpose: ++ * Retrieve information related to the channel manager. ++ * Parameters: ++ * hChnlMgr: Handle to a valid channel manager, or NULL. ++ * uChnlID: Channel ID. ++ * pMgrInfo: Location to store channel manager info. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnlMgr. ++ * DSP_EPOINTER: pMgrInfo == NULL. ++ * CHNL_E_BADCHANID: Invalid channel ID. ++ * Requires: ++ * Ensures: ++ * DSP_SOK: pMgrInfo points to a filled in CHNL_MGRINFO ++ * struct, if (pMgrInfo != NULL). ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_GETMGRINFO) (struct CHNL_MGR ++ *hChnlMgr, ++ u32 uChnlID, ++ OUT struct CHNL_MGRINFO ++ *pMgrInfo); ++ ++/* ++ * ======== WMD_CHNL_Idle ======== ++ * Purpose: ++ * Idle a channel. If this is an input channel, or if this is an output ++ * channel and fFlush is TRUE, all currently enqueued buffers will be ++ * dequeued (data discarded for output channel). ++ * If this is an output channel and fFlush is FALSE, this function ++ * will block until all currently buffered data is output, or the timeout ++ * specified has been reached. ++ * ++ * Parameters: ++ * hChnl: Channel object handle. ++ * dwTimeOut: If output channel and fFlush is FALSE, timeout value ++ * to wait for buffers to be output. (Not used for ++ * input channel). ++ * fFlush: If output channel and fFlush is TRUE, discard any ++ * currently buffered data. If FALSE, wait for currently ++ * buffered data to be output, or timeout, whichever ++ * occurs first. fFlush is ignored for input channel. ++ * Returns: ++ * DSP_SOK: Success; ++ * DSP_EHANDLE: Invalid hChnl. ++ * CHNL_E_WAITTIMEOUT: Timeout occured before channel could be idled. ++ * Requires: ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_IDLE) (struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut, ++ bool fFlush); ++ ++/* ++ * ======== WMD_CHNL_RegisterNotify ======== ++ * Purpose: ++ * Register for notification of events on a channel. ++ * Parameters: ++ * hChnl: Channel object handle. ++ * uEventMask: Type of events to be notified about: IO completion ++ * (DSP_STREAMIOCOMPLETION) or end of stream ++ * (DSP_STREAMDONE). ++ * uNotifyType: DSP_SIGNALEVENT. ++ * hNotification: Handle of a DSP_NOTIFICATION object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory. ++ * DSP_EVALUE: uEventMask is 0 and hNotification was not ++ * previously registered. ++ * DSP_EHANDLE: NULL hNotification, hNotification event name ++ * too long, or hNotification event name NULL. ++ * Requires: ++ * Valid hChnl. ++ * hNotification != NULL. ++ * (uEventMask & ~(DSP_STREAMIOCOMPLETION | DSP_STREAMDONE)) == 0. ++ * uNotifyType == DSP_SIGNALEVENT. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_CHNL_REGISTERNOTIFY) ++ (struct CHNL_OBJECT *hChnl, ++ u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification); ++ ++/* ++ * ======== WMD_DEV_Create ======== ++ * Purpose: ++ * Complete creation of the device object for this board. ++ * Parameters: ++ * phDevContext: Ptr to location to store a WMD device context. ++ * hDevObject: Handle to a Device Object, created and managed by WCD. ++ * pConfig: Ptr to configuration parameters provided by the Windows ++ * Configuration Manager during device loading. ++ * pDspConfig: DSP resources, as specified in the registry key for this ++ * device. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Unable to allocate memory for device context. ++ * WMD_E_BADCONFIG: One or more of the host or DSP configuration ++ * parameters did not satisfy hardware assumptions ++ * made by this WMD. ++ * Requires: ++ * phDevContext != NULL; ++ * hDevObject != NULL; ++ * pConfig != NULL; ++ * pDspConfig != NULL; ++ * Fields in pConfig and pDspConfig contain valid values. ++ * Ensures: ++ * DSP_SOK: All mini-driver specific DSP resource and other ++ * board context has been allocated. ++ * DSP_EMEMORY: WMD failed to allocate resources. ++ * Any acquired resources have been freed. The WCD will ++ * not call WMD_DEV_Destroy() if WMD_DEV_Create() fails. ++ * Details: ++ * Called during the CONFIGMG's Device_Init phase. Based on host and ++ * DSP configuration information, create a board context, a handle to ++ * which is passed into other WMD BRD and CHNL functions. The ++ * board context contains state information for the device. Since the ++ * addresses of all IN pointer parameters may be invalid when this ++ * function returns, they must not be stored into the device context ++ * structure. ++ */ ++ typedef DSP_STATUS(*WMD_DEV_CREATE) (OUT struct WMD_DEV_CONTEXT ++ **phDevContext, ++ struct DEV_OBJECT ++ *hDevObject, ++ IN CONST struct CFG_HOSTRES ++ *pConfig, ++ IN CONST struct CFG_DSPRES ++ *pDspConfig); ++ ++/* ++ * ======== WMD_DEV_Ctrl ======== ++ * Purpose: ++ * Mini-driver specific interface. ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device info. ++ * dwCmd: WMD defined command code. ++ * pArgs: Pointer to an arbitrary argument structure. ++ * Returns: ++ * DSP_SOK or DSP_EFAIL. Actual command error codes should be passed back ++ * in the pArgs structure, and are defined by the WMD implementor. ++ * Requires: ++ * All calls are currently assumed to be synchronous. There are no ++ * IOCTL completion routines provided. ++ * Ensures: ++ */ ++typedef DSP_STATUS(*WMD_DEV_CTRL)(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwCmd, ++ IN OUT void *pArgs); ++ ++/* ++ * ======== WMD_DEV_Destroy ======== ++ * Purpose: ++ * Deallocate WMD device extension structures and all other resources ++ * acquired by the mini-driver. ++ * No calls to other mini driver functions may subsequently ++ * occur, except for WMD_DEV_Create(). ++ * Parameters: ++ * hDevContext: Handle to mini-driver defined device information. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Failed to release a resource previously acquired. ++ * Requires: ++ * hDevContext != NULL; ++ * Ensures: ++ * DSP_SOK: Device context is freed. ++ */ ++ typedef DSP_STATUS(*WMD_DEV_DESTROY) (struct WMD_DEV_CONTEXT ++ *hDevContext); ++ ++/* ++ * ======== WMD_DEH_Create ======== ++ * Purpose: ++ * Create an object that manages DSP exceptions from the GPP. ++ * Parameters: ++ * phDehMgr: Location to store DEH manager on output. ++ * hDevObject: Handle to DEV object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EFAIL: Creation failed. ++ * Requires: ++ * hDevObject != NULL; ++ * phDehMgr != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_DEH_CREATE) (OUT struct DEH_MGR ++ **phDehMgr, ++ struct DEV_OBJECT ++ *hDevObject); ++ ++/* ++ * ======== WMD_DEH_Destroy ======== ++ * Purpose: ++ * Destroy the DEH object. ++ * Parameters: ++ * hDehMgr: Handle to DEH manager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Destroy failed. ++ * Requires: ++ * hDehMgr != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_DEH_DESTROY) (struct DEH_MGR *hDehMgr); ++ ++/* ++ * ======== WMD_DEH_RegisterNotify ======== ++ * Purpose: ++ * Register for DEH event notification. ++ * Parameters: ++ * hDehMgr: Handle to DEH manager object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Destroy failed. ++ * Requires: ++ * hDehMgr != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_DEH_REGISTERNOTIFY) ++ (struct DEH_MGR *hDehMgr, ++ u32 uEventMask, u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification); ++ ++/* ++ * ======== WMD_DEH_GetInfo ======== ++ * Purpose: ++ * Get DSP exception info. ++ * Parameters: ++ * phDehMgr: Location to store DEH manager on output. ++ * pErrInfo: Ptr to error info structure. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Creation failed. ++ * Requires: ++ * phDehMgr != NULL; ++ * pErrorInfo != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_DEH_GETINFO) (struct DEH_MGR *phDehMgr, ++ struct DSP_ERRORINFO *pErrInfo); ++ ++/* ++ * ======== WMD_IO_Create ======== ++ * Purpose: ++ * Create an object that manages I/O between CHNL and MSG. ++ * Parameters: ++ * phIOMgr: Location to store IO manager on output. ++ * hChnlMgr: Handle to channel manager. ++ * hMsgMgr: Handle to message manager. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EFAIL: Creation failed. ++ * Requires: ++ * hDevObject != NULL; ++ * Channel manager already created; ++ * Message manager already created; ++ * pMgrAttrs != NULL; ++ * phIOMgr != NULL; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_IO_CREATE) (OUT struct IO_MGR **phIOMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct IO_ATTRS *pMgrAttrs); ++ ++/* ++ * ======== WMD_IO_Destroy ======== ++ * Purpose: ++ * Destroy object created in WMD_IO_Create. ++ * Parameters: ++ * hIOMgr: IO Manager. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Memory allocation failure. ++ * DSP_EFAIL: Creation failed. ++ * Requires: ++ * Valid hIOMgr; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_IO_DESTROY) (struct IO_MGR *hIOMgr); ++ ++/* ++ * ======== WMD_IO_OnLoaded ======== ++ * Purpose: ++ * Called whenever a program is loaded to update internal data. For ++ * example, if shared memory is used, this function would update the ++ * shared memory location and address. ++ * Parameters: ++ * hIOMgr: IO Manager. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Internal failure occurred. ++ * Requires: ++ * Valid hIOMgr; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_IO_ONLOADED) (struct IO_MGR *hIOMgr); ++ ++/* ++ * ======== WMD_IO_GETPROCLOAD ======== ++ * Purpose: ++ * Called to get the Processor's current and predicted load ++ * Parameters: ++ * hIOMgr: IO Manager. ++ * pProcLoadStat Processor Load statistics ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EFAIL: Internal failure occurred. ++ * Requires: ++ * Valid hIOMgr; ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_IO_GETPROCLOAD)(struct IO_MGR *hIOMgr, ++ struct DSP_PROCLOADSTAT *pProcLoadStat); ++ ++/* ++ * ======== WMD_MSG_Create ======== ++ * Purpose: ++ * Create an object to manage message queues. Only one of these objects ++ * can exist per device object. ++ * Parameters: ++ * phMsgMgr: Location to store MSG manager on output. ++ * hDevObject: Handle to a device object. ++ * msgCallback: Called whenever an RMS_EXIT message is received. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory. ++ * Requires: ++ * phMsgMgr != NULL. ++ * msgCallback != NULL. ++ * hDevObject != NULL. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_MSG_CREATE) ++ (OUT struct MSG_MGR **phMsgMgr, ++ struct DEV_OBJECT *hDevObject, ++ MSG_ONEXIT msgCallback); ++ ++/* ++ * ======== WMD_MSG_CreateQueue ======== ++ * Purpose: ++ * Create a MSG queue for sending or receiving messages from a Message ++ * node on the DSP. ++ * Parameters: ++ * hMsgMgr: MSG queue manager handle returned from ++ * WMD_MSG_Create. ++ * phMsgQueue: Location to store MSG queue on output. ++ * dwId: Identifier for messages (node environment pointer). ++ * uMaxMsgs: Max number of simultaneous messages for the node. ++ * h: Handle passed to hMsgMgr->msgCallback(). ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory. ++ * Requires: ++ * phMsgQueue != NULL. ++ * h != NULL. ++ * uMaxMsgs > 0. ++ * Ensures: ++ * phMsgQueue !=NULL <==> DSP_SOK. ++ */ ++ typedef DSP_STATUS(*WMD_MSG_CREATEQUEUE) ++ (struct MSG_MGR *hMsgMgr, ++ OUT struct MSG_QUEUE **phMsgQueue, ++ u32 dwId, u32 uMaxMsgs, HANDLE h); ++ ++/* ++ * ======== WMD_MSG_Delete ======== ++ * Purpose: ++ * Delete a MSG manager allocated in WMD_MSG_Create(). ++ * Parameters: ++ * hMsgMgr: Handle returned from WMD_MSG_Create(). ++ * Returns: ++ * Requires: ++ * Valid hMsgMgr. ++ * Ensures: ++ */ ++ typedef void(*WMD_MSG_DELETE) (struct MSG_MGR *hMsgMgr); ++ ++/* ++ * ======== WMD_MSG_DeleteQueue ======== ++ * Purpose: ++ * Delete a MSG queue allocated in WMD_MSG_CreateQueue. ++ * Parameters: ++ * hMsgQueue: Handle to MSG queue returned from ++ * WMD_MSG_CreateQueue. ++ * Returns: ++ * Requires: ++ * Valid hMsgQueue. ++ * Ensures: ++ */ ++ typedef void(*WMD_MSG_DELETEQUEUE) (struct MSG_QUEUE *hMsgQueue); ++ ++/* ++ * ======== WMD_MSG_Get ======== ++ * Purpose: ++ * Get a message from a MSG queue. ++ * Parameters: ++ * hMsgQueue: Handle to MSG queue returned from ++ * WMD_MSG_CreateQueue. ++ * pMsg: Location to copy message into. ++ * uTimeout: Timeout to wait for a message. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETIMEOUT: Timeout occurred. ++ * DSP_EFAIL: No frames available for message (uMaxMessages too ++ * small). ++ * Requires: ++ * Valid hMsgQueue. ++ * pMsg != NULL. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_MSG_GET) (struct MSG_QUEUE *hMsgQueue, ++ struct DSP_MSG *pMsg, ++ u32 uTimeout); ++ ++/* ++ * ======== WMD_MSG_Put ======== ++ * Purpose: ++ * Put a message onto a MSG queue. ++ * Parameters: ++ * hMsgQueue: Handle to MSG queue returned from ++ * WMD_MSG_CreateQueue. ++ * pMsg: Pointer to message. ++ * uTimeout: Timeout to wait for a message. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_ETIMEOUT: Timeout occurred. ++ * DSP_EFAIL: No frames available for message (uMaxMessages too ++ * small). ++ * Requires: ++ * Valid hMsgQueue. ++ * pMsg != NULL. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_MSG_PUT) (struct MSG_QUEUE *hMsgQueue, ++ IN CONST struct DSP_MSG *pMsg, ++ u32 uTimeout); ++ ++/* ++ * ======== WMD_MSG_RegisterNotify ======== ++ * Purpose: ++ * Register notification for when a message is ready. ++ * Parameters: ++ * hMsgQueue: Handle to MSG queue returned from ++ * WMD_MSG_CreateQueue. ++ * uEventMask: Type of events to be notified about: Must be ++ * DSP_NODEMESSAGEREADY, or 0 to unregister. ++ * uNotifyType: DSP_SIGNALEVENT. ++ * hNotification: Handle of notification object. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Insufficient memory. ++ * Requires: ++ * Valid hMsgQueue. ++ * hNotification != NULL. ++ * uNotifyType == DSP_SIGNALEVENT. ++ * uEventMask == DSP_NODEMESSAGEREADY || uEventMask == 0. ++ * Ensures: ++ */ ++ typedef DSP_STATUS(*WMD_MSG_REGISTERNOTIFY) ++ (struct MSG_QUEUE *hMsgQueue, ++ u32 uEventMask, u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification); ++ ++/* ++ * ======== WMD_MSG_SetQueueId ======== ++ * Purpose: ++ * Set message queue id to node environment. Allows WMD_MSG_CreateQueue ++ * to be called in NODE_Allocate, before the node environment is known. ++ * Parameters: ++ * hMsgQueue: Handle to MSG queue returned from ++ * WMD_MSG_CreateQueue. ++ * dwId: Node environment pointer. ++ * Returns: ++ * Requires: ++ * Valid hMsgQueue. ++ * dwId != 0. ++ * Ensures: ++ */ ++ typedef void(*WMD_MSG_SETQUEUEID) (struct MSG_QUEUE *hMsgQueue, ++ u32 dwId); ++ ++/* ++ * 'Bridge Mini Driver (WMD) interface function table. ++ * ++ * The information in this table is filled in by the specific mini-driver, ++ * and copied into the 'Bridge class driver's own space. If any interface ++ * function field is set to a value of NULL, then the class driver will ++ * consider that function not implemented, and return the error code ++ * DSP_ENOTIMPL when a WMD client attempts to call that function. ++ * ++ * This function table contains WCD version numbers, which are used by the ++ * WMD loader to help ensure backwards compatility between older WMD's and a ++ * newer 'Bridge Class Driver. These must be set to WCD_MAJOR_VERSION ++ * and WCD_MINOR_VERSION, respectively. ++ * ++ * A mini-driver need not export a CHNL interface. In this case, *all* of ++ * the WMD_CHNL_* entries must be set to NULL. ++ */ ++ struct WMD_DRV_INTERFACE { ++ u32 dwWCDMajorVersion; /* Set to WCD_MAJOR_VERSION. */ ++ u32 dwWCDMinorVersion; /* Set to WCD_MINOR_VERSION. */ ++ WMD_DEV_CREATE pfnDevCreate; /* Create device context */ ++ WMD_DEV_DESTROY pfnDevDestroy; /* Destroy device context */ ++ WMD_DEV_CTRL pfnDevCntrl; /* Optional vendor interface */ ++ WMD_BRD_MONITOR pfnBrdMonitor; /* Load and/or start monitor */ ++ WMD_BRD_START pfnBrdStart; /* Start DSP program. */ ++ WMD_BRD_STOP pfnBrdStop; /* Stop/reset board. */ ++ WMD_BRD_STATUS pfnBrdStatus; /* Get current board status. */ ++ WMD_BRD_READ pfnBrdRead; /* Read board memory */ ++ WMD_BRD_WRITE pfnBrdWrite; /* Write board memory. */ ++ WMD_BRD_SETSTATE pfnBrdSetState; /* Sets the Board State */ ++ WMD_BRD_MEMCOPY pfnBrdMemCopy; /* Copies DSP Memory */ ++ WMD_BRD_MEMWRITE pfnBrdMemWrite; /* Write DSP Memory w/o halt */ ++ WMD_BRD_MEMMAP pfnBrdMemMap; /* Maps MPU mem to DSP mem */ ++ WMD_BRD_MEMUNMAP pfnBrdMemUnMap; /* Unmaps MPU mem to DSP mem */ ++ WMD_CHNL_CREATE pfnChnlCreate; /* Create channel manager. */ ++ WMD_CHNL_DESTROY pfnChnlDestroy; /* Destroy channel manager. */ ++ WMD_CHNL_OPEN pfnChnlOpen; /* Create a new channel. */ ++ WMD_CHNL_CLOSE pfnChnlClose; /* Close a channel. */ ++ WMD_CHNL_ADDIOREQ pfnChnlAddIOReq; /* Req I/O on a channel. */ ++ WMD_CHNL_GETIOC pfnChnlGetIOC; /* Wait for I/O completion. */ ++ WMD_CHNL_CANCELIO pfnChnlCancelIO; /* Cancl I/O on a channel. */ ++ WMD_CHNL_FLUSHIO pfnChnlFlushIO; /* Flush I/O. */ ++ WMD_CHNL_GETINFO pfnChnlGetInfo; /* Get channel specific info */ ++ /* Get channel manager info. */ ++ WMD_CHNL_GETMGRINFO pfnChnlGetMgrInfo; ++ WMD_CHNL_IDLE pfnChnlIdle; /* Idle the channel */ ++ /* Register for notif. */ ++ WMD_CHNL_REGISTERNOTIFY pfnChnlRegisterNotify; ++ WMD_DEH_CREATE pfnDehCreate; /* Create DEH manager */ ++ WMD_DEH_DESTROY pfnDehDestroy; /* Destroy DEH manager */ ++ WMD_DEH_NOTIFY pfnDehNotify; /* Notify of DSP error */ ++ /* register for deh notif. */ ++ WMD_DEH_REGISTERNOTIFY pfnDehRegisterNotify; ++ WMD_DEH_GETINFO pfnDehGetInfo; /* register for deh notif. */ ++ WMD_IO_CREATE pfnIOCreate; /* Create IO manager */ ++ WMD_IO_DESTROY pfnIODestroy; /* Destroy IO manager */ ++ WMD_IO_ONLOADED pfnIOOnLoaded; /* Notify of program loaded */ ++ /* Get Processor's current and predicted load */ ++ WMD_IO_GETPROCLOAD pfnIOGetProcLoad; ++ WMD_MSG_CREATE pfnMsgCreate; /* Create message manager */ ++ /* Create message queue */ ++ WMD_MSG_CREATEQUEUE pfnMsgCreateQueue; ++ WMD_MSG_DELETE pfnMsgDelete; /* Delete message manager */ ++ /* Delete message queue */ ++ WMD_MSG_DELETEQUEUE pfnMsgDeleteQueue; ++ WMD_MSG_GET pfnMsgGet; /* Get a message */ ++ WMD_MSG_PUT pfnMsgPut; /* Send a message */ ++ /* Register for notif. */ ++ WMD_MSG_REGISTERNOTIFY pfnMsgRegisterNotify; ++ /* Set message queue id */ ++ WMD_MSG_SETQUEUEID pfnMsgSetQueueId; ++ } ; ++ ++/* ++ * ======== WMD_DRV_Entry ======== ++ * Purpose: ++ * Registers WMD functions with the class driver. Called only once ++ * by the WCD. The caller will first check WCD version compatibility, and ++ * then copy the interface functions into its own memory space. ++ * Parameters: ++ * ppDrvInterface Pointer to a location to receive a pointer to the ++ * mini driver interface. ++ * Returns: ++ * Requires: ++ * The code segment this function resides in must expect to be discarded ++ * after completion. ++ * Ensures: ++ * ppDrvInterface pointer initialized to WMD's function interface. ++ * No system resources are acquired by this function. ++ * Details: ++ * Win95: Called during the Device_Init phase. ++ */ ++ void WMD_DRV_Entry(OUT struct WMD_DRV_INTERFACE **ppDrvInterface, ++ IN CONST char *pstrWMDFileName); ++ ++#endif /* WMD_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmdchnl.h b/arch/arm/plat-omap/include/dspbridge/wmdchnl.h +new file mode 100644 +index 0000000..2c1f072 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmdchnl.h +@@ -0,0 +1,90 @@ ++/* ++ * wmdchnl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmdchnl.h ======== ++ * Description: ++ * Declares the upper edge channel class library functions required by ++ * all WMD / WCD driver interface tables. These functions are implemented ++ * by every class of WMD channel library. ++ * ++ * Public Functions: ++ * ++ * Notes: ++ * The function comment headers reside with the function typedefs in wmd.h. ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Jan-2002 ag Added cBufSize to WMD_CHNL_AddIOReq(). ++ *! 13-Oct-2000 jeh Added dwArg parameter to WMD_CHNL_AddIOReq(), added ++ *! WMD_CHNL_Idle and WMD_CHNL_RegisterNotify for DSPStream ++ *! support. ++ *! 11-Jul-1996 gp: Created. ++ */ ++ ++#ifndef WMDCHNL_ ++#define WMDCHNL_ ++ ++ extern DSP_STATUS WMD_CHNL_Create(OUT struct CHNL_MGR **phChnlMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CHNL_MGRATTRS ++ *pMgrAttrs); ++ ++ extern DSP_STATUS WMD_CHNL_Destroy(struct CHNL_MGR *hChnlMgr); ++ ++ extern DSP_STATUS WMD_CHNL_Open(OUT struct CHNL_OBJECT **phChnl, ++ struct CHNL_MGR *hChnlMgr, ++ CHNL_MODE uMode, ++ u32 uChnlId, ++ CONST IN OPTIONAL struct CHNL_ATTRS ++ *pAttrs); ++ ++ extern DSP_STATUS WMD_CHNL_Close(struct CHNL_OBJECT *hChnl); ++ ++ extern DSP_STATUS WMD_CHNL_AddIOReq(struct CHNL_OBJECT *hChnl, ++ void *pHostBuf, ++ u32 cBytes, u32 cBufSize, ++ OPTIONAL u32 dwDspAddr, ++ u32 dwArg); ++ ++ extern DSP_STATUS WMD_CHNL_GetIOC(struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut, ++ OUT struct CHNL_IOC *pIOC); ++ ++ extern DSP_STATUS WMD_CHNL_CancelIO(struct CHNL_OBJECT *hChnl); ++ ++ extern DSP_STATUS WMD_CHNL_FlushIO(struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut); ++ ++ extern DSP_STATUS WMD_CHNL_GetInfo(struct CHNL_OBJECT *hChnl, ++ OUT struct CHNL_INFO *pInfo); ++ ++ extern DSP_STATUS WMD_CHNL_GetMgrInfo(struct CHNL_MGR *hChnlMgr, ++ u32 uChnlID, ++ OUT struct CHNL_MGRINFO ++ *pMgrInfo); ++ ++ extern DSP_STATUS WMD_CHNL_Idle(struct CHNL_OBJECT *hChnl, ++ u32 dwTimeOut, bool fFlush); ++ ++ extern DSP_STATUS WMD_CHNL_RegisterNotify(struct CHNL_OBJECT *hChnl, ++ u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++#endif /* WMDCHNL_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmddeh.h b/arch/arm/plat-omap/include/dspbridge/wmddeh.h +new file mode 100644 +index 0000000..dd50a3a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmddeh.h +@@ -0,0 +1,64 @@ ++/* ++ * wmddeh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmddeh.h ======== ++ * Description: ++ * Defines upper edge DEH functions required by all WMD/WCD driver ++ * interface tables. ++ * ++ * Public Functions: ++ * WMD_DEH_Create ++ * IVA_DEH_Create ++ * WMD_DEH_Destroy ++ * WMD_DEH_GetInfo ++ * WMD_DEH_RegisterNotify ++ * WMD_DEH_Notify ++ * ++ * Notes: ++ * Function comment headers reside with the function typedefs in wmd.h. ++ * ++ *! Revision History: ++ *! ================ ++ *! 26-Dec-2004 hn: added IVA_DEH_Create. ++ *! 13-Sep-2001 kc: created. ++ */ ++ ++#ifndef WMDDEH_ ++#define WMDDEH_ ++ ++#include <dspbridge/devdefs.h> ++ ++#include <dspbridge/dehdefs.h> ++ ++ extern DSP_STATUS WMD_DEH_Create(OUT struct DEH_MGR **phDehMgr, ++ struct DEV_OBJECT *hDevObject); ++ ++ extern DSP_STATUS WMD_DEH_Destroy(struct DEH_MGR *hDehMgr); ++ ++ extern DSP_STATUS WMD_DEH_GetInfo(struct DEH_MGR *hDehMgr, ++ struct DSP_ERRORINFO *pErrInfo); ++ ++ extern DSP_STATUS WMD_DEH_RegisterNotify(struct DEH_MGR *hDehMgr, ++ u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++ extern void WMD_DEH_Notify(struct DEH_MGR *hDehMgr, ++ u32 ulEventMask, u32 dwErrInfo); ++#endif /* WMDDEH_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmdio.h b/arch/arm/plat-omap/include/dspbridge/wmdio.h +new file mode 100644 +index 0000000..8525474 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmdio.h +@@ -0,0 +1,53 @@ ++/* ++ * wmdio.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmdio.h ======== ++ * Description: ++ * Declares the upper edge IO functions required by ++ * all WMD / WCD driver interface tables. ++ * ++ * Public Functions: ++ * ++ * Notes: ++ * Function comment headers reside with the function typedefs in wmd.h. ++ * ++ *! Revision History: ++ *! ================ ++ *! 27-Feb-2004 vp Added IVA releated function. ++ *! 06-Nov-2000 jeh Created. ++ */ ++ ++#ifndef WMDIO_ ++#define WMDIO_ ++ ++#include <dspbridge/devdefs.h> ++#include <dspbridge/iodefs.h> ++ ++ extern DSP_STATUS WMD_IO_Create(OUT struct IO_MGR **phIOMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct IO_ATTRS *pMgrAttrs); ++ ++ extern DSP_STATUS WMD_IO_Destroy(struct IO_MGR *hIOMgr); ++ ++ extern DSP_STATUS WMD_IO_OnLoaded(struct IO_MGR *hIOMgr); ++ ++ extern DSP_STATUS IVA_IO_OnLoaded(struct IO_MGR *hIOMgr); ++ extern DSP_STATUS WMD_IO_GetProcLoad(IN struct IO_MGR *hIOMgr, ++ OUT struct DSP_PROCLOADSTAT *pProcStat); ++ ++#endif /* WMDIO_ */ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmdioctl.h b/arch/arm/plat-omap/include/dspbridge/wmdioctl.h +new file mode 100644 +index 0000000..a41c61a +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmdioctl.h +@@ -0,0 +1,91 @@ ++/* ++ * wmdioctl.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmdioctl.h ======== ++ * Description: ++ * BRIDGE Minidriver BRD_IOCtl reserved command definitions. ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Apr-2004 sb Updated HW typedefs ++ *! 16-Feb-2004 vp Added MMU endianness attributes to WMDIOCTL_EXTPROC ++ *! 21-Mar-2003 sb Changed WMDIOCTL_NUMOFMMUTLB from 7 to 32 ++ *! 14-May-2001 sg Added codes for PWR. ++ *! 10-Aug-2001 ag Added _SETMMUCONFIG ioctl used for DSP-MMU init. ++ *! 16-Nov-1999 rajesh ? ++ *! 18-Jun-1998 ag Moved EMIF, SDRAM_C, & CE space init to ENBLEXTMEM ioctl. ++ *! Added ENBLEXTMEM, RESETDSP, UNRESETDSP & ASSERTSIG ioctls. ++ *! 07-Jun-1998 ag Added JTAG_SELECT, MAP_TBC, GET_CONFIGURATION ioctls. ++ *! 26-Jan-1998 jeh: Added START, RECV, and SEND ioctls. ++ *! 07-Nov-1997 nn: Added command to interrupt DSP for interrupt test. ++ *! 20-Oct-1997 nn: Added commands for getting and resetting interrupt count. ++ *! 17-Oct-1997 gp: Moved to src/wmd. Standardized prefix. ++ *! 08-Oct-1997 nn: Created. ++ */ ++ ++#ifndef WMDIOCTL_ ++#define WMDIOCTL_ ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_mmu.h> ++ ++/* Any IOCTLS at or above this value are reserved for standard WMD interfaces.*/ ++#define WMDIOCTL_RESERVEDBASE 0x8000 ++ ++#define WMDIOCTL_CHNLREAD (WMDIOCTL_RESERVEDBASE + 0x10) ++#define WMDIOCTL_CHNLWRITE (WMDIOCTL_RESERVEDBASE + 0x20) ++#define WMDIOCTL_GETINTRCOUNT (WMDIOCTL_RESERVEDBASE + 0x30) ++#define WMDIOCTL_RESETINTRCOUNT (WMDIOCTL_RESERVEDBASE + 0x40) ++#define WMDIOCTL_INTERRUPTDSP (WMDIOCTL_RESERVEDBASE + 0x50) ++#define WMDIOCTL_SETMMUCONFIG (WMDIOCTL_RESERVEDBASE + 0x60) /* DMMU */ ++#define WMDIOCTL_PWRCONTROL (WMDIOCTL_RESERVEDBASE + 0x70) /* PWR */ ++ ++/* attention, modifiers: ++ * Some of these control enumerations are made visible to user for power ++ * control, so any changes to this list, should also be updated in the user ++ * header file 'dbdefs.h' ***/ ++/* These ioctls are reserved for PWR power commands for the DSP */ ++#define WMDIOCTL_DEEPSLEEP (WMDIOCTL_PWRCONTROL + 0x0) ++#define WMDIOCTL_EMERGENCYSLEEP (WMDIOCTL_PWRCONTROL + 0x1) ++#define WMDIOCTL_WAKEUP (WMDIOCTL_PWRCONTROL + 0x2) ++#define WMDIOCTL_PWRENABLE (WMDIOCTL_PWRCONTROL + 0x3) ++#define WMDIOCTL_PWRDISABLE (WMDIOCTL_PWRCONTROL + 0x4) ++#define WMDIOCTL_CLK_CTRL (WMDIOCTL_PWRCONTROL + 0x7) ++#define WMDIOCTL_PWR_HIBERNATE (WMDIOCTL_PWRCONTROL + 0x8) /*DSP Initiated ++ * Hibernate*/ ++#define WMDIOCTL_PRESCALE_NOTIFY (WMDIOCTL_PWRCONTROL + 0x9) ++#define WMDIOCTL_POSTSCALE_NOTIFY (WMDIOCTL_PWRCONTROL + 0xA) ++#define WMDIOCTL_CONSTRAINT_REQUEST (WMDIOCTL_PWRCONTROL + 0xB) ++ ++/* Number of actual DSP-MMU TLB entrries */ ++#define WMDIOCTL_NUMOFMMUTLB 32 ++ ++struct WMDIOCTL_EXTPROC { ++ u32 ulDspVa; /* DSP virtual address */ ++ u32 ulGppPa; /* GPP physical address */ ++ /* GPP virtual address. __va does not work for ioremapped addresses */ ++ u32 ulGppVa; ++ u32 ulSize; /* Size of the mapped memory in bytes */ ++ enum HW_Endianism_t endianism; ++ enum HW_MMUMixedSize_t mixedMode; ++ enum HW_ElementSize_t elemSize; ++}; ++ ++#endif /* WMDIOCTL_ */ ++ +diff --git a/arch/arm/plat-omap/include/dspbridge/wmdmsg.h b/arch/arm/plat-omap/include/dspbridge/wmdmsg.h +new file mode 100644 +index 0000000..81198d4 +--- /dev/null ++++ b/arch/arm/plat-omap/include/dspbridge/wmdmsg.h +@@ -0,0 +1,70 @@ ++/* ++ * wmdmsg.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== wmdmsg.h ======== ++ * Description: ++ * Declares the upper edge message class library functions required by ++ * all WMD / WCD driver interface tables. These functions are ++ * implemented by every class of WMD channel library. ++ * ++ * Public Functions: ++ * ++ * Notes: ++ * Function comment headers reside with the function typedefs in wmd.h. ++ * ++ *! Revision History: ++ *! ================ ++ *! 06-Dec-2000 jeh Added uEventMask to WMD_MSG_RegisterNotify(). Added ++ *! WMD_MSG_SetQueueId(). ++ *! 17-Nov-2000 jeh Created. ++ */ ++ ++#ifndef WMDMSG_ ++#define WMDMSG_ ++ ++#include <dspbridge/msgdefs.h> ++ ++ extern DSP_STATUS WMD_MSG_Create(OUT struct MSG_MGR **phMsgMgr, ++ struct DEV_OBJECT *hDevObject, ++ MSG_ONEXIT msgCallback); ++ ++ extern DSP_STATUS WMD_MSG_CreateQueue(struct MSG_MGR *hMsgMgr, ++ OUT struct MSG_QUEUE **phMsgQueue, ++ u32 dwId, u32 uMaxMsgs, ++ HANDLE h); ++ ++ extern void WMD_MSG_Delete(struct MSG_MGR *hMsgMgr); ++ ++ extern void WMD_MSG_DeleteQueue(struct MSG_QUEUE *hMsgQueue); ++ ++ extern DSP_STATUS WMD_MSG_Get(struct MSG_QUEUE *hMsgQueue, ++ struct DSP_MSG *pMsg, u32 uTimeout); ++ ++ extern DSP_STATUS WMD_MSG_Put(struct MSG_QUEUE *hMsgQueue, ++ IN CONST struct DSP_MSG *pMsg, ++ u32 uTimeout); ++ ++ extern DSP_STATUS WMD_MSG_RegisterNotify(struct MSG_QUEUE *hMsgQueue, ++ u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION ++ *hNotification); ++ ++ extern void WMD_MSG_SetQueueId(struct MSG_QUEUE *hMsgQueue, u32 dwId); ++ ++#endif /* WMDMSG_ */ +diff --git a/drivers/Makefile b/drivers/Makefile +index fec4d8e..6fcee09 100644 +--- a/drivers/Makefile ++++ b/drivers/Makefile +@@ -42,6 +42,7 @@ obj-$(CONFIG_PARPORT) += parport/ + obj-y += base/ block/ misc/ mfd/ net/ media/ + obj-y += i2c/ + obj-y += cbus/ ++obj-$(CONFIG_MPU_BRIDGE) += dsp/bridge/ + obj-$(CONFIG_NUBUS) += nubus/ + obj-$(CONFIG_ATM) += atm/ + obj-y += macintosh/ +diff --git a/drivers/dsp/bridge/Kbuild b/drivers/dsp/bridge/Kbuild +new file mode 100644 +index 0000000..3432ff2 +--- /dev/null ++++ b/drivers/dsp/bridge/Kbuild +@@ -0,0 +1,39 @@ ++obj-$(CONFIG_MPU_BRIDGE) += bridgedriver.o ++ ++libgen = gen/gb.o gen/gt.o gen/gs.o gen/gh.o gen/_gt_para.o gen/uuidutil.o ++libservices = services/csl.o services/mem.o services/list.o services/dpc.o \ ++ services/kfile.o services/sync.o \ ++ services/clk.o services/cfg.o services/reg.o \ ++ services/regsup.o services/ntfy.o \ ++ services/dbg.o services/services.o ++libwmd = wmd/chnl_sm.o wmd/msg_sm.o wmd/io_sm.o wmd/tiomap3430.o \ ++ wmd/tiomap3430_pwr.o wmd/tiomap_sm.o wmd/tiomap_io.o \ ++ wmd/mmu_fault.o wmd/ue_deh.o ++libpmgr = pmgr/chnl.o pmgr/io.o pmgr/msg.o pmgr/cod.o pmgr/dev.o pmgr/wcd.o \ ++ pmgr/dmm.o pmgr/cmm.o pmgr/dbll.o ++librmgr = rmgr/dbdcd.o rmgr/disp.o rmgr/drv.o rmgr/mgr.o rmgr/node.o \ ++ rmgr/proc.o rmgr/pwr.o rmgr/rmm.o rmgr/strm.o rmgr/dspdrv.o \ ++ rmgr/nldr.o rmgr/drv_interface.o ++libdload = dynload/cload.o dynload/getsection.o dynload/reloc.o ++libhw = hw/hw_prcm.o hw/hw_dspssC64P.o hw/hw_mmu.o hw/hw_mbox.o ++ ++bridgedriver-objs = $(libgen) $(libservices) $(libwmd) $(libpmgr) $(librmgr) \ ++ $(libdload) $(libhw) ++ ++# Debug ++ifeq ($(CONFIG_BRIDGE_DEBUG),y) ++ccflags-y += -DGT_TRACE -DDEBUG ++endif ++ ++#Machine dependent ++ccflags-y += -D_TI_ -D_DB_TIOMAP -DTMS32060 \ ++ -DTICFG_PROC_VER -DTICFG_EVM_TYPE -DCHNL_SMCLASS \ ++ -DCHNL_MESSAGES -DUSE_LEVEL_1_MACROS ++ ++#Header files ++ccflags-y += -Idrivers/dsp/bridge/services ++ccflags-y += -Idrivers/dsp/bridge/wmd ++ccflags-y += -Idrivers/dsp/bridge/pmgr ++ccflags-y += -Idrivers/dsp/bridge/rmgr ++ccflags-y += -Idrivers/dsp/bridge/hw ++ccflags-y += -Iarch/arm +diff --git a/drivers/dsp/bridge/Kconfig b/drivers/dsp/bridge/Kconfig +new file mode 100644 +index 0000000..2fed82c +--- /dev/null ++++ b/drivers/dsp/bridge/Kconfig +@@ -0,0 +1,36 @@ ++# ++# DSP Bridge Driver Support ++# ++ ++menuconfig MPU_BRIDGE ++ tristate "DSP Bridge driver" ++ default n ++ help ++ DSP/BIOS Bridge is designed for platforms that contain a GPP and ++ one or more attached DSPs. The GPP is considered the master or ++ "host" processor, and the attached DSPs are processing resources ++ that can be utilized by applications and drivers running on the GPP. ++ ++config BRIDGE_DVFS ++ bool "Enable Bridge Dynamic Voltage and Frequency Scaling (DVFS)" ++ depends on MPU_BRIDGE && OMAP_PM_SRF ++ default n ++ help ++ DVFS allows DSP Bridge to initiate the operating point change to ++ scale the chip voltage and frequency in order to match the ++ performance and power consumption to the current processing ++ requirements. ++ ++config BRIDGE_MEMPOOL_SIZE ++ hex "Physical memory pool size (Byte)" ++ depends on MPU_BRIDGE ++ default 0x600000 ++ help ++ Allocate specified size of memory at booting time to avoid allocation ++ failure under heavy memory fragmentation after some use time. ++ ++config BRIDGE_DEBUG ++ bool "DSP Bridge Debug Support" ++ depends on MPU_BRIDGE ++ help ++ Say Y to enable Bridge debugging capabilities +diff --git a/drivers/dsp/bridge/dynload/cload.c b/drivers/dsp/bridge/dynload/cload.c +new file mode 100644 +index 0000000..271ab81 +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/cload.c +@@ -0,0 +1,1854 @@ ++/* ++ * cload.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#include "header.h" ++ ++#include "module_list.h" ++#define LINKER_MODULES_HEADER ("_" MODULES_HEADER) ++ ++/* ++ * we use the fact that DOFF section records are shaped just like ++ * LDR_SECTION_INFO to reduce our section storage usage. This macro marks ++ * the places where that assumption is made ++ */ ++#define DOFFSEC_IS_LDRSEC(pdoffsec) ((struct LDR_SECTION_INFO *)(pdoffsec)) ++ ++/* ++ * forward references ++ */ ++static void dload_symbols(struct dload_state *dlthis); ++static void dload_data(struct dload_state *dlthis); ++static void allocate_sections(struct dload_state *dlthis); ++static void string_table_free(struct dload_state *dlthis); ++static void symbol_table_free(struct dload_state *dlthis); ++static void section_table_free(struct dload_state *dlthis); ++static void init_module_handle(struct dload_state *dlthis); ++#if BITS_PER_AU > BITS_PER_BYTE ++static char *unpack_name(struct dload_state *dlthis, u32 soffset); ++#endif ++ ++static const char CINITNAME[] = { ".cinit" }; ++static const char LOADER_DLLVIEW_ROOT[] = { "?DLModules?" }; ++ ++/* ++ * Error strings ++ */ ++static const char E_READSTRM[] = { "Error reading %s from input stream" }; ++static const char E_ALLOC[] = { "Syms->Allocate( %d ) failed" }; ++static const char E_TGTALLOC[] = ++ { "Target memory allocate failed, section %s size " FMT_UI32 }; ++static const char E_INITFAIL[] = { "%s to target address " FMT_UI32 " failed" }; ++static const char E_DLVWRITE[] = { "Write to DLLview list failed" }; ++static const char E_ICONNECT[] = { "Connect call to init interface failed" }; ++static const char E_CHECKSUM[] = { "Checksum failed on %s" }; ++ ++/************************************************************************* ++ * Procedure dload_error ++ * ++ * Parameters: ++ * errtxt description of the error, printf style ++ * ... additional information ++ * ++ * Effect: ++ * Reports or records the error as appropriate. ++ ************************************************************************/ ++void dload_error(struct dload_state *dlthis, const char *errtxt, ...) ++{ ++ va_list args; ++ ++ va_start(args, errtxt); ++ dlthis->mysym->Error_Report(dlthis->mysym, errtxt, args); ++ va_end(args); ++ dlthis->dload_errcount += 1; ++ ++} /* dload_error */ ++ ++#define DL_ERROR(zza, zzb) dload_error(dlthis, zza, zzb) ++ ++/************************************************************************* ++ * Procedure dload_syms_error ++ * ++ * Parameters: ++ * errtxt description of the error, printf style ++ * ... additional information ++ * ++ * Effect: ++ * Reports or records the error as appropriate. ++ ************************************************************************/ ++void dload_syms_error(struct Dynamic_Loader_Sym *syms, const char *errtxt, ...) ++{ ++ va_list args; ++ ++ va_start(args, errtxt); ++ syms->Error_Report(syms, errtxt, args); ++ va_end(args); ++} ++ ++/************************************************************************* ++ * Procedure Dynamic_Load_Module ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * init Target-side memory initialization ++ * options Option flags DLOAD_* ++ * mhandle A module handle for use with Dynamic_Unload ++ * ++ * Effect: ++ * The module image is read using *module. Target storage for the new ++ * image is ++ * obtained from *alloc. Symbols defined and referenced by the module are ++ * managed using *syms. The image is then relocated and references ++ * resolved as necessary, and the resulting executable bits are placed ++ * into target memory using *init. ++ * ++ * Returns: ++ * On a successful load, a module handle is placed in *mhandle, ++ * and zero is returned. On error, the number of errors detected is ++ * returned. Individual errors are reported during the load process ++ * using syms->Error_Report(). ++ ***********************************************************************/ ++int Dynamic_Load_Module(struct Dynamic_Loader_Stream *module, ++ struct Dynamic_Loader_Sym *syms , ++ struct Dynamic_Loader_Allocate *alloc, ++ struct Dynamic_Loader_Initialize *init, ++ unsigned options, DLOAD_mhandle *mhandle) ++{ ++ register unsigned *dp, sz; ++ struct dload_state dl_state; /* internal state for this call */ ++ ++ /* blast our internal state */ ++ dp = (unsigned *)&dl_state; ++ for (sz = sizeof(dl_state) / sizeof(unsigned); sz > 0; sz -= 1) ++ *dp++ = 0; ++ ++ /* Enable _only_ BSS initialization if enabled by user */ ++ if ((options & DLOAD_INITBSS) == DLOAD_INITBSS) ++ dl_state.myoptions = DLOAD_INITBSS; ++ ++ /* Check that mandatory arguments are present */ ++ if (!module || !syms) { ++ dload_error(&dl_state, "Required parameter is NULL"); ++ } else { ++ dl_state.strm = module; ++ dl_state.mysym = syms; ++ dload_headers(&dl_state); ++ if (!dl_state.dload_errcount) ++ dload_strings(&dl_state, false); ++ if (!dl_state.dload_errcount) ++ dload_sections(&dl_state); ++ ++ if (init && !dl_state.dload_errcount) { ++ if (init->connect(init)) { ++ dl_state.myio = init; ++ dl_state.myalloc = alloc; ++ /* do now, before reducing symbols */ ++ allocate_sections(&dl_state); ++ } else ++ dload_error(&dl_state, E_ICONNECT); ++ } ++ ++ if (!dl_state.dload_errcount) { ++ /* fix up entry point address */ ++ unsigned sref = dl_state.dfile_hdr.df_entry_secn - 1; ++ if (sref < dl_state.allocated_secn_count) ++ dl_state.dfile_hdr.df_entrypt += ++ dl_state.ldr_sections[sref].run_addr; ++ ++ dload_symbols(&dl_state); ++ } ++ ++ if (init && !dl_state.dload_errcount) ++ dload_data(&dl_state); ++ ++ init_module_handle(&dl_state); ++ ++ if (dl_state.myio) { ++ if ((!dl_state.dload_errcount) && ++ (dl_state.dfile_hdr.df_entry_secn != DN_UNDEF)) { ++ if (init != NULL) { ++ if (!init->execute(init, ++ dl_state.dfile_hdr.df_entrypt)) ++ dload_error(&dl_state, ++ "Init->Execute Failed"); ++ } else { ++ dload_error(&dl_state, "init is NULL"); ++ } ++ } ++ init->release(init); ++ } ++ ++ symbol_table_free(&dl_state); ++ section_table_free(&dl_state); ++ string_table_free(&dl_state); ++ ++ if (dl_state.dload_errcount) { ++ Dynamic_Unload_Module(dl_state.myhandle, syms, alloc, ++ init); ++ dl_state.myhandle = NULL; ++ } ++ } ++ ++ if (mhandle) ++ *mhandle = dl_state.myhandle; /* give back the handle */ ++ ++ return dl_state.dload_errcount; ++} /* DLOAD_File */ ++ ++/************************************************************************* ++ * Procedure Dynamic_Open_Module ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * init Target-side memory initialization ++ * options Option flags DLOAD_* ++ * mhandle A module handle for use with Dynamic_Unload ++ * ++ * Effect: ++ * The module image is read using *module. Target storage for the new ++ * image is ++ * obtained from *alloc. Symbols defined and referenced by the module are ++ * managed using *syms. The image is then relocated and references ++ * resolved as necessary, and the resulting executable bits are placed ++ * into target memory using *init. ++ * ++ * Returns: ++ * On a successful load, a module handle is placed in *mhandle, ++ * and zero is returned. On error, the number of errors detected is ++ * returned. Individual errors are reported during the load process ++ * using syms->Error_Report(). ++ ***********************************************************************/ ++int ++Dynamic_Open_Module(struct Dynamic_Loader_Stream *module, ++ struct Dynamic_Loader_Sym *syms, ++ struct Dynamic_Loader_Allocate *alloc, ++ struct Dynamic_Loader_Initialize *init, ++ unsigned options, DLOAD_mhandle *mhandle) ++{ ++ register unsigned *dp, sz; ++ struct dload_state dl_state; /* internal state for this call */ ++ ++ /* blast our internal state */ ++ dp = (unsigned *)&dl_state; ++ for (sz = sizeof(dl_state) / sizeof(unsigned); sz > 0; sz -= 1) ++ *dp++ = 0; ++ ++ /* Enable _only_ BSS initialization if enabled by user */ ++ if ((options & DLOAD_INITBSS) == DLOAD_INITBSS) ++ dl_state.myoptions = DLOAD_INITBSS; ++ ++ /* Check that mandatory arguments are present */ ++ if (!module || !syms) { ++ dload_error(&dl_state, "Required parameter is NULL"); ++ } else { ++ dl_state.strm = module; ++ dl_state.mysym = syms; ++ dload_headers(&dl_state); ++ if (!dl_state.dload_errcount) ++ dload_strings(&dl_state, false); ++ if (!dl_state.dload_errcount) ++ dload_sections(&dl_state); ++ ++ if (init && !dl_state.dload_errcount) { ++ if (init->connect(init)) { ++ dl_state.myio = init; ++ dl_state.myalloc = alloc; ++ /* do now, before reducing symbols */ ++ allocate_sections(&dl_state); ++ } else ++ dload_error(&dl_state, E_ICONNECT); ++ } ++ ++ if (!dl_state.dload_errcount) { ++ /* fix up entry point address */ ++ unsigned sref = dl_state.dfile_hdr.df_entry_secn - 1; ++ if (sref < dl_state.allocated_secn_count) ++ dl_state.dfile_hdr.df_entrypt += ++ dl_state.ldr_sections[sref].run_addr; ++ ++ dload_symbols(&dl_state); ++ } ++ ++ init_module_handle(&dl_state); ++ ++ if (dl_state.myio) { ++ if ((!dl_state.dload_errcount) ++ && (dl_state.dfile_hdr.df_entry_secn != DN_UNDEF)) ++ if (!init->execute(init, ++ dl_state.dfile_hdr.df_entrypt)) ++ dload_error(&dl_state, ++ "Init->Execute Failed"); ++ init->release(init); ++ } ++ ++ symbol_table_free(&dl_state); ++ section_table_free(&dl_state); ++ string_table_free(&dl_state); ++ ++ if (dl_state.dload_errcount) { ++ Dynamic_Unload_Module(dl_state.myhandle, syms, alloc, ++ init); ++ dl_state.myhandle = NULL; ++ } ++ } ++ ++ if (mhandle) ++ *mhandle = dl_state.myhandle; /* give back the handle */ ++ ++ return dl_state.dload_errcount; ++} /* DLOAD_File */ ++ ++/************************************************************************* ++ * Procedure dload_headers ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Loads the DOFF header and verify record. Deals with any byte-order ++ * issues and checks them for validity. ++ ************************************************************************/ ++#define COMBINED_HEADER_SIZE (sizeof(struct doff_filehdr_t)+ \ ++ sizeof(struct doff_verify_rec_t)) ++ ++void dload_headers(struct dload_state *dlthis) ++{ ++ u32 map; ++ ++ /* Read the header and the verify record as one. If we don't get it ++ all, we're done */ ++ if (dlthis->strm->read_buffer(dlthis->strm, &dlthis->dfile_hdr, ++ COMBINED_HEADER_SIZE) != COMBINED_HEADER_SIZE) { ++ DL_ERROR(E_READSTRM, "File Headers"); ++ return; ++ } ++ /* ++ * Verify that we have the byte order of the file correct. ++ * If not, must fix it before we can continue ++ */ ++ map = REORDER_MAP(dlthis->dfile_hdr.df_byte_reshuffle); ++ if (map != REORDER_MAP(BYTE_RESHUFFLE_VALUE)) { ++ /* input is either byte-shuffled or bad */ ++ if ((map & 0xFCFCFCFC) == 0) { /* no obviously bogus bits */ ++ dload_reorder(&dlthis->dfile_hdr, COMBINED_HEADER_SIZE, ++ map); ++ } ++ if (dlthis->dfile_hdr.df_byte_reshuffle != ++ BYTE_RESHUFFLE_VALUE) { ++ /* didn't fix the problem, the byte swap map is bad */ ++ dload_error(dlthis, ++ "Bad byte swap map " FMT_UI32 " in header", ++ dlthis->dfile_hdr.df_byte_reshuffle); ++ return; ++ } ++ dlthis->reorder_map = map; /* keep map for future use */ ++ } ++ ++ /* ++ * Verify checksum of header and verify record ++ */ ++ if (~dload_checksum(&dlthis->dfile_hdr, ++ sizeof(struct doff_filehdr_t)) || ++ ~dload_checksum(&dlthis->verify, ++ sizeof(struct doff_verify_rec_t))) { ++ DL_ERROR(E_CHECKSUM, "header or verify record"); ++ return; ++ } ++#if HOST_ENDIANNESS ++ dlthis->dfile_hdr.df_byte_reshuffle = map; /* put back for later */ ++#endif ++ ++ /* Check for valid target ID */ ++ if ((dlthis->dfile_hdr.df_target_id != TARGET_ID) && ++ -(dlthis->dfile_hdr.df_target_id != TMS470_ID)) { ++ dload_error(dlthis, "Bad target ID 0x%x and TARGET_ID 0x%x", ++ dlthis->dfile_hdr.df_target_id, TARGET_ID); ++ return; ++ } ++ /* Check for valid file format */ ++ if ((dlthis->dfile_hdr.df_doff_version != DOFF0)) { ++ dload_error(dlthis, "Bad DOFF version 0x%x", ++ dlthis->dfile_hdr.df_doff_version); ++ return; ++ } ++ ++ /* ++ * Apply reasonableness checks to count fields ++ */ ++ if (dlthis->dfile_hdr.df_strtab_size > MAX_REASONABLE_STRINGTAB) { ++ dload_error(dlthis, "Excessive string table size " FMT_UI32, ++ dlthis->dfile_hdr.df_strtab_size); ++ return; ++ } ++ if (dlthis->dfile_hdr.df_no_scns > MAX_REASONABLE_SECTIONS) { ++ dload_error(dlthis, "Excessive section count 0x%x", ++ dlthis->dfile_hdr.df_no_scns); ++ return; ++ } ++#ifndef TARGET_ENDIANNESS ++ /* ++ * Check that endianness does not disagree with explicit specification ++ */ ++ if ((dlthis->dfile_hdr.df_flags >> ALIGN_COFF_ENDIANNESS) & ++ dlthis->myoptions & ENDIANNESS_MASK) { ++ dload_error(dlthis, ++ "Input endianness disagrees with specified option"); ++ return; ++ } ++ dlthis->big_e_target = dlthis->dfile_hdr.df_flags & DF_BIG; ++#endif ++ ++} /* dload_headers */ ++ ++/* COFF Section Processing ++ * ++ * COFF sections are read in and retained intact. Each record is embedded ++ * in a new structure that records the updated load and ++ * run addresses of the section */ ++ ++static const char SECN_ERRID[] = { "section" }; ++ ++/************************************************************************* ++ * Procedure dload_sections ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Loads the section records into an internal table. ++ ************************************************************************/ ++void ++dload_sections(struct dload_state *dlthis) ++{ ++ s16 siz; ++ struct doff_scnhdr_t *shp; ++ unsigned nsecs = dlthis->dfile_hdr.df_no_scns; ++ ++ /* allocate space for the DOFF section records */ ++ siz = nsecs * sizeof(struct doff_scnhdr_t); ++ shp = (struct doff_scnhdr_t *)dlthis->mysym->Allocate(dlthis->mysym, ++ siz); ++ if (!shp) { /* not enough storage */ ++ DL_ERROR(E_ALLOC, siz); ++ return; ++ } ++ dlthis->sect_hdrs = shp; ++ ++ /* read in the section records */ ++ if (dlthis->strm->read_buffer(dlthis->strm, shp, siz) != siz) { ++ DL_ERROR(E_READSTRM, SECN_ERRID); ++ return; ++ } ++ ++ /* if we need to fix up byte order, do it now */ ++ if (dlthis->reorder_map) ++ dload_reorder(shp, siz, dlthis->reorder_map); ++ ++ /* check for validity */ ++ if (~dload_checksum(dlthis->sect_hdrs, siz) != ++ dlthis->verify.dv_scn_rec_checksum) { ++ DL_ERROR(E_CHECKSUM, SECN_ERRID); ++ return; ++ } ++ ++} /* dload_sections */ ++ ++/***************************************************************************** ++ * Procedure allocate_sections ++ * ++ * Parameters: ++ * alloc target memory allocator class ++ * ++ * Effect: ++ * Assigns new (target) addresses for sections ++ *****************************************************************************/ ++static void allocate_sections(struct dload_state *dlthis) ++{ ++ u16 curr_sect, nsecs, siz; ++ struct doff_scnhdr_t *shp; ++ struct LDR_SECTION_INFO *asecs; ++ struct my_handle *hndl; ++ nsecs = dlthis->dfile_hdr.df_no_scns; ++ if (!nsecs) ++ return; ++ if ((dlthis->myalloc == NULL) && ++ (dlthis->dfile_hdr.df_target_scns > 0)) { ++ DL_ERROR("Arg 3 (alloc) required but NULL", 0); ++ return; ++ } ++ /* allocate space for the module handle, which we will ++ * keep for unload purposes */ ++ siz = dlthis->dfile_hdr.df_target_scns * ++ sizeof(struct LDR_SECTION_INFO) + MY_HANDLE_SIZE; ++ hndl = (struct my_handle *)dlthis->mysym->Allocate(dlthis->mysym, siz); ++ if (!hndl) { /* not enough storage */ ++ DL_ERROR(E_ALLOC, siz); ++ return; ++ } ++ /* initialize the handle header */ ++ hndl->dm.hnext = hndl->dm.hprev = hndl; /* circular list */ ++ hndl->dm.hroot = NULL; ++ hndl->dm.dbthis = 0; ++ dlthis->myhandle = hndl; /* save away for return */ ++ /* pointer to the section list of allocated sections */ ++ dlthis->ldr_sections = asecs = hndl->secns; ++ /* * Insert names into all sections, make copies of ++ the sections we allocate */ ++ shp = dlthis->sect_hdrs; ++ for (curr_sect = 0; curr_sect < nsecs; curr_sect++) { ++ u32 soffset = shp->ds_offset; ++#if BITS_PER_AU <= BITS_PER_BYTE ++ /* attempt to insert the name of this section */ ++ if (soffset < dlthis->dfile_hdr.df_strtab_size) ++ DOFFSEC_IS_LDRSEC(shp)->name = dlthis->str_head + ++ soffset; ++ else { ++ dload_error(dlthis, "Bad name offset in section %d", ++ curr_sect); ++ DOFFSEC_IS_LDRSEC(shp)->name = NULL; ++ } ++#endif ++ /* allocate target storage for sections that require it */ ++ if (DS_NEEDS_ALLOCATION(shp)) { ++ *asecs = *DOFFSEC_IS_LDRSEC(shp); ++ asecs->context = 0; /* zero the context field */ ++#if BITS_PER_AU > BITS_PER_BYTE ++ asecs->name = unpack_name(dlthis, soffset); ++ dlthis->debug_string_size = soffset + dlthis->temp_len; ++#else ++ dlthis->debug_string_size = soffset; ++#endif ++ if (dlthis->myalloc != NULL) { ++ if (!dlthis->myalloc->Allocate(dlthis->myalloc, asecs, ++ DS_ALIGNMENT(asecs->type))) { ++ dload_error(dlthis, E_TGTALLOC, asecs->name, ++ asecs->size); ++ return; ++ } ++ } ++ /* keep address deltas in original section table */ ++ shp->ds_vaddr = asecs->load_addr - shp->ds_vaddr; ++ shp->ds_paddr = asecs->run_addr - shp->ds_paddr; ++ dlthis->allocated_secn_count += 1; ++ } /* allocate target storage */ ++ shp += 1; ++ asecs += 1; ++ } ++#if BITS_PER_AU <= BITS_PER_BYTE ++ dlthis->debug_string_size += ++ strlen(dlthis->str_head + dlthis->debug_string_size) + 1; ++#endif ++} /* allocate sections */ ++ ++/************************************************************************* ++ * Procedure section_table_free ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Frees any state used by the symbol table. ++ * ++ * WARNING: ++ * This routine is not allowed to declare errors! ++ ************************************************************************/ ++static void section_table_free(struct dload_state *dlthis) ++{ ++ struct doff_scnhdr_t *shp; ++ ++ shp = dlthis->sect_hdrs; ++ if (shp) ++ dlthis->mysym->Deallocate(dlthis->mysym, shp); ++ ++} /* section_table_free */ ++ ++/************************************************************************* ++ * Procedure dload_strings ++ * ++ * Parameters: ++ * sec_names_only If true only read in the "section names" ++ * portion of the string table ++ * ++ * Effect: ++ * Loads the DOFF string table into memory. DOFF keeps all strings in a ++ * big unsorted array. We just read that array into memory in bulk. ++ ************************************************************************/ ++static const char S_STRINGTBL[] = { "string table" }; ++void dload_strings(struct dload_state *dlthis, boolean sec_names_only) ++{ ++ u32 ssiz; ++ char *strbuf; ++ ++ if (sec_names_only) { ++ ssiz = BYTE_TO_HOST(DOFF_ALIGN ++ (dlthis->dfile_hdr.df_scn_name_size)); ++ } else { ++ ssiz = BYTE_TO_HOST(DOFF_ALIGN ++ (dlthis->dfile_hdr.df_strtab_size)); ++ } ++ if (ssiz == 0) ++ return; ++ ++ /* get some memory for the string table */ ++#if BITS_PER_AU > BITS_PER_BYTE ++ strbuf = (char *)dlthis->mysym->Allocate(dlthis->mysym, ssiz + ++ dlthis->dfile_hdr.df_max_str_len); ++#else ++ strbuf = (char *)dlthis->mysym->Allocate(dlthis->mysym, ssiz); ++#endif ++ if (strbuf == NULL) { ++ DL_ERROR(E_ALLOC, ssiz); ++ return; ++ } ++ dlthis->str_head = strbuf; ++#if BITS_PER_AU > BITS_PER_BYTE ++ dlthis->str_temp = strbuf + ssiz; ++#endif ++ /* read in the strings and verify them */ ++ if ((unsigned)(dlthis->strm->read_buffer(dlthis->strm, strbuf, ++ ssiz)) != ssiz) { ++ DL_ERROR(E_READSTRM, S_STRINGTBL); ++ } ++ /* if we need to fix up byte order, do it now */ ++#ifndef _BIG_ENDIAN ++ if (dlthis->reorder_map) ++ dload_reorder(strbuf, ssiz, dlthis->reorder_map); ++ ++ if ((!sec_names_only) && (~dload_checksum(strbuf, ssiz) != ++ dlthis->verify.dv_str_tab_checksum)) { ++ DL_ERROR(E_CHECKSUM, S_STRINGTBL); ++ } ++#else ++ if (dlthis->dfile_hdr.df_byte_reshuffle != ++ HOST_BYTE_ORDER(REORDER_MAP(BYTE_RESHUFFLE_VALUE))) { ++ /* put strings in big-endian order, not in PC order */ ++ dload_reorder(strbuf, ssiz, HOST_BYTE_ORDER(dlthis->dfile_hdr. ++ df_byte_reshuffle)); ++ } ++ if ((!sec_names_only) && (~dload_reverse_checksum(strbuf, ssiz) != ++ dlthis->verify.dv_str_tab_checksum)) { ++ DL_ERROR(E_CHECKSUM, S_STRINGTBL); ++ } ++#endif ++} /* dload_strings */ ++ ++/************************************************************************* ++ * Procedure string_table_free ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Frees any state used by the string table. ++ * ++ * WARNING: ++ * This routine is not allowed to declare errors! ++ *************************************************************************/ ++static void string_table_free(struct dload_state *dlthis) ++{ ++ if (dlthis->str_head) ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis->str_head); ++ ++} /* string_table_free */ ++ ++/* ++ * Symbol Table Maintenance Functions ++ * ++ * COFF symbols are read by dload_symbols(), which is called after ++ * sections have been allocated. Symbols which might be used in ++ * relocation (ie, not debug info) are retained in an internal temporary ++ * compressed table (type Local_Symbol). A particular symbol is recovered ++ * by index by calling dload_find_symbol(). dload_find_symbol ++ * reconstructs a more explicit representation (type SLOTVEC) which is ++ * used by reloc.c ++ */ ++/* real size of debug header */ ++#define DBG_HDR_SIZE (sizeof(struct dll_module) - sizeof(struct dll_sect)) ++ ++static const char SYM_ERRID[] = { "symbol" }; ++ ++/************************************************************************** ++ * Procedure dload_symbols ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Reads in symbols and retains ones that might be needed for relocation ++ * purposes. ++ ************************************************************************/ ++/* size of symbol buffer no bigger than target data buffer, to limit stack ++ * usage*/ ++#define MY_SYM_BUF_SIZ (BYTE_TO_HOST(IMAGE_PACKET_SIZE)/\ ++ sizeof(struct doff_syment_t)) ++ ++static void dload_symbols(struct dload_state *dlthis) ++{ ++ u32 s_count, siz, dsiz, symbols_left; ++ u32 checks; ++ struct Local_Symbol *sp; ++ struct dynload_symbol *symp; ++ struct dynload_symbol *newsym; ++ ++ s_count = dlthis->dfile_hdr.df_no_syms; ++ if (s_count == 0) ++ return; ++ ++ /* We keep a local symbol table for all of the symbols in the input. ++ * This table contains only section & value info, as we do not have ++ * to do any name processing for locals. We reuse this storage ++ * as a temporary for .dllview record construction. ++ * Allocate storage for the whole table.*/ ++ siz = s_count * sizeof(struct Local_Symbol); ++ dsiz = DBG_HDR_SIZE + ++ (sizeof(struct dll_sect) * dlthis->allocated_secn_count) + ++ BYTE_TO_HOST_ROUND(dlthis->debug_string_size + 1); ++ if (dsiz > siz) ++ siz = dsiz; /* larger of symbols and .dllview temp */ ++ sp = (struct Local_Symbol *)dlthis->mysym->Allocate(dlthis->mysym, siz); ++ if (!sp) { ++ DL_ERROR(E_ALLOC, siz); ++ return; ++ } ++ dlthis->local_symtab = sp; ++ /* Read the symbols in the input, store them in the table, and post any ++ * globals to the global symbol table. In the process, externals ++ become defined from the global symbol table */ ++ checks = dlthis->verify.dv_sym_tab_checksum; ++ symbols_left = s_count; ++ do { /* read all symbols */ ++ char *sname; ++ u32 val; ++ s32 delta; ++ struct doff_syment_t *input_sym; ++ unsigned syms_in_buf; ++ struct doff_syment_t my_sym_buf[MY_SYM_BUF_SIZ]; ++ input_sym = my_sym_buf; ++ syms_in_buf = symbols_left > MY_SYM_BUF_SIZ ? ++ MY_SYM_BUF_SIZ : symbols_left; ++ siz = syms_in_buf * sizeof(struct doff_syment_t); ++ if (dlthis->strm->read_buffer(dlthis->strm, input_sym, siz) != ++ siz) { ++ DL_ERROR(E_READSTRM, SYM_ERRID); ++ return; ++ } ++ if (dlthis->reorder_map) ++ dload_reorder(input_sym, siz, dlthis->reorder_map); ++ ++ checks += dload_checksum(input_sym, siz); ++ do { /* process symbols in buffer */ ++ symbols_left -= 1; ++ /* attempt to derive the name of this symbol */ ++ sname = NULL; ++ if (input_sym->dn_offset > 0) { ++#if BITS_PER_AU <= BITS_PER_BYTE ++ if ((u32) input_sym->dn_offset < ++ dlthis->dfile_hdr.df_strtab_size) ++ sname = dlthis->str_head + ++ BYTE_TO_HOST(input_sym->dn_offset); ++ else ++ dload_error(dlthis, ++ "Bad name offset in symbol %d", ++ symbols_left); ++#else ++ sname = unpack_name(dlthis, ++ input_sym->dn_offset); ++#endif ++ } ++ val = input_sym->dn_value; ++ delta = 0; ++ sp->sclass = input_sym->dn_sclass; ++ sp->secnn = input_sym->dn_scnum; ++ /* if this is an undefined symbol, ++ * define it (or fail) now */ ++ if (sp->secnn == DN_UNDEF) { ++ /* pointless for static undefined */ ++ if (input_sym->dn_sclass != DN_EXT) ++ goto loop_cont; ++ ++ /* try to define symbol from previously ++ * loaded images */ ++ symp = dlthis->mysym->Find_Matching_Symbol ++ (dlthis->mysym, sname); ++ if (!symp) { ++ DL_ERROR ++ ("Undefined external symbol %s", ++ sname); ++ goto loop_cont; ++ } ++ val = delta = symp->value; ++ goto loop_cont; ++ } ++ /* symbol defined by this module */ ++ if (sp->secnn > 0) { /* symbol references a section */ ++ if ((unsigned)sp->secnn <= ++ dlthis->allocated_secn_count) { ++ /* section was allocated */ ++ struct doff_scnhdr_t *srefp = ++ &dlthis->sect_hdrs ++ [sp->secnn - 1]; ++ ++ if (input_sym->dn_sclass == ++ DN_STATLAB || ++ input_sym->dn_sclass == DN_EXTLAB){ ++ /* load */ ++ delta = srefp->ds_vaddr; ++ } else { ++ /* run */ ++ delta = srefp->ds_paddr; ++ } ++ val += delta; ++ } ++ goto loop_itr; ++ } ++ /* This symbol is an absolute symbol */ ++ if (sp->secnn == DN_ABS && ((sp->sclass == DN_EXT) || ++ (sp->sclass == DN_EXTLAB))) { ++ symp = dlthis->mysym->Find_Matching_Symbol ++ (dlthis->mysym, sname); ++ if (!symp) ++ goto loop_itr; ++ /* This absolute symbol is already defined. */ ++ if (symp->value == input_sym->dn_value) { ++ /* If symbol values are equal, continue ++ * but don't add to the global symbol ++ * table */ ++ sp->value = val; ++ sp->delta = delta; ++ sp += 1; ++ input_sym += 1; ++ continue; ++ } else { ++ /* If symbol values are not equal, ++ * return with redefinition error */ ++ DL_ERROR("Absolute symbol %s is " ++ "defined multiple times with " ++ "different values", sname); ++ return; ++ } ++ } ++loop_itr: ++ /* if this is a global symbol, post it to the ++ * global table */ ++ if (input_sym->dn_sclass == DN_EXT || ++ input_sym->dn_sclass == DN_EXTLAB) { ++ /* Keep this global symbol for subsequent ++ * modules. Don't complain on error, to allow ++ * symbol API to suppress global symbols */ ++ if (!sname) ++ goto loop_cont; ++ ++ newsym = dlthis->mysym->Add_To_Symbol_Table ++ (dlthis->mysym, sname, ++ (unsigned)dlthis->myhandle); ++ if (newsym) ++ newsym->value = val; ++ ++ } /* global */ ++loop_cont: ++ sp->value = val; ++ sp->delta = delta; ++ sp += 1; ++ input_sym += 1; ++ } while ((syms_in_buf -= 1) > 0); /* process sym in buffer */ ++ } while (symbols_left > 0); /* read all symbols */ ++ if (~checks) ++ dload_error(dlthis, "Checksum of symbols failed"); ++ ++} /* dload_symbols */ ++ ++/***************************************************************************** ++ * Procedure symbol_table_free ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Frees any state used by the symbol table. ++ * ++ * WARNING: ++ * This routine is not allowed to declare errors! ++ *****************************************************************************/ ++static void symbol_table_free(struct dload_state *dlthis) ++{ ++ if (dlthis->local_symtab) { ++ if (dlthis->dload_errcount) { /* blow off our symbols */ ++ dlthis->mysym->Purge_Symbol_Table(dlthis->mysym, ++ (unsigned)dlthis->myhandle); ++ } ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis->local_symtab); ++ } ++} /* symbol_table_free */ ++ ++/* .cinit Processing ++ * ++ * The dynamic loader does .cinit interpretation. cload_cinit() ++ * acts as a special write-to-target function, in that it takes relocated ++ * data from the normal data flow, and interprets it as .cinit actions. ++ * Because the normal data flow does not necessarily process the whole ++ * .cinit section in one buffer, cload_cinit() must be prepared to ++ * interpret the data piecemeal. A state machine is used for this ++ * purpose. ++ */ ++ ++/* The following are only for use by reloc.c and things it calls */ ++static const struct LDR_SECTION_INFO CINIT_INFO_INIT = { CINITNAME, 0, 0, ++ (LDR_ADDR) -1, 0, DLOAD_BSS, 0 }; ++ ++/************************************************************************* ++ * Procedure cload_cinit ++ * ++ * Parameters: ++ * ipacket Pointer to data packet to be loaded ++ * ++ * Effect: ++ * Interprets the data in the buffer as .cinit data, and performs the ++ * appropriate initializations. ++ ************************************************************************/ ++static void cload_cinit(struct dload_state *dlthis, ++ struct image_packet_t *ipacket) ++{ ++#if TDATA_TO_HOST(CINIT_COUNT)*BITS_PER_AU > 16 ++ s32 init_count, left; ++#else ++ s16 init_count, left; ++#endif ++ unsigned char *pktp = ipacket->i_bits; ++ unsigned char *pktend = pktp + ++ BYTE_TO_HOST_ROUND(ipacket->i_packet_size); ++ int temp; ++ LDR_ADDR atmp; ++ struct LDR_SECTION_INFO cinit_info; ++ ++ /* PROCESS ALL THE INITIALIZATION RECORDS IN THE BUFFER. */ ++ while (true) { ++ left = pktend - pktp; ++ switch (dlthis->cinit_state) { ++ case CI_count: /* count field */ ++ if (left < TDATA_TO_HOST(CINIT_COUNT)) ++ goto loopexit; ++ temp = dload_unpack(dlthis, (TgtAU_t *)pktp, ++ CINIT_COUNT * TDATA_AU_BITS, 0, ++ ROP_SGN); ++ pktp += TDATA_TO_HOST(CINIT_COUNT); ++ /* negative signifies BSS table, zero means done */ ++ if (temp <= 0) { ++ dlthis->cinit_state = CI_done; ++ break; ++ } ++ dlthis->cinit_count = temp; ++ dlthis->cinit_state = CI_address; ++ break; ++#if CINIT_ALIGN < CINIT_ADDRESS ++ case CI_partaddress: ++ pktp -= TDATA_TO_HOST(CINIT_ALIGN); ++ /* back up pointer into space courtesy of caller */ ++ *(uint16_t *)pktp = dlthis->cinit_addr; ++ /* stuff in saved bits !! FALL THRU !! */ ++#endif ++ case CI_address: /* Address field for a copy packet */ ++ if (left < TDATA_TO_HOST(CINIT_ADDRESS)) { ++#if CINIT_ALIGN < CINIT_ADDRESS ++ if (left == TDATA_TO_HOST(CINIT_ALIGN)) { ++ /* address broken into halves */ ++ dlthis->cinit_addr = *(uint16_t *)pktp; ++ /* remember 1st half */ ++ dlthis->cinit_state = CI_partaddress; ++ left = 0; ++ } ++#endif ++ goto loopexit; ++ } ++ atmp = dload_unpack(dlthis, (TgtAU_t *)pktp, ++ CINIT_ADDRESS * TDATA_AU_BITS, 0, ++ ROP_UNS); ++ pktp += TDATA_TO_HOST(CINIT_ADDRESS); ++#if CINIT_PAGE_BITS > 0 ++ dlthis->cinit_page = atmp & ++ ((1 << CINIT_PAGE_BITS) - 1); ++ atmp >>= CINIT_PAGE_BITS; ++#else ++ dlthis->cinit_page = CINIT_DEFAULT_PAGE; ++#endif ++ dlthis->cinit_addr = atmp; ++ dlthis->cinit_state = CI_copy; ++ break; ++ case CI_copy: /* copy bits to the target */ ++ init_count = HOST_TO_TDATA(left); ++ if (init_count > dlthis->cinit_count) ++ init_count = dlthis->cinit_count; ++ if (init_count == 0) ++ goto loopexit; /* get more bits */ ++ cinit_info = CINIT_INFO_INIT; ++ cinit_info.page = dlthis->cinit_page; ++ if (!dlthis->myio->writemem(dlthis->myio, pktp, ++ TDATA_TO_TADDR(dlthis->cinit_addr), ++ &cinit_info, ++ TDATA_TO_HOST(init_count))) { ++ dload_error(dlthis, E_INITFAIL, "write", ++ dlthis->cinit_addr); ++ } ++ dlthis->cinit_count -= init_count; ++ if (dlthis->cinit_count <= 0) { ++ dlthis->cinit_state = CI_count; ++ init_count = (init_count + CINIT_ALIGN - 1) & ++ -CINIT_ALIGN; ++ /* align to next init */ ++ } ++ pktp += TDATA_TO_HOST(init_count); ++ dlthis->cinit_addr += init_count; ++ break; ++ case CI_done: /* no more .cinit to do */ ++ return; ++ } /* switch (cinit_state) */ ++ } /* while */ ++ ++loopexit: ++ if (left > 0) { ++ dload_error(dlthis, "%d bytes left over in cinit packet", left); ++ dlthis->cinit_state = CI_done; /* left over bytes are bad */ ++ } ++} /* cload_cinit */ ++ ++/* Functions to interface to reloc.c ++ * ++ * reloc.c is the relocation module borrowed from the linker, with ++ * minimal (we hope) changes for our purposes. cload_sect_data() invokes ++ * this module on a section to relocate and load the image data for that ++ * section. The actual read and write actions are supplied by the global ++ * routines below. ++ */ ++ ++/************************************************************************ ++ * Procedure relocate_packet ++ * ++ * Parameters: ++ * ipacket Pointer to an image packet to relocate ++ * ++ * Effect: ++ * Performs the required relocations on the packet. Returns a checksum ++ * of the relocation operations. ++ ************************************************************************/ ++#define MY_RELOC_BUF_SIZ 8 ++/* careful! exists at the same time as the image buffer*/ ++static int relocate_packet(struct dload_state *dlthis, ++ struct image_packet_t *ipacket, u32 *checks) ++{ ++ u32 rnum; ++ ++ rnum = ipacket->i_num_relocs; ++ do { /* all relocs */ ++ unsigned rinbuf; ++ int siz; ++ struct reloc_record_t *rp, rrec[MY_RELOC_BUF_SIZ]; ++ rp = rrec; ++ rinbuf = rnum > MY_RELOC_BUF_SIZ ? MY_RELOC_BUF_SIZ : rnum; ++ siz = rinbuf * sizeof(struct reloc_record_t); ++ if (dlthis->strm->read_buffer(dlthis->strm, rp, siz) != siz) { ++ DL_ERROR(E_READSTRM, "relocation"); ++ return 0; ++ } ++ /* reorder the bytes if need be */ ++ if (dlthis->reorder_map) ++ dload_reorder(rp, siz, dlthis->reorder_map); ++ ++ *checks += dload_checksum(rp, siz); ++ do { ++ /* perform the relocation operation */ ++ dload_relocate(dlthis, (TgtAU_t *) ipacket->i_bits, rp); ++ rp += 1; ++ rnum -= 1; ++ } while ((rinbuf -= 1) > 0); ++ } while (rnum > 0); /* all relocs */ ++ return 1; ++} /* dload_read_reloc */ ++ ++#define IPH_SIZE (sizeof(struct image_packet_t) - sizeof(u32)) ++ ++/* VERY dangerous */ ++static const char IMAGEPAK[] = { "image packet" }; ++ ++/************************************************************************* ++ * Procedure dload_data ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Read image data from input file, relocate it, and download it to the ++ * target. ++ ************************************************************************/ ++static void dload_data(struct dload_state *dlthis) ++{ ++ u16 curr_sect; ++ struct doff_scnhdr_t *sptr = dlthis->sect_hdrs; ++ struct LDR_SECTION_INFO *lptr = dlthis->ldr_sections; ++#ifdef OPT_ZERO_COPY_LOADER ++ boolean bZeroCopy = false; ++#endif ++ u8 *pDest; ++ ++ struct { ++ struct image_packet_t ipacket; ++ u8 bufr[BYTE_TO_HOST(IMAGE_PACKET_SIZE)]; ++ } ibuf; ++ ++ /* Indicates whether CINIT processing has occurred */ ++ boolean cinit_processed = false; ++ ++ /* Loop through the sections and load them one at a time. ++ */ ++ for (curr_sect = 0; curr_sect < dlthis->dfile_hdr.df_no_scns; ++ curr_sect += 1) { ++ if (DS_NEEDS_DOWNLOAD(sptr)) { ++ s32 nip; ++ LDR_ADDR image_offset = 0; ++ /* set relocation info for this section */ ++ if (curr_sect < dlthis->allocated_secn_count) ++ dlthis->delta_runaddr = sptr->ds_paddr; ++ else { ++ lptr = DOFFSEC_IS_LDRSEC(sptr); ++ dlthis->delta_runaddr = 0; ++ } ++ dlthis->image_secn = lptr; ++#if BITS_PER_AU > BITS_PER_BYTE ++ lptr->name = unpack_name(dlthis, sptr->ds_offset); ++#endif ++ nip = sptr->ds_nipacks; ++ while ((nip -= 1) >= 0) { /* process packets */ ++ ++ s32 ipsize; ++ u32 checks; ++ /* get the fixed header bits */ ++ if (dlthis->strm->read_buffer(dlthis->strm, ++ &ibuf.ipacket, IPH_SIZE) != IPH_SIZE) { ++ DL_ERROR(E_READSTRM, IMAGEPAK); ++ return; ++ } ++ /* reorder the header if need be */ ++ if (dlthis->reorder_map) { ++ dload_reorder(&ibuf.ipacket, IPH_SIZE, ++ dlthis->reorder_map); ++ } ++ /* now read the rest of the packet */ ++ ipsize = ++ BYTE_TO_HOST(DOFF_ALIGN ++ (ibuf.ipacket.i_packet_size)); ++ if (ipsize > BYTE_TO_HOST(IMAGE_PACKET_SIZE)) { ++ DL_ERROR("Bad image packet size %d", ++ ipsize); ++ return; ++ } ++ pDest = ibuf.bufr; ++#ifdef OPT_ZERO_COPY_LOADER ++ bZeroCopy = false; ++ if (DLOAD_SECT_TYPE(sptr) != DLOAD_CINIT) { ++ dlthis->myio->writemem(dlthis->myio, ++ &pDest, lptr->load_addr + ++ image_offset, lptr, 0); ++ bZeroCopy = (pDest != ibuf.bufr); ++ } ++#endif ++ /* End of determination */ ++ ++ if (dlthis->strm->read_buffer(dlthis->strm, ++ ibuf.bufr, ipsize) != ipsize) { ++ DL_ERROR(E_READSTRM, IMAGEPAK); ++ return; ++ } ++ ibuf.ipacket.i_bits = pDest; ++ ++ /* reorder the bytes if need be */ ++#if !defined(_BIG_ENDIAN) || (TARGET_AU_BITS > 16) ++ if (dlthis->reorder_map) { ++ dload_reorder(pDest, ipsize, ++ dlthis->reorder_map); ++ } ++ checks = dload_checksum(pDest, ipsize); ++#else ++ if (dlthis->dfile_hdr.df_byte_reshuffle != ++ TARGET_ORDER(REORDER_MAP ++ (BYTE_RESHUFFLE_VALUE))) { ++ /* put image bytes in big-endian order, ++ * not PC order */ ++ dload_reorder(pDest, ipsize, ++ TARGET_ORDER ++ (dlthis->dfile_hdr.df_byte_reshuffle)); ++ } ++#if TARGET_AU_BITS > 8 ++ checks = dload_reverse_checksum_16(pDest, ++ ipsize); ++#else ++ checks = dload_reverse_checksum(pDest, ++ ipsize); ++#endif ++#endif ++ ++ checks += dload_checksum(&ibuf.ipacket, ++ IPH_SIZE); ++ /* relocate the image bits as needed */ ++ if (ibuf.ipacket.i_num_relocs) { ++ dlthis->image_offset = image_offset; ++ if (!relocate_packet(dlthis, ++ &ibuf.ipacket, &checks)) ++ return; /* serious error */ ++ } ++ if (~checks) ++ DL_ERROR(E_CHECKSUM, IMAGEPAK); ++ /* stuff the result into target memory */ ++ if (DLOAD_SECT_TYPE(sptr) == DLOAD_CINIT) { ++ cload_cinit(dlthis, &ibuf.ipacket); ++ cinit_processed = true; ++ } else { ++#ifdef OPT_ZERO_COPY_LOADER ++ if (!bZeroCopy) { ++#endif ++ ++ if (!dlthis->myio->writemem ++ (dlthis->myio, ibuf.bufr, ++ lptr->load_addr + image_offset, lptr, ++ BYTE_TO_HOST ++ (ibuf.ipacket.i_packet_size))) { ++ DL_ERROR( ++ "Write to " FMT_UI32 " failed", ++ lptr->load_addr + image_offset); ++ } ++#ifdef OPT_ZERO_COPY_LOADER ++ } ++#endif ++ ++ } ++ image_offset += ++ BYTE_TO_TADDR(ibuf.ipacket.i_packet_size); ++ } /* process packets */ ++ /* if this is a BSS section, we may want to fill it */ ++ if (DLOAD_SECT_TYPE(sptr) != DLOAD_BSS) ++ goto loop_cont; ++ ++ if (!(dlthis->myoptions & DLOAD_INITBSS)) ++ goto loop_cont; ++ ++ if (cinit_processed) { ++ /* Don't clear BSS after load-time ++ * initialization */ ++ DL_ERROR ++ ("Zero-initialization at " FMT_UI32 " after " ++ "load-time initialization!", lptr->load_addr); ++ goto loop_cont; ++ } ++ /* fill the .bss area */ ++ dlthis->myio->fillmem(dlthis->myio, ++ TADDR_TO_HOST(lptr->load_addr), ++ lptr, TADDR_TO_HOST(lptr->size), ++ dload_fill_bss); ++ goto loop_cont; ++ } /* if DS_DOWNLOAD_MASK */ ++ /* If not loading, but BSS, zero initialize */ ++ if (DLOAD_SECT_TYPE(sptr) != DLOAD_BSS) ++ goto loop_cont; ++ ++ if (!(dlthis->myoptions & DLOAD_INITBSS)) ++ goto loop_cont; ++ ++ if (curr_sect >= dlthis->allocated_secn_count) ++ lptr = DOFFSEC_IS_LDRSEC(sptr); ++ ++ if (cinit_processed) { ++ /*Don't clear BSS after load-time initialization */ ++ DL_ERROR( ++ "Zero-initialization at " FMT_UI32 " attempted after " ++ "load-time initialization!", lptr->load_addr); ++ goto loop_cont; ++ } ++ /* fill the .bss area */ ++ dlthis->myio->fillmem(dlthis->myio, ++ TADDR_TO_HOST(lptr->load_addr), lptr, ++ TADDR_TO_HOST(lptr->size), dload_fill_bss); ++loop_cont: ++ sptr += 1; ++ lptr += 1; ++ } /* load sections */ ++} /* dload_data */ ++ ++/************************************************************************* ++ * Procedure dload_reorder ++ * ++ * Parameters: ++ * data 32-bit aligned pointer to data to be byte-swapped ++ * dsiz size of the data to be reordered in sizeof() units. ++ * map 32-bit map defining how to reorder the data. Value ++ * must be REORDER_MAP() of some permutation ++ * of 0x00 01 02 03 ++ * ++ * Effect: ++ * Re-arranges the bytes in each word according to the map specified. ++ * ++ ************************************************************************/ ++/* mask for byte shift count */ ++#define SHIFT_COUNT_MASK (3 << LOG_BITS_PER_BYTE) ++ ++void dload_reorder(void *data, int dsiz, unsigned int map) ++{ ++ register u32 tmp, tmap, datv; ++ u32 *dp = (u32 *)data; ++ ++ map <<= LOG_BITS_PER_BYTE; /* align map with SHIFT_COUNT_MASK */ ++ do { ++ tmp = 0; ++ datv = *dp; ++ tmap = map; ++ do { ++ tmp |= (datv & BYTE_MASK) << (tmap & SHIFT_COUNT_MASK); ++ tmap >>= BITS_PER_BYTE; ++ } while (datv >>= BITS_PER_BYTE); ++ *dp++ = tmp; ++ } while ((dsiz -= sizeof(u32)) > 0); ++} /* dload_reorder */ ++ ++/************************************************************************* ++ * Procedure dload_checksum ++ * ++ * Parameters: ++ * data 32-bit aligned pointer to data to be checksummed ++ * siz size of the data to be checksummed in sizeof() units. ++ * ++ * Effect: ++ * Returns a checksum of the specified block ++ * ++ ************************************************************************/ ++u32 dload_checksum(void *data, unsigned siz) ++{ ++ u32 sum; ++ u32 *dp; ++ int left; ++ ++ sum = 0; ++ dp = (u32 *)data; ++ for (left = siz; left > 0; left -= sizeof(u32)) ++ sum += *dp++; ++ return sum; ++} /* dload_checksum */ ++ ++#if HOST_ENDIANNESS ++/************************************************************************* ++ * Procedure dload_reverse_checksum ++ * ++ * Parameters: ++ * data 32-bit aligned pointer to data to be checksummed ++ * siz size of the data to be checksummed in sizeof() units. ++ * ++ * Effect: ++ * Returns a checksum of the specified block, which is assumed to be bytes ++ * in big-endian order. ++ * ++ * Notes: ++ * In a big-endian host, things like the string table are stored as bytes ++ * in host order. But dllcreate always checksums in little-endian order. ++ * It is most efficient to just handle the difference a word at a time. ++ * ++ ***********************************************************************/ ++u32 dload_reverse_checksum(void *data, unsigned siz) ++{ ++ u32 sum, temp; ++ u32 *dp; ++ int left; ++ ++ sum = 0; ++ dp = (u32 *)data; ++ ++ for (left = siz; left > 0; left -= sizeof(u32)) { ++ temp = *dp++; ++ sum += temp << BITS_PER_BYTE * 3; ++ sum += temp >> BITS_PER_BYTE * 3; ++ sum += (temp >> BITS_PER_BYTE) & (BYTE_MASK << BITS_PER_BYTE); ++ sum += (temp & (BYTE_MASK << BITS_PER_BYTE)) << BITS_PER_BYTE; ++ } ++ ++ return sum; ++} /* dload_reverse_checksum */ ++ ++#if (TARGET_AU_BITS > 8) && (TARGET_AU_BITS < 32) ++u32 dload_reverse_checksum_16(void *data, unsigned siz) ++{ ++ uint_fast32_t sum, temp; ++ u32 *dp; ++ int left; ++ ++ sum = 0; ++ dp = (u32 *)data; ++ ++ for (left = siz; left > 0; left -= sizeof(u32)) { ++ temp = *dp++; ++ sum += temp << BITS_PER_BYTE * 2; ++ sum += temp >> BITS_PER_BYTE * 2; ++ } ++ ++ return sum; ++} /* dload_reverse_checksum_16 */ ++#endif ++#endif ++ ++/************************************************************************* ++ * Procedure swap_words ++ * ++ * Parameters: ++ * data 32-bit aligned pointer to data to be swapped ++ * siz size of the data to be swapped. ++ * bitmap Bit map of how to swap each 32-bit word; 1 => 2 shorts, ++ * 0 => 1 long ++ * ++ * Effect: ++ * Swaps the specified data according to the specified map ++ * ++ ************************************************************************/ ++static void swap_words(void *data, unsigned siz, unsigned bitmap) ++{ ++ register int i; ++#if TARGET_AU_BITS < 16 ++ register u16 *sp; ++#endif ++ register u32 *lp; ++ ++ siz /= sizeof(u16); ++ ++#if TARGET_AU_BITS < 16 ++ /* pass 1: do all the bytes */ ++ i = siz; ++ sp = (u16 *) data; ++ do { ++ register u16 tmp; ++ tmp = *sp; ++ *sp++ = SWAP16BY8(tmp); ++ } while ((i -= 1) > 0); ++#endif ++ ++#if TARGET_AU_BITS < 32 ++ /* pass 2: fixup the 32-bit words */ ++ i = siz >> 1; ++ lp = (u32 *) data; ++ do { ++ if ((bitmap & 1) == 0) { ++ register u32 tmp; ++ tmp = *lp; ++ *lp = SWAP32BY16(tmp); ++ } ++ lp += 1; ++ bitmap >>= 1; ++ } while ((i -= 1) > 0); ++#endif ++} /* swap_words */ ++ ++/************************************************************************* ++ * Procedure copy_tgt_strings ++ * ++ * Parameters: ++ * dstp Destination address. Assumed to be 32-bit aligned ++ * srcp Source address. Assumed to be 32-bit aligned ++ * charcount Number of characters to copy. ++ * ++ * Effect: ++ * Copies strings from the source (which is in usual .dof file order on ++ * the loading processor) to the destination buffer (which should be in proper ++ * target addressable unit order). Makes sure the last string in the ++ * buffer is NULL terminated (for safety). ++ * Returns the first unused destination address. ++ ************************************************************************/ ++static char *copy_tgt_strings(void *dstp, void *srcp, unsigned charcount) ++{ ++ register TgtAU_t *src = (TgtAU_t *)srcp; ++ register TgtAU_t *dst = (TgtAU_t *)dstp; ++ register int cnt = charcount; ++ do { ++#if TARGET_AU_BITS <= BITS_PER_AU ++ /* byte-swapping issues may exist for strings on target */ ++ *dst++ = *src++; ++#elif TARGET_ENDIANNESS_DIFFERS(TARGET_BIG_ENDIAN) ++ register TgtAU_t tmp; ++ tmp = *src++; ++ *dst++ = SWAP16BY8(tmp); /* right for TARGET_AU_BITS == 16 */ ++#else ++ *dst++ = *src++; ++#endif ++ } while ((cnt -= (sizeof(TgtAU_t) * BITS_PER_AU / BITS_PER_BYTE)) > 0); ++ /*apply force to make sure that the string table has null terminator */ ++#if (BITS_PER_AU == BITS_PER_BYTE) && (TARGET_AU_BITS == BITS_PER_BYTE) ++ dst[-1] = 0; ++#elif TARGET_BIG_ENDIAN ++ dst[-1] &= ~BYTE_MASK; /* big-endian */ ++#else ++ dst[-1] &= (1 << (BITS_PER_AU - BITS_PER_BYTE)) - 1; /* little endian */ ++#endif ++ return (char *)dst; ++} /* copy_tgt_strings */ ++ ++/************************************************************************* ++ * Procedure init_module_handle ++ * ++ * Parameters: ++ * none ++ * ++ * Effect: ++ * Initializes the module handle we use to enable unloading, and installs ++ * the debug information required by the target. ++ * ++ * Notes: ++ * The handle returned from Dynamic_Load_Module needs to encapsulate all the ++ * allocations done for the module, and enable them plus the modules symbols to ++ * be deallocated. ++ * ++ ************************************************************************/ ++#ifndef _BIG_ENDIAN ++static const struct LDR_SECTION_INFO DLLVIEW_INFO_INIT = { ".dllview", 0, 0, ++ (LDR_ADDR) -1, DBG_LIST_PAGE, DLOAD_DATA, 0 }; ++#else ++static const struct LDR_SECTION_INFO DLLVIEW_INFO_INIT = { ".dllview", 0, 0, ++ (LDR_ADDR) -1, DLOAD_DATA, DBG_LIST_PAGE, 0 }; ++#endif ++static void init_module_handle(struct dload_state *dlthis) ++{ ++ struct my_handle *hndl; ++ u16 curr_sect; ++ struct LDR_SECTION_INFO *asecs; ++ struct dll_module *dbmod; ++ struct dll_sect *dbsec; ++ struct dbg_mirror_root *mlist; ++ register char *cp; ++ struct modules_header mhdr; ++ struct LDR_SECTION_INFO dllview_info; ++ struct dynload_symbol *debug_mirror_sym; ++ hndl = dlthis->myhandle; ++ if (!hndl) ++ return; /* must be errors detected, so forget it */ ++ hndl->secn_count = dlthis->allocated_secn_count << 1; ++#ifndef TARGET_ENDIANNESS ++ if (dlthis->big_e_target) ++ hndl->secn_count += 1; /* flag for big-endian */ ++#endif ++ if (dlthis->dload_errcount) ++ return; /* abandon if errors detected */ ++ /* Locate the symbol that names the header for the CCS debug list ++ of modules. If not found, we just don't generate the debug record. ++ If found, we create our modules list. We make sure to create the ++ LOADER_DLLVIEW_ROOT even if there is no relocation info to record, ++ just to try to put both symbols in the same symbol table and ++ module.*/ ++ debug_mirror_sym = dlthis->mysym->Find_Matching_Symbol(dlthis->mysym, ++ LOADER_DLLVIEW_ROOT); ++ if (!debug_mirror_sym) { ++ struct dynload_symbol *dlmodsym; ++ struct dbg_mirror_root *mlst; ++ ++ /* our root symbol is not yet present; ++ check if we have DLModules defined */ ++ dlmodsym = dlthis->mysym->Find_Matching_Symbol(dlthis->mysym, ++ LINKER_MODULES_HEADER); ++ if (!dlmodsym) ++ return; /* no DLModules list so no debug info */ ++ /* if we have DLModules defined, construct our header */ ++ mlst = (struct dbg_mirror_root *) ++ dlthis->mysym->Allocate(dlthis->mysym, ++ sizeof(struct dbg_mirror_root)); ++ if (!mlst) { ++ DL_ERROR(E_ALLOC, sizeof(struct dbg_mirror_root)); ++ return; ++ } ++ mlst->hnext = NULL; ++ mlst->changes = 0; ++ mlst->refcount = 0; ++ mlst->dbthis = TDATA_TO_TADDR(dlmodsym->value); ++ /* add our root symbol */ ++ debug_mirror_sym = dlthis->mysym->Add_To_Symbol_Table ++ (dlthis->mysym, LOADER_DLLVIEW_ROOT, ++ (unsigned)dlthis->myhandle); ++ if (!debug_mirror_sym) { ++ /* failed, recover memory */ ++ dlthis->mysym->Deallocate(dlthis->mysym, mlst); ++ return; ++ } ++ debug_mirror_sym->value = (u32)mlst; ++ } ++ /* First create the DLLview record and stuff it into the buffer. ++ Then write it to the DSP. Record pertinent locations in our hndl, ++ and add it to the per-processor list of handles with debug info.*/ ++#ifndef DEBUG_HEADER_IN_LOADER ++ mlist = (struct dbg_mirror_root *)debug_mirror_sym->value; ++ if (!mlist) ++ return; ++#else ++ mlist = (struct dbg_mirror_root *)&debug_list_header; ++#endif ++ hndl->dm.hroot = mlist; /* set pointer to root into our handle */ ++ if (!dlthis->allocated_secn_count) ++ return; /* no load addresses to be recorded */ ++ /* reuse temporary symbol storage */ ++ dbmod = (struct dll_module *) dlthis->local_symtab; ++ /* Create the DLLview record in the memory we retain for our handle*/ ++ dbmod->num_sects = dlthis->allocated_secn_count; ++ dbmod->timestamp = dlthis->verify.dv_timdat; ++ dbmod->version = INIT_VERSION; ++ dbmod->verification = VERIFICATION; ++ asecs = dlthis->ldr_sections; ++ dbsec = dbmod->sects; ++ for (curr_sect = dlthis->allocated_secn_count; ++ curr_sect > 0; curr_sect -= 1) { ++ dbsec->sect_load_adr = asecs->load_addr; ++ dbsec->sect_run_adr = asecs->run_addr; ++ dbsec += 1; ++ asecs += 1; ++ } ++ /* now cram in the names */ ++ cp = copy_tgt_strings(dbsec, dlthis->str_head, ++ dlthis->debug_string_size); ++ ++ /* round off the size of the debug record, and remember same */ ++ hndl->dm.dbsiz = HOST_TO_TDATA_ROUND(cp - (char *)dbmod); ++ *cp = 0; /* strictly to make our test harness happy */ ++ dllview_info = DLLVIEW_INFO_INIT; ++ dllview_info.size = TDATA_TO_TADDR(hndl->dm.dbsiz); ++ /* Initialize memory context to default heap */ ++ dllview_info.context = 0; ++ hndl->dm.context = 0; ++ /* fill in next pointer and size */ ++ if (mlist->hnext) { ++ dbmod->next_module = TADDR_TO_TDATA(mlist->hnext->dm.dbthis); ++ dbmod->next_module_size = mlist->hnext->dm.dbsiz; ++ } else { ++ dbmod->next_module_size = 0; ++ dbmod->next_module = 0; ++ } ++ /* allocate memory for on-DSP DLLview debug record */ ++ if (!dlthis->myalloc) ++ return; ++ if (!dlthis->myalloc->Allocate(dlthis->myalloc, &dllview_info, ++ HOST_TO_TADDR(sizeof(u32)))) { ++ return; ++ } ++ /* Store load address of .dllview section */ ++ hndl->dm.dbthis = dllview_info.load_addr; ++ /* Store memory context (segid) in which .dllview section ++ * was allocated */ ++ hndl->dm.context = dllview_info.context; ++ mlist->refcount += 1; ++ /* swap bytes in the entire debug record, but not the string table */ ++ if (TARGET_ENDIANNESS_DIFFERS(TARGET_BIG_ENDIAN)) { ++ swap_words(dbmod, (char *)dbsec - (char *)dbmod, ++ DLL_MODULE_BITMAP); ++ } ++ /* Update the DLLview list on the DSP write new record */ ++ if (!dlthis->myio->writemem(dlthis->myio, dbmod, ++ dllview_info.load_addr, &dllview_info, ++ TADDR_TO_HOST(dllview_info.size))) { ++ return; ++ } ++ /* write new header */ ++ mhdr.first_module_size = hndl->dm.dbsiz; ++ mhdr.first_module = TADDR_TO_TDATA(dllview_info.load_addr); ++ /* swap bytes in the module header, if needed */ ++ if (TARGET_ENDIANNESS_DIFFERS(TARGET_BIG_ENDIAN)) { ++ swap_words(&mhdr, sizeof(struct modules_header) - sizeof(u16), ++ MODULES_HEADER_BITMAP); ++ } ++ dllview_info = DLLVIEW_INFO_INIT; ++ if (!dlthis->myio->writemem(dlthis->myio, &mhdr, mlist->dbthis, ++ &dllview_info, sizeof(struct modules_header) - ++ sizeof(u16))) { ++ return; ++ } ++ /* Add the module handle to this processor's list ++ of handles with debug info */ ++ hndl->dm.hnext = mlist->hnext; ++ if (hndl->dm.hnext) ++ hndl->dm.hnext->dm.hprev = hndl; ++ hndl->dm.hprev = (struct my_handle *) mlist; ++ mlist->hnext = hndl; /* insert after root*/ ++} /* init_module_handle */ ++ ++/************************************************************************* ++ * Procedure Dynamic_Unload_Module ++ * ++ * Parameters: ++ * mhandle A module handle from Dynamic_Load_Module ++ * syms Host-side symbol table and malloc/free functions ++ * alloc Target-side memory allocation ++ * ++ * Effect: ++ * The module specified by mhandle is unloaded. Unloading causes all ++ * target memory to be deallocated, all symbols defined by the module to ++ * be purged, and any host-side storage used by the dynamic loader for ++ * this module to be released. ++ * ++ * Returns: ++ * Zero for success. On error, the number of errors detected is returned. ++ * Individual errors are reported using syms->Error_Report(). ++ ************************************************************************/ ++int Dynamic_Unload_Module(DLOAD_mhandle mhandle, ++ struct Dynamic_Loader_Sym *syms, ++ struct Dynamic_Loader_Allocate *alloc, ++ struct Dynamic_Loader_Initialize *init) ++{ ++ s16 curr_sect; ++ struct LDR_SECTION_INFO *asecs; ++ struct my_handle *hndl; ++ struct dbg_mirror_root *root; ++ unsigned errcount = 0; ++ struct LDR_SECTION_INFO dllview_info = DLLVIEW_INFO_INIT; ++ struct modules_header mhdr; ++ ++ hndl = (struct my_handle *)mhandle; ++ if (!hndl) ++ return 0; /* if handle is null, nothing to do */ ++ /* Clear out the module symbols ++ * Note that if this is the module that defined MODULES_HEADER ++ (the head of the target debug list) ++ * then this operation will blow away that symbol. ++ It will therefore be impossible for subsequent ++ * operations to add entries to this un-referenceable list.*/ ++ if (!syms) ++ return 1; ++ syms->Purge_Symbol_Table(syms, (unsigned) hndl); ++ /* Deallocate target memory for sections */ ++ asecs = hndl->secns; ++ if (alloc) ++ for (curr_sect = (hndl->secn_count >> 1); curr_sect > 0; ++ curr_sect -= 1) { ++ asecs->name = NULL; ++ alloc->Deallocate(alloc, asecs++); ++ } ++ root = hndl->dm.hroot; ++ if (!root) { ++ /* there is a debug list containing this module */ ++ goto func_end; ++ } ++ if (!hndl->dm.dbthis) { /* target-side dllview record exists */ ++ goto loop_end; ++ } ++ /* Retrieve memory context in which .dllview was allocated */ ++ dllview_info.context = hndl->dm.context; ++ if (hndl->dm.hprev == hndl) ++ goto exitunltgt; ++ ++ /* target-side dllview record is in list */ ++ /* dequeue this record from our GPP-side mirror list */ ++ hndl->dm.hprev->dm.hnext = hndl->dm.hnext; ++ if (hndl->dm.hnext) ++ hndl->dm.hnext->dm.hprev = hndl->dm.hprev; ++ /* Update next_module of previous entry in target list ++ * We are using mhdr here as a surrogate for either a ++ struct modules_header or a dll_module */ ++ if (hndl->dm.hnext) { ++ mhdr.first_module = TADDR_TO_TDATA(hndl->dm.hnext->dm.dbthis); ++ mhdr.first_module_size = hndl->dm.hnext->dm.dbsiz; ++ } else { ++ mhdr.first_module = 0; ++ mhdr.first_module_size = 0; ++ } ++ if (!init) ++ goto exitunltgt; ++ ++ if (!init->connect(init)) { ++ dload_syms_error(syms, E_ICONNECT); ++ errcount += 1; ++ goto exitunltgt; ++ } ++ /* swap bytes in the module header, if needed */ ++ if (TARGET_ENDIANNESS_DIFFERS(hndl->secn_count & 0x1)) { ++ swap_words(&mhdr, sizeof(struct modules_header) - sizeof(u16), ++ MODULES_HEADER_BITMAP); ++ } ++ if (!init->writemem(init, &mhdr, hndl->dm.hprev->dm.dbthis, ++ &dllview_info, sizeof(struct modules_header) - ++ sizeof(mhdr.update_flag))) { ++ dload_syms_error(syms, E_DLVWRITE); ++ errcount += 1; ++ } ++ /* update change counter */ ++ root->changes += 1; ++ if (!init->writemem(init, &(root->changes), ++ root->dbthis + HOST_TO_TADDR ++ (sizeof(mhdr.first_module) + ++ sizeof(mhdr.first_module_size)), ++ &dllview_info, ++ sizeof(mhdr.update_flag))) { ++ dload_syms_error(syms, E_DLVWRITE); ++ errcount += 1; ++ } ++ init->release(init); ++exitunltgt: ++ /* release target storage */ ++ dllview_info.size = TDATA_TO_TADDR(hndl->dm.dbsiz); ++ dllview_info.load_addr = hndl->dm.dbthis; ++ if (alloc) ++ alloc->Deallocate(alloc, &dllview_info); ++ root->refcount -= 1; ++ /* target-side dllview record exists */ ++loop_end: ++#ifndef DEBUG_HEADER_IN_LOADER ++ if (root->refcount <= 0) { ++ /* if all references gone, blow off the header */ ++ /* our root symbol may be gone due to the Purge above, ++ but if not, do not destroy the root */ ++ if (syms->Find_Matching_Symbol ++ (syms, LOADER_DLLVIEW_ROOT) == NULL) ++ syms->Deallocate(syms, root); ++ } ++#endif ++func_end: ++ /* there is a debug list containing this module */ ++ syms->Deallocate(syms, mhandle); /* release our storage */ ++ return errcount; ++} /* Dynamic_Unload_Module */ ++ ++#if BITS_PER_AU > BITS_PER_BYTE ++/************************************************************************* ++ * Procedure unpack_name ++ * ++ * Parameters: ++ * soffset Byte offset into the string table ++ * ++ * Effect: ++ * Returns a pointer to the string specified by the offset supplied, or ++ * NULL for error. ++ * ++ ************************************************************************/ ++static char *unpack_name(struct dload_state *dlthis, u32 soffset) ++{ ++ u8 tmp, *src; ++ char *dst; ++ ++ if (soffset >= dlthis->dfile_hdr.df_strtab_size) { ++ dload_error(dlthis, "Bad string table offset " FMT_UI32, ++ soffset); ++ return NULL; ++ } ++ src = (uint_least8_t *)dlthis->str_head + ++ (soffset >> (LOG_BITS_PER_AU - LOG_BITS_PER_BYTE)); ++ dst = dlthis->str_temp; ++ if (soffset & 1) ++ *dst++ = *src++; /* only 1 character in first word */ ++ do { ++ tmp = *src++; ++ *dst = (tmp >> BITS_PER_BYTE); ++ if (!(*dst++)) ++ break; ++ } while ((*dst++ = tmp & BYTE_MASK)); ++ dlthis->temp_len = dst - dlthis->str_temp; ++ /* squirrel away length including terminating null */ ++ return dlthis->str_temp; ++} /* unpack_name */ ++#endif +diff --git a/drivers/dsp/bridge/dynload/dlclasses_hdr.h b/drivers/dsp/bridge/dynload/dlclasses_hdr.h +new file mode 100644 +index 0000000..04f136e +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/dlclasses_hdr.h +@@ -0,0 +1,41 @@ ++/* ++ * dlclasses_hdr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#ifndef _DLCLASSES_HDR_H ++#define _DLCLASSES_HDR_H ++ ++/***************************************************************************** ++ ***************************************************************************** ++ * ++ * DLCLASSES_HDR.H ++ * ++ * Sample classes in support of the dynamic loader ++ * ++ * These are just concrete derivations of the virtual ones in dynamic_loader.h ++ * with a few additional interfaces for init, etc. ++ ***************************************************************************** ++ *****************************************************************************/ ++ ++#include <dspbridge/dynamic_loader.h> ++ ++#include "DLstream.h" ++#include "DLsymtab.h" ++#include "DLalloc.h" ++#include "DLinit.h" ++ ++#endif /* _DLCLASSES_HDR_H */ +diff --git a/drivers/dsp/bridge/dynload/dload_internal.h b/drivers/dsp/bridge/dynload/dload_internal.h +new file mode 100644 +index 0000000..78f5058 +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/dload_internal.h +@@ -0,0 +1,237 @@ ++/* ++ * dload_internal.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#ifndef __DLOAD_INTERNAL__ ++#define __DLOAD_INTERNAL__ ++ ++#include <linux/types.h> ++ ++/* ++ * Internal state definitions for the dynamic loader ++ */ ++ ++#define TRUE 1 ++#define FALSE 0 ++typedef int boolean; ++ ++ ++/* type used for relocation intermediate results */ ++typedef s32 RVALUE; ++ ++/* unsigned version of same; must have at least as many bits */ ++typedef u32 URVALUE; ++ ++/* ++ * Dynamic loader configuration constants ++ */ ++/* error issued if input has more sections than this limit */ ++#define REASONABLE_SECTION_LIMIT 100 ++ ++/* (Addressable unit) value used to clear BSS section */ ++#define dload_fill_bss 0 ++ ++/* ++ * Reorder maps explained (?) ++ * ++ * The doff file format defines a 32-bit pattern used to determine the ++ * byte order of an image being read. That value is ++ * BYTE_RESHUFFLE_VALUE == 0x00010203 ++ * For purposes of the reorder routine, we would rather have the all-is-OK ++ * for 32-bits pattern be 0x03020100. This first macro makes the ++ * translation from doff file header value to MAP value: */ ++#define REORDER_MAP(rawmap) ((rawmap) ^ 0x3030303) ++/* This translation is made in dload_headers. Thereafter, the all-is-OK ++ * value for the maps stored in dlthis is REORDER_MAP(BYTE_RESHUFFLE_VALUE). ++ * But sadly, not all bits of the doff file are 32-bit integers. ++ * The notable exceptions are strings and image bits. ++ * Strings obey host byte order: */ ++#if defined(_BIG_ENDIAN) ++#define HOST_BYTE_ORDER(cookedmap) ((cookedmap) ^ 0x3030303) ++#else ++#define HOST_BYTE_ORDER(cookedmap) (cookedmap) ++#endif ++/* Target bits consist of target AUs (could be bytes, or 16-bits, ++ * or 32-bits) stored as an array in host order. A target order ++ * map is defined by: */ ++#if !defined(_BIG_ENDIAN) || TARGET_AU_BITS > 16 ++#define TARGET_ORDER(cookedmap) (cookedmap) ++#elif TARGET_AU_BITS > 8 ++#define TARGET_ORDER(cookedmap) ((cookedmap) ^ 0x2020202) ++#else ++#define TARGET_ORDER(cookedmap) ((cookedmap) ^ 0x3030303) ++#endif ++ ++/* forward declaration for handle returned by dynamic loader */ ++struct my_handle; ++ ++/* ++ * a list of module handles, which mirrors the debug list on the target ++ */ ++struct dbg_mirror_root { ++ /* must be same as dbg_mirror_list; __DLModules address on target */ ++ u32 dbthis; ++ struct my_handle *hnext; /* must be same as dbg_mirror_list */ ++ u16 changes; /* change counter */ ++ u16 refcount; /* number of modules referencing this root */ ++} ; ++ ++struct dbg_mirror_list { ++ u32 dbthis; ++ struct my_handle *hnext, *hprev; ++ struct dbg_mirror_root *hroot; ++ u16 dbsiz; ++ u32 context; /* Save context for .dllview memory allocation */ ++} ; ++ ++#define VARIABLE_SIZE 1 ++/* ++ * the structure we actually return as an opaque module handle ++ */ ++struct my_handle { ++ struct dbg_mirror_list dm; /* !!! must be first !!! */ ++ /* sections following << 1, LSB is set for big-endian target */ ++ u16 secn_count; ++ struct LDR_SECTION_INFO secns[VARIABLE_SIZE]; ++} ; ++#define MY_HANDLE_SIZE (sizeof(struct my_handle) -\ ++ sizeof(struct LDR_SECTION_INFO)) ++/* real size of my_handle */ ++ ++/* ++ * reduced symbol structure used for symbols during relocation ++ */ ++struct Local_Symbol { ++ s32 value; /* Relocated symbol value */ ++ s32 delta; /* Original value in input file */ ++ s16 secnn; /* section number */ ++ s16 sclass; /* symbol class */ ++} ; ++ ++/* ++ * States of the .cinit state machine ++ */ ++enum cinit_mode { ++ CI_count = 0, /* expecting a count */ ++ CI_address, /* expecting an address */ ++#if CINIT_ALIGN < CINIT_ADDRESS /* handle case of partial address field */ ++ CI_partaddress, /* have only part of the address */ ++#endif ++ CI_copy, /* in the middle of copying data */ ++ CI_done /* end of .cinit table */ ++}; ++ ++/* ++ * The internal state of the dynamic loader, which is passed around as ++ * an object ++ */ ++struct dload_state { ++ struct Dynamic_Loader_Stream *strm; /* The module input stream */ ++ struct Dynamic_Loader_Sym *mysym; /* Symbols for this session */ ++ struct Dynamic_Loader_Allocate *myalloc; /* target memory allocator */ ++ struct Dynamic_Loader_Initialize *myio; /* target memory initializer */ ++ unsigned myoptions; /* Options parameter Dynamic_Load_Module */ ++ ++ char *str_head; /* Pointer to string table */ ++#if BITS_PER_AU > BITS_PER_BYTE ++ char *str_temp; /* Pointer to temporary buffer for strings */ ++ /* big enough to hold longest string */ ++ unsigned temp_len; /* length of last temporary string */ ++ char *xstrings; /* Pointer to buffer for expanded */ ++ /* strings for sec names */ ++#endif ++ /* Total size of strings for DLLView section names */ ++ unsigned debug_string_size; ++ /* Pointer to parallel section info for allocated sections only */ ++ struct doff_scnhdr_t *sect_hdrs; /* Pointer to section table */ ++ struct LDR_SECTION_INFO *ldr_sections; ++#if TMS32060 ++ /* The address of the start of the .bss section */ ++ LDR_ADDR bss_run_base; ++#endif ++ struct Local_Symbol *local_symtab; /* Relocation symbol table */ ++ ++ /* pointer to DL section info for the section being relocated */ ++ struct LDR_SECTION_INFO *image_secn; ++ /* change in run address for current section during relocation */ ++ LDR_ADDR delta_runaddr; ++ LDR_ADDR image_offset; /* offset of current packet in section */ ++ enum cinit_mode cinit_state; /* current state of cload_cinit() */ ++ int cinit_count; /* the current count */ ++ LDR_ADDR cinit_addr; /* the current address */ ++ s16 cinit_page; /* the current page */ ++ /* Handle to be returned by Dynamic_Load_Module */ ++ struct my_handle *myhandle; ++ unsigned dload_errcount; /* Total # of errors reported so far */ ++ /* Number of target sections that require allocation and relocation */ ++ unsigned allocated_secn_count; ++#ifndef TARGET_ENDIANNESS ++ boolean big_e_target; /* Target data in big-endian format */ ++#endif ++ /* map for reordering bytes, 0 if not needed */ ++ u32 reorder_map; ++ struct doff_filehdr_t dfile_hdr; /* DOFF file header structure */ ++ struct doff_verify_rec_t verify; /* Verify record */ ++ ++ int relstkidx; /* index into relocation value stack */ ++ /* relocation value stack used in relexp.c */ ++ RVALUE relstk[STATIC_EXPR_STK_SIZE]; ++ ++} ; ++ ++#ifdef TARGET_ENDIANNESS ++#define TARGET_BIG_ENDIAN TARGET_ENDIANNESS ++#else ++#define TARGET_BIG_ENDIAN (dlthis->big_e_target) ++#endif ++ ++/* ++ * Exports from cload.c to rest of the world ++ */ ++extern void dload_error(struct dload_state *dlthis, const char *errtxt, ...); ++extern void dload_syms_error(struct Dynamic_Loader_Sym *syms, ++ const char *errtxt, ...); ++extern void dload_headers(struct dload_state *dlthis); ++extern void dload_strings(struct dload_state *dlthis, boolean sec_names_only); ++extern void dload_sections(struct dload_state *dlthis); ++extern void dload_reorder(void *data, int dsiz, u32 map); ++extern u32 dload_checksum(void *data, unsigned siz); ++ ++#if HOST_ENDIANNESS ++extern uint32_t dload_reverse_checksum(void *data, unsigned siz); ++#if (TARGET_AU_BITS > 8) && (TARGET_AU_BITS < 32) ++extern uint32_t dload_reverse_checksum_16(void *data, unsigned siz); ++#endif ++#endif ++ ++#define is_data_scn(zzz) (DLOAD_SECTION_TYPE((zzz)->type) != DLOAD_TEXT) ++#define is_data_scn_num(zzz) \ ++ (DLOAD_SECT_TYPE(&dlthis->sect_hdrs[(zzz)-1]) != DLOAD_TEXT) ++ ++/* ++ * exported by reloc.c ++ */ ++extern void dload_relocate(struct dload_state *dlthis, TgtAU_t *data, ++ struct reloc_record_t *rp); ++ ++extern RVALUE dload_unpack(struct dload_state *dlthis, TgtAU_t *data, ++ int fieldsz, int offset, unsigned sgn); ++ ++extern int dload_repack(struct dload_state *dlthis, RVALUE val, TgtAU_t *data, ++ int fieldsz, int offset, unsigned sgn); ++ ++#endif /* __DLOAD_INTERNAL__ */ +diff --git a/drivers/dsp/bridge/dynload/doff.h b/drivers/dsp/bridge/dynload/doff.h +new file mode 100644 +index 0000000..2b8fc37 +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/doff.h +@@ -0,0 +1,347 @@ ++/* ++ * doff.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/*****************************************************************************/ ++/* DOFF.H - Structures & definitions used for dynamically */ ++/* loaded modules file format. This format is a reformatted */ ++/* version of COFF.(see coff.h for details) It optimizes the */ ++/* layout for the dynamic loader. */ ++/* */ ++/* .dof files, when viewed as a sequence of 32-bit integers, look the same */ ++/* on big-endian and little-endian machines. */ ++/*****************************************************************************/ ++#ifndef _DOFF_H ++#define _DOFF_H ++ ++#ifndef UINT32_C ++#define UINT32_C(zzz) ((u32)zzz) ++#endif ++ ++#define BYTE_RESHUFFLE_VALUE UINT32_C(0x00010203) ++ ++/* DOFF file header containing fields categorizing the remainder of the file */ ++struct doff_filehdr_t { ++ ++ /* string table size, including filename, in bytes */ ++ u32 df_strtab_size; ++ ++ /* entry point if one exists */ ++ u32 df_entrypt; ++ ++ /* identifies byte ordering of file; ++ * always set to BYTE_RESHUFFLE_VALUE */ ++ u32 df_byte_reshuffle; ++ ++ /* Size of the string table up to and including the last section name */ ++ /* Size includes the name of the COFF file also */ ++ u32 df_scn_name_size; ++ ++#ifndef _BIG_ENDIAN ++ /* number of symbols */ ++ u16 df_no_syms; ++ ++ /* length in bytes of the longest string, including terminating NULL */ ++ /* excludes the name of the file */ ++ u16 df_max_str_len; ++ ++ /* total number of sections including no-load ones */ ++ u16 df_no_scns; ++ ++ /* number of sections containing target code allocated or downloaded */ ++ u16 df_target_scns; ++ ++ /* unique id for dll file format & version */ ++ u16 df_doff_version; ++ ++ /* identifies ISA */ ++ u16 df_target_id; ++ ++ /* useful file flags */ ++ u16 df_flags; ++ ++ /* section reference for entry point, N_UNDEF for none, */ ++ /* N_ABS for absolute address */ ++ s16 df_entry_secn; ++#else ++ /* length of the longest string, including terminating NULL */ ++ u16 df_max_str_len; ++ ++ /* number of symbols */ ++ u16 df_no_syms; ++ ++ /* number of sections containing target code allocated or downloaded */ ++ u16 df_target_scns; ++ ++ /* total number of sections including no-load ones */ ++ u16 df_no_scns; ++ ++ /* identifies ISA */ ++ u16 df_target_id; ++ ++ /* unique id for dll file format & version */ ++ u16 df_doff_version; ++ ++ /* section reference for entry point, N_UNDEF for none, */ ++ /* N_ABS for absolute address */ ++ s16 df_entry_secn; ++ ++ /* useful file flags */ ++ u16 df_flags; ++#endif ++ /* checksum for file header record */ ++ u32 df_checksum; ++ ++} ; ++ ++/* flags in the df_flags field */ ++#define DF_LITTLE 0x100 ++#define DF_BIG 0x200 ++#define DF_BYTE_ORDER (DF_LITTLE | DF_BIG) ++ ++/* Supported processors */ ++#define TMS470_ID 0x97 ++#define LEAD_ID 0x98 ++#define TMS32060_ID 0x99 ++#define LEAD3_ID 0x9c ++ ++/* Primary processor for loading */ ++#if TMS32060 ++#define TARGET_ID TMS32060_ID ++#endif ++ ++/* Verification record containing values used to test integrity of the bits */ ++struct doff_verify_rec_t { ++ ++ /* time and date stamp */ ++ u32 dv_timdat; ++ ++ /* checksum for all section records */ ++ u32 dv_scn_rec_checksum; ++ ++ /* checksum for string table */ ++ u32 dv_str_tab_checksum; ++ ++ /* checksum for symbol table */ ++ u32 dv_sym_tab_checksum; ++ ++ /* checksum for verification record */ ++ u32 dv_verify_rec_checksum; ++ ++} ; ++ ++/* String table is an array of null-terminated strings. The first entry is ++ * the filename, which is added by DLLcreate. No new structure definitions ++ * are required. ++ */ ++ ++/* Section Records including information on the corresponding image packets */ ++/* ++ * !!WARNING!! ++ * ++ * This structure is expected to match in form LDR_SECTION_INFO in ++ * dynamic_loader.h ++ */ ++ ++struct doff_scnhdr_t { ++ ++ s32 ds_offset; /* offset into string table of name */ ++ s32 ds_paddr; /* RUN address, in target AU */ ++ s32 ds_vaddr; /* LOAD address, in target AU */ ++ s32 ds_size; /* section size, in target AU */ ++#ifndef _BIG_ENDIAN ++ u16 ds_page; /* memory page id */ ++ u16 ds_flags; /* section flags */ ++#else ++ u16 ds_flags; /* section flags */ ++ u16 ds_page; /* memory page id */ ++#endif ++ u32 ds_first_pkt_offset; ++ /* Absolute byte offset into the file */ ++ /* where the first image record resides */ ++ ++ s32 ds_nipacks; /* number of image packets */ ++ ++}; ++ ++/* Symbol table entry */ ++struct doff_syment_t { ++ ++ s32 dn_offset; /* offset into string table of name */ ++ s32 dn_value; /* value of symbol */ ++#ifndef _BIG_ENDIAN ++ s16 dn_scnum; /* section number */ ++ s16 dn_sclass; /* storage class */ ++#else ++ s16 dn_sclass; /* storage class */ ++ s16 dn_scnum; /* section number, 1-based */ ++#endif ++ ++} ; ++ ++/* special values for dn_scnum */ ++#define DN_UNDEF 0 /* undefined symbol */ ++#define DN_ABS (-1) /* value of symbol is absolute */ ++/* special values for dn_sclass */ ++#define DN_EXT 2 ++#define DN_STATLAB 20 ++#define DN_EXTLAB 21 ++ ++/* Default value of image bits in packet */ ++/* Configurable by user on the command line */ ++#define IMAGE_PACKET_SIZE 1024 ++ ++/* An image packet contains a chunk of data from a section along with */ ++/* information necessary for its processing. */ ++struct image_packet_t { ++ ++ s32 i_num_relocs; /* number of relocations for */ ++ /* this packet */ ++ ++ s32 i_packet_size; /* number of bytes in array */ ++ /* "bits" occupied by */ ++ /* valid data. Could be */ ++ /* < IMAGE_PACKET_SIZE to */ ++ /* prevent splitting a */ ++ /* relocation across packets. */ ++ /* Last packet of a section */ ++ /* will most likely contain */ ++ /* < IMAGE_PACKET_SIZE bytes */ ++ /* of valid data */ ++ ++ s32 i_checksum; /* Checksum for image packet */ ++ /* and the corresponding */ ++ /* relocation records */ ++ ++ u8 *i_bits; /* Actual data in section */ ++ ++}; ++ ++/* The relocation structure definition matches the COFF version. Offsets */ ++/* however are relative to the image packet base not the section base. */ ++struct reloc_record_t { ++ ++ s32 r_vaddr; ++ ++ /* expressed in target AUs */ ++ ++ union { ++ struct { ++#ifndef _BIG_ENDIAN ++ u8 _offset; /* bit offset of rel fld */ ++ u8 _fieldsz; /* size of rel fld */ ++ u8 _wordsz; /* # bytes containing rel fld */ ++ u8 _dum1; ++ u16 _dum2; ++ u16 _type; ++#else ++ unsigned _dum1:8; ++ unsigned _wordsz:8; /* # bytes containing rel fld */ ++ unsigned _fieldsz:8; /* size of rel fld */ ++ unsigned _offset:8; /* bit offset of rel fld */ ++ u16 _type; ++ u16 _dum2; ++#endif ++ } _r_field; ++ ++ struct { ++ u32 _spc; /* image packet relative PC */ ++#ifndef _BIG_ENDIAN ++ u16 _dum; ++ u16 _type; /* relocation type */ ++#else ++ u16 _type; /* relocation type */ ++ u16 _dum; ++#endif ++ } _r_spc; ++ ++ struct { ++ u32 _uval; /* constant value */ ++#ifndef _BIG_ENDIAN ++ u16 _dum; ++ u16 _type; /* relocation type */ ++#else ++ u16 _type; /* relocation type */ ++ u16 _dum; ++#endif ++ } _r_uval; ++ ++ struct { ++ s32 _symndx; /* 32-bit sym tbl index */ ++#ifndef _BIG_ENDIAN ++ u16 _disp; /* extra addr encode data */ ++ u16 _type; /* relocation type */ ++#else ++ u16 _type; /* relocation type */ ++ u16 _disp; /* extra addr encode data */ ++#endif ++ } _r_sym; ++ } _u_reloc; ++ ++} ; ++ ++/* abbreviations for convenience */ ++#ifndef r_type ++#define r_type _u_reloc._r_sym._type ++#define r_uval _u_reloc._r_uval._uval ++#define r_symndx _u_reloc._r_sym._symndx ++#define r_offset _u_reloc._r_field._offset ++#define r_fieldsz _u_reloc._r_field._fieldsz ++#define r_wordsz _u_reloc._r_field._wordsz ++#define r_disp _u_reloc._r_sym._disp ++#endif ++ ++/*****************************************************************************/ ++/* */ ++/* Important DOFF macros used for file processing */ ++/* */ ++/*****************************************************************************/ ++ ++/* DOFF Versions */ ++#define DOFF0 0 ++ ++/* Return the address/size >= to addr that is at a 32-bit boundary */ ++/* This assumes that a byte is 8 bits */ ++#define DOFF_ALIGN(addr) (((addr) + 3) & ~UINT32_C(3)) ++ ++/*****************************************************************************/ ++/* */ ++/* The DOFF section header flags field is laid out as follows: */ ++/* */ ++/* Bits 0-3 : Section Type */ ++/* Bit 4 : Set when section requires target memory to be allocated by DL */ ++/* Bit 5 : Set when section requires downloading */ ++/* Bits 8-11: Alignment, same as COFF */ ++/* */ ++/*****************************************************************************/ ++ ++/* Enum for DOFF section types (bits 0-3 of flag): See dynamic_loader.h */ ++ ++/* Macros to help processing of sections */ ++#define DLOAD_SECT_TYPE(s_hdr) ((s_hdr)->ds_flags & 0xF) ++ ++/* DS_ALLOCATE indicates whether a section needs space on the target */ ++#define DS_ALLOCATE_MASK 0x10 ++#define DS_NEEDS_ALLOCATION(s_hdr) ((s_hdr)->ds_flags & DS_ALLOCATE_MASK) ++ ++/* DS_DOWNLOAD indicates that the loader needs to copy bits */ ++#define DS_DOWNLOAD_MASK 0x20 ++#define DS_NEEDS_DOWNLOAD(s_hdr) ((s_hdr)->ds_flags & DS_DOWNLOAD_MASK) ++ ++/* Section alignment requirement in AUs */ ++#define DS_ALIGNMENT(ds_flags) (1 << (((ds_flags) >> 8) & 0xF)) ++ ++#endif /* _DOFF_H */ +diff --git a/drivers/dsp/bridge/dynload/getsection.c b/drivers/dsp/bridge/dynload/getsection.c +new file mode 100644 +index 0000000..78a301a +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/getsection.c +@@ -0,0 +1,412 @@ ++/* ++ * getsection.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#include <dspbridge/getsection.h> ++#include "header.h" ++ ++/* ++ * Error strings ++ */ ++static const char E_READSTRM[] = { "Error reading %s from input stream" }; ++static const char E_SEEK[] = { "Set file position to %d failed" }; ++static const char E_ISIZ[] = { "Bad image packet size %d" }; ++static const char E_CHECKSUM[] = { "Checksum failed on %s" }; ++static const char E_RELOC[] = { "DLOAD_GetSection unable to read" ++ "sections containing relocation entries"}; ++#if BITS_PER_AU > BITS_PER_BYTE ++static const char E_ALLOC[] = { "Syms->Allocate( %d ) failed" }; ++static const char E_STBL[] = { "Bad string table offset " FMT_UI32 }; ++#endif ++ ++/* ++ * we use the fact that DOFF section records are shaped just like ++ * LDR_SECTION_INFO to reduce our section storage usage. These macros ++ * marks the places where that assumption is made ++ */ ++#define DOFFSEC_IS_LDRSEC(pdoffsec) ((struct LDR_SECTION_INFO *)(pdoffsec)) ++#define LDRSEC_IS_DOFFSEC(ldrsec) ((struct doff_scnhdr_t *)(ldrsec)) ++ ++/***************************************************************/ ++/********************* SUPPORT FUNCTIONS ***********************/ ++/***************************************************************/ ++ ++#if BITS_PER_AU > BITS_PER_BYTE ++/************************************************************************** ++ * Procedure unpack_sec_name ++ * ++ * Parameters: ++ * dlthis Handle from DLOAD_module_open for this module ++ * soffset Byte offset into the string table ++ * dst Place to store the expanded string ++ * ++ * Effect: ++ * Stores a string from the string table into the destination, expanding ++ * it in the process. Returns a pointer just past the end of the stored ++ * string on success, or NULL on failure. ++ * ++ *************************************************************************/ ++static char *unpack_sec_name(struct dload_state *dlthis, ++ u32 soffset, char *dst) ++{ ++ u8 tmp, *src; ++ ++ if (soffset >= dlthis->dfile_hdr.df_scn_name_size) { ++ dload_error(dlthis, E_STBL, soffset); ++ return NULL; ++ } ++ src = (u8 *)dlthis->str_head + ++ (soffset >> (LOG_BITS_PER_AU - LOG_BITS_PER_BYTE)); ++ if (soffset & 1) ++ *dst++ = *src++; /* only 1 character in first word */ ++ do { ++ tmp = *src++; ++ *dst = (tmp >> BITS_PER_BYTE) ++ if (!(*dst++)) ++ break; ++ } while ((*dst++ = tmp & BYTE_MASK)); ++ ++ return dst; ++} ++ ++/************************************************************************** ++ * Procedure expand_sec_names ++ * ++ * Parameters: ++ * dlthis Handle from DLOAD_module_open for this module ++ * ++ * Effect: ++ * Allocates a buffer, unpacks and copies strings from string table into it. ++ * Stores a pointer to the buffer into a state variable. ++ **************************************************************************/ ++static void expand_sec_names(struct dload_state *dlthis) ++{ ++ char *xstrings, *curr, *next; ++ u32 xsize; ++ u16 sec; ++ struct LDR_SECTION_INFO *shp; ++ /* assume worst-case size requirement */ ++ xsize = dlthis->dfile_hdr.df_max_str_len * dlthis->dfile_hdr.df_no_scns; ++ xstrings = (char *)dlthis->mysym->Allocate(dlthis->mysym, xsize); ++ if (xstrings == NULL) { ++ dload_error(dlthis, E_ALLOC, xsize); ++ return; ++ } ++ dlthis->xstrings = xstrings; ++ /* For each sec, copy and expand its name */ ++ curr = xstrings; ++ for (sec = 0; sec < dlthis->dfile_hdr.df_no_scns; sec++) { ++ shp = DOFFSEC_IS_LDRSEC(&dlthis->sect_hdrs[sec]); ++ next = unpack_sec_name(dlthis, *(u32 *) &shp->name, curr); ++ if (next == NULL) ++ break; /* error */ ++ shp->name = curr; ++ curr = next; ++ } ++} ++ ++#endif ++ ++/***************************************************************/ ++/********************* EXPORTED FUNCTIONS **********************/ ++/***************************************************************/ ++ ++/************************************************************************** ++ * Procedure DLOAD_module_open ++ * ++ * Parameters: ++ * module The input stream that supplies the module image ++ * syms Host-side malloc/free and error reporting functions. ++ * Other methods are unused. ++ * ++ * Effect: ++ * Reads header information from a dynamic loader module using the ++ specified ++ * stream object, and returns a handle for the module information. This ++ * handle may be used in subsequent query calls to obtain information ++ * contained in the module. ++ * ++ * Returns: ++ * NULL if an error is encountered, otherwise a module handle for use ++ * in subsequent operations. ++ **************************************************************************/ ++DLOAD_module_info DLOAD_module_open(struct Dynamic_Loader_Stream *module, ++ struct Dynamic_Loader_Sym *syms) ++{ ++ struct dload_state *dlthis; /* internal state for this call */ ++ unsigned *dp, sz; ++ u32 sec_start; ++#if BITS_PER_AU <= BITS_PER_BYTE ++ u16 sec; ++#endif ++ ++ /* Check that mandatory arguments are present */ ++ if (!module || !syms) { ++ if (syms != NULL) ++ dload_syms_error(syms, "Required parameter is NULL"); ++ ++ return NULL; ++ } ++ ++ dlthis = (struct dload_state *) ++ syms->Allocate(syms, sizeof(struct dload_state)); ++ if (!dlthis) { ++ /* not enough storage */ ++ dload_syms_error(syms, "Can't allocate module info"); ++ return NULL; ++ } ++ ++ /* clear our internal state */ ++ dp = (unsigned *)dlthis; ++ for (sz = sizeof(struct dload_state) / sizeof(unsigned); ++ sz > 0; sz -= 1) ++ *dp++ = 0; ++ ++ dlthis->strm = module; ++ dlthis->mysym = syms; ++ ++ /* read in the doff image and store in our state variable */ ++ dload_headers(dlthis); ++ ++ if (!dlthis->dload_errcount) ++ dload_strings(dlthis, true); ++ ++ /* skip ahead past the unread portion of the string table */ ++ sec_start = sizeof(struct doff_filehdr_t) + ++ sizeof(struct doff_verify_rec_t) + ++ BYTE_TO_HOST(DOFF_ALIGN(dlthis->dfile_hdr.df_strtab_size)); ++ ++ if (dlthis->strm->set_file_posn(dlthis->strm, sec_start) != 0) { ++ dload_error(dlthis, E_SEEK, sec_start); ++ return NULL; ++ } ++ ++ if (!dlthis->dload_errcount) ++ dload_sections(dlthis); ++ ++ if (dlthis->dload_errcount) { ++ DLOAD_module_close(dlthis); /* errors, blow off our state */ ++ dlthis = NULL; ++ return NULL; ++ } ++#if BITS_PER_AU > BITS_PER_BYTE ++ /* Expand all section names from the string table into the */ ++ /* state variable, and convert section names from a relative */ ++ /* string table offset to a pointers to the expanded string. */ ++ expand_sec_names(dlthis); ++#else ++ /* Convert section names from a relative string table offset */ ++ /* to a pointer into the string table. */ ++ for (sec = 0; sec < dlthis->dfile_hdr.df_no_scns; sec++) { ++ struct LDR_SECTION_INFO *shp = ++ DOFFSEC_IS_LDRSEC(&dlthis->sect_hdrs[sec]); ++ shp->name = dlthis->str_head + *(u32 *)&shp->name; ++ } ++#endif ++ ++ return dlthis; ++} ++ ++/*************************************************************************** ++ * Procedure DLOAD_GetSectionInfo ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * sectionName Pointer to the string name of the section desired ++ * sectionInfo Address of a section info structure pointer to be ++ * initialized ++ * ++ * Effect: ++ * Finds the specified section in the module information, and initializes ++ * the provided struct LDR_SECTION_INFO pointer. ++ * ++ * Returns: ++ * true for success, false for section not found ++ **************************************************************************/ ++int DLOAD_GetSectionInfo(DLOAD_module_info minfo, const char *sectionName, ++ const struct LDR_SECTION_INFO **const sectionInfo) ++{ ++ struct dload_state *dlthis; ++ struct LDR_SECTION_INFO *shp; ++ u16 sec; ++ ++ dlthis = (struct dload_state *)minfo; ++ if (!dlthis) ++ return false; ++ ++ for (sec = 0; sec < dlthis->dfile_hdr.df_no_scns; sec++) { ++ shp = DOFFSEC_IS_LDRSEC(&dlthis->sect_hdrs[sec]); ++ if (strcmp(sectionName, shp->name) == 0) { ++ *sectionInfo = shp; ++ return true; ++ } ++ } ++ ++ return false; ++} ++ ++#define IPH_SIZE (sizeof(struct image_packet_t) - sizeof(u32)) ++#define REVERSE_REORDER_MAP(rawmap) ((rawmap) ^ 0x3030303) ++ ++/************************************************************************** ++ * Procedure DLOAD_GetSection ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * sectionInfo Pointer to a section info structure for the desired ++ * section ++ * sectionData Buffer to contain the section initialized data ++ * ++ * Effect: ++ * Copies the initialized data for the specified section into the ++ * supplied buffer. ++ * ++ * Returns: ++ * true for success, false for section not found ++ **************************************************************************/ ++int DLOAD_GetSection(DLOAD_module_info minfo, ++ const struct LDR_SECTION_INFO *sectionInfo, void *sectionData) ++{ ++ struct dload_state *dlthis; ++ u32 pos; ++ struct doff_scnhdr_t *sptr = NULL; ++ s32 nip; ++ struct image_packet_t ipacket; ++ s32 ipsize; ++ u32 checks; ++ s8 *dest = (s8 *)sectionData; ++ ++ dlthis = (struct dload_state *)minfo; ++ if (!dlthis) ++ return false; ++ sptr = LDRSEC_IS_DOFFSEC(sectionInfo); ++ if (sptr == NULL) ++ return false; ++ ++ /* skip ahead to the start of the first packet */ ++ pos = BYTE_TO_HOST(DOFF_ALIGN((u32) sptr->ds_first_pkt_offset)); ++ if (dlthis->strm->set_file_posn(dlthis->strm, pos) != 0) { ++ dload_error(dlthis, E_SEEK, pos); ++ return false; ++ } ++ ++ nip = sptr->ds_nipacks; ++ while ((nip -= 1) >= 0) { /* for each packet */ ++ /* get the fixed header bits */ ++ if (dlthis->strm-> ++ read_buffer(dlthis->strm, &ipacket, IPH_SIZE) != IPH_SIZE) { ++ dload_error(dlthis, E_READSTRM, "image packet"); ++ return false; ++ } ++ /* reorder the header if need be */ ++ if (dlthis->reorder_map) ++ dload_reorder(&ipacket, IPH_SIZE, dlthis->reorder_map); ++ ++ /* Now read the packet image bits. Note: round the size up to ++ * the next multiple of 4 bytes; this is what checksum ++ * routines want. */ ++ ipsize = BYTE_TO_HOST(DOFF_ALIGN(ipacket.i_packet_size)); ++ if (ipsize > BYTE_TO_HOST(IMAGE_PACKET_SIZE)) { ++ dload_error(dlthis, E_ISIZ, ipsize); ++ return false; ++ } ++ if (dlthis->strm->read_buffer ++ (dlthis->strm, dest, ipsize) != ipsize) { ++ dload_error(dlthis, E_READSTRM, "image packet"); ++ return false; ++ } ++ /* reorder the bytes if need be */ ++#if !defined(_BIG_ENDIAN) || (TARGET_AU_BITS > 16) ++ if (dlthis->reorder_map) ++ dload_reorder(dest, ipsize, dlthis->reorder_map); ++ ++ checks = dload_checksum(dest, ipsize); ++#else ++ if (dlthis->dfile_hdr.df_byte_reshuffle != ++ TARGET_ORDER(REORDER_MAP(BYTE_RESHUFFLE_VALUE))) { ++ /* put image bytes in big-endian order, not PC order */ ++ dload_reorder(dest, ipsize, ++ TARGET_ORDER(dlthis->dfile_hdr. ++ df_byte_reshuffle)); ++ } ++#if TARGET_AU_BITS > 8 ++ checks = dload_reverse_checksum_16(dest, ipsize); ++#else ++ checks = dload_reverse_checksum(dest, ipsize); ++#endif ++#endif ++ checks += dload_checksum(&ipacket, IPH_SIZE); ++ ++ /* NYI: unable to handle relocation entries here. Reloc ++ * entries referring to fields that span the packet boundaries ++ * may result in packets of sizes that are not multiple of ++ * 4 bytes. Our checksum implementation works on 32-bit words ++ * only. */ ++ if (ipacket.i_num_relocs != 0) { ++ dload_error(dlthis, E_RELOC, ipsize); ++ return false; ++ } ++ ++ if (~checks) { ++ dload_error(dlthis, E_CHECKSUM, "image packet"); ++ return false; ++ } ++ ++ /*Advance destination ptr by the size of the just-read packet*/ ++ dest += ipsize; ++ } ++ ++ return true; ++} ++ ++/*************************************************************************** ++ * Procedure DLOAD_module_close ++ * ++ * Parameters: ++ * minfo Handle from DLOAD_module_open for this module ++ * ++ * Effect: ++ * Releases any storage associated with the module handle. On return, ++ * the module handle is invalid. ++ * ++ * Returns: ++ * Zero for success. On error, the number of errors detected is returned. ++ * Individual errors are reported using syms->Error_Report(), where syms was ++ * an argument to DLOAD_module_open ++ **************************************************************************/ ++void DLOAD_module_close(DLOAD_module_info minfo) ++{ ++ struct dload_state *dlthis; ++ ++ dlthis = (struct dload_state *)minfo; ++ if (!dlthis) ++ return; ++ ++ if (dlthis->str_head) ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis->str_head); ++ ++ if (dlthis->sect_hdrs) ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis->sect_hdrs); ++ ++#if BITS_PER_AU > BITS_PER_BYTE ++ if (dlthis->xstrings) ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis->xstrings); ++ ++#endif ++ ++ dlthis->mysym->Deallocate(dlthis->mysym, dlthis); ++} +diff --git a/drivers/dsp/bridge/dynload/header.h b/drivers/dsp/bridge/dynload/header.h +new file mode 100644 +index 0000000..0de744b +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/header.h +@@ -0,0 +1,59 @@ ++/* ++ * header.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#define TRUE 1 ++#define FALSE 0 ++#ifndef NULL ++#define NULL 0 ++#endif ++ ++#include <linux/string.h> ++#define DL_STRCMP strcmp ++ ++/* maximum parenthesis nesting in relocation stack expressions */ ++#define STATIC_EXPR_STK_SIZE 10 ++ ++#include <linux/types.h> ++typedef unsigned int uint_least32_t; ++typedef unsigned short int uint_least16_t; ++ ++#include "doff.h" ++#include <dspbridge/dynamic_loader.h> ++#include "params.h" ++#include "dload_internal.h" ++#include "reloc_table.h" ++ ++/* ++ * Plausibility limits ++ * ++ * These limits are imposed upon the input DOFF file as a check for validity. ++ * They are hard limits, in that the load will fail if they are exceeded. ++ * The numbers selected are arbitrary, in that the loader implementation does ++ * not require these limits. ++ */ ++ ++/* maximum number of bytes in string table */ ++#define MAX_REASONABLE_STRINGTAB (0x100000) ++/* maximum number of code,data,etc. sections */ ++#define MAX_REASONABLE_SECTIONS (200) ++/* maximum number of linker symbols */ ++#define MAX_REASONABLE_SYMBOLS (100000) ++ ++/* shift count to align F_BIG with DLOAD_LITTLE */ ++#define ALIGN_COFF_ENDIANNESS 7 ++#define ENDIANNESS_MASK (DF_BYTE_ORDER >> ALIGN_COFF_ENDIANNESS) +diff --git a/drivers/dsp/bridge/dynload/module_list.h b/drivers/dsp/bridge/dynload/module_list.h +new file mode 100644 +index 0000000..9c4876a +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/module_list.h +@@ -0,0 +1,161 @@ ++/* ++ * dspbridge/mpu_driver/src/dynload/module_list.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/*============================================================================ ++ Filename: module_list.h ++ ++ Copyright (C) 2002 Texas Instruments Incorporated ++ ++ ++ This C header file gives the layout of the data structure created by the ++ dynamic loader to describe the set of modules loaded into the DSP. ++ ++ Linked List Structure: ++ ---------------------- ++ The data structure defined here is a singly-linked list. The list ++ represents the set of modules which are currently loaded in the DSP memory. ++ The first entry in the list is a header record which contains a flag ++ representing the state of the list. The rest of the entries in the list ++ are module records. ++ ++ Global symbol _DLModules designates the first record in the list (i.e. the ++ header record). This symbol must be defined in any program that wishes to ++ use DLLview plug-in. ++ ++ String Representation: ++ ---------------------- ++ The string names of the module and its sections are stored in a block of ++ memory which follows the module record itself. The strings are ordered: ++ module name first, followed by section names in order from the first ++ section to the last. String names are tightly packed arrays of 8-bit ++ characters (two characters per 16-bit word on the C55x). Strings are ++ zero-byte-terminated. ++ ++ Creating and updating the list: ++------------------------------- ++ Upon loading a new module into the DSP memory the dynamic loader inserts a ++new module record as the first module record in the list. The fields of ++ this module record are initialized to reflect the properties of the module. ++ The dynamic loader does NOT increment the flag/counter in the list's header ++ record. ++ ++ Upon unloading a module from the DSP memory the dynamic loader removes the ++module's record from this list. The dynamic loader also increments the ++ flag/counter in the list's header record to indicate that the list has been ++ changed. ++ ++============================================================================*/ ++ ++#ifndef _MODULE_LIST_H_ ++#define _MODULE_LIST_H_ ++ ++#include <linux/types.h> ++ ++/* Global pointer to the modules_header structure*/ ++#define MODULES_HEADER "_DLModules" ++#define MODULES_HEADER_NO_UNDERSCORE "DLModules" ++ ++/* Initial version number*/ ++#define INIT_VERSION 1 ++ ++/* Verification number -- to be recorded in each module record */ ++#define VERIFICATION 0x79 ++ ++/* forward declarations */ ++struct dll_module; ++struct dll_sect; ++ ++/* the first entry in the list is the modules_header record; ++ * its address is contained in the global _DLModules pointer */ ++struct modules_header { ++ ++ /* Address of the first dll_module record in the list or NULL. ++ Note: for C55x this is a word address (C55x data is word-addressable)*/ ++ u32 first_module; ++ ++ /* Combined storage size (in target addressable units) of the ++ * dll_module record which follows this header record, or zero ++ * if the list is empty. This size includes the module's string table. ++ * Note: for C55x the unit is a 16-bit word */ ++ u16 first_module_size; ++ ++ /* Counter is incremented whenever a module record is removed from ++ * the list */ ++ u16 update_flag; ++ ++} ; ++ ++/* for each 32-bits in above structure, a bitmap, LSB first, whose bits are: ++ * 0 => a 32-bit value, 1 => 2 16-bit values */ ++#define MODULES_HEADER_BITMAP 0x2 /* swapping bitmap for type modules_header */ ++ ++/* information recorded about each section in a module */ ++struct dll_sect { ++ ++ /* Load-time address of the section. ++ * Note: for C55x this is a byte address for program sections, and ++ * a word address for data sections. C55x program memory is ++ * byte-addressable, while data memory is word-addressable. */ ++ u32 sect_load_adr; ++ ++ /* Run-time address of the section. ++ * Note 1: for C55x this is a byte address for program sections, and ++ * a word address for data sections. ++ * Note 2: for C55x two most significant bits of this field indicate ++ * the section type: '00' for a code section, '11' for a data section ++ * (C55 addresses are really only 24-bits wide). */ ++ u32 sect_run_adr; ++ ++} ; ++ ++/* the rest of the entries in the list are module records */ ++struct dll_module { ++ ++ /* Address of the next dll_module record in the list, or 0 if this is ++ * the last record in the list. ++ * Note: for C55x this is a word address (C55x data is ++ * word-addressable) */ ++ u32 next_module; ++ ++ /* Combined storage size (in target addressable units) of the ++ * dll_module record which follows this one, or zero if this is the ++ * last record in the list. This size includes the module's string ++ * table. ++ * Note: for C55x the unit is a 16-bit word. */ ++ u16 next_module_size; ++ ++ /* version number of the tooling; set to INIT_VERSION for Phase 1 */ ++ u16 version; ++ ++ /* the verification word; set to VERIFICATION */ ++ u16 verification; ++ ++ /* Number of sections in the sects array */ ++ u16 num_sects; ++ ++ /* Module's "unique" id; copy of the timestamp from the host ++ * COFF file */ ++ u32 timestamp; ++ ++ /* Array of num_sects elements of the module's section records */ ++ struct dll_sect sects[1]; ++} ; ++ ++/* for each 32 bits in above structure, a bitmap, LSB first, whose bits are: ++ * 0 => a 32-bit value, 1 => 2 16-bit values */ ++#define DLL_MODULE_BITMAP 0x6 /* swapping bitmap for type dll_module */ ++ ++#endif /* _MODULE_LIST_H_ */ +diff --git a/drivers/dsp/bridge/dynload/params.h b/drivers/dsp/bridge/dynload/params.h +new file mode 100644 +index 0000000..ade430d +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/params.h +@@ -0,0 +1,231 @@ ++/* ++ * params.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++/****************************************************************************** ++ * ++ * This file defines host and target properties for all machines ++ * supported by the dynamic loader. To be tedious... ++ * ++ * host == the machine on which the dynamic loader runs ++ * target == the machine that the dynamic loader is loading ++ * ++ * Host and target may or may not be the same, depending upon the particular ++ * use. ++ *****************************************************************************/ ++ ++/****************************************************************************** ++ * ++ * Host Properties ++ * ++ *****************************************************************************/ ++ ++#define BITS_PER_BYTE 8 /* bits in the standard PC/SUN byte */ ++#define LOG_BITS_PER_BYTE 3 /* log base 2 of same */ ++#define BYTE_MASK ((1U<<BITS_PER_BYTE)-1) ++ ++#if defined(__TMS320C55X__) || defined(_TMS320C5XX) ++#define BITS_PER_AU 16 ++#define LOG_BITS_PER_AU 4 ++ /* use this print string in error messages for uint32_t */ ++#define FMT_UI32 "0x%lx" ++#define FMT8_UI32 "%08lx" /* same but no 0x, fixed width field */ ++#else ++#define BITS_PER_AU 8 /* bits in the smallest addressable data storage unit */ ++#define LOG_BITS_PER_AU 3 /* log base 2 of the same; useful for shift counts */ ++#define FMT_UI32 "0x%x" ++#define FMT8_UI32 "%08x" ++#endif ++ ++/* generic fastest method for swapping bytes and shorts */ ++#define SWAP32BY16(zz) (((zz) << 16) | ((zz) >> 16)) ++#define SWAP16BY8(zz) (((zz) << 8) | ((zz) >> 8)) ++ ++/* !! don't be tempted to insert type definitions here; use <stdint.h> !! */ ++ ++/****************************************************************************** ++ * ++ * Target Properties ++ * ++ *****************************************************************************/ ++ ++ ++/*--------------------------------------------------------------------------*/ ++/* TMS320C6x Target Specific Parameters (byte-addressable) */ ++/*--------------------------------------------------------------------------*/ ++#if TMS32060 ++#define MEMORG 0x0L /* Size of configured memory */ ++#define MEMSIZE 0x0L /* (full address space) */ ++ ++#define CINIT_ALIGN 8 /* alignment of cinit record in TDATA AUs */ ++#define CINIT_COUNT 4 /* width of count field in TDATA AUs */ ++#define CINIT_ADDRESS 4 /* width of address field in TDATA AUs */ ++#define CINIT_PAGE_BITS 0 /* Number of LSBs of address that ++ * are page number */ ++ ++#define LENIENT_SIGNED_RELEXPS 0 /* DOES SIGNED ALLOW MAX UNSIGNED */ ++ ++#undef TARGET_ENDIANNESS /* may be big or little endian */ ++ ++/* align a target address to a word boundary */ ++#define TARGET_WORD_ALIGN(zz) (((zz) + 0x3) & -0x4) ++#endif ++ ++ ++/*-------------------------------------------------------------------------- ++ * ++ * DEFAULT SETTINGS and DERIVED PROPERTIES ++ * ++ * This section establishes defaults for values not specified above ++ *--------------------------------------------------------------------------*/ ++#ifndef TARGET_AU_BITS ++#define TARGET_AU_BITS 8 /* width of the target addressable unit */ ++#define LOG_TARGET_AU_BITS 3 /* log2 of same */ ++#endif ++ ++#ifndef CINIT_DEFAULT_PAGE ++#define CINIT_DEFAULT_PAGE 0 /* default .cinit page number */ ++#endif ++ ++#ifndef DATA_RUN2LOAD ++#define DATA_RUN2LOAD(zz) (zz) /* translate data run address to load address */ ++#endif ++ ++#ifndef DBG_LIST_PAGE ++#define DBG_LIST_PAGE 0 /* page number for .dllview section */ ++#endif ++ ++#ifndef TARGET_WORD_ALIGN ++/* align a target address to a word boundary */ ++#define TARGET_WORD_ALIGN(zz) (zz) ++#endif ++ ++#ifndef TDATA_TO_TADDR ++#define TDATA_TO_TADDR(zz) (zz) /* target data address to target AU address */ ++#define TADDR_TO_TDATA(zz) (zz) /* target AU address to target data address */ ++#define TDATA_AU_BITS TARGET_AU_BITS /* bits per data AU */ ++#define LOG_TDATA_AU_BITS LOG_TARGET_AU_BITS ++#endif ++ ++/* ++ * ++ * Useful properties and conversions derived from the above ++ * ++ */ ++ ++/* ++ * Conversions between host and target addresses ++ */ ++#if LOG_BITS_PER_AU == LOG_TARGET_AU_BITS ++/* translate target addressable unit to host address */ ++#define TADDR_TO_HOST(x) (x) ++/* translate host address to target addressable unit */ ++#define HOST_TO_TADDR(x) (x) ++#elif LOG_BITS_PER_AU > LOG_TARGET_AU_BITS ++#define TADDR_TO_HOST(x) ((x) >> (LOG_BITS_PER_AU-LOG_TARGET_AU_BITS)) ++#define HOST_TO_TADDR(x) ((x) << (LOG_BITS_PER_AU-LOG_TARGET_AU_BITS)) ++#else ++#define TADDR_TO_HOST(x) ((x) << (LOG_TARGET_AU_BITS-LOG_BITS_PER_AU)) ++#define HOST_TO_TADDR(x) ((x) >> (LOG_TARGET_AU_BITS-LOG_BITS_PER_AU)) ++#endif ++ ++#if LOG_BITS_PER_AU == LOG_TDATA_AU_BITS ++/* translate target addressable unit to host address */ ++#define TDATA_TO_HOST(x) (x) ++/* translate host address to target addressable unit */ ++#define HOST_TO_TDATA(x) (x) ++/* translate host address to target addressable unit, round up */ ++#define HOST_TO_TDATA_ROUND(x) (x) ++/* byte offset to host offset, rounded up for TDATA size */ ++#define BYTE_TO_HOST_TDATA_ROUND(x) BYTE_TO_HOST_ROUND(x) ++#elif LOG_BITS_PER_AU > LOG_TDATA_AU_BITS ++#define TDATA_TO_HOST(x) ((x) >> (LOG_BITS_PER_AU-LOG_TDATA_AU_BITS)) ++#define HOST_TO_TDATA(x) ((x) << (LOG_BITS_PER_AU-LOG_TDATA_AU_BITS)) ++#define HOST_TO_TDATA_ROUND(x) ((x) << (LOG_BITS_PER_AU-LOG_TDATA_AU_BITS)) ++#define BYTE_TO_HOST_TDATA_ROUND(x) BYTE_TO_HOST_ROUND(x) ++#else ++#define TDATA_TO_HOST(x) ((x) << (LOG_TDATA_AU_BITS-LOG_BITS_PER_AU)) ++#define HOST_TO_TDATA(x) ((x) >> (LOG_TDATA_AU_BITS-LOG_BITS_PER_AU)) ++#define HOST_TO_TDATA_ROUND(x) (((x) +\ ++ (1<<(LOG_TDATA_AU_BITS-LOG_BITS_PER_AU))-1) >>\ ++ (LOG_TDATA_AU_BITS-LOG_BITS_PER_AU)) ++#define BYTE_TO_HOST_TDATA_ROUND(x) (BYTE_TO_HOST((x) +\ ++ (1<<(LOG_TDATA_AU_BITS-LOG_BITS_PER_BYTE))-1) &\ ++ -(TDATA_AU_BITS/BITS_PER_AU)) ++#endif ++ ++/* ++ * Input in DOFF format is always expresed in bytes, regardless of loading host ++ * so we wind up converting from bytes to target and host units even when the ++ * host is not a byte machine. ++ */ ++#if LOG_BITS_PER_AU == LOG_BITS_PER_BYTE ++#define BYTE_TO_HOST(x) (x) ++#define BYTE_TO_HOST_ROUND(x) (x) ++#define HOST_TO_BYTE(x) (x) ++#elif LOG_BITS_PER_AU >= LOG_BITS_PER_BYTE ++#define BYTE_TO_HOST(x) ((x) >> (LOG_BITS_PER_AU - LOG_BITS_PER_BYTE)) ++#define BYTE_TO_HOST_ROUND(x) ((x + (BITS_PER_AU/BITS_PER_BYTE-1)) >>\ ++ (LOG_BITS_PER_AU - LOG_BITS_PER_BYTE)) ++#define HOST_TO_BYTE(x) ((x) << (LOG_BITS_PER_AU - LOG_BITS_PER_BYTE)) ++#else ++/* lets not try to deal with sub-8-bit byte machines */ ++#endif ++ ++#if LOG_TARGET_AU_BITS == LOG_BITS_PER_BYTE ++/* translate target addressable unit to byte address */ ++#define TADDR_TO_BYTE(x) (x) ++/* translate byte address to target addressable unit */ ++#define BYTE_TO_TADDR(x) (x) ++#elif LOG_TARGET_AU_BITS > LOG_BITS_PER_BYTE ++#define TADDR_TO_BYTE(x) ((x) << (LOG_TARGET_AU_BITS-LOG_BITS_PER_BYTE)) ++#define BYTE_TO_TADDR(x) ((x) >> (LOG_TARGET_AU_BITS-LOG_BITS_PER_BYTE)) ++#else ++/* lets not try to deal with sub-8-bit byte machines */ ++#endif ++ ++#ifdef _BIG_ENDIAN ++#define HOST_ENDIANNESS 1 ++#else ++#define HOST_ENDIANNESS 0 ++#endif ++ ++#ifdef TARGET_ENDIANNESS ++#define TARGET_ENDIANNESS_DIFFERS(rtend) (HOST_ENDIANNESS^TARGET_ENDIANNESS) ++#elif HOST_ENDIANNESS ++#define TARGET_ENDIANNESS_DIFFERS(rtend) (!(rtend)) ++#else ++#define TARGET_ENDIANNESS_DIFFERS(rtend) (rtend) ++#endif ++ ++/* the unit in which we process target image data */ ++#if TARGET_AU_BITS <= 8 ++typedef u8 TgtAU_t; ++#elif TARGET_AU_BITS <= 16 ++typedef u16 TgtAU_t; ++#else ++typedef u32 TgtAU_t; ++#endif ++ ++/* size of that unit */ ++#if TARGET_AU_BITS < BITS_PER_AU ++#define TGTAU_BITS BITS_PER_AU ++#define LOG_TGTAU_BITS LOG_BITS_PER_AU ++#else ++#define TGTAU_BITS TARGET_AU_BITS ++#define LOG_TGTAU_BITS LOG_TARGET_AU_BITS ++#endif +diff --git a/drivers/dsp/bridge/dynload/reloc.c b/drivers/dsp/bridge/dynload/reloc.c +new file mode 100644 +index 0000000..54e460e +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/reloc.c +@@ -0,0 +1,425 @@ ++/* ++ * reloc.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#include "header.h" ++ ++#if TMS32060 ++/* the magic symbol for the start of BSS */ ++static const char BSSSYMBOL[] = {".bss"}; ++#endif ++ ++#if TMS32060 ++#include "reloc_table_c6000.c" ++#endif ++ ++#if TMS32060 ++/* From coff.h - ignore these relocation operations */ ++#define R_C60ALIGN 0x76 /* C60: Alignment info for compressor */ ++#define R_C60FPHEAD 0x77 /* C60: Explicit assembly directive */ ++#define R_C60NOCMP 0x100 /* C60: Don't compress this code scn */ ++#endif ++ ++/************************************************************************** ++ * Procedure dload_unpack ++ * ++ * Parameters: ++ * data pointer to storage unit containing lowest host address of ++ * image data ++ * fieldsz Size of bit field, 0 < fieldsz <= sizeof(RVALUE)*BITS_PER_AU ++ * offset Offset from LSB, 0 <= offset < BITS_PER_AU ++ * sgn Signedness of the field (ROP_SGN, ROP_UNS, ROP_MAX, ROP_ANY) ++ * ++ * Effect: ++ * Extracts the specified field and returns it. ++ **************************************************************************/ ++RVALUE dload_unpack(struct dload_state *dlthis, TgtAU_t *data, int fieldsz, ++ int offset, unsigned sgn) ++{ ++ register RVALUE objval; ++ register int shift, direction; ++ register TgtAU_t *dp = data; ++ ++ fieldsz -= 1; /* avoid nastiness with 32-bit shift of 32-bit value*/ ++ /* * collect up enough bits to contain the desired field */ ++ if (TARGET_BIG_ENDIAN) { ++ dp += (fieldsz + offset) >> LOG_TGTAU_BITS; ++ direction = -1; ++ } else ++ direction = 1; ++ objval = *dp >> offset; ++ shift = TGTAU_BITS - offset; ++ while (shift <= fieldsz) { ++ dp += direction; ++ objval += (RVALUE)*dp << shift; ++ shift += TGTAU_BITS; ++ } ++ ++ /* * sign or zero extend the value appropriately */ ++ if (sgn == ROP_UNS) ++ objval &= (2 << fieldsz) - 1; ++ else { ++ shift = sizeof(RVALUE) * BITS_PER_AU-1 - fieldsz; ++ objval = (objval << shift) >> shift; ++ } ++ ++ return objval; ++ ++} /* dload_unpack */ ++ ++ ++/************************************************************************** ++ * Procedure dload_repack ++ * ++ * Parameters: ++ * val Value to insert ++ * data Pointer to storage unit containing lowest host address of ++ * image data ++ * fieldsz Size of bit field, 0 < fieldsz <= sizeof(RVALUE)*BITS_PER_AU ++ * offset Offset from LSB, 0 <= offset < BITS_PER_AU ++ * sgn Signedness of the field (ROP_SGN, ROP_UNS, ROP_MAX, ROP_ANY) ++ * ++ * Effect: ++ * Stuffs the specified value in the specified field. Returns 0 for ++ * success ++ * or 1 if the value will not fit in the specified field according to the ++ * specified signedness rule. ++ **************************************************************************/ ++static const unsigned char ovf_limit[] = {1, 2, 2}; ++int dload_repack(struct dload_state *dlthis, RVALUE val, TgtAU_t *data, ++ int fieldsz, int offset, unsigned sgn) ++{ ++ register URVALUE objval, mask; ++ register int shift, direction; ++ register TgtAU_t *dp = data; ++ ++ ++ fieldsz -= 1; /* avoid nastiness with 32-bit shift of 32-bit value */ ++ /* clip the bits */ ++ mask = ((UINT32_C(2) << fieldsz) - 1); ++ objval = (val & mask); ++ /* * store the bits through the specified mask */ ++ if (TARGET_BIG_ENDIAN) { ++ dp += (fieldsz + offset) >> LOG_TGTAU_BITS; ++ direction = -1; ++ } else ++ direction = 1; ++ ++ /* insert LSBs */ ++ *dp = (*dp & ~(mask << offset)) + (objval << offset); ++ shift = TGTAU_BITS-offset; ++ /* align mask and objval with AU boundary */ ++ objval >>= shift; ++ mask >>= shift; ++ ++ while (mask) { ++ dp += direction; ++ *dp = (*dp & ~mask) + objval; ++ objval >>= TGTAU_BITS; ++ mask >>= TGTAU_BITS; ++ } ++ ++ /* ++ * check for overflow ++ */ ++ if (sgn) { ++ unsigned tmp = (val >> fieldsz) + (sgn & 0x1); ++ if (tmp > ovf_limit[sgn-1]) ++ return 1; ++ } ++ return 0; ++ ++} /* dload_repack */ ++ ++/* lookup table for the scaling amount in a C6x instruction */ ++#if TMS32060 ++#define SCALE_BITS 4 /* there are 4 bits in the scale field */ ++#define SCALE_MASK 0x7 /* we really only use the bottom 3 bits */ ++static const u8 C60_Scale[SCALE_MASK+1] = { ++ 1, 0, 0, 0, 1, 1, 2, 2 ++}; ++#endif ++ ++/************************************************************************** ++ * Procedure dload_relocate ++ * ++ * Parameters: ++ * data Pointer to base of image data ++ * rp Pointer to relocation operation ++ * ++ * Effect: ++ * Performs the specified relocation operation ++ **************************************************************************/ ++void dload_relocate(struct dload_state *dlthis, TgtAU_t *data, ++ struct reloc_record_t *rp) ++{ ++ RVALUE val = 0; ++ RVALUE reloc_amt = 0; ++ unsigned int fieldsz = 0; ++ unsigned int offset = 0; ++ unsigned int reloc_info = 0; ++ unsigned int reloc_action = 0; ++ register int rx = 0; ++ RVALUE *stackp = NULL; ++ int top; ++ struct Local_Symbol *svp = NULL; ++#ifdef RFV_SCALE ++ unsigned int scale = 0; ++#endif ++ ++ rx = HASH_FUNC(rp->r_type); ++ while (rop_map1[rx] != rp->r_type) { ++ rx = HASH_L(rop_map2[rx]); ++ if (rx < 0) { ++#if TMS32060 ++ switch (rp->r_type) { ++ case R_C60ALIGN: ++ case R_C60NOCMP: ++ case R_C60FPHEAD: ++ /* Ignore these reloc types and return */ ++ break; ++ default: ++ /* Unknown reloc type, print error and return */ ++ dload_error(dlthis, "Bad coff operator 0x%x", rp->r_type); ++ } ++#else ++ dload_error(dlthis, "Bad coff operator 0x%x", rp->r_type); ++#endif ++ return; ++ } ++ } ++ rx = HASH_I(rop_map2[rx]); ++ if ((rx < (sizeof(rop_action)/sizeof(uint_least16_t))) ++ && (rx < (sizeof(rop_info)/sizeof(uint_least16_t))) && (rx > 0)) { ++ reloc_action = rop_action[rx]; reloc_info = rop_info[rx]; ++ } else { ++ dload_error(dlthis, "Buffer Overflow - Array Index Out of Bounds"); ++ } ++ ++ /* Compute the relocation amount for the referenced symbol, if any */ ++ reloc_amt = rp->r_uval; ++ if (RFV_SYM(reloc_info)) { /* relocation uses a symbol reference */ ++ if ((u32)rp->r_symndx < dlthis->dfile_hdr.df_no_syms) { ++ /* real symbol reference */ ++ svp = &dlthis->local_symtab[rp->r_symndx]; ++ reloc_amt = (RFV_SYM(reloc_info) == ROP_SYMD) ? ++ svp->delta : svp->value; ++ } ++ /* reloc references current section */ ++ else if (rp->r_symndx == -1) ++ reloc_amt = (RFV_SYM(reloc_info) == ROP_SYMD) ? ++ dlthis->delta_runaddr : dlthis->image_secn->run_addr; ++ } /* relocation uses a symbol reference */ ++ /* Handle stack adjustment */ ++ val = 0; ++ top = RFV_STK(reloc_info); ++ if (top) { ++ top += dlthis->relstkidx - RSTK_UOP; ++ if (top >= STATIC_EXPR_STK_SIZE) { ++ dload_error(dlthis, ++ "Expression stack overflow in %s at offset " ++ FMT_UI32, dlthis->image_secn->name, ++ rp->r_vaddr + dlthis->image_offset); ++ return; ++ } ++ val = dlthis->relstk[dlthis->relstkidx]; ++ dlthis->relstkidx = top; ++ stackp = &dlthis->relstk[top]; ++ } ++ /* Derive field position and size, if we need them */ ++ if (reloc_info & ROP_RW) { /* read or write action in our future */ ++ fieldsz = RFV_WIDTH(reloc_action); ++ if (fieldsz) { /* field info from table */ ++ offset = RFV_POSN(reloc_action); ++ if (TARGET_BIG_ENDIAN) ++ /* make sure r_vaddr is the lowest target ++ * address containing bits */ ++ rp->r_vaddr += RFV_BIGOFF(reloc_info); ++ } else { /* field info from relocation op */ ++ fieldsz = rp->r_fieldsz; offset = rp->r_offset; ++ if (TARGET_BIG_ENDIAN) ++ /* make sure r_vaddr is the lowest target ++ address containing bits */ ++ rp->r_vaddr += (rp->r_wordsz - offset - fieldsz) ++ >> LOG_TARGET_AU_BITS; ++ } ++ data = (TgtAU_t *)((char *)data + TADDR_TO_HOST(rp->r_vaddr)); ++ /* compute lowest host location of referenced data */ ++#if BITS_PER_AU > TARGET_AU_BITS ++ /* conversion from target address to host address may lose ++ address bits; add loss to offset */ ++ if (TARGET_BIG_ENDIAN) { ++ offset += -((rp->r_vaddr << LOG_TARGET_AU_BITS) + ++ offset + fieldsz) & ++ (BITS_PER_AU-TARGET_AU_BITS); ++ } else { ++ offset += (rp->r_vaddr << LOG_TARGET_AU_BITS) & ++ (BITS_PER_AU-1); ++ } ++#endif ++#ifdef RFV_SCALE ++ scale = RFV_SCALE(reloc_info); ++#endif ++ } ++ /* read the object value from the current image, if so ordered */ ++ if (reloc_info & ROP_R) { /* relocation reads current image value */ ++ val = dload_unpack(dlthis, data, fieldsz, offset, ++ RFV_SIGN(reloc_info)); ++#ifdef RFV_SCALE ++ val <<= scale; ++#endif ++ } ++ /* perform the necessary arithmetic */ ++ switch (RFV_ACTION(reloc_action)) { /* relocation actions */ ++ case RACT_VAL: ++ break; ++ case RACT_ASGN: ++ val = reloc_amt; ++ break; ++ case RACT_ADD: ++ val += reloc_amt; ++ break; ++ case RACT_PCR: ++ /*----------------------------------------------------------- ++ * Handle special cases of jumping from absolute sections ++ * (special reloc type) or to absolute destination ++ * (symndx == -1). In either case, set the appropriate ++ * relocation amount to 0. ++ *-----------------------------------------------------------*/ ++ if (rp->r_symndx == -1) ++ reloc_amt = 0; ++ val += reloc_amt - dlthis->delta_runaddr; ++ break; ++ case RACT_ADDISP: ++ val += rp->r_disp + reloc_amt; ++ break; ++ case RACT_ASGPC: ++ val = dlthis->image_secn->run_addr + reloc_amt; ++ break; ++ case RACT_PLUS: ++ if (stackp != NULL) ++ val += *stackp; ++ break; ++ case RACT_SUB: ++ if (stackp != NULL) ++ val = *stackp - val; ++ break; ++ case RACT_NEG: ++ val = -val; ++ break; ++ case RACT_MPY: ++ if (stackp != NULL) ++ val *= *stackp; ++ break; ++ case RACT_DIV: ++ if (stackp != NULL) ++ val = *stackp / val; ++ break; ++ case RACT_MOD: ++ if (stackp != NULL) ++ val = *stackp % val; ++ break; ++ case RACT_SR: ++ if (val >= sizeof(RVALUE) * BITS_PER_AU) ++ val = 0; ++ else if (stackp != NULL) ++ val = (URVALUE)*stackp >> val; ++ break; ++ case RACT_ASR: ++ if (val >= sizeof(RVALUE)*BITS_PER_AU) ++ val = sizeof(RVALUE)*BITS_PER_AU - 1; ++ else if (stackp != NULL) ++ val = *stackp >> val; ++ break; ++ case RACT_SL: ++ if (val >= sizeof(RVALUE)*BITS_PER_AU) ++ val = 0; ++ else if (stackp != NULL) ++ val = *stackp << val; ++ break; ++ case RACT_AND: ++ if (stackp != NULL) ++ val &= *stackp; ++ break; ++ case RACT_OR: ++ if (stackp != NULL) ++ val |= *stackp; ++ break; ++ case RACT_XOR: ++ if (stackp != NULL) ++ val ^= *stackp; ++ break; ++ case RACT_NOT: ++ val = ~val; ++ break; ++#if TMS32060 ++ case RACT_C6SECT: ++ /* actually needed address of secn containing symbol */ ++ if (svp != NULL) { ++ if (rp->r_symndx >= 0) ++ if (svp->secnn > 0) ++ reloc_amt = dlthis->ldr_sections ++ [svp->secnn-1].run_addr; ++ } ++ /* !!! FALL THRU !!! */ ++ case RACT_C6BASE: ++ if (dlthis->bss_run_base == 0) { ++ struct dynload_symbol *symp; ++ symp = dlthis->mysym->Find_Matching_Symbol ++ (dlthis->mysym, BSSSYMBOL); ++ /* lookup value of global BSS base */ ++ if (symp) ++ dlthis->bss_run_base = symp->value; ++ else ++ dload_error(dlthis, ++ "Global BSS base referenced in %s offset"\ ++ FMT_UI32 " but not defined", ++ dlthis->image_secn->name, ++ rp->r_vaddr + dlthis->image_offset); ++ } ++ reloc_amt -= dlthis->bss_run_base; ++ /* !!! FALL THRU !!! */ ++ case RACT_C6DSPL: ++ /* scale factor determined by 3 LSBs of field */ ++ scale = C60_Scale[val & SCALE_MASK]; ++ offset += SCALE_BITS; ++ fieldsz -= SCALE_BITS; ++ val >>= SCALE_BITS; /* ignore the scale field hereafter */ ++ val <<= scale; ++ val += reloc_amt; /* do the usual relocation */ ++ if (((1 << scale)-1) & val) ++ dload_error(dlthis, ++ "Unaligned reference in %s offset " FMT_UI32, ++ dlthis->image_secn->name, ++ rp->r_vaddr + dlthis->image_offset); ++ break; ++#endif ++ } /* relocation actions */ ++ /* * Put back result as required */ ++ if (reloc_info & ROP_W) { /* relocation writes image value */ ++#ifdef RFV_SCALE ++ val >>= scale; ++#endif ++ if (dload_repack(dlthis, val, data, fieldsz, offset, ++ RFV_SIGN(reloc_info))) { ++ dload_error(dlthis, "Relocation value " FMT_UI32 ++ " overflows %d bits in %s offset " FMT_UI32, val, ++ fieldsz, dlthis->image_secn->name, ++ dlthis->image_offset + rp->r_vaddr); ++ } ++ } else if (top) ++ *stackp = val; ++} /* reloc_value */ ++ +diff --git a/drivers/dsp/bridge/dynload/reloc_table.h b/drivers/dsp/bridge/dynload/reloc_table.h +new file mode 100644 +index 0000000..6326146 +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/reloc_table.h +@@ -0,0 +1,102 @@ ++/* ++ * reloc_table.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#ifndef __RELOC_TABLE_H__ ++#define __RELOC_TABLE_H__ ++/* ++ * Table of relocation operator properties ++ */ ++#include <linux/types.h> ++ ++/* How does this relocation operation access the program image? */ ++#define ROP_N 0 /* does not access image */ ++#define ROP_R 1 /* read from image */ ++#define ROP_W 2 /* write to image */ ++#define ROP_RW 3 /* read from and write to image */ ++ ++/* For program image access, what are the overflow rules for the bit field? */ ++/* Beware! Procedure repack depends on this encoding */ ++#define ROP_ANY 0 /* no overflow ever, just truncate the value */ ++#define ROP_SGN 1 /* signed field */ ++#define ROP_UNS 2 /* unsigned field */ ++#define ROP_MAX 3 /* allow maximum range of either signed or unsigned */ ++ ++/* How does the relocation operation use the symbol reference */ ++#define ROP_IGN 0 /* no symbol is referenced */ ++#define ROP_LIT 0 /* use rp->r_uval literal field */ ++#define ROP_SYM 1 /* symbol value is used in relocation */ ++#define ROP_SYMD 2 /* delta value vs last link is used */ ++ ++/* How does the reloc op use the stack? */ ++#define RSTK_N 0 /* Does not use */ ++#define RSTK_POP 1 /* Does a POP */ ++#define RSTK_UOP 2 /* Unary op, stack position unaffected */ ++#define RSTK_PSH 3 /* Does a push */ ++ ++/* ++ * Computational actions performed by the dynamic loader ++ */ ++enum Dload_Actions { ++ RACT_VAL, /* don't alter the current val (from stack or mem fetch) */ ++ RACT_ASGN, /* set value to reference amount (from symbol reference) */ ++ RACT_ADD, /* add reference to value */ ++ RACT_PCR, /* add reference minus PC delta to value */ ++ RACT_ADDISP, /* add reference plus r_disp */ ++ RACT_ASGPC, /* set value to section address plus reference */ ++ ++ RACT_PLUS, /* stack + */ ++ RACT_SUB, /* stack - */ ++ RACT_NEG, /* stack unary - */ ++ ++ RACT_MPY, /* stack * */ ++ RACT_DIV, /* stack / */ ++ RACT_MOD, /* stack % */ ++ ++ RACT_SR, /* stack unsigned >> */ ++ RACT_ASR, /* stack signed >> */ ++ RACT_SL, /* stack << */ ++ RACT_AND, /* stack & */ ++ RACT_OR, /* stack | */ ++ RACT_XOR, /* stack ^ */ ++ RACT_NOT, /* stack ~ */ ++ RACT_C6SECT, /* for C60 R_SECT op */ ++ RACT_C6BASE, /* for C60 R_BASE op */ ++ RACT_C6DSPL, /* for C60 scaled 15-bit displacement */ ++ RACT_PCR23T /* for ARM Thumb long branch */ ++}; ++ ++/* ++ * macros used to extract values ++ */ ++#define RFV_POSN(aaa) ((aaa) & 0xF) ++#define RFV_WIDTH(aaa) (((aaa) >> 4) & 0x3F) ++#define RFV_ACTION(aaa) ((aaa) >> 10) ++ ++#define RFV_SIGN(iii) (((iii) >> 2) & 0x3) ++#define RFV_SYM(iii) (((iii) >> 4) & 0x3) ++#define RFV_STK(iii) (((iii) >> 6) & 0x3) ++#define RFV_ACCS(iii) ((iii) & 0x3) ++ ++#if (TMS32060) ++#define RFV_SCALE(iii) ((iii) >> 11) ++#define RFV_BIGOFF(iii) (((iii) >> 8) & 0x7) ++#else ++#define RFV_BIGOFF(iii) ((iii) >> 8) ++#endif ++ ++#endif /* __RELOC_TABLE_H__ */ +diff --git a/drivers/dsp/bridge/dynload/reloc_table_c6000.c b/drivers/dsp/bridge/dynload/reloc_table_c6000.c +new file mode 100644 +index 0000000..978834c +--- /dev/null ++++ b/drivers/dsp/bridge/dynload/reloc_table_c6000.c +@@ -0,0 +1,258 @@ ++/* ++ * reloc_table_c6000.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* Tables generated for c6000 */ ++ ++#define HASH_FUNC(zz) (((((zz) + 1) * UINT32_C(1845)) >> 11) & 63) ++#define HASH_L(zz) ((zz) >> 8) ++#define HASH_I(zz) ((zz) & 0xFF) ++ ++static const u16 rop_map1[] = { ++ 0, ++ 1, ++ 2, ++ 20, ++ 4, ++ 5, ++ 6, ++ 15, ++ 80, ++ 81, ++ 82, ++ 83, ++ 84, ++ 85, ++ 86, ++ 87, ++ 17, ++ 18, ++ 19, ++ 21, ++ 16, ++ 16394, ++ 16404, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 32, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 65535, ++ 40, ++ 112, ++ 113, ++ 65535, ++ 16384, ++ 16385, ++ 16386, ++ 16387, ++ 16388, ++ 16389, ++ 16390, ++ 16391, ++ 16392, ++ 16393, ++ 16395, ++ 16396, ++ 16397, ++ 16398, ++ 16399, ++ 16400, ++ 16401, ++ 16402, ++ 16403, ++ 16405, ++ 16406, ++ 65535, ++ 65535, ++ 65535 ++}; ++ ++static const s16 rop_map2[] = { ++ -256, ++ -255, ++ -254, ++ -245, ++ -253, ++ -252, ++ -251, ++ -250, ++ -241, ++ -240, ++ -239, ++ -238, ++ -237, ++ -236, ++ 1813, ++ 5142, ++ -248, ++ -247, ++ 778, ++ -244, ++ -249, ++ -221, ++ -211, ++ -1, ++ -1, ++ -1, ++ -1, ++ -1, ++ -1, ++ -243, ++ -1, ++ -1, ++ -1, ++ -1, ++ -1, ++ -1, ++ -242, ++ -233, ++ -232, ++ -1, ++ -231, ++ -230, ++ -229, ++ -228, ++ -227, ++ -226, ++ -225, ++ -224, ++ -223, ++ 5410, ++ -220, ++ -219, ++ -218, ++ -217, ++ -216, ++ -215, ++ -214, ++ -213, ++ 5676, ++ -210, ++ -209, ++ -1, ++ -1, ++ -1 ++}; ++ ++static const u16 rop_action[] = { ++ 2560, ++ 2304, ++ 2304, ++ 2432, ++ 2432, ++ 2560, ++ 2176, ++ 2304, ++ 2560, ++ 3200, ++ 3328, ++ 3584, ++ 3456, ++ 2304, ++ 4208, ++ 20788, ++ 21812, ++ 3415, ++ 3245, ++ 2311, ++ 4359, ++ 19764, ++ 2311, ++ 3191, ++ 3280, ++ 6656, ++ 7680, ++ 8704, ++ 9728, ++ 10752, ++ 11776, ++ 12800, ++ 13824, ++ 14848, ++ 15872, ++ 16896, ++ 17920, ++ 18944, ++ 0, ++ 0, ++ 0, ++ 0, ++ 1536, ++ 1536, ++ 1536, ++ 5632, ++ 512, ++ 0 ++}; ++ ++static const u16 rop_info[] = { ++ 0, ++ 35, ++ 35, ++ 35, ++ 35, ++ 35, ++ 35, ++ 35, ++ 35, ++ 39, ++ 39, ++ 39, ++ 39, ++ 35, ++ 34, ++ 283, ++ 299, ++ 4135, ++ 4391, ++ 291, ++ 33059, ++ 283, ++ 295, ++ 4647, ++ 4135, ++ 64, ++ 64, ++ 128, ++ 64, ++ 64, ++ 64, ++ 64, ++ 64, ++ 64, ++ 64, ++ 64, ++ 64, ++ 128, ++ 201, ++ 197, ++ 74, ++ 70, ++ 208, ++ 196, ++ 200, ++ 192, ++ 192, ++ 66 ++}; +diff --git a/drivers/dsp/bridge/gen/_gt_para.c b/drivers/dsp/bridge/gen/_gt_para.c +new file mode 100644 +index 0000000..181fe41 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/_gt_para.c +@@ -0,0 +1,107 @@ ++/* ++ * _gt_para.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _gt_para.c ======== ++ * Description: ++ * Configuration parameters for GT. This file is separated from ++ * gt.c so that GT_assert() can reference the error function without ++ * forcing the linker to include all the code for GT_set(), GT_init(), ++ * etc. into a fully bound image. Thus, GT_assert() can be retained in ++ * a program for which GT_?trace() has been compiled out. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 vp: Code Review Updates. ++ *! 18-Oct-2002 sb: Ported to Linux platform. ++ *! 03-Jul-2001 rr: Removed kfuncs.h because of build errors. ++ *! 07-Dec-1999 ag: Fxn error now causes a WinCE DebugBreak; ++ *! 30-Aug-1999 ag: Now uses GP_printf for printf and error. ++ *! ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- Function Prototypes */ ++static void error(char *msg, ...); ++static s32 GT_nop(void); ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++ ++struct GT_Config _GT_params = { ++ (Fxn) printk, /* printf */ ++ (Fxn) NULL, /* procid */ ++ (Fxn) GT_nop, /* taskid */ ++ (Fxn) error, /* error */ ++}; ++ ++/* ----------------------------------- Globals */ ++struct GT_Config *GT = &_GT_params; ++ ++/* ++ * ======== GT_nop ======== ++ */ ++static s32 GT_nop(void) ++{ ++ return 0; ++} ++ ++/* ++ * ======== error ======== ++ * purpose: ++ * Prints error onto the standard output. ++ */ ++static void error(char *fmt, ...) ++{ ++ s32 arg1, arg2, arg3, arg4, arg5, arg6; ++ ++ va_list va; ++ ++ va_start(va, fmt); ++ ++ arg1 = va_arg(va, s32); ++ arg2 = va_arg(va, s32); ++ arg3 = va_arg(va, s32); ++ arg4 = va_arg(va, s32); ++ arg5 = va_arg(va, s32); ++ arg6 = va_arg(va, s32); ++ ++ va_end(va); ++ ++ printk("ERROR: "); ++ printk(fmt, arg1, arg2, arg3, arg4, arg5, arg6); ++ ++#if defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT) ++ if (in_interrupt()) { ++ printk(KERN_INFO "Not stopping after error since ISR/DPC " ++ "are disabled\n"); ++ } else { ++ set_current_state(TASK_INTERRUPTIBLE); ++ flush_signals(current); ++ schedule(); ++ flush_signals(current); ++ printk(KERN_INFO "Signaled in error function\n"); ++ } ++#endif ++} +diff --git a/drivers/dsp/bridge/gen/gb.c b/drivers/dsp/bridge/gen/gb.c +new file mode 100644 +index 0000000..1d21e97 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/gb.c +@@ -0,0 +1,182 @@ ++/* ++ * gb.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gb.c ======== ++ * Description: Generic bitmap operations. ++ * ++ *! Revision History ++ *! ================ ++ *! 24-Feb-2003 vp Code review updates. ++ *! 17-Dec-2002 map Fixed GB_minset(), GB_empty(), and GB_full(), ++ *! to ensure only 'len' bits are considered in the map ++ *! 18-Oct-2002 sb Ported to Linux platform. ++ *! 06-Dec-2001 jeh Fixed bug in GB_minclear(). ++ *! ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <linux/types.h> ++/* ----------------------------------- This */ ++#include <dspbridge/gs.h> ++#include <dspbridge/gb.h> ++ ++typedef GB_BitNum GB_WordNum; ++ ++struct GB_TMap { ++ GB_BitNum len; ++ GB_WordNum wcnt; ++ u32 *words; ++}; ++ ++/* ++ * ======== GB_clear ======== ++ * purpose: ++ * Clears a bit in the bit map. ++ */ ++ ++void GB_clear(struct GB_TMap *map, GB_BitNum bitn) ++{ ++ u32 mask; ++ ++ mask = 1L << (bitn % BITS_PER_LONG); ++ map->words[bitn / BITS_PER_LONG] &= ~mask; ++} ++ ++/* ++ * ======== GB_create ======== ++ * purpose: ++ * Creates a bit map. ++ */ ++ ++struct GB_TMap *GB_create(GB_BitNum len) ++{ ++ struct GB_TMap *map; ++ GB_WordNum i; ++ map = (struct GB_TMap *)GS_alloc(sizeof(struct GB_TMap)); ++ if (map != NULL) { ++ map->len = len; ++ map->wcnt = len / BITS_PER_LONG + 1; ++ map->words = (u32 *)GS_alloc(map->wcnt * sizeof(u32)); ++ if (map->words != NULL) { ++ for (i = 0; i < map->wcnt; i++) ++ map->words[i] = 0L; ++ ++ } else { ++ GS_frees(map, sizeof(struct GB_TMap)); ++ map = NULL; ++ } ++ } ++ ++ return map; ++} ++ ++/* ++ * ======== GB_delete ======== ++ * purpose: ++ * Frees a bit map. ++ */ ++ ++void GB_delete(struct GB_TMap *map) ++{ ++ GS_frees(map->words, map->wcnt * sizeof(u32)); ++ GS_frees(map, sizeof(struct GB_TMap)); ++} ++ ++/* ++ * ======== GB_findandset ======== ++ * purpose: ++ * Finds a free bit and sets it. ++ */ ++GB_BitNum GB_findandset(struct GB_TMap *map) ++{ ++ GB_BitNum bitn; ++ ++ bitn = GB_minclear(map); ++ ++ if (bitn != GB_NOBITS) ++ GB_set(map, bitn); ++ ++ return bitn; ++} ++ ++/* ++ * ======== GB_minclear ======== ++ * purpose: ++ * returns the location of the first unset bit in the bit map. ++ */ ++GB_BitNum GB_minclear(struct GB_TMap *map) ++{ ++ GB_BitNum bit_location = 0; ++ GB_BitNum bitAcc = 0; ++ GB_WordNum i; ++ GB_BitNum bit; ++ u32 *word; ++ ++ for (word = map->words, i = 0; i < map->wcnt; word++, i++) { ++ if (~*word) { ++ for (bit = 0; bit < BITS_PER_LONG; bit++, bitAcc++) { ++ if (bitAcc == map->len) ++ return GB_NOBITS; ++ ++ if (~*word & (1L << bit)) { ++ bit_location = i * BITS_PER_LONG + bit; ++ return bit_location; ++ } ++ ++ } ++ } else { ++ bitAcc += BITS_PER_LONG; ++ } ++ } ++ ++ return GB_NOBITS; ++} ++ ++/* ++ * ======== GB_set ======== ++ * purpose: ++ * Sets a bit in the bit map. ++ */ ++ ++void GB_set(struct GB_TMap *map, GB_BitNum bitn) ++{ ++ u32 mask; ++ ++ mask = 1L << (bitn % BITS_PER_LONG); ++ map->words[bitn / BITS_PER_LONG] |= mask; ++} ++ ++/* ++ * ======== GB_test ======== ++ * purpose: ++ * Returns true if the bit is set in the specified location. ++ */ ++ ++bool GB_test(struct GB_TMap *map, GB_BitNum bitn) ++{ ++ bool state; ++ u32 mask; ++ u32 word; ++ ++ mask = 1L << (bitn % BITS_PER_LONG); ++ word = map->words[bitn / BITS_PER_LONG]; ++ state = word & mask ? TRUE : FALSE; ++ ++ return state; ++} +diff --git a/drivers/dsp/bridge/gen/gh.c b/drivers/dsp/bridge/gen/gh.c +new file mode 100644 +index 0000000..a20ae16 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/gh.c +@@ -0,0 +1,191 @@ ++/* ++ * gh.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gh.c ======== ++ */ ++ ++#include <dspbridge/std.h> ++ ++#include <dspbridge/host_os.h> ++ ++#include <dspbridge/gs.h> ++ ++#include <dspbridge/gh.h> ++ ++struct Elem { ++ struct Elem *next; ++ u8 data[1]; ++}; ++ ++struct GH_THashTab { ++ u16 maxBucket; ++ u16 valSize; ++ struct Elem **buckets; ++ u16(*hash) (void *, u16); ++ bool(*match) (void *, void *); ++ void(*delete) (void *); ++}; ++ ++static void Nop(void *p); ++static s32 curInit; ++static void myfree(void *ptr, s32 size); ++ ++/* ++ * ======== GH_create ======== ++ */ ++ ++struct GH_THashTab *GH_create(u16 maxBucket, u16 valSize, ++ u16(*hash)(void *, u16), bool(*match)(void *, void *), ++ void(*delete)(void *)) ++{ ++ struct GH_THashTab *hashTab; ++ u16 i; ++ hashTab = (struct GH_THashTab *)GS_alloc(sizeof(struct GH_THashTab)); ++ if (hashTab == NULL) ++ return NULL; ++ hashTab->maxBucket = maxBucket; ++ hashTab->valSize = valSize; ++ hashTab->hash = hash; ++ hashTab->match = match; ++ hashTab->delete = delete == NULL ? Nop : delete; ++ ++ hashTab->buckets = (struct Elem **) ++ GS_alloc(sizeof(struct Elem *) * maxBucket); ++ if (hashTab->buckets == NULL) { ++ GH_delete(hashTab); ++ return NULL; ++ } ++ ++ for (i = 0; i < maxBucket; i++) ++ hashTab->buckets[i] = NULL; ++ ++ return hashTab; ++} ++ ++/* ++ * ======== GH_delete ======== ++ */ ++void GH_delete(struct GH_THashTab *hashTab) ++{ ++ struct Elem *elem, *next; ++ u16 i; ++ ++ if (hashTab != NULL) { ++ if (hashTab->buckets != NULL) { ++ for (i = 0; i < hashTab->maxBucket; i++) { ++ for (elem = hashTab->buckets[i]; elem != NULL; ++ elem = next) { ++ next = elem->next; ++ (*hashTab->delete) (elem->data); ++ myfree(elem, sizeof(struct Elem) - 1 + ++ hashTab->valSize); ++ } ++ } ++ ++ myfree(hashTab->buckets, sizeof(struct Elem *) ++ * hashTab->maxBucket); ++ } ++ ++ myfree(hashTab, sizeof(struct GH_THashTab)); ++ } ++} ++ ++/* ++ * ======== GH_exit ======== ++ */ ++ ++void GH_exit(void) ++{ ++ if (curInit-- == 1) ++ GS_exit(); ++ ++} ++ ++/* ++ * ======== GH_find ======== ++ */ ++ ++void *GH_find(struct GH_THashTab *hashTab, void *key) ++{ ++ struct Elem *elem; ++ ++ elem = hashTab->buckets[(*hashTab->hash)(key, hashTab->maxBucket)]; ++ ++ for (; elem; elem = elem->next) { ++ if ((*hashTab->match)(key, elem->data)) ++ return elem->data; ++ } ++ ++ return NULL; ++} ++ ++/* ++ * ======== GH_init ======== ++ */ ++ ++void GH_init(void) ++{ ++ if (curInit++ == 0) ++ GS_init(); ++} ++ ++/* ++ * ======== GH_insert ======== ++ */ ++ ++void *GH_insert(struct GH_THashTab *hashTab, void *key, void *value) ++{ ++ struct Elem *elem; ++ u16 i; ++ char *src, *dst; ++ ++ elem = (struct Elem *)GS_alloc(sizeof(struct Elem) - 1 + ++ hashTab->valSize); ++ if (elem != NULL) { ++ ++ dst = (char *)elem->data; ++ src = (char *)value; ++ for (i = 0; i < hashTab->valSize; i++) ++ *dst++ = *src++; ++ ++ i = (*hashTab->hash)(key, hashTab->maxBucket); ++ elem->next = hashTab->buckets[i]; ++ hashTab->buckets[i] = elem; ++ ++ return elem->data; ++ } ++ ++ return NULL; ++} ++ ++/* ++ * ======== Nop ======== ++ */ ++/* ARGSUSED */ ++static void Nop(void *p) ++{ ++ p = p; /* stifle compiler warning */ ++} ++ ++/* ++ * ======== myfree ======== ++ */ ++static void myfree(void *ptr, s32 size) ++{ ++ GS_free(ptr); ++} +diff --git a/drivers/dsp/bridge/gen/gs.c b/drivers/dsp/bridge/gen/gs.c +new file mode 100644 +index 0000000..ef5f923 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/gs.c +@@ -0,0 +1,108 @@ ++/* ++ * gs.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gs.c ======== ++ * Description: ++ * General storage memory allocator services. ++ * ++ *! Revision History ++ *! ================ ++ *! 29-Sep-1999 ag: Un-commented MEM_Init in GS_init(). ++ *! 14-May-1997 mg: Modified to use new GS API for GS_free() and GS_frees(). ++ *! 06-Nov-1996 gp: Re-commented MEM_Init in GS_init(). GS needs GS_Exit(). ++ *! 21-Oct-1996 db: Un-commented MEM_Init in GS_init(). ++ *! 21-May-1996 mg: Created from original stdlib implementation. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <linux/types.h> ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/gs.h> ++ ++/* ----------------------------------- Globals */ ++static u32 cumsize; ++ ++/* ++ * ======== GS_alloc ======== ++ * purpose: ++ * Allocates memory of the specified size. ++ */ ++void *GS_alloc(u32 size) ++{ ++ void *p; ++ ++ p = MEM_Calloc(size, MEM_PAGED); ++ if (p == NULL) ++ return NULL; ++ cumsize += size; ++ return p; ++} ++ ++/* ++ * ======== GS_exit ======== ++ * purpose: ++ * Discontinue the usage of the GS module. ++ */ ++void GS_exit(void) ++{ ++ MEM_Exit(); ++} ++ ++/* ++ * ======== GS_free ======== ++ * purpose: ++ * Frees the memory. ++ */ ++void GS_free(void *ptr) ++{ ++ MEM_Free(ptr); ++ /* ack! no size info */ ++ /* cumsize -= size; */ ++} ++ ++/* ++ * ======== GS_frees ======== ++ * purpose: ++ * Frees the memory. ++ */ ++void GS_frees(void *ptr, u32 size) ++{ ++ MEM_Free(ptr); ++ cumsize -= size; ++} ++ ++/* ++ * ======== GS_init ======== ++ * purpose: ++ * Initializes the GS module. ++ */ ++void GS_init(void) ++{ ++ static bool curInit; ++ ++ if (curInit == false) { ++ curInit = true; ++ ++ MEM_Init(); ++ } ++} +diff --git a/drivers/dsp/bridge/gen/gt.c b/drivers/dsp/bridge/gen/gt.c +new file mode 100644 +index 0000000..452d6e6 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/gt.c +@@ -0,0 +1,348 @@ ++/* ++ * gt.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== gt.c ======== ++ * Description: This module implements the trace mechanism for bridge. ++ * ++ *! Revision History ++ *! ================ ++ *! 16-May-1997 dr Changed GT_Config member names to conform to coding ++ *! standards. ++ *! 23-Apr-1997 ge Check for GT->TIDFXN for NULL before calling it. ++ *! 03-Jan-1997 ge Changed GT_Config structure member names to eliminate ++ *! preprocessor confusion with other macros. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/gt.h> ++ ++#define GT_WILD '*' ++ ++#define GT_CLEAR '=' ++#define GT_ON '+' ++#define GT_OFF '-' ++ ++enum GT_State { ++ GT_SEP, ++ GT_FIRST, ++ GT_SECOND, ++ GT_OP, ++ GT_DIGITS ++} ; ++ ++#ifdef CONFIG_BRIDGE_DEBUG ++static char *GT_1format = "%s - %d: "; ++static char *GT_2format = "%s - %d(%d): "; ++#endif /* CONFIG_BRIDGE_DEBUG */ ++ ++static unsigned char *GT_tMask[GT_BOUND]; ++ ++static bool curInit; ++static char *separator; ++static unsigned char tabMem[GT_BOUND][sizeof(unsigned char) * GT_BOUND]; ++ ++static void error(char *string); ++static void setMask(s16 index1, s16 index2, char op, unsigned char mask); ++ ++/* ++ * ======== _GT_create ======== ++ * purpose: ++ * Creates GT mask. ++ */ ++void _GT_create(struct GT_Mask *mask, char *modName) ++{ ++ mask->modName = modName; ++ mask->flags = &(GT_tMask[modName[0] - 'A'][modName[1] - 'A']); ++} ++ ++/* ++ * ======== GT_init ======== ++ * purpose: ++ * Initializes GT module. ++ */ ++#ifdef GT_init ++#undef GT_init ++#endif ++void GT_init(void) ++{ ++ register unsigned char index1; ++ register unsigned char index2; ++ ++ if (!curInit) { ++ curInit = true; ++ ++ separator = " ,;/"; ++ ++ for (index1 = 0; index1 < GT_BOUND; index1++) { ++ GT_tMask[index1] = tabMem[index1]; ++ for (index2 = 0; index2 < GT_BOUND; index2++) { ++ /* no tracing */ ++ GT_tMask[index1][index2] = 0x00; ++ } ++ } ++ } ++} ++ ++/* ++ * ======== _GT_set ======== ++ * purpose: ++ * Sets the trace string format. ++ */ ++ ++void _GT_set(char *str) ++{ ++ enum GT_State state; ++ char *sep; ++ s16 index1 = GT_BOUND; /* indicates all values */ ++ s16 index2 = GT_BOUND; /* indicates all values */ ++ char op = GT_CLEAR; ++ bool maskValid; ++ s16 digit; ++ register unsigned char mask = 0x0; /* no tracing */ ++ ++ if (str == NULL) ++ return; ++ ++ maskValid = false; ++ state = GT_SEP; ++ while (*str != '\0') { ++ switch ((s32) state) { ++ case (s32) GT_SEP: ++ maskValid = false; ++ sep = separator; ++ while (*sep != '\0') { ++ if (*str == *sep) { ++ str++; ++ break; ++ } else { ++ sep++; ++ } ++ } ++ if (*sep == '\0') ++ state = GT_FIRST; ++ ++ break; ++ case (s32) GT_FIRST: ++ if (*str == GT_WILD) { ++ /* indicates all values */ ++ index1 = GT_BOUND; ++ /* indicates all values */ ++ index2 = GT_BOUND; ++ state = GT_OP; ++ } else { ++ if (*str >= 'a') ++ index1 = (s16) (*str - 'a'); ++ else ++ index1 = (s16) (*str - 'A'); ++ if ((index1 >= 0) && (index1 < GT_BOUND)) ++ state = GT_SECOND; ++ else ++ state = GT_SEP; ++ } ++ str++; ++ break; ++ case (s32) GT_SECOND: ++ if (*str == GT_WILD) { ++ index2 = GT_BOUND; /* indicates all values */ ++ state = GT_OP; ++ str++; ++ } else { ++ if (*str >= 'a') ++ index2 = (s16) (*str - 'a'); ++ else ++ index2 = (s16) (*str - 'A'); ++ if ((index2 >= 0) && (index2 < GT_BOUND)) { ++ state = GT_OP; ++ str++; ++ } else { ++ state = GT_SEP; ++ } ++ } ++ break; ++ case (s32) GT_OP: ++ op = *str; ++ mask = 0x0; /* no tracing */ ++ switch (op) { ++ case (s32) GT_CLEAR: ++ maskValid = true; ++ case (s32) GT_ON: ++ case (s32) GT_OFF: ++ state = GT_DIGITS; ++ str++; ++ break; ++ default: ++ state = GT_SEP; ++ break; ++ } ++ break; ++ case (s32) GT_DIGITS: ++ digit = (s16) (*str - '0'); ++ if ((digit >= 0) && (digit <= 7)) { ++ mask |= (0x01 << digit); ++ maskValid = true; ++ str++; ++ } else { ++ if (maskValid == true) { ++ setMask(index1, index2, op, mask); ++ maskValid = false; ++ } ++ state = GT_SEP; ++ } ++ break; ++ default: ++ error("illegal trace mask"); ++ break; ++ } ++ } ++ ++ if (maskValid) ++ setMask(index1, index2, op, mask); ++} ++ ++/* ++ * ======== _GT_trace ======== ++ * purpose: ++ * Prints the input string onto standard output ++ */ ++ ++s32 _GT_trace(struct GT_Mask *mask, char *format, ...) ++{ ++ s32 arg1, arg2, arg3, arg4, arg5, arg6; ++ va_list va; ++ ++ va_start(va, format); ++ ++ arg1 = va_arg(va, s32); ++ arg2 = va_arg(va, s32); ++ arg3 = va_arg(va, s32); ++ arg4 = va_arg(va, s32); ++ arg5 = va_arg(va, s32); ++ arg6 = va_arg(va, s32); ++ ++ va_end(va); ++#ifdef DEBUG ++ if (GT->PIDFXN == NULL) { ++ printk(GT_1format, mask->modName, GT->TIDFXN ? ++ (*GT->TIDFXN)() : 0); ++ } else { ++ printk(GT_2format, mask->modName, (*GT->PIDFXN)(), ++ GT->TIDFXN ? (*GT->TIDFXN)() : 0); ++ } ++#endif ++ printk(format, arg1, arg2, arg3, arg4, arg5, arg6); ++ ++ return 0; ++} ++ ++/* ++ * ======== error ======== ++ * purpose: ++ * Prints errors onto the standard output. ++ */ ++static void error(char *string) ++{ ++ printk("GT: %s", string); ++} ++ ++/* ++ * ======== setmask ======== ++ * purpose: ++ * Sets mask for the GT module. ++ */ ++ ++static void setMask(s16 index1, s16 index2, char op, u8 mask) ++{ ++ register s16 index; ++ ++ if (index1 < GT_BOUND) { ++ if (index2 < GT_BOUND) { ++ switch (op) { ++ case (s32) GT_CLEAR: ++ GT_tMask[index1][index2] = mask; ++ break; ++ case (s32) GT_ON: ++ GT_tMask[index1][index2] |= mask; ++ break; ++ case (s32) GT_OFF: ++ GT_tMask[index1][index2] &= ~mask; ++ break; ++ default: ++ error("illegal trace mask"); ++ break; ++ } ++ } else { ++ for (index2--; index2 >= 0; index2--) { ++ switch (op) { ++ case (s32) GT_CLEAR: ++ GT_tMask[index1][index2] = mask; ++ break; ++ case (s32) GT_ON: ++ GT_tMask[index1][index2] |= mask; ++ break; ++ case (s32) GT_OFF: ++ GT_tMask[index1][index2] &= ~mask; ++ break; ++ default: ++ error("illegal trace mask"); ++ break; ++ } ++ } ++ } ++ } else { ++ for (index1--; index1 >= 0; index1--) { ++ if (index2 < GT_BOUND) { ++ switch (op) { ++ case (s32) GT_CLEAR: ++ GT_tMask[index1][index2] = mask; ++ break; ++ case (s32) GT_ON: ++ GT_tMask[index1][index2] |= mask; ++ break; ++ case (s32) GT_OFF: ++ GT_tMask[index1][index2] &= ~mask; ++ break; ++ default: ++ error("illegal trace mask"); ++ break; ++ } ++ } else { ++ index = GT_BOUND; ++ for (index--; index >= 0; index--) { ++ switch (op) { ++ case (s32) GT_CLEAR: ++ GT_tMask[index1][index] = mask; ++ break; ++ case (s32) GT_ON: ++ GT_tMask[index1][index] |= mask; ++ break; ++ case (s32) GT_OFF: ++ GT_tMask[index1][index] &= ++ ~mask; ++ break; ++ default: ++ error("illegal trace mask"); ++ break; ++ } ++ } ++ } ++ } ++ } ++} +diff --git a/drivers/dsp/bridge/gen/uuidutil.c b/drivers/dsp/bridge/gen/uuidutil.c +new file mode 100644 +index 0000000..a45f448 +--- /dev/null ++++ b/drivers/dsp/bridge/gen/uuidutil.c +@@ -0,0 +1,238 @@ ++/* ++ * uuidutil.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== uuidutil.c ======== ++ * Description: ++ * This file contains the implementation of UUID helper functions. ++ * ++ *! Revision History ++ *! ================ ++ *! 23-Feb-2003 vp: Code review updates. ++ *! 18-Oct-2003 vp: Ported to Linux platform. ++ *! 31-Aug-2000 rr: UUID_UuidFromString bug fixed. ++ *! 29-Aug-2000 rr: Modified UUID_UuidFromString. ++ *! 09-Nov-2000 kc: Modified UUID_UuidFromString to simplify implementation. ++ *! 30-Oct-2000 kc: Modified UUID utility module function prefix. ++ *! 10-Aug-2000 kc: Created. ++ *! ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/uuidutil.h> ++ ++/* ++ * ======== UUID_UuidToString ======== ++ * Purpose: ++ * Converts a struct DSP_UUID to a string. ++ * Note: snprintf format specifier is: ++ * %[flags] [width] [.precision] [{h | l | I64 | L}]type ++ */ ++void UUID_UuidToString(IN struct DSP_UUID *pUuid, OUT char *pszUuid, ++ IN s32 size) ++{ ++ s32 i; /* return result from snprintf. */ ++ ++ DBC_Require(pUuid && pszUuid); ++ ++ i = snprintf(pszUuid, size, ++ "%.8X_%.4X_%.4X_%.2X%.2X_%.2X%.2X%.2X%.2X%.2X%.2X", ++ pUuid->ulData1, pUuid->usData2, pUuid->usData3, ++ pUuid->ucData4, pUuid->ucData5, pUuid->ucData6[0], ++ pUuid->ucData6[1], pUuid->ucData6[2], pUuid->ucData6[3], ++ pUuid->ucData6[4], pUuid->ucData6[5]); ++ ++ DBC_Ensure(i != -1); ++} ++ ++/* ++ * ======== htoi ======== ++ * Purpose: ++ * Converts a hex value to a decimal integer. ++ */ ++ ++static int htoi(char c) ++{ ++ switch (c) { ++ case '0': ++ return 0; ++ case '1': ++ return 1; ++ case '2': ++ return 2; ++ case '3': ++ return 3; ++ case '4': ++ return 4; ++ case '5': ++ return 5; ++ case '6': ++ return 6; ++ case '7': ++ return 7; ++ case '8': ++ return 8; ++ case '9': ++ return 9; ++ case 'A': ++ return 10; ++ case 'B': ++ return 11; ++ case 'C': ++ return 12; ++ case 'D': ++ return 13; ++ case 'E': ++ return 14; ++ case 'F': ++ return 15; ++ case 'a': ++ return 10; ++ case 'b': ++ return 11; ++ case 'c': ++ return 12; ++ case 'd': ++ return 13; ++ case 'e': ++ return 14; ++ case 'f': ++ return 15; ++ } ++ return 0; ++} ++ ++/* ++ * ======== UUID_UuidFromString ======== ++ * Purpose: ++ * Converts a string to a struct DSP_UUID. ++ */ ++void UUID_UuidFromString(IN char *pszUuid, OUT struct DSP_UUID *pUuid) ++{ ++ char c; ++ s32 i, j; ++ s32 result; ++ char *temp = pszUuid; ++ ++ result = 0; ++ for (i = 0; i < 8; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->ulData1 = result; ++ ++ /* Step over underscore */ ++ temp++; ++ ++ result = 0; ++ for (i = 0; i < 4; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->usData2 = (u16)result; ++ ++ /* Step over underscore */ ++ temp++; ++ ++ result = 0; ++ for (i = 0; i < 4; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->usData3 = (u16)result; ++ ++ /* Step over underscore */ ++ temp++; ++ ++ result = 0; ++ for (i = 0; i < 2; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->ucData4 = (u8)result; ++ ++ result = 0; ++ for (i = 0; i < 2; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->ucData5 = (u8)result; ++ ++ /* Step over underscore */ ++ temp++; ++ ++ for (j = 0; j < 6; j++) { ++ result = 0; ++ for (i = 0; i < 2; i++) { ++ /* Get first character in string */ ++ c = *temp; ++ ++ /* Increase the results by new value */ ++ result *= 16; ++ result += htoi(c); ++ ++ /* Go to next character in string */ ++ temp++; ++ } ++ pUuid->ucData6[j] = (u8)result; ++ } ++} +diff --git a/drivers/dsp/bridge/hw/EasiGlobal.h b/drivers/dsp/bridge/hw/EasiGlobal.h +new file mode 100644 +index 0000000..b023826 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/EasiGlobal.h +@@ -0,0 +1,42 @@ ++/* ++ * EasiGlobal.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef __EASIGLOBAL_H ++#define __EASIGLOBAL_H ++#include <linux/types.h> ++ ++/* ++ * DEFINE: READ_ONLY, WRITE_ONLY & READ_WRITE ++ * ++ * DESCRIPTION: Defines used to describe register types for EASI-checker tests. ++ */ ++ ++#define READ_ONLY 1 ++#define WRITE_ONLY 2 ++#define READ_WRITE 3 ++ ++/* ++ * MACRO: _DEBUG_LEVEL_1_EASI ++ * ++ * DESCRIPTION: A MACRO which can be used to indicate that a particular beach ++ * register access function was called. ++ * ++ * NOTE: We currently dont use this functionality. ++ */ ++#define _DEBUG_LEVEL_1_EASI(easiNum) ((void)0) ++ ++#endif /* __EASIGLOBAL_H */ ++ +diff --git a/drivers/dsp/bridge/hw/GlobalTypes.h b/drivers/dsp/bridge/hw/GlobalTypes.h +new file mode 100644 +index 0000000..9004a37 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/GlobalTypes.h +@@ -0,0 +1,325 @@ ++/* ++ * GlobalTypes.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== GlobalTypes.h ======== ++ * Description: ++ * Global HW definitions ++ * ++ *! Revision History: ++ *! ================ ++ *! 16 Feb 2003 sb: Initial version ++ */ ++#ifndef __GLOBALTYPES_H ++#define __GLOBALTYPES_H ++ ++/* ++ * Definition: TRUE, FALSE ++ * ++ * DESCRIPTION: Boolean Definitions ++ */ ++#ifndef TRUE ++#define FALSE 0 ++#define TRUE (!(FALSE)) ++#endif ++ ++/* ++ * Definition: NULL ++ * ++ * DESCRIPTION: Invalid pointer ++ */ ++#ifndef NULL ++#define NULL (void *)0 ++#endif ++ ++/* ++ * Definition: RET_CODE_BASE ++ * ++ * DESCRIPTION: Base value for return code offsets ++ */ ++#define RET_CODE_BASE 0 ++ ++/* ++ * Definition: *BIT_OFFSET ++ * ++ * DESCRIPTION: offset in bytes from start of 32-bit word. ++ */ ++#define LOWER_16BIT_OFFSET 0 ++#define UPPER_16BIT_OFFSET 2 ++ ++#define LOWER_8BIT_OFFSET 0 ++#define LOWER_MIDDLE_8BIT_OFFSET 1 ++#define UPPER_MIDDLE_8BIT_OFFSET 2 ++#define UPPER_8BIT_OFFSET 3 ++ ++#define LOWER_8BIT_OF16_OFFSET 0 ++#define UPPER_8BIT_OF16_OFFSET 1 ++ ++/* ++ * Definition: *BIT_SHIFT ++ * ++ * DESCRIPTION: offset in bits from start of 32-bit word. ++ */ ++#define LOWER_16BIT_SHIFT 0 ++#define UPPER_16BIT_SHIFT 16 ++ ++#define LOWER_8BIT_SHIFT 0 ++#define LOWER_MIDDLE_8BIT_SHIFT 8 ++#define UPPER_MIDDLE_8BIT_SHIFT 16 ++#define UPPER_8BIT_SHIFT 24 ++ ++#define LOWER_8BIT_OF16_SHIFT 0 ++#define UPPER_8BIT_OF16_SHIFT 8 ++ ++ ++/* ++ * Definition: LOWER_16BIT_MASK ++ * ++ * DESCRIPTION: 16 bit mask used for inclusion of lower 16 bits i.e. mask out ++ * the upper 16 bits ++ */ ++#define LOWER_16BIT_MASK 0x0000FFFF ++ ++ ++/* ++ * Definition: LOWER_8BIT_MASK ++ * ++ * DESCRIPTION: 8 bit masks used for inclusion of 8 bits i.e. mask out ++ * the upper 16 bits ++ */ ++#define LOWER_8BIT_MASK 0x000000FF ++ ++/* ++ * Definition: RETURN_32BITS_FROM_16LOWER_AND_16UPPER(lower16Bits, upper16Bits) ++ * ++ * DESCRIPTION: Returns a 32 bit value given a 16 bit lower value and a 16 ++ * bit upper value ++ */ ++#define RETURN_32BITS_FROM_16LOWER_AND_16UPPER(lower16Bits,upper16Bits)\ ++ (((((u32)lower16Bits) & LOWER_16BIT_MASK)) | \ ++ (((((u32)upper16Bits) & LOWER_16BIT_MASK) << UPPER_16BIT_SHIFT))) ++ ++/* ++ * Definition: RETURN_16BITS_FROM_8LOWER_AND_8UPPER(lower16Bits, upper16Bits) ++ * ++ * DESCRIPTION: Returns a 16 bit value given a 8 bit lower value and a 8 ++ * bit upper value ++ */ ++#define RETURN_16BITS_FROM_8LOWER_AND_8UPPER(lower8Bits,upper8Bits)\ ++ (((((u32)lower8Bits) & LOWER_8BIT_MASK)) | \ ++ (((((u32)upper8Bits) & LOWER_8BIT_MASK) << UPPER_8BIT_OF16_SHIFT))) ++ ++/* ++ * Definition: RETURN_32BITS_FROM_4_8BIT_VALUES(lower8Bits, lowerMiddle8Bits, ++ * lowerUpper8Bits, upper8Bits) ++ * ++ * DESCRIPTION: Returns a 32 bit value given four 8 bit values ++ */ ++#define RETURN_32BITS_FROM_4_8BIT_VALUES(lower8Bits, lowerMiddle8Bits,\ ++ lowerUpper8Bits, upper8Bits)\ ++ (((((u32)lower8Bits) & LOWER_8BIT_MASK)) | \ ++ (((((u32)lowerMiddle8Bits) & LOWER_8BIT_MASK) <<\ ++ LOWER_MIDDLE_8BIT_SHIFT)) | \ ++ (((((u32)lowerUpper8Bits) & LOWER_8BIT_MASK) <<\ ++ UPPER_MIDDLE_8BIT_SHIFT)) | \ ++ (((((u32)upper8Bits) & LOWER_8BIT_MASK) <<\ ++ UPPER_8BIT_SHIFT))) ++ ++/* ++ * Definition: READ_LOWER_16BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 16 lower bits of 32bit value ++ */ ++#define READ_LOWER_16BITS_OF_32(value32bits)\ ++ ((u16)((u32)(value32bits) & LOWER_16BIT_MASK)) ++ ++/* ++ * Definition: READ_UPPER_16BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 16 lower bits of 32bit value ++ */ ++#define READ_UPPER_16BITS_OF_32(value32bits)\ ++ (((u16)((u32)(value32bits) >> UPPER_16BIT_SHIFT)) &\ ++ LOWER_16BIT_MASK) ++ ++ ++/* ++ * Definition: READ_LOWER_8BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 8 lower bits of 32bit value ++ */ ++#define READ_LOWER_8BITS_OF_32(value32bits)\ ++ ((u8)((u32)(value32bits) & LOWER_8BIT_MASK)) ++ ++/* ++ * Definition: READ_LOWER_MIDDLE_8BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 8 lower middle bits of 32bit value ++ */ ++#define READ_LOWER_MIDDLE_8BITS_OF_32(value32bits)\ ++ (((u8)((u32)(value32bits) >> LOWER_MIDDLE_8BIT_SHIFT)) &\ ++ LOWER_8BIT_MASK) ++ ++/* ++ * Definition: READ_LOWER_MIDDLE_8BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 8 lower middle bits of 32bit value ++ */ ++#define READ_UPPER_MIDDLE_8BITS_OF_32(value32bits)\ ++ (((u8)((u32)(value32bits) >> LOWER_MIDDLE_8BIT_SHIFT)) &\ ++ LOWER_8BIT_MASK) ++ ++/* ++ * Definition: READ_UPPER_8BITS_OF_32(value32bits) ++ * ++ * DESCRIPTION: Returns a 8 upper bits of 32bit value ++ */ ++#define READ_UPPER_8BITS_OF_32(value32bits)\ ++ (((u8)((u32)(value32bits) >> UPPER_8BIT_SHIFT)) & LOWER_8BIT_MASK) ++ ++ ++/* ++ * Definition: READ_LOWER_8BITS_OF_16(value16bits) ++ * ++ * DESCRIPTION: Returns a 8 lower bits of 16bit value ++ */ ++#define READ_LOWER_8BITS_OF_16(value16bits)\ ++ ((u8)((u16)(value16bits) & LOWER_8BIT_MASK)) ++ ++/* ++ * Definition: READ_UPPER_8BITS_OF_16(value32bits) ++ * ++ * DESCRIPTION: Returns a 8 upper bits of 16bit value ++ */ ++#define READ_UPPER_8BITS_OF_16(value16bits)\ ++ (((u8)((u32)(value16bits) >> UPPER_8BIT_SHIFT)) & LOWER_8BIT_MASK) ++ ++ ++ ++/* UWORD16: 16 bit tpyes */ ++ ++ ++/* REG_UWORD8, REG_WORD8: 8 bit register types */ ++typedef volatile unsigned char REG_UWORD8; ++typedef volatile signed char REG_WORD8; ++ ++/* REG_UWORD16, REG_WORD16: 16 bit register types */ ++#ifndef OMAPBRIDGE_TYPES ++typedef volatile unsigned short REG_UWORD16; ++#endif ++typedef volatile short REG_WORD16; ++ ++/* REG_UWORD32, REG_WORD32: 32 bit register types */ ++typedef volatile unsigned long REG_UWORD32; ++ ++/* FLOAT ++ * ++ * Type to be used for floating point calculation. Note that floating point ++ * calculation is very CPU expensive, and you should only use if you ++ * absolutely need this. */ ++ ++ ++/* boolean_t: Boolean Type True, False */ ++/* ReturnCode_t: Return codes to be returned by all library functions */ ++typedef enum ReturnCode_label { ++ RET_OK = 0, ++ RET_FAIL = -1, ++ RET_BAD_NULL_PARAM = -2, ++ RET_PARAM_OUT_OF_RANGE = -3, ++ RET_INVALID_ID = -4, ++ RET_EMPTY = -5, ++ RET_FULL = -6, ++ RET_TIMEOUT = -7, ++ RET_INVALID_OPERATION = -8, ++ ++ /* Add new error codes at end of above list */ ++ ++ RET_NUM_RET_CODES /* this should ALWAYS be LAST entry */ ++} ReturnCode_t, *pReturnCode_t; ++ ++/* MACRO: RD_MEM_8, WR_MEM_8 ++ * ++ * DESCRIPTION: 32 bit memory access macros ++ */ ++#define RD_MEM_8(addr) ((u8)(*((u8 *)(addr)))) ++#define WR_MEM_8(addr, data) (*((u8 *)(addr)) = (u8)(data)) ++ ++/* MACRO: RD_MEM_8_VOLATILE, WR_MEM_8_VOLATILE ++ * ++ * DESCRIPTION: 8 bit register access macros ++ */ ++#define RD_MEM_8_VOLATILE(addr) ((u8)(*((REG_UWORD8 *)(addr)))) ++#define WR_MEM_8_VOLATILE(addr, data) (*((REG_UWORD8 *)(addr)) = (u8)(data)) ++ ++ ++/* ++ * MACRO: RD_MEM_16, WR_MEM_16 ++ * ++ * DESCRIPTION: 16 bit memory access macros ++ */ ++#define RD_MEM_16(addr) ((u16)(*((u16 *)(addr)))) ++#define WR_MEM_16(addr, data) (*((u16 *)(addr)) = (u16)(data)) ++ ++/* ++ * MACRO: RD_MEM_16_VOLATILE, WR_MEM_16_VOLATILE ++ * ++ * DESCRIPTION: 16 bit register access macros ++ */ ++#define RD_MEM_16_VOLATILE(addr) ((u16)(*((REG_UWORD16 *)(addr)))) ++#define WR_MEM_16_VOLATILE(addr, data) (*((REG_UWORD16 *)(addr)) =\ ++ (u16)(data)) ++ ++/* ++ * MACRO: RD_MEM_32, WR_MEM_32 ++ * ++ * DESCRIPTION: 32 bit memory access macros ++ */ ++#define RD_MEM_32(addr) ((u32)(*((u32 *)(addr)))) ++#define WR_MEM_32(addr, data) (*((u32 *)(addr)) = (u32)(data)) ++ ++/* ++ * MACRO: RD_MEM_32_VOLATILE, WR_MEM_32_VOLATILE ++ * ++ * DESCRIPTION: 32 bit register access macros ++ */ ++#define RD_MEM_32_VOLATILE(addr) ((u32)(*((REG_UWORD32 *)(addr)))) ++#define WR_MEM_32_VOLATILE(addr, data) (*((REG_UWORD32 *)(addr)) =\ ++ (u32)(data)) ++ ++/* Not sure if this all belongs here */ ++ ++#define CHECK_RETURN_VALUE(actualValue, expectedValue, returnCodeIfMismatch,\ ++ spyCodeIfMisMatch) ++#define CHECK_RETURN_VALUE_RET(actualValue, expectedValue, returnCodeIfMismatch) ++#define CHECK_RETURN_VALUE_RES(actualValue, expectedValue, spyCodeIfMisMatch) ++#define CHECK_RETURN_VALUE_RET_VOID(actualValue, expectedValue,\ ++ spyCodeIfMisMatch) ++ ++#define CHECK_INPUT_PARAM(actualValue, invalidValue, returnCodeIfMismatch,\ ++ spyCodeIfMisMatch) ++#define CHECK_INPUT_PARAM_NO_SPY(actualValue, invalidValue,\ ++ returnCodeIfMismatch) ++#define CHECK_INPUT_RANGE(actualValue, minValidValue, maxValidValue,\ ++ returnCodeIfMismatch, spyCodeIfMisMatch) ++#define CHECK_INPUT_RANGE_NO_SPY(actualValue, minValidValue, maxValidValue,\ ++ returnCodeIfMismatch) ++#define CHECK_INPUT_RANGE_MIN0(actualValue, maxValidValue,\ ++ returnCodeIfMismatch, spyCodeIfMisMatch) ++#define CHECK_INPUT_RANGE_NO_SPY_MIN0(actualValue, maxValidValue,\ ++ returnCodeIfMismatch) ++ ++#endif /* __GLOBALTYPES_H */ +diff --git a/drivers/dsp/bridge/hw/IPIAccInt.h b/drivers/dsp/bridge/hw/IPIAccInt.h +new file mode 100644 +index 0000000..b88a58c +--- /dev/null ++++ b/drivers/dsp/bridge/hw/IPIAccInt.h +@@ -0,0 +1,41 @@ ++/* ++ * IPIAccInt.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef _IPI_ACC_INT_H ++#define _IPI_ACC_INT_H ++ ++/* Bitfield mask and offset declarations */ ++#define SYSC_IVA2BOOTMOD_OFFSET 0x404 ++#define SYSC_IVA2BOOTADDR_OFFSET 0x400 ++#define SYSC_IVA2BOOTADDR_MASK 0xfffffc00 ++ ++ ++/* The following represent the enumerated values for each bitfield */ ++ ++enum IPIIPI_SYSCONFIGAutoIdleE { ++ IPIIPI_SYSCONFIGAutoIdleclkfree = 0x0000, ++ IPIIPI_SYSCONFIGAutoIdleautoclkgate = 0x0001 ++} ; ++ ++enum IPIIPI_ENTRYElemSizeValueE { ++ IPIIPI_ENTRYElemSizeValueElemSz8b = 0x0000, ++ IPIIPI_ENTRYElemSizeValueElemSz16b = 0x0001, ++ IPIIPI_ENTRYElemSizeValueElemSz32b = 0x0002, ++ IPIIPI_ENTRYElemSizeValueReserved = 0x0003 ++} ; ++ ++#endif /* _IPI_ACC_INT_H */ ++/* EOF */ +diff --git a/drivers/dsp/bridge/hw/IVA2RegAcM.h b/drivers/dsp/bridge/hw/IVA2RegAcM.h +new file mode 100644 +index 0000000..6c1e300 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/IVA2RegAcM.h +@@ -0,0 +1,28 @@ ++/* ++ * IVA1RegAcM.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++ ++#ifndef _IVA2_REG_ACM_H ++#define _IVA2_REG_ACM_H ++ ++#include <GlobalTypes.h> ++#include <EasiGlobal.h> ++ ++#define SYSC_IVA2BOOTMOD_OFFSET 0x404 ++#define SYSC_IVA2BOOTADDR_OFFSET 0x400 ++ ++#endif +diff --git a/drivers/dsp/bridge/hw/MLBAccInt.h b/drivers/dsp/bridge/hw/MLBAccInt.h +new file mode 100644 +index 0000000..7a03c6a +--- /dev/null ++++ b/drivers/dsp/bridge/hw/MLBAccInt.h +@@ -0,0 +1,132 @@ ++/* ++ * MLBAccInt.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++#ifndef _MLB_ACC_INT_H ++#define _MLB_ACC_INT_H ++ ++/* Mappings of level 1 EASI function numbers to function names */ ++ ++#define EASIL1_MLBMAILBOX_SYSCONFIGReadRegister32 (MLB_BASE_EASIL1 + 3) ++#define EASIL1_MLBMAILBOX_SYSCONFIGWriteRegister32 (MLB_BASE_EASIL1 + 4) ++#define EASIL1_MLBMAILBOX_SYSCONFIGSIdleModeRead32 (MLB_BASE_EASIL1 + 7) ++#define EASIL1_MLBMAILBOX_SYSCONFIGSIdleModeWrite32 (MLB_BASE_EASIL1 + 17) ++#define EASIL1_MLBMAILBOX_SYSCONFIGSoftResetWrite32 (MLB_BASE_EASIL1 + 29) ++#define EASIL1_MLBMAILBOX_SYSCONFIGAutoIdleRead32 \ ++ (MLB_BASE_EASIL1 + 33) ++#define EASIL1_MLBMAILBOX_SYSCONFIGAutoIdleWrite32 (MLB_BASE_EASIL1 + 39) ++#define EASIL1_MLBMAILBOX_SYSSTATUSResetDoneRead32 (MLB_BASE_EASIL1 + 44) ++#define EASIL1_MLBMAILBOX_MESSAGE___0_15ReadRegister32 \ ++ (MLB_BASE_EASIL1 + 50) ++#define EASIL1_MLBMAILBOX_MESSAGE___0_15WriteRegister32 \ ++ (MLB_BASE_EASIL1 + 51) ++#define EASIL1_MLBMAILBOX_FIFOSTATUS___0_15ReadRegister32 \ ++ (MLB_BASE_EASIL1 + 56) ++#define EASIL1_MLBMAILBOX_FIFOSTATUS___0_15FifoFullMBmRead32 \ ++ (MLB_BASE_EASIL1 + 57) ++#define EASIL1_MLBMAILBOX_MSGSTATUS___0_15NbOfMsgMBmRead32 \ ++ (MLB_BASE_EASIL1 + 60) ++#define EASIL1_MLBMAILBOX_IRQSTATUS___0_3ReadRegister32 \ ++ (MLB_BASE_EASIL1 + 62) ++#define EASIL1_MLBMAILBOX_IRQSTATUS___0_3WriteRegister32 \ ++ (MLB_BASE_EASIL1 + 63) ++#define EASIL1_MLBMAILBOX_IRQENABLE___0_3ReadRegister32 \ ++ (MLB_BASE_EASIL1 + 192) ++#define EASIL1_MLBMAILBOX_IRQENABLE___0_3WriteRegister32 \ ++ (MLB_BASE_EASIL1 + 193) ++ ++/* Register set MAILBOX_MESSAGE___REGSET_0_15 address offset, bank address ++ * increment and number of banks */ ++ ++#define MLB_MAILBOX_MESSAGE___REGSET_0_15_OFFSET (u32)(0x0040) ++#define MLB_MAILBOX_MESSAGE___REGSET_0_15_STEP (u32)(0x0004) ++ ++/* Register offset address definitions relative to register set ++ * MAILBOX_MESSAGE___REGSET_0_15 */ ++ ++#define MLB_MAILBOX_MESSAGE___0_15_OFFSET (u32)(0x0) ++ ++ ++/* Register set MAILBOX_FIFOSTATUS___REGSET_0_15 address offset, bank address ++ * increment and number of banks */ ++ ++#define MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_OFFSET (u32)(0x0080) ++#define MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_STEP (u32)(0x0004) ++ ++/* Register offset address definitions relative to register set ++ * MAILBOX_FIFOSTATUS___REGSET_0_15 */ ++ ++#define MLB_MAILBOX_FIFOSTATUS___0_15_OFFSET (u32)(0x0) ++ ++ ++/* Register set MAILBOX_MSGSTATUS___REGSET_0_15 address offset, bank address ++ * increment and number of banks */ ++ ++#define MLB_MAILBOX_MSGSTATUS___REGSET_0_15_OFFSET (u32)(0x00c0) ++#define MLB_MAILBOX_MSGSTATUS___REGSET_0_15_STEP (u32)(0x0004) ++ ++/* Register offset address definitions relative to register set ++ * MAILBOX_MSGSTATUS___REGSET_0_15 */ ++ ++#define MLB_MAILBOX_MSGSTATUS___0_15_OFFSET (u32)(0x0) ++ ++ ++/* Register set MAILBOX_IRQSTATUS___REGSET_0_3 address offset, bank address ++ * increment and number of banks */ ++ ++#define MLB_MAILBOX_IRQSTATUS___REGSET_0_3_OFFSET (u32)(0x0100) ++#define MLB_MAILBOX_IRQSTATUS___REGSET_0_3_STEP (u32)(0x0008) ++ ++/* Register offset address definitions relative to register set ++ * MAILBOX_IRQSTATUS___REGSET_0_3 */ ++ ++#define MLB_MAILBOX_IRQSTATUS___0_3_OFFSET (u32)(0x0) ++ ++ ++/* Register set MAILBOX_IRQENABLE___REGSET_0_3 address offset, bank address ++ * increment and number of banks */ ++ ++#define MLB_MAILBOX_IRQENABLE___REGSET_0_3_OFFSET (u32)(0x0104) ++#define MLB_MAILBOX_IRQENABLE___REGSET_0_3_STEP (u32)(0x0008) ++ ++/* Register offset address definitions relative to register set ++ * MAILBOX_IRQENABLE___REGSET_0_3 */ ++ ++#define MLB_MAILBOX_IRQENABLE___0_3_OFFSET (u32)(0x0) ++ ++ ++/* Register offset address definitions */ ++ ++#define MLB_MAILBOX_SYSCONFIG_OFFSET (u32)(0x10) ++#define MLB_MAILBOX_SYSSTATUS_OFFSET (u32)(0x14) ++ ++ ++/* Bitfield mask and offset declarations */ ++ ++#define MLB_MAILBOX_SYSCONFIG_SIdleMode_MASK (u32)(0x18) ++#define MLB_MAILBOX_SYSCONFIG_SIdleMode_OFFSET (u32)(3) ++#define MLB_MAILBOX_SYSCONFIG_SoftReset_MASK (u32)(0x2) ++#define MLB_MAILBOX_SYSCONFIG_SoftReset_OFFSET (u32)(1) ++#define MLB_MAILBOX_SYSCONFIG_AutoIdle_MASK (u32)(0x1) ++#define MLB_MAILBOX_SYSCONFIG_AutoIdle_OFFSET (u32)(0) ++#define MLB_MAILBOX_SYSSTATUS_ResetDone_MASK (u32)(0x1) ++#define MLB_MAILBOX_SYSSTATUS_ResetDone_OFFSET (u32)(0) ++#define MLB_MAILBOX_FIFOSTATUS___0_15_FifoFullMBm_MASK (u32)(0x1) ++#define MLB_MAILBOX_FIFOSTATUS___0_15_FifoFullMBm_OFFSET (u32)(0) ++#define MLB_MAILBOX_MSGSTATUS___0_15_NbOfMsgMBm_MASK (u32)(0x7f) ++#define MLB_MAILBOX_MSGSTATUS___0_15_NbOfMsgMBm_OFFSET (u32)(0) ++ ++#endif /* _MLB_ACC_INT_H */ +diff --git a/drivers/dsp/bridge/hw/MLBRegAcM.h b/drivers/dsp/bridge/hw/MLBRegAcM.h +new file mode 100644 +index 0000000..747a2e1 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/MLBRegAcM.h +@@ -0,0 +1,200 @@ ++/* ++ * MLBRegAcM.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef _MLB_REG_ACM_H ++#define _MLB_REG_ACM_H ++ ++#include <GlobalTypes.h> ++#include <EasiGlobal.h> ++#include "MLBAccInt.h" ++ ++#if defined(USE_LEVEL_1_MACROS) ++ ++#define MLBMAILBOX_SYSCONFIGReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+ \ ++ MLB_MAILBOX_SYSCONFIG_OFFSET)) ++ ++ ++#define MLBMAILBOX_SYSCONFIGWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_SYSCONFIG_OFFSET;\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGWriteRegister32);\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_SYSCONFIGSIdleModeRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGSIdleModeRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (MLB_MAILBOX_SYSCONFIG_OFFSET)))) &\ ++ MLB_MAILBOX_SYSCONFIG_SIdleMode_MASK) >>\ ++ MLB_MAILBOX_SYSCONFIG_SIdleMode_OFFSET)) ++ ++ ++#define MLBMAILBOX_SYSCONFIGSIdleModeWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_SYSCONFIG_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE(((u32)(baseAddress)) +\ ++ offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGSIdleModeWrite32);\ ++ data &= ~(MLB_MAILBOX_SYSCONFIG_SIdleMode_MASK);\ ++ newValue <<= MLB_MAILBOX_SYSCONFIG_SIdleMode_OFFSET;\ ++ newValue &= MLB_MAILBOX_SYSCONFIG_SIdleMode_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_SYSCONFIGSoftResetWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_SYSCONFIG_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGSoftResetWrite32);\ ++ data &= ~(MLB_MAILBOX_SYSCONFIG_SoftReset_MASK);\ ++ newValue <<= MLB_MAILBOX_SYSCONFIG_SoftReset_OFFSET;\ ++ newValue &= MLB_MAILBOX_SYSCONFIG_SoftReset_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_SYSCONFIGAutoIdleRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGAutoIdleRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (MLB_MAILBOX_SYSCONFIG_OFFSET)))) &\ ++ MLB_MAILBOX_SYSCONFIG_AutoIdle_MASK) >>\ ++ MLB_MAILBOX_SYSCONFIG_AutoIdle_OFFSET)) ++ ++ ++#define MLBMAILBOX_SYSCONFIGAutoIdleWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_SYSCONFIG_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSCONFIGAutoIdleWrite32);\ ++ data &= ~(MLB_MAILBOX_SYSCONFIG_AutoIdle_MASK);\ ++ newValue <<= MLB_MAILBOX_SYSCONFIG_AutoIdle_OFFSET;\ ++ newValue &= MLB_MAILBOX_SYSCONFIG_AutoIdle_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_SYSSTATUSResetDoneRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_SYSSTATUSResetDoneRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (MLB_MAILBOX_SYSSTATUS_OFFSET)))) &\ ++ MLB_MAILBOX_SYSSTATUS_ResetDone_MASK) >>\ ++ MLB_MAILBOX_SYSSTATUS_ResetDone_OFFSET)) ++ ++ ++#define MLBMAILBOX_MESSAGE___0_15ReadRegister32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_MESSAGE___0_15ReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_MESSAGE___REGSET_0_15_OFFSET +\ ++ MLB_MAILBOX_MESSAGE___0_15_OFFSET+(\ ++ (bank)*MLB_MAILBOX_MESSAGE___REGSET_0_15_STEP)))) ++ ++ ++#define MLBMAILBOX_MESSAGE___0_15WriteRegister32(baseAddress, bank, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_MESSAGE___REGSET_0_15_OFFSET +\ ++ MLB_MAILBOX_MESSAGE___0_15_OFFSET +\ ++ ((bank)*MLB_MAILBOX_MESSAGE___REGSET_0_15_STEP);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_MESSAGE___0_15WriteRegister32);\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_FIFOSTATUS___0_15ReadRegister32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(\ ++ EASIL1_MLBMAILBOX_FIFOSTATUS___0_15ReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_OFFSET +\ ++ MLB_MAILBOX_FIFOSTATUS___0_15_OFFSET+\ ++ ((bank)*MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_STEP)))) ++ ++ ++#define MLBMAILBOX_FIFOSTATUS___0_15FifoFullMBmRead32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(\ ++ EASIL1_MLBMAILBOX_FIFOSTATUS___0_15FifoFullMBmRead32),\ ++ (((RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_OFFSET +\ ++ MLB_MAILBOX_FIFOSTATUS___0_15_OFFSET+\ ++ ((bank)*MLB_MAILBOX_FIFOSTATUS___REGSET_0_15_STEP)))) &\ ++ MLB_MAILBOX_FIFOSTATUS___0_15_FifoFullMBm_MASK) >>\ ++ MLB_MAILBOX_FIFOSTATUS___0_15_FifoFullMBm_OFFSET)) ++ ++ ++#define MLBMAILBOX_MSGSTATUS___0_15NbOfMsgMBmRead32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(\ ++ EASIL1_MLBMAILBOX_MSGSTATUS___0_15NbOfMsgMBmRead32),\ ++ (((RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_MSGSTATUS___REGSET_0_15_OFFSET +\ ++ MLB_MAILBOX_MSGSTATUS___0_15_OFFSET+\ ++ ((bank)*MLB_MAILBOX_MSGSTATUS___REGSET_0_15_STEP)))) &\ ++ MLB_MAILBOX_MSGSTATUS___0_15_NbOfMsgMBm_MASK) >>\ ++ MLB_MAILBOX_MSGSTATUS___0_15_NbOfMsgMBm_OFFSET)) ++ ++ ++#define MLBMAILBOX_IRQSTATUS___0_3ReadRegister32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_IRQSTATUS___0_3ReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_IRQSTATUS___REGSET_0_3_OFFSET +\ ++ MLB_MAILBOX_IRQSTATUS___0_3_OFFSET+\ ++ ((bank)*MLB_MAILBOX_IRQSTATUS___REGSET_0_3_STEP)))) ++ ++ ++#define MLBMAILBOX_IRQSTATUS___0_3WriteRegister32(baseAddress, bank, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_IRQSTATUS___REGSET_0_3_OFFSET +\ ++ MLB_MAILBOX_IRQSTATUS___0_3_OFFSET +\ ++ ((bank)*MLB_MAILBOX_IRQSTATUS___REGSET_0_3_STEP);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_IRQSTATUS___0_3WriteRegister32);\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define MLBMAILBOX_IRQENABLE___0_3ReadRegister32(baseAddress, bank)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_IRQENABLE___0_3ReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+\ ++ (MLB_MAILBOX_IRQENABLE___REGSET_0_3_OFFSET +\ ++ MLB_MAILBOX_IRQENABLE___0_3_OFFSET+\ ++ ((bank)*MLB_MAILBOX_IRQENABLE___REGSET_0_3_STEP)))) ++ ++ ++#define MLBMAILBOX_IRQENABLE___0_3WriteRegister32(baseAddress, bank, value)\ ++{\ ++ const u32 offset = MLB_MAILBOX_IRQENABLE___REGSET_0_3_OFFSET +\ ++ MLB_MAILBOX_IRQENABLE___0_3_OFFSET +\ ++ ((bank)*MLB_MAILBOX_IRQENABLE___REGSET_0_3_STEP);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MLBMAILBOX_IRQENABLE___0_3WriteRegister32);\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#endif /* USE_LEVEL_1_MACROS */ ++ ++#endif /* _MLB_REG_ACM_H */ +diff --git a/drivers/dsp/bridge/hw/MMUAccInt.h b/drivers/dsp/bridge/hw/MMUAccInt.h +new file mode 100644 +index 0000000..6ca1573 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/MMUAccInt.h +@@ -0,0 +1,76 @@ ++/* ++ * MMUAccInt.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef _MMU_ACC_INT_H ++#define _MMU_ACC_INT_H ++ ++/* Mappings of level 1 EASI function numbers to function names */ ++ ++#define EASIL1_MMUMMU_SYSCONFIGReadRegister32 (MMU_BASE_EASIL1 + 3) ++#define EASIL1_MMUMMU_SYSCONFIGIdleModeWrite32 (MMU_BASE_EASIL1 + 17) ++#define EASIL1_MMUMMU_SYSCONFIGAutoIdleWrite32 (MMU_BASE_EASIL1 + 39) ++#define EASIL1_MMUMMU_IRQSTATUSWriteRegister32 (MMU_BASE_EASIL1 + 51) ++#define EASIL1_MMUMMU_IRQENABLEReadRegister32 (MMU_BASE_EASIL1 + 102) ++#define EASIL1_MMUMMU_IRQENABLEWriteRegister32 (MMU_BASE_EASIL1 + 103) ++#define EASIL1_MMUMMU_WALKING_STTWLRunningRead32 (MMU_BASE_EASIL1 + 156) ++#define EASIL1_MMUMMU_CNTLTWLEnableRead32 (MMU_BASE_EASIL1 + 174) ++#define EASIL1_MMUMMU_CNTLTWLEnableWrite32 (MMU_BASE_EASIL1 + 180) ++#define EASIL1_MMUMMU_CNTLMMUEnableWrite32 (MMU_BASE_EASIL1 + 190) ++#define EASIL1_MMUMMU_FAULT_ADReadRegister32 (MMU_BASE_EASIL1 + 194) ++#define EASIL1_MMUMMU_TTBWriteRegister32 (MMU_BASE_EASIL1 + 198) ++#define EASIL1_MMUMMU_LOCKReadRegister32 (MMU_BASE_EASIL1 + 203) ++#define EASIL1_MMUMMU_LOCKWriteRegister32 (MMU_BASE_EASIL1 + 204) ++#define EASIL1_MMUMMU_LOCKBaseValueRead32 (MMU_BASE_EASIL1 + 205) ++#define EASIL1_MMUMMU_LOCKCurrentVictimRead32 (MMU_BASE_EASIL1 + 209) ++#define EASIL1_MMUMMU_LOCKCurrentVictimWrite32 (MMU_BASE_EASIL1 + 211) ++#define EASIL1_MMUMMU_LOCKCurrentVictimSet32 (MMU_BASE_EASIL1 + 212) ++#define EASIL1_MMUMMU_LD_TLBReadRegister32 (MMU_BASE_EASIL1 + 213) ++#define EASIL1_MMUMMU_LD_TLBWriteRegister32 (MMU_BASE_EASIL1 + 214) ++#define EASIL1_MMUMMU_CAMWriteRegister32 (MMU_BASE_EASIL1 + 226) ++#define EASIL1_MMUMMU_RAMWriteRegister32 (MMU_BASE_EASIL1 + 268) ++#define EASIL1_MMUMMU_FLUSH_ENTRYWriteRegister32 (MMU_BASE_EASIL1 + 322) ++ ++/* Register offset address definitions */ ++#define MMU_MMU_SYSCONFIG_OFFSET 0x10 ++#define MMU_MMU_IRQSTATUS_OFFSET 0x18 ++#define MMU_MMU_IRQENABLE_OFFSET 0x1c ++#define MMU_MMU_WALKING_ST_OFFSET 0x40 ++#define MMU_MMU_CNTL_OFFSET 0x44 ++#define MMU_MMU_FAULT_AD_OFFSET 0x48 ++#define MMU_MMU_TTB_OFFSET 0x4c ++#define MMU_MMU_LOCK_OFFSET 0x50 ++#define MMU_MMU_LD_TLB_OFFSET 0x54 ++#define MMU_MMU_CAM_OFFSET 0x58 ++#define MMU_MMU_RAM_OFFSET 0x5c ++#define MMU_MMU_GFLUSH_OFFSET 0x60 ++#define MMU_MMU_FLUSH_ENTRY_OFFSET 0x64 ++/* Bitfield mask and offset declarations */ ++#define MMU_MMU_SYSCONFIG_IdleMode_MASK 0x18 ++#define MMU_MMU_SYSCONFIG_IdleMode_OFFSET 3 ++#define MMU_MMU_SYSCONFIG_AutoIdle_MASK 0x1 ++#define MMU_MMU_SYSCONFIG_AutoIdle_OFFSET 0 ++#define MMU_MMU_WALKING_ST_TWLRunning_MASK 0x1 ++#define MMU_MMU_WALKING_ST_TWLRunning_OFFSET 0 ++#define MMU_MMU_CNTL_TWLEnable_MASK 0x4 ++#define MMU_MMU_CNTL_TWLEnable_OFFSET 2 ++#define MMU_MMU_CNTL_MMUEnable_MASK 0x2 ++#define MMU_MMU_CNTL_MMUEnable_OFFSET 1 ++#define MMU_MMU_LOCK_BaseValue_MASK 0xfc00 ++#define MMU_MMU_LOCK_BaseValue_OFFSET 10 ++#define MMU_MMU_LOCK_CurrentVictim_MASK 0x3f0 ++#define MMU_MMU_LOCK_CurrentVictim_OFFSET 4 ++ ++#endif /* _MMU_ACC_INT_H */ +diff --git a/drivers/dsp/bridge/hw/MMURegAcM.h b/drivers/dsp/bridge/hw/MMURegAcM.h +new file mode 100644 +index 0000000..e46fdcb +--- /dev/null ++++ b/drivers/dsp/bridge/hw/MMURegAcM.h +@@ -0,0 +1,253 @@ ++/* ++ * MMURegAcM.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++#ifndef _MMU_REG_ACM_H ++#define _MMU_REG_ACM_H ++ ++#include <GlobalTypes.h> ++ ++#include <EasiGlobal.h> ++ ++#include "MMUAccInt.h" ++ ++#if defined(USE_LEVEL_1_MACROS) ++ ++ ++#define MMUMMU_SYSCONFIGReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_SYSCONFIGReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_SYSCONFIG_OFFSET)) ++ ++ ++#define MMUMMU_SYSCONFIGIdleModeWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_SYSCONFIG_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_SYSCONFIGIdleModeWrite32);\ ++ data &= ~(MMU_MMU_SYSCONFIG_IdleMode_MASK);\ ++ newValue <<= MMU_MMU_SYSCONFIG_IdleMode_OFFSET;\ ++ newValue &= MMU_MMU_SYSCONFIG_IdleMode_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_SYSCONFIGAutoIdleWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_SYSCONFIG_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_SYSCONFIGAutoIdleWrite32);\ ++ data &= ~(MMU_MMU_SYSCONFIG_AutoIdle_MASK);\ ++ newValue <<= MMU_MMU_SYSCONFIG_AutoIdle_OFFSET;\ ++ newValue &= MMU_MMU_SYSCONFIG_AutoIdle_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_IRQSTATUSReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_IRQSTATUSReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_IRQSTATUS_OFFSET)) ++ ++ ++#define MMUMMU_IRQSTATUSWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_IRQSTATUS_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_IRQSTATUSWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_IRQENABLEReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_IRQENABLEReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_IRQENABLE_OFFSET)) ++ ++ ++#define MMUMMU_IRQENABLEWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_IRQENABLE_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_IRQENABLEWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_WALKING_STTWLRunningRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_WALKING_STTWLRunningRead32),\ ++ (((RD_MEM_32_VOLATILE(((baseAddress)+(MMU_MMU_WALKING_ST_OFFSET))))\ ++ & MMU_MMU_WALKING_ST_TWLRunning_MASK) >>\ ++ MMU_MMU_WALKING_ST_TWLRunning_OFFSET)) ++ ++ ++#define MMUMMU_CNTLTWLEnableRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_CNTLTWLEnableRead32),\ ++ (((RD_MEM_32_VOLATILE(((baseAddress)+(MMU_MMU_CNTL_OFFSET)))) &\ ++ MMU_MMU_CNTL_TWLEnable_MASK) >>\ ++ MMU_MMU_CNTL_TWLEnable_OFFSET)) ++ ++ ++#define MMUMMU_CNTLTWLEnableWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_CNTL_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_CNTLTWLEnableWrite32);\ ++ data &= ~(MMU_MMU_CNTL_TWLEnable_MASK);\ ++ newValue <<= MMU_MMU_CNTL_TWLEnable_OFFSET;\ ++ newValue &= MMU_MMU_CNTL_TWLEnable_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_CNTLMMUEnableWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_CNTL_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_CNTLMMUEnableWrite32);\ ++ data &= ~(MMU_MMU_CNTL_MMUEnable_MASK);\ ++ newValue <<= MMU_MMU_CNTL_MMUEnable_OFFSET;\ ++ newValue &= MMU_MMU_CNTL_MMUEnable_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_FAULT_ADReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_FAULT_ADReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_FAULT_AD_OFFSET)) ++ ++ ++#define MMUMMU_TTBWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_TTB_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_TTBWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_LOCKReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_LOCK_OFFSET)) ++ ++ ++#define MMUMMU_LOCKWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_LOCK_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_LOCKBaseValueRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKBaseValueRead32),\ ++ (((RD_MEM_32_VOLATILE(((baseAddress)+(MMU_MMU_LOCK_OFFSET)))) &\ ++ MMU_MMU_LOCK_BaseValue_MASK) >>\ ++ MMU_MMU_LOCK_BaseValue_OFFSET)) ++ ++ ++#define MMUMMU_LOCKBaseValueWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_LOCK_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKBaseValueWrite32);\ ++ data &= ~(MMU_MMU_LOCK_BaseValue_MASK);\ ++ newValue <<= MMU_MMU_LOCK_BaseValue_OFFSET;\ ++ newValue &= MMU_MMU_LOCK_BaseValue_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_LOCKCurrentVictimRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKCurrentVictimRead32),\ ++ (((RD_MEM_32_VOLATILE(((baseAddress)+(MMU_MMU_LOCK_OFFSET)))) &\ ++ MMU_MMU_LOCK_CurrentVictim_MASK) >>\ ++ MMU_MMU_LOCK_CurrentVictim_OFFSET)) ++ ++ ++#define MMUMMU_LOCKCurrentVictimWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_LOCK_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((baseAddress)+offset);\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKCurrentVictimWrite32);\ ++ data &= ~(MMU_MMU_LOCK_CurrentVictim_MASK);\ ++ newValue <<= MMU_MMU_LOCK_CurrentVictim_OFFSET;\ ++ newValue &= MMU_MMU_LOCK_CurrentVictim_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(baseAddress+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_LOCKCurrentVictimSet32(var, value)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LOCKCurrentVictimSet32),\ ++ (((var) & ~(MMU_MMU_LOCK_CurrentVictim_MASK)) |\ ++ (((value) << MMU_MMU_LOCK_CurrentVictim_OFFSET) &\ ++ MMU_MMU_LOCK_CurrentVictim_MASK))) ++ ++ ++#define MMUMMU_LD_TLBReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LD_TLBReadRegister32),\ ++ RD_MEM_32_VOLATILE((baseAddress)+MMU_MMU_LD_TLB_OFFSET)) ++ ++ ++#define MMUMMU_LD_TLBWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_LD_TLB_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_LD_TLBWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_CAMWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_CAM_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_CAMWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_RAMWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_RAM_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_RAMWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#define MMUMMU_FLUSH_ENTRYWriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = MMU_MMU_FLUSH_ENTRY_OFFSET;\ ++ register u32 newValue = (value);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_MMUMMU_FLUSH_ENTRYWriteRegister32);\ ++ WR_MEM_32_VOLATILE((baseAddress)+offset, newValue);\ ++} ++ ++ ++#endif /* USE_LEVEL_1_MACROS */ ++ ++#endif /* _MMU_REG_ACM_H */ +diff --git a/drivers/dsp/bridge/hw/PRCMAccInt.h b/drivers/dsp/bridge/hw/PRCMAccInt.h +new file mode 100644 +index 0000000..42baa68 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/PRCMAccInt.h +@@ -0,0 +1,300 @@ ++/* ++ * PRCMAccInt.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef _PRCM_ACC_INT_H ++#define _PRCM_ACC_INT_H ++ ++/* Mappings of level 1 EASI function numbers to function names */ ++ ++#define EASIL1_PRCMPRCM_CLKCFG_CTRLValid_configWriteClk_valid32 \ ++ (PRCM_BASE_EASIL1 + 349) ++#define EASIL1_PRCMCM_FCLKEN1_COREReadRegister32 (PRCM_BASE_EASIL1 + 743) ++#define EASIL1_PRCMCM_FCLKEN1_COREEN_GPT8Write32 (PRCM_BASE_EASIL1 + 951) ++#define EASIL1_PRCMCM_FCLKEN1_COREEN_GPT7Write32 (PRCM_BASE_EASIL1 + 961) ++#define EASIL1_PRCMCM_ICLKEN1_COREReadRegister32 \ ++ (PRCM_BASE_EASIL1 + 1087) ++#define EASIL1_PRCMCM_ICLKEN1_COREEN_MAILBOXESWrite32 \ ++ (PRCM_BASE_EASIL1 + 1105) ++#define EASIL1_PRCMCM_ICLKEN1_COREEN_GPT8Write32 \ ++ (PRCM_BASE_EASIL1 + 1305) ++#define EASIL1_PRCMCM_ICLKEN1_COREEN_GPT7Write32 \ ++ (PRCM_BASE_EASIL1 + 1315) ++#define EASIL1_PRCMCM_CLKSEL1_CORECLKSEL_L3ReadIssel132 \ ++ (PRCM_BASE_EASIL1 + 2261) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8Write32k32 \ ++ (PRCM_BASE_EASIL1 + 2364) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteSys32 \ ++ (PRCM_BASE_EASIL1 + 2365) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteExt32 \ ++ (PRCM_BASE_EASIL1 + 2366) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7Write32k32 \ ++ (PRCM_BASE_EASIL1 + 2380) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteSys32 \ ++ (PRCM_BASE_EASIL1 + 2381) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteExt32 \ ++ (PRCM_BASE_EASIL1 + 2382) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteSys32 \ ++ (PRCM_BASE_EASIL1 + 2397) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteExt32 \ ++ (PRCM_BASE_EASIL1 + 2398) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteSys32 \ ++ (PRCM_BASE_EASIL1 + 2413) ++#define EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteExt32 \ ++ (PRCM_BASE_EASIL1 + 2414) ++#define EASIL1_PRCMCM_CLKSEL1_PLLAPLLs_ClkinRead32 \ ++ (PRCM_BASE_EASIL1 + 3747) ++#define EASIL1_PRCMCM_FCLKEN_DSPEN_DSPWrite32 (PRCM_BASE_EASIL1 + 3834) ++#define EASIL1_PRCMCM_ICLKEN_DSPEN_DSP_IPIWrite32 \ ++ (PRCM_BASE_EASIL1 + 3846) ++#define EASIL1_PRCMCM_IDLEST_DSPReadRegister32 (PRCM_BASE_EASIL1 + 3850) ++#define EASIL1_PRCMCM_IDLEST_DSPST_IPIRead32 (PRCM_BASE_EASIL1 + 3857) ++#define EASIL1_PRCMCM_IDLEST_DSPST_DSPRead32 (PRCM_BASE_EASIL1 + 3863) ++#define EASIL1_PRCMCM_AUTOIDLE_DSPAUTO_DSP_IPIWrite32 \ ++ (PRCM_BASE_EASIL1 + 3877) ++#define EASIL1_PRCMCM_CLKSEL_DSPSYNC_DSPWrite32 (PRCM_BASE_EASIL1 + 3927) ++#define EASIL1_PRCMCM_CLKSEL_DSPCLKSEL_DSP_IFWrite32 \ ++ (PRCM_BASE_EASIL1 + 3941) ++#define EASIL1_PRCMCM_CLKSEL_DSPCLKSEL_DSPWrite32 \ ++ (PRCM_BASE_EASIL1 + 3965) ++#define EASIL1_PRCMCM_CLKSTCTRL_DSPAutostate_DSPRead32 \ ++ (PRCM_BASE_EASIL1 + 3987) ++#define EASIL1_PRCMCM_CLKSTCTRL_DSPAutostate_DSPWrite32 \ ++ (PRCM_BASE_EASIL1 + 3993) ++#define EASIL1_PRCMRM_RSTCTRL_DSPReadRegister32 (PRCM_BASE_EASIL1 + 3997) ++#define EASIL1_PRCMRM_RSTCTRL_DSPRST1_DSPWrite32 \ ++ (PRCM_BASE_EASIL1 + 4025) ++#define EASIL1_PRCMRM_RSTST_DSPReadRegister32 (PRCM_BASE_EASIL1 + 4029) ++#define EASIL1_PRCMRM_RSTST_DSPWriteRegister32 (PRCM_BASE_EASIL1 + 4030) ++#define EASIL1_PRCMPM_PWSTCTRL_DSPForceStateWrite32 \ ++ (PRCM_BASE_EASIL1 + 4165) ++#define EASIL1_PRCMPM_PWSTCTRL_DSPPowerStateWriteRET32 \ ++ (PRCM_BASE_EASIL1 + 4193) ++#define EASIL1_PRCMPM_PWSTST_DSPReadRegister32 (PRCM_BASE_EASIL1 + 4197) ++#define EASIL1_PRCMPM_PWSTST_DSPInTransitionRead32 \ ++ (PRCM_BASE_EASIL1 + 4198) ++#define EASIL1_PRCMPM_PWSTST_DSPPowerStateStGet32 \ ++ (PRCM_BASE_EASIL1 + 4235) ++#define EASIL1_CM_FCLKEN_PER_GPT5WriteRegister32 \ ++ (PRCM_BASE_EASIL1 + 4368) ++#define EASIL1_CM_ICLKEN_PER_GPT5WriteRegister32 \ ++ (PRCM_BASE_EASIL1 + 4370) ++#define EASIL1_CM_CLKSEL_PER_GPT5Write32k32 (PRCM_BASE_EASIL1 + 4372) ++#define EASIL1_CM_CLKSEL_PER_GPT6Write32k32 (PRCM_BASE_EASIL1 + 4373) ++#define EASIL1_PRCMCM_CLKSTCTRL_IVA2WriteRegister32 \ ++ (PRCM_BASE_EASIL1 + 4374) ++#define EASIL1_PRCMPM_PWSTCTRL_IVA2PowerStateWriteON32 \ ++ (PRCM_BASE_EASIL1 + 4375) ++#define EASIL1_PRCMPM_PWSTCTRL_IVA2PowerStateWriteOFF32 \ ++ (PRCM_BASE_EASIL1 + 4376) ++#define EASIL1_PRCMPM_PWSTST_IVA2InTransitionRead32 \ ++ (PRCM_BASE_EASIL1 + 4377) ++#define EASIL1_PRCMPM_PWSTST_IVA2PowerStateStGet32 \ ++ (PRCM_BASE_EASIL1 + 4378) ++#define EASIL1_PRCMPM_PWSTST_IVA2ReadRegister32 (PRCM_BASE_EASIL1 + 4379) ++ ++/* Register offset address definitions */ ++ ++#define PRCM_PRCM_CLKCFG_CTRL_OFFSET (u32)(0x80) ++#define PRCM_CM_FCLKEN1_CORE_OFFSET (u32)(0x200) ++#define PRCM_CM_ICLKEN1_CORE_OFFSET (u32)(0x210) ++#define PRCM_CM_CLKSEL2_CORE_OFFSET (u32)(0x244) ++#define PRCM_CM_CLKSEL1_PLL_OFFSET (u32)(0x540) ++#define PRCM_CM_ICLKEN_DSP_OFFSET (u32)(0x810) ++#define PRCM_CM_IDLEST_DSP_OFFSET (u32)(0x820) ++#define PRCM_CM_AUTOIDLE_DSP_OFFSET (u32)(0x830) ++#define PRCM_CM_CLKSEL_DSP_OFFSET (u32)(0x840) ++#define PRCM_CM_CLKSTCTRL_DSP_OFFSET (u32)(0x848) ++#define PRCM_RM_RSTCTRL_DSP_OFFSET (u32)(0x850) ++#define PRCM_RM_RSTST_DSP_OFFSET (u32)(0x858) ++#define PRCM_PM_PWSTCTRL_DSP_OFFSET (u32)(0x8e0) ++#define PRCM_PM_PWSTST_DSP_OFFSET (u32)(0x8e4) ++#define PRCM_PM_PWSTST_IVA2_OFFSET (u32)(0xE4) ++#define PRCM_PM_PWSTCTRL_IVA2_OFFSET (u32)(0xE0) ++#define PRCM_CM_CLKSTCTRL_IVA2_OFFSET (u32)(0x48) ++#define CM_CLKSEL_PER_OFFSET (u32)(0x40) ++ ++/* Bitfield mask and offset declarations */ ++ ++#define PRCM_PRCM_CLKCFG_CTRL_Valid_config_MASK (u32)(0x1) ++#define PRCM_PRCM_CLKCFG_CTRL_Valid_config_OFFSET (u32)(0) ++ ++#define PRCM_CM_FCLKEN1_CORE_EN_GPT8_MASK (u32)(0x400) ++#define PRCM_CM_FCLKEN1_CORE_EN_GPT8_OFFSET (u32)(10) ++ ++#define PRCM_CM_FCLKEN1_CORE_EN_GPT7_MASK (u32)(0x200) ++#define PRCM_CM_FCLKEN1_CORE_EN_GPT7_OFFSET (u32)(9) ++ ++#define PRCM_CM_ICLKEN1_CORE_EN_GPT8_MASK (u32)(0x400) ++#define PRCM_CM_ICLKEN1_CORE_EN_GPT8_OFFSET (u32)(10) ++ ++#define PRCM_CM_ICLKEN1_CORE_EN_GPT7_MASK (u32)(0x200) ++#define PRCM_CM_ICLKEN1_CORE_EN_GPT7_OFFSET (u32)(9) ++ ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_MASK (u32)(0xc000) ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_OFFSET (u32)(14) ++ ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_MASK (u32)(0x3000) ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_OFFSET (u32)(12) ++ ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_MASK (u32)(0xc00) ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_OFFSET (u32)(10) ++ ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_MASK (u32)(0x300) ++#define PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_OFFSET (u32)(8) ++ ++#define PRCM_CM_CLKSEL1_PLL_APLLs_Clkin_MASK (u32)(0x3800000) ++#define PRCM_CM_CLKSEL1_PLL_APLLs_Clkin_OFFSET (u32)(23) ++ ++#define PRCM_CM_ICLKEN_DSP_EN_DSP_IPI_MASK (u32)(0x2) ++#define PRCM_CM_ICLKEN_DSP_EN_DSP_IPI_OFFSET (u32)(1) ++ ++#define PRCM_CM_IDLEST_DSP_ST_IPI_MASK (u32)(0x2) ++#define PRCM_CM_IDLEST_DSP_ST_IPI_OFFSET (u32)(1) ++ ++#define PRCM_CM_AUTOIDLE_DSP_AUTO_DSP_IPI_MASK (u32)(0x2) ++#define PRCM_CM_AUTOIDLE_DSP_AUTO_DSP_IPI_OFFSET (u32)(1) ++ ++#define PRCM_CM_CLKSEL_DSP_SYNC_DSP_MASK (u32)(0x80) ++#define PRCM_CM_CLKSEL_DSP_SYNC_DSP_OFFSET (u32)(7) ++ ++#define PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_IF_MASK (u32)(0x60) ++#define PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_IF_OFFSET (u32)(5) ++ ++#define PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_MASK (u32)(0x1f) ++#define PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_OFFSET (u32)(0) ++ ++#define PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_MASK (u32)(0x1) ++#define PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_OFFSET (u32)(0) ++ ++#define PRCM_PM_PWSTCTRL_DSP_ForceState_MASK (u32)(0x40000) ++#define PRCM_PM_PWSTCTRL_DSP_ForceState_OFFSET (u32)(18) ++ ++#define PRCM_PM_PWSTCTRL_DSP_PowerState_MASK (u32)(0x3) ++#define PRCM_PM_PWSTCTRL_DSP_PowerState_OFFSET (u32)(0) ++ ++#define PRCM_PM_PWSTCTRL_IVA2_PowerState_MASK (u32)(0x3) ++#define PRCM_PM_PWSTCTRL_IVA2_PowerState_OFFSET (u32)(0) ++ ++#define PRCM_PM_PWSTST_DSP_InTransition_MASK (u32)(0x100000) ++#define PRCM_PM_PWSTST_DSP_InTransition_OFFSET (u32)(20) ++ ++#define PRCM_PM_PWSTST_IVA2_InTransition_MASK (u32)(0x100000) ++#define PRCM_PM_PWSTST_IVA2_InTransition_OFFSET (u32)(20) ++ ++#define PRCM_PM_PWSTST_DSP_PowerStateSt_MASK (u32)(0x3) ++#define PRCM_PM_PWSTST_DSP_PowerStateSt_OFFSET (u32)(0) ++ ++#define PRCM_PM_PWSTST_IVA2_PowerStateSt_MASK (u32)(0x3) ++#define PRCM_PM_PWSTST_IVA2_PowerStateSt_OFFSET (u32)(0) ++ ++#define CM_FCLKEN_PER_OFFSET (u32)(0x0) ++#define CM_FCLKEN_PER_GPT5_OFFSET (u32)(6) ++#define CM_FCLKEN_PER_GPT5_MASK (u32)(0x40) ++ ++#define CM_FCLKEN_PER_GPT6_OFFSET (u32)(7) ++#define CM_FCLKEN_PER_GPT6_MASK (u32)(0x80) ++ ++#define CM_ICLKEN_PER_OFFSET (u32)(0x10) ++#define CM_ICLKEN_PER_GPT5_OFFSET (u32)(6) ++#define CM_ICLKEN_PER_GPT5_MASK (u32)(0x40) ++ ++#define CM_ICLKEN_PER_GPT6_OFFSET (u32)(7) ++#define CM_ICLKEN_PER_GPT6_MASK (u32)(0x80) ++ ++#define CM_CLKSEL_PER_GPT5_OFFSET (u32)(3) ++#define CM_CLKSEL_PER_GPT5_MASK (u32)(0x8) ++ ++#define CM_CLKSEL_PER_GPT6_OFFSET (u32)(4) ++#define CM_CLKSEL_PER_GPT6_MASK (u32)(0x10) ++ ++ ++#define CM_FCLKEN_IVA2_OFFSET (u32)(0x0) ++#define CM_FCLKEN_IVA2_EN_MASK (u32)(0x1) ++#define CM_FCLKEN_IVA2_EN_OFFSET (u32)(0x0) ++ ++#define CM_IDLEST_IVA2_OFFSET (u32)(0x20) ++#define CM_IDLEST_IVA2_ST_IVA2_MASK (u32) (0x01) ++#define CM_IDLEST_IVA2_ST_IVA2_OFFSET (u32) (0x00) ++ ++#define CM_FCLKEN1_CORE_OFFSET (u32)(0xA00) ++ ++#define CM_ICLKEN1_CORE_OFFSET (u32)(0xA10) ++#define CM_ICLKEN1_CORE_EN_MAILBOXES_MASK (u32)(0x00000080) /* bit 7 */ ++#define CM_ICLKEN1_CORE_EN_MAILBOXES_OFFSET (u32)(7) ++ ++#define CM_CLKSTCTRL_IVA2_OFFSET (u32)(0x0) ++#define CM_CLKSTCTRL_IVA2_MASK (u32)(0x3) ++ ++ ++#define PRM_RSTCTRL_IVA2_OFFSET (u32)(0x50) ++#define PRM_RSTCTRL_IVA2_RST1_MASK (u32)(0x1) ++#define PRM_RSTCTRL_IVA2_RST1_OFFSET (u32)(0x0) ++#define PRM_RSTCTRL_IVA2_RST2_MASK (u32)(0x2) ++#define PRM_RSTCTRL_IVA2_RST2_OFFSET (u32)(0x1) ++#define PRM_RSTCTRL_IVA2_RST3_MASK (u32)(0x4) ++#define PRM_RSTCTRL_IVA2_RST3_OFFSET (u32)(0x2) ++ ++ ++/* The following represent the enumerated values for each bitfield */ ++ ++enum PRCMPRCM_CLKCFG_CTRLValid_configE { ++ PRCMPRCM_CLKCFG_CTRLValid_configUpdated = 0x0000, ++ PRCMPRCM_CLKCFG_CTRLValid_configClk_valid = 0x0001 ++} ; ++ ++enum PRCMCM_CLKSEL2_CORECLKSEL_GPT8E { ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT832k = 0x0000, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT8Sys = 0x0001, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT8Ext = 0x0002, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT8Reserved = 0x0003 ++} ; ++ ++enum PRCMCM_CLKSEL2_CORECLKSEL_GPT7E { ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT732k = 0x0000, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT7Sys = 0x0001, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT7Ext = 0x0002, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT7Reserved = 0x0003 ++} ; ++ ++enum PRCMCM_CLKSEL2_CORECLKSEL_GPT6E { ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT632k = 0x0000, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT6Sys = 0x0001, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT6Ext = 0x0002, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT6Reserved = 0x0003 ++} ; ++ ++enum PRCMCM_CLKSEL2_CORECLKSEL_GPT5E { ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT532k = 0x0000, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT5Sys = 0x0001, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT5Ext = 0x0002, ++ PRCMCM_CLKSEL2_CORECLKSEL_GPT5Reserved = 0x0003 ++} ; ++ ++enum PRCMPM_PWSTCTRL_DSPPowerStateE { ++ PRCMPM_PWSTCTRL_DSPPowerStateON = 0x0000, ++ PRCMPM_PWSTCTRL_DSPPowerStateRET = 0x0001, ++ PRCMPM_PWSTCTRL_DSPPowerStateReserved = 0x0002, ++ PRCMPM_PWSTCTRL_DSPPowerStateOFF = 0x0003 ++} ; ++ ++enum PRCMPM_PWSTCTRL_IVA2PowerStateE { ++ PRCMPM_PWSTCTRL_IVA2PowerStateON = 0x0003, ++ PRCMPM_PWSTCTRL_IVA2PowerStateRET = 0x0001, ++ PRCMPM_PWSTCTRL_IVA2PowerStateReserved = 0x0002, ++ PRCMPM_PWSTCTRL_IVA2PowerStateOFF = 0x0000 ++} ; ++ ++#endif /* _PRCM_ACC_INT_H */ +diff --git a/drivers/dsp/bridge/hw/PRCMRegAcM.h b/drivers/dsp/bridge/hw/PRCMRegAcM.h +new file mode 100644 +index 0000000..91cb33c +--- /dev/null ++++ b/drivers/dsp/bridge/hw/PRCMRegAcM.h +@@ -0,0 +1,669 @@ ++/* ++ * PRCMRegAcM.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#ifndef _PRCM_REG_ACM_H ++#define _PRCM_REG_ACM_H ++ ++#include <GlobalTypes.h> ++ ++#include <EasiGlobal.h> ++ ++#include "PRCMAccInt.h" ++ ++#if defined(USE_LEVEL_1_MACROS) ++ ++#define PRCMPRCM_CLKCFG_CTRLValid_configWriteClk_valid32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_PRCM_CLKCFG_CTRL_OFFSET;\ ++ const u32 newValue = \ ++ (u32)PRCMPRCM_CLKCFG_CTRLValid_configClk_valid <<\ ++ PRCM_PRCM_CLKCFG_CTRL_Valid_config_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(\ ++ EASIL1_PRCMPRCM_CLKCFG_CTRLValid_configWriteClk_valid32);\ ++ data &= ~(PRCM_PRCM_CLKCFG_CTRL_Valid_config_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define CM_FCLKEN_PERReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN1_COREReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+CM_FCLKEN_PER_OFFSET)) ++ ++ ++#define CM_ICLKEN_PERReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN1_COREReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+CM_ICLKEN_PER_OFFSET)) ++ ++ ++#define CM_FCLKEN_PER_GPT5WriteRegister32(baseAddress,value)\ ++{\ ++ const u32 offset = CM_FCLKEN_PER_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_FCLKEN_PER_GPT5WriteRegister32);\ ++ data &= ~(CM_FCLKEN_PER_GPT5_MASK);\ ++ newValue <<= CM_FCLKEN_PER_GPT5_OFFSET;\ ++ newValue &= CM_FCLKEN_PER_GPT5_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define CM_FCLKEN_PER_GPT6WriteRegister32(baseAddress,value)\ ++{\ ++ const u32 offset = CM_FCLKEN_PER_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_FCLKEN_PER_GPT5WriteRegister32);\ ++ data &= ~(CM_FCLKEN_PER_GPT6_MASK);\ ++ newValue <<= CM_FCLKEN_PER_GPT6_OFFSET;\ ++ newValue &= CM_FCLKEN_PER_GPT6_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define CM_ICLKEN_PER_GPT5WriteRegister32(baseAddress,value)\ ++{\ ++ const u32 offset = CM_ICLKEN_PER_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_ICLKEN_PER_GPT5WriteRegister32);\ ++ data &= ~(CM_ICLKEN_PER_GPT5_MASK);\ ++ newValue <<= CM_ICLKEN_PER_GPT5_OFFSET;\ ++ newValue &= CM_ICLKEN_PER_GPT5_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define CM_ICLKEN_PER_GPT6WriteRegister32(baseAddress,value)\ ++{\ ++ const u32 offset = CM_ICLKEN_PER_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_ICLKEN_PER_GPT5WriteRegister32);\ ++ data &= ~(CM_ICLKEN_PER_GPT6_MASK);\ ++ newValue <<= CM_ICLKEN_PER_GPT6_OFFSET;\ ++ newValue &= CM_ICLKEN_PER_GPT6_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define CM_FCLKEN1_COREReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN1_COREReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+CM_FCLKEN1_CORE_OFFSET)) ++ ++ ++#define PRCMCM_FCLKEN1_COREEN_GPT8Write32(baseAddress,value)\ ++{\ ++ const u32 offset = PRCM_CM_FCLKEN1_CORE_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN1_COREEN_GPT8Write32);\ ++ data &= ~(PRCM_CM_FCLKEN1_CORE_EN_GPT8_MASK);\ ++ newValue <<= PRCM_CM_FCLKEN1_CORE_EN_GPT8_OFFSET;\ ++ newValue &= PRCM_CM_FCLKEN1_CORE_EN_GPT8_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_FCLKEN1_COREEN_GPT7Write32(baseAddress,value)\ ++{\ ++ const u32 offset = PRCM_CM_FCLKEN1_CORE_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN1_COREEN_GPT7Write32);\ ++ data &= ~(PRCM_CM_FCLKEN1_CORE_EN_GPT7_MASK);\ ++ newValue <<= PRCM_CM_FCLKEN1_CORE_EN_GPT7_OFFSET;\ ++ newValue &= PRCM_CM_FCLKEN1_CORE_EN_GPT7_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define CM_ICLKEN1_COREReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_ICLKEN1_COREReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+CM_ICLKEN1_CORE_OFFSET)) ++ ++ ++#define CM_ICLKEN1_COREEN_MAILBOXESWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = CM_ICLKEN1_CORE_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_ICLKEN1_COREEN_MAILBOXESWrite32);\ ++ data &= ~(CM_ICLKEN1_CORE_EN_MAILBOXES_MASK);\ ++ newValue <<= CM_ICLKEN1_CORE_EN_MAILBOXES_OFFSET;\ ++ newValue &= CM_ICLKEN1_CORE_EN_MAILBOXES_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_ICLKEN1_COREEN_GPT8Write32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_ICLKEN1_CORE_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_ICLKEN1_COREEN_GPT8Write32);\ ++ data &= ~(PRCM_CM_ICLKEN1_CORE_EN_GPT8_MASK);\ ++ newValue <<= PRCM_CM_ICLKEN1_CORE_EN_GPT8_OFFSET;\ ++ newValue &= PRCM_CM_ICLKEN1_CORE_EN_GPT8_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_ICLKEN1_COREEN_GPT7Write32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_ICLKEN1_CORE_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_ICLKEN1_COREEN_GPT7Write32);\ ++ data &= ~(PRCM_CM_ICLKEN1_CORE_EN_GPT7_MASK);\ ++ newValue <<= PRCM_CM_ICLKEN1_CORE_EN_GPT7_OFFSET;\ ++ newValue &= PRCM_CM_ICLKEN1_CORE_EN_GPT7_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT8Write32k32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT832k <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8Write32k32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteSys32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT8Sys <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteSys32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteExt32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT8Ext <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT8WriteExt32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT8_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT7Write32k32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT732k <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7Write32k32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteSys32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT7Sys <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteSys32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteExt32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT7Ext <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT7WriteExt32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT7_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteSys32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT6Sys <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteSys32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteExt32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT6Ext <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT6WriteExt32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT6_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define CM_CLKSEL_PER_GPT5Write32k32(baseAddress)\ ++{\ ++ const u32 offset = CM_CLKSEL_PER_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT532k <<\ ++ CM_CLKSEL_PER_GPT5_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_CLKSEL_PER_GPT5Write32k32);\ ++ data &= ~(CM_CLKSEL_PER_GPT5_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define CM_CLKSEL_PER_GPT6Write32k32(baseAddress)\ ++{\ ++ const u32 offset = CM_CLKSEL_PER_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT532k <<\ ++ CM_CLKSEL_PER_GPT6_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_CM_CLKSEL_PER_GPT6Write32k32);\ ++ data &= ~(CM_CLKSEL_PER_GPT6_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteSys32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT5Sys <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteSys32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteExt32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL2_CORE_OFFSET;\ ++ const u32 newValue = (u32)PRCMCM_CLKSEL2_CORECLKSEL_GPT5Ext <<\ ++ PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL2_CORECLKSEL_GPT5WriteExt32);\ ++ data &= ~(PRCM_CM_CLKSEL2_CORE_CLKSEL_GPT5_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMCM_CLKSEL1_PLLAPLLs_ClkinRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL1_PLLAPLLs_ClkinRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (PRCM_CM_CLKSEL1_PLL_OFFSET)))) &\ ++ PRCM_CM_CLKSEL1_PLL_APLLs_Clkin_MASK) >>\ ++ PRCM_CM_CLKSEL1_PLL_APLLs_Clkin_OFFSET)) ++ ++ ++#define CM_FCLKEN_IVA2EN_DSPWrite32(baseAddress,value)\ ++{\ ++ const u32 offset = CM_FCLKEN_IVA2_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_FCLKEN_DSPEN_DSPWrite32);\ ++ data &= ~(CM_FCLKEN_IVA2_EN_MASK);\ ++ newValue <<= CM_FCLKEN_IVA2_EN_OFFSET;\ ++ newValue &= CM_FCLKEN_IVA2_EN_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_ICLKEN_DSPEN_DSP_IPIWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_ICLKEN_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_ICLKEN_DSPEN_DSP_IPIWrite32);\ ++ data &= ~(PRCM_CM_ICLKEN_DSP_EN_DSP_IPI_MASK);\ ++ newValue <<= PRCM_CM_ICLKEN_DSP_EN_DSP_IPI_OFFSET;\ ++ newValue &= PRCM_CM_ICLKEN_DSP_EN_DSP_IPI_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_IDLEST_DSPReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_IDLEST_DSPReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+PRCM_CM_IDLEST_DSP_OFFSET)) ++ ++ ++#define PRCMCM_IDLEST_DSPST_IPIRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_IDLEST_DSPST_IPIRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (PRCM_CM_IDLEST_DSP_OFFSET)))) &\ ++ PRCM_CM_IDLEST_DSP_ST_IPI_MASK) >>\ ++ PRCM_CM_IDLEST_DSP_ST_IPI_OFFSET)) ++ ++ ++#define PRM_IDLEST_IVA2ST_IVA2Read32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_IDLEST_DSPST_DSPRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (CM_IDLEST_IVA2_OFFSET)))) &\ ++ CM_IDLEST_IVA2_ST_IVA2_MASK) >>\ ++ CM_IDLEST_IVA2_ST_IVA2_OFFSET)) ++ ++ ++#define PRCMCM_AUTOIDLE_DSPAUTO_DSP_IPIWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_AUTOIDLE_DSP_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_AUTOIDLE_DSPAUTO_DSP_IPIWrite32);\ ++ data &= ~(PRCM_CM_AUTOIDLE_DSP_AUTO_DSP_IPI_MASK);\ ++ newValue <<= PRCM_CM_AUTOIDLE_DSP_AUTO_DSP_IPI_OFFSET;\ ++ newValue &= PRCM_CM_AUTOIDLE_DSP_AUTO_DSP_IPI_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSEL_DSPSYNC_DSPWrite32(baseAddress,value)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL_DSPSYNC_DSPWrite32);\ ++ data &= ~(PRCM_CM_CLKSEL_DSP_SYNC_DSP_MASK);\ ++ newValue <<= PRCM_CM_CLKSEL_DSP_SYNC_DSP_OFFSET;\ ++ newValue &= PRCM_CM_CLKSEL_DSP_SYNC_DSP_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSEL_DSPCLKSEL_DSP_IFWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL_DSPCLKSEL_DSP_IFWrite32);\ ++ data &= ~(PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_IF_MASK);\ ++ newValue <<= PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_IF_OFFSET;\ ++ newValue &= PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_IF_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSEL_DSPCLKSEL_DSPWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSEL_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSEL_DSPCLKSEL_DSPWrite32);\ ++ data &= ~(PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_MASK);\ ++ newValue <<= PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_OFFSET;\ ++ newValue &= PRCM_CM_CLKSEL_DSP_CLKSEL_DSP_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSTCTRL_IVA2WriteRegister32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSTCTRL_IVA2_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSTCTRL_IVA2WriteRegister32);\ ++ data &= ~(CM_CLKSTCTRL_IVA2_MASK);\ ++ newValue <<= CM_CLKSTCTRL_IVA2_OFFSET;\ ++ newValue &= CM_CLKSTCTRL_IVA2_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMCM_CLKSTCTRL_DSPAutostate_DSPRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSTCTRL_DSPAutostate_DSPRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (PRCM_CM_CLKSTCTRL_DSP_OFFSET)))) &\ ++ PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_MASK) >>\ ++ PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_OFFSET)) ++ ++ ++#define PRCMCM_CLKSTCTRL_DSPAutostate_DSPWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_CM_CLKSTCTRL_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMCM_CLKSTCTRL_DSPAutostate_DSPWrite32);\ ++ data &= ~(PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_MASK);\ ++ newValue <<= PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_OFFSET;\ ++ newValue &= PRCM_CM_CLKSTCTRL_DSP_Autostate_DSP_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMRM_RSTCTRL_DSPReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTCTRL_DSPReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+PRCM_RM_RSTCTRL_DSP_OFFSET)) ++ ++ ++#define PRM_RSTCTRL_IVA2RST1_DSPWrite32(baseAddress,value)\ ++{\ ++ const u32 offset = PRM_RSTCTRL_IVA2_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTCTRL_DSPRST1_DSPWrite32);\ ++ data &= ~(PRM_RSTCTRL_IVA2_RST1_MASK);\ ++ newValue <<= PRM_RSTCTRL_IVA2_RST1_OFFSET;\ ++ newValue &= PRM_RSTCTRL_IVA2_RST1_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRM_RSTCTRL_IVA2RST2_DSPWrite32(baseAddress,value)\ ++{\ ++ const u32 offset = PRM_RSTCTRL_IVA2_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTCTRL_DSPRST1_DSPWrite32);\ ++ data &= ~(PRM_RSTCTRL_IVA2_RST2_MASK);\ ++ newValue <<= PRM_RSTCTRL_IVA2_RST2_OFFSET;\ ++ newValue &= PRM_RSTCTRL_IVA2_RST2_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRM_RSTCTRL_IVA2RST3_DSPWrite32(baseAddress,value)\ ++{\ ++ const u32 offset = PRM_RSTCTRL_IVA2_OFFSET;\ ++ register u32 data =\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTCTRL_DSPRST1_DSPWrite32);\ ++ data &= ~(PRM_RSTCTRL_IVA2_RST3_MASK);\ ++ newValue <<= PRM_RSTCTRL_IVA2_RST3_OFFSET;\ ++ newValue &= PRM_RSTCTRL_IVA2_RST3_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMRM_RSTST_DSPReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTST_DSPReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+PRCM_RM_RSTST_DSP_OFFSET)) ++ ++ ++#define PRCMRM_RSTST_DSPWriteRegister32(baseAddress,value)\ ++{\ ++ const u32 offset = PRCM_RM_RSTST_DSP_OFFSET;\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMRM_RSTST_DSPWriteRegister32);\ ++ WR_MEM_32_VOLATILE(((u32)(baseAddress))+offset, newValue);\ ++} ++ ++ ++#define PRCMPM_PWSTCTRL_DSPForceStateWrite32(baseAddress, value)\ ++{\ ++ const u32 offset = PRCM_PM_PWSTCTRL_DSP_OFFSET;\ ++ register u32 data = \ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+offset);\ ++ register u32 newValue = ((u32)(value));\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTCTRL_DSPForceStateWrite32);\ ++ data &= ~(PRCM_PM_PWSTCTRL_DSP_ForceState_MASK);\ ++ newValue <<= PRCM_PM_PWSTCTRL_DSP_ForceState_OFFSET;\ ++ newValue &= PRCM_PM_PWSTCTRL_DSP_ForceState_MASK;\ ++ newValue |= data;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, newValue);\ ++} ++ ++ ++#define PRCMPM_PWSTCTRL_IVA2PowerStateWriteON32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_PM_PWSTCTRL_IVA2_OFFSET;\ ++ const u32 newValue = (u32)PRCMPM_PWSTCTRL_IVA2PowerStateON <<\ ++ PRCM_PM_PWSTCTRL_IVA2_PowerState_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTCTRL_IVA2PowerStateWriteON32);\ ++ data &= ~(PRCM_PM_PWSTCTRL_IVA2_PowerState_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMPM_PWSTCTRL_IVA2PowerStateWriteOFF32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_PM_PWSTCTRL_IVA2_OFFSET;\ ++ const u32 newValue = (u32)PRCMPM_PWSTCTRL_IVA2PowerStateOFF <<\ ++ PRCM_PM_PWSTCTRL_IVA2_PowerState_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTCTRL_IVA2PowerStateWriteOFF32);\ ++ data &= ~(PRCM_PM_PWSTCTRL_IVA2_PowerState_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMPM_PWSTCTRL_DSPPowerStateWriteRET32(baseAddress)\ ++{\ ++ const u32 offset = PRCM_PM_PWSTCTRL_DSP_OFFSET;\ ++ const u32 newValue = (u32)PRCMPM_PWSTCTRL_DSPPowerStateRET <<\ ++ PRCM_PM_PWSTCTRL_DSP_PowerState_OFFSET;\ ++ register u32 data = RD_MEM_32_VOLATILE((u32)(baseAddress)+offset);\ ++ _DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTCTRL_DSPPowerStateWriteRET32);\ ++ data &= ~(PRCM_PM_PWSTCTRL_DSP_PowerState_MASK);\ ++ data |= newValue;\ ++ WR_MEM_32_VOLATILE((u32)(baseAddress)+offset, data);\ ++} ++ ++ ++#define PRCMPM_PWSTST_DSPReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_DSPReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+PRCM_PM_PWSTST_DSP_OFFSET)) ++ ++ ++#define PRCMPM_PWSTST_IVA2ReadRegister32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_IVA2ReadRegister32),\ ++ RD_MEM_32_VOLATILE(((u32)(baseAddress))+PRCM_PM_PWSTST_IVA2_OFFSET)) ++ ++ ++#define PRCMPM_PWSTST_DSPInTransitionRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_DSPInTransitionRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (PRCM_PM_PWSTST_DSP_OFFSET)))) &\ ++ PRCM_PM_PWSTST_DSP_InTransition_MASK) >>\ ++ PRCM_PM_PWSTST_DSP_InTransition_OFFSET)) ++ ++ ++#define PRCMPM_PWSTST_IVA2InTransitionRead32(baseAddress)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_IVA2InTransitionRead32),\ ++ (((RD_MEM_32_VOLATILE((((u32)(baseAddress))+\ ++ (PRCM_PM_PWSTST_IVA2_OFFSET)))) &\ ++ PRCM_PM_PWSTST_IVA2_InTransition_MASK) >>\ ++ PRCM_PM_PWSTST_IVA2_InTransition_OFFSET)) ++ ++ ++#define PRCMPM_PWSTST_DSPPowerStateStGet32(var)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_DSPPowerStateStGet32),\ ++ (u32)((((u32)(var)) & PRCM_PM_PWSTST_DSP_PowerStateSt_MASK) >>\ ++ PRCM_PM_PWSTST_DSP_PowerStateSt_OFFSET)) ++ ++ ++#define PRCMPM_PWSTST_IVA2PowerStateStGet32(var)\ ++ (_DEBUG_LEVEL_1_EASI(EASIL1_PRCMPM_PWSTST_IVA2PowerStateStGet32),\ ++ (u32)((((u32)(var)) & PRCM_PM_PWSTST_IVA2_PowerStateSt_MASK) >>\ ++ PRCM_PM_PWSTST_IVA2_PowerStateSt_OFFSET)) ++ ++ ++#endif /* USE_LEVEL_1_MACROS */ ++ ++#endif /* _PRCM_REG_ACM_H */ +diff --git a/drivers/dsp/bridge/hw/hw_defs.h b/drivers/dsp/bridge/hw/hw_defs.h +new file mode 100644 +index 0000000..a973f5c +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_defs.h +@@ -0,0 +1,73 @@ ++/* ++ * hw_defs.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== hw_defs.h ======== ++ * Description: ++ * Global HW definitions ++ * ++ *! Revision History: ++ *! ================ ++ *! 19 Apr 2004 sb: Added generic page size, endianness and element size defns ++ *! 16 Feb 2003 sb: Initial version ++ */ ++#ifndef __HW_DEFS_H ++#define __HW_DEFS_H ++ ++#include <GlobalTypes.h> ++ ++/* Page size */ ++#define HW_PAGE_SIZE_4KB 0x1000 ++#define HW_PAGE_SIZE_64KB 0x10000 ++#define HW_PAGE_SIZE_1MB 0x100000 ++#define HW_PAGE_SIZE_16MB 0x1000000 ++ ++/* HW_STATUS: return type for HW API */ ++typedef long HW_STATUS; ++ ++/* HW_SetClear_t: Enumerated Type used to set and clear any bit */ ++enum HW_SetClear_t { ++ HW_CLEAR, ++ HW_SET ++} ; ++ ++/* HW_Endianism_t: Enumerated Type used to specify the endianism ++ * Do NOT change these values. They are used as bit fields. */ ++enum HW_Endianism_t { ++ HW_LITTLE_ENDIAN, ++ HW_BIG_ENDIAN ++ ++} ; ++ ++/* HW_ElementSize_t: Enumerated Type used to specify the element size ++ * Do NOT change these values. They are used as bit fields. */ ++enum HW_ElementSize_t { ++ HW_ELEM_SIZE_8BIT, ++ HW_ELEM_SIZE_16BIT, ++ HW_ELEM_SIZE_32BIT, ++ HW_ELEM_SIZE_64BIT ++ ++} ; ++ ++/* HW_IdleMode_t: Enumerated Type used to specify Idle modes */ ++ enum HW_IdleMode_t { ++ HW_FORCE_IDLE, ++ HW_NO_IDLE, ++ HW_SMART_IDLE ++ } ; ++ ++#endif /* __HW_DEFS_H */ +diff --git a/drivers/dsp/bridge/hw/hw_dspssC64P.c b/drivers/dsp/bridge/hw/hw_dspssC64P.c +new file mode 100644 +index 0000000..a4b7c30 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_dspssC64P.c +@@ -0,0 +1,55 @@ ++/* ++ * hw_dspss64P.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== hw_dspss64P.c ======== ++ * Description: ++ * API definitions to configure DSP Subsystem modules like IPI ++ * ++ *! Revision History: ++ *! ================ ++ *! 19 Apr 2004 sb: Implemented HW_DSPSS_IPIEndianismSet ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++/* PROJECT SPECIFIC INCLUDE FILES */ ++#include <GlobalTypes.h> ++#include <hw_defs.h> ++#include <hw_dspssC64P.h> ++#include <IVA2RegAcM.h> ++#include <IPIAccInt.h> ++ ++/* HW FUNCTIONS */ ++HW_STATUS HW_DSPSS_BootModeSet(const u32 baseAddress, ++ enum HW_DSPSYSC_BootMode_t bootMode, ++ const u32 bootAddress) ++{ ++ HW_STATUS status = RET_OK; ++ u32 offset = SYSC_IVA2BOOTMOD_OFFSET; ++ u32 alignedBootAddr; ++ ++ /* if Boot mode it DIRECT BOOT, check that the bootAddress is ++ * aligned to atleast 1K :: TODO */ ++ WR_MEM_32_VOLATILE((baseAddress) + offset, bootMode); ++ ++ offset = SYSC_IVA2BOOTADDR_OFFSET; ++ ++ alignedBootAddr = bootAddress & SYSC_IVA2BOOTADDR_MASK; ++ ++ WR_MEM_32_VOLATILE((baseAddress) + offset, alignedBootAddr); ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/hw/hw_dspssC64P.h b/drivers/dsp/bridge/hw/hw_dspssC64P.h +new file mode 100644 +index 0000000..493effd +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_dspssC64P.h +@@ -0,0 +1,48 @@ ++/* ++ * hw_dspssC64P.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== hw_dspss.h ======== ++ * Description: ++ * DSP Subsystem API declarations ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb: Removed redundant argument from HW_DSPSS_IPIEndianismSet ++ *! Moved endianness and element size to generic hw_defs.h ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++#ifndef __HW_DSPSS_H ++#define __HW_DSPSS_H ++#include <linux/types.h> ++ ++ enum HW_DSPSYSC_BootMode_t { ++ HW_DSPSYSC_DIRECTBOOT = 0x0, ++ HW_DSPSYSC_IDLEBOOT = 0x1, ++ HW_DSPSYSC_SELFLOOPBOOT = 0x2, ++ HW_DSPSYSC_USRBOOTSTRAP = 0x3, ++ HW_DSPSYSC_DEFAULTRESTORE = 0x4 ++ } ; ++ ++#define HW_DSP_IDLEBOOT_ADDR 0x007E0000 ++ ++ extern HW_STATUS HW_DSPSS_BootModeSet(const u32 baseAddress, ++ enum HW_DSPSYSC_BootMode_t bootMode, ++ const u32 bootAddress); ++ ++#endif /* __HW_DSPSS_H */ +diff --git a/drivers/dsp/bridge/hw/hw_mbox.c b/drivers/dsp/bridge/hw/hw_mbox.c +new file mode 100644 +index 0000000..9f14f34 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_mbox.c +@@ -0,0 +1,244 @@ ++/* ++ * hw_mbox.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== hw_mbox.c ======== ++ * Description: ++ * Mailbox messaging & configuration API definitions ++ * ++ *! Revision History: ++ *! ================ ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++#include <GlobalTypes.h> ++#include "MLBRegAcM.h" ++#include <hw_defs.h> ++#include <hw_mbox.h> ++ ++/* width in bits of MBOX Id */ ++#define HW_MBOX_ID_WIDTH 2 ++ ++struct MAILBOX_CONTEXT mboxsetting = {0x4, 0x1, 0x1}; ++ ++/* Saves the mailbox context */ ++HW_STATUS HW_MBOX_saveSettings(u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ ++ mboxsetting.sysconfig = MLBMAILBOX_SYSCONFIGReadRegister32(baseAddress); ++ /* Get current enable status */ ++ mboxsetting.irqEnable0 = MLBMAILBOX_IRQENABLE___0_3ReadRegister32 ++ (baseAddress, HW_MBOX_U0_ARM); ++ mboxsetting.irqEnable1 = MLBMAILBOX_IRQENABLE___0_3ReadRegister32 ++ (baseAddress, HW_MBOX_U1_DSP1); ++ return status; ++} ++ ++/* Restores the mailbox context */ ++HW_STATUS HW_MBOX_restoreSettings(u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ /* Restor IRQ enable status */ ++ MLBMAILBOX_IRQENABLE___0_3WriteRegister32(baseAddress, HW_MBOX_U0_ARM, ++ mboxsetting.irqEnable0); ++ MLBMAILBOX_IRQENABLE___0_3WriteRegister32(baseAddress, HW_MBOX_U1_DSP1, ++ mboxsetting.irqEnable1); ++ /* Restore Sysconfig register */ ++ MLBMAILBOX_SYSCONFIGWriteRegister32(baseAddress, mboxsetting.sysconfig); ++ return status; ++} ++ ++/* Reads a u32 from the sub module message box Specified. if there are no ++ * messages in the mailbox then and error is returned. */ ++HW_STATUS HW_MBOX_MsgRead(const u32 baseAddress, const HW_MBOX_Id_t mailBoxId, ++ u32 *const pReadValue) ++{ ++ HW_STATUS status = RET_OK; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_PARAM(pReadValue, NULL, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* Read 32-bit message in mail box */ ++ *pReadValue = MLBMAILBOX_MESSAGE___0_15ReadRegister32(baseAddress, ++ (u32)mailBoxId); ++ ++ return status; ++} ++ ++/* Writes a u32 from the sub module message box Specified. */ ++HW_STATUS HW_MBOX_MsgWrite(const u32 baseAddress, const HW_MBOX_Id_t mailBoxId, ++ const u32 writeValue) ++{ ++ HW_STATUS status = RET_OK; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* Write 32-bit value to mailbox */ ++ MLBMAILBOX_MESSAGE___0_15WriteRegister32(baseAddress, (u32)mailBoxId, ++ (u32)writeValue); ++ ++ return status; ++} ++ ++/* Gets number of messages in a specified mailbox. */ ++HW_STATUS HW_MBOX_NumMsgGet(const u32 baseAddress, const HW_MBOX_Id_t mailBoxId, ++ u32 *const pNumMsg) ++{ ++ HW_STATUS status = RET_OK; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_PARAM(pNumMsg, NULL, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* Get number of messages available for MailBox */ ++ *pNumMsg = MLBMAILBOX_MSGSTATUS___0_15NbOfMsgMBmRead32(baseAddress, ++ (u32)mailBoxId); ++ ++ return status; ++} ++ ++/* Enables the specified IRQ. */ ++HW_STATUS HW_MBOX_EventEnable(const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, ++ const u32 events) ++{ ++ HW_STATUS status = RET_OK; ++ u32 irqEnableReg; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(enableIrq, HW_MBOX_INT_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(userId, HW_MBOX_USER_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* Get current enable status */ ++ irqEnableReg = MLBMAILBOX_IRQENABLE___0_3ReadRegister32(baseAddress, ++ (u32)userId); ++ ++ /* update enable value */ ++ irqEnableReg |= ((u32)(events)) << (((u32)(mailBoxId)) * ++ HW_MBOX_ID_WIDTH); ++ ++ /* write new enable status */ ++ MLBMAILBOX_IRQENABLE___0_3WriteRegister32(baseAddress, (u32)userId, ++ (u32)irqEnableReg); ++ ++ mboxsetting.sysconfig = MLBMAILBOX_SYSCONFIGReadRegister32(baseAddress); ++ /* Get current enable status */ ++ mboxsetting.irqEnable0 = MLBMAILBOX_IRQENABLE___0_3ReadRegister32 ++ (baseAddress, HW_MBOX_U0_ARM); ++ mboxsetting.irqEnable1 = MLBMAILBOX_IRQENABLE___0_3ReadRegister32 ++ (baseAddress, HW_MBOX_U1_DSP1); ++ return status; ++} ++ ++/* Disables the specified IRQ. */ ++HW_STATUS HW_MBOX_EventDisable(const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, ++ const u32 events) ++{ ++ HW_STATUS status = RET_OK; ++ u32 irqDisableReg; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(disableIrq, HW_MBOX_INT_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(userId, HW_MBOX_USER_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* Get current enable status */ ++ irqDisableReg = MLBMAILBOX_IRQENABLE___0_3ReadRegister32(baseAddress, ++ (u32)userId); ++ ++ /* update enable value */ ++ irqDisableReg &= ~(((u32)(events)) << (((u32)(mailBoxId)) * ++ HW_MBOX_ID_WIDTH)); ++ ++ /* write new enable status */ ++ MLBMAILBOX_IRQENABLE___0_3WriteRegister32(baseAddress, (u32)userId, ++ (u32)irqDisableReg); ++ ++ return status; ++} ++ ++/* Sets the status of the specified IRQ. */ ++HW_STATUS HW_MBOX_EventAck(const u32 baseAddress, const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, const u32 event) ++{ ++ HW_STATUS status = RET_OK; ++ u32 irqStatusReg; ++ ++ /* Check input parameters */ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, RES_MBOX_BASE + ++ RES_INVALID_INPUT_PARAM); ++ ++ CHECK_INPUT_RANGE_MIN0(irqStatus, HW_MBOX_INT_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mailBoxId, HW_MBOX_ID_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(userId, HW_MBOX_USER_MAX, RET_INVALID_ID, ++ RES_MBOX_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* calculate status to write */ ++ irqStatusReg = ((u32)event) << (((u32)(mailBoxId)) * ++ HW_MBOX_ID_WIDTH); ++ ++ /* clear Irq Status for specified mailbox/User Id */ ++ MLBMAILBOX_IRQSTATUS___0_3WriteRegister32(baseAddress, (u32)userId, ++ (u32)irqStatusReg); ++ ++ /* ++ * FIXME: Replace all this custom register access with standard ++ * __raw_read/write(). ++ * ++ * FIXME: Replace all interrupt handlers with standard linux style ++ * interrupt handlers. ++ * ++ * FIXME: Replace direct access to PRCM registers with omap standard ++ * PRCM register access. ++ * ++ * Flush posted write for the irq status to avoid spurious interrupts. ++ */ ++ MLBMAILBOX_IRQSTATUS___0_3ReadRegister32(baseAddress, (u32)userId); ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/hw/hw_mbox.h b/drivers/dsp/bridge/hw/hw_mbox.h +new file mode 100644 +index 0000000..d2981d3 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_mbox.h +@@ -0,0 +1,323 @@ ++/* ++ * hw_mbox.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== hw_mbox.h ======== ++ * Description: ++ * HW Mailbox API and types definitions ++ * ++ *! Revision History: ++ *! ================ ++ *! 16 Feb 2003 sb: Initial version ++ */ ++#ifndef __MBOX_H ++#define __MBOX_H ++ ++/* Bitmasks for Mailbox interrupt sources */ ++#define HW_MBOX_INT_NEW_MSG 0x1 ++#define HW_MBOX_INT_NOT_FULL 0x2 ++#define HW_MBOX_INT_ALL 0x3 ++ ++/* Maximum number of messages that mailbox can hald at a time. */ ++#define HW_MBOX_MAX_NUM_MESSAGES 4 ++ ++/* HW_MBOX_Id_t: Enumerated Type used to specify Mailbox Sub Module Id Number */ ++typedef enum HW_MBOX_Id_label { ++ HW_MBOX_ID_0, ++ HW_MBOX_ID_1, ++ HW_MBOX_ID_2, ++ HW_MBOX_ID_3, ++ HW_MBOX_ID_4, ++ HW_MBOX_ID_5 ++ ++} HW_MBOX_Id_t, *pHW_MBOX_Id_t; ++ ++/* HW_MBOX_UserId_t: Enumerated Type used to specify Mail box User Id */ ++typedef enum HW_MBOX_UserId_label { ++ HW_MBOX_U0_ARM, ++ HW_MBOX_U1_DSP1, ++ HW_MBOX_U2_DSP2, ++ HW_MBOX_U3_ARM ++ ++} HW_MBOX_UserId_t, *pHW_MBOX_UserId_t; ++ ++/* Mailbox context settings */ ++struct MAILBOX_CONTEXT { ++ u32 sysconfig; ++ u32 irqEnable0; ++ u32 irqEnable1; ++}; ++ ++/* ++* FUNCTION : HW_MBOX_MsgRead ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to read ++* ++* OUTPUTS: ++* ++* Identifier : pReadValue ++* Type : u32 *const ++* Description : Value read from MailBox ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address/ptr Paramater was set to 0/NULL ++* RET_INVALID_ID Invalid Id used ++* RET_EMPTY Mailbox empty ++* ++* PURPOSE: : this function reads a u32 from the sub module message ++* box Specified. if there are no messages in the mailbox ++* then and error is returned. ++*/ ++extern HW_STATUS HW_MBOX_MsgRead(const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ u32 *const pReadValue); ++ ++/* ++* FUNCTION : HW_MBOX_MsgWrite ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to write ++* ++* Identifier : writeValue ++* Type : const u32 ++* Description : Value to write to MailBox ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* RET_INVALID_ID Invalid Id used ++* ++* PURPOSE: : this function writes a u32 from the sub module message ++* box Specified. ++*/ ++extern HW_STATUS HW_MBOX_MsgWrite( ++ const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const u32 writeValue ++ ); ++ ++/* ++* FUNCTION : HW_MBOX_NumMsgGet ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to get num messages ++* ++* OUTPUTS: ++* ++* Identifier : pNumMsg ++* Type : u32 *const ++* Description : Number of messages in mailbox ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* RET_INVALID_ID Inavlid ID input at parameter ++* ++* PURPOSE: : this function gets number of messages in a specified mailbox. ++*/ ++extern HW_STATUS HW_MBOX_NumMsgGet( ++ const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ u32 *const pNumMsg ++ ); ++ ++/* ++* FUNCTION : HW_MBOX_EventEnable ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to enable ++* ++* Identifier : userId ++* Type : const HW_MBOX_UserId_t ++* Description : Mail box User Id to enable ++* ++* Identifier : enableIrq ++* Type : const u32 ++* Description : Irq value to enable ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM A Pointer Paramater was set to NULL ++* RET_INVALID_ID Invalid Id used ++* ++* PURPOSE: : this function enables the specified IRQ. ++*/ ++extern HW_STATUS HW_MBOX_EventEnable( ++ const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, ++ const u32 events ++ ); ++ ++/* ++* FUNCTION : HW_MBOX_EventDisable ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to disable ++* ++* Identifier : userId ++* Type : const HW_MBOX_UserId_t ++* Description : Mail box User Id to disable ++* ++* Identifier : enableIrq ++* Type : const u32 ++* Description : Irq value to disable ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM A Pointer Paramater was set to NULL ++* RET_INVALID_ID Invalid Id used ++* ++* PURPOSE: : this function disables the specified IRQ. ++*/ ++extern HW_STATUS HW_MBOX_EventDisable( ++ const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, ++ const u32 events ++ ); ++ ++/* ++* FUNCTION : HW_MBOX_EventAck ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* Identifier : mailBoxId ++* Type : const HW_MBOX_Id_t ++* Description : Mail Box Sub module Id to set ++* ++* Identifier : userId ++* Type : const HW_MBOX_UserId_t ++* Description : Mail box User Id to set ++* ++* Identifier : irqStatus ++* Type : const u32 ++* Description : The value to write IRQ status ++* ++* OUTPUTS: ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address Paramater was set to 0 ++* RET_INVALID_ID Invalid Id used ++* ++* PURPOSE: : this function sets the status of the specified IRQ. ++*/ ++extern HW_STATUS HW_MBOX_EventAck( ++ const u32 baseAddress, ++ const HW_MBOX_Id_t mailBoxId, ++ const HW_MBOX_UserId_t userId, ++ const u32 event ++ ); ++ ++/* ++* FUNCTION : HW_MBOX_saveSettings ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* RET_INVALID_ID Invalid Id used ++* RET_EMPTY Mailbox empty ++* ++* PURPOSE: : this function saves the context of mailbox ++*/ ++extern HW_STATUS HW_MBOX_saveSettings(u32 baseAddres); ++ ++/* ++* FUNCTION : HW_MBOX_restoreSettings ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of Mailbox module ++* ++* ++* RETURNS: ++* ++* Type : ReturnCode_t ++* Description : RET_OK No errors occured ++* RET_BAD_NULL_PARAM Address/pointer Paramater was set to 0/NULL ++* RET_INVALID_ID Invalid Id used ++* RET_EMPTY Mailbox empty ++* ++* PURPOSE: : this function restores the context of mailbox ++*/ ++extern HW_STATUS HW_MBOX_restoreSettings(u32 baseAddres); ++ ++#endif /* __MBOX_H */ +diff --git a/drivers/dsp/bridge/hw/hw_mmu.c b/drivers/dsp/bridge/hw/hw_mmu.c +new file mode 100644 +index 0000000..ab65de0 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_mmu.c +@@ -0,0 +1,598 @@ ++/* ++ * hw_mmu.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== hw_mmu.c ======== ++ * Description: ++ * API definitions to setup MMU TLB and PTE ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb TLBAdd and TLBFlush input the page size in bytes instead ++ of an enum. TLBAdd inputs mapping attributes struct instead ++ of individual arguments. ++ Removed MMU.h and other cosmetic updates. ++ *! 08-Mar-2004 sb Added the Page Table Management APIs ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++#include <GlobalTypes.h> ++#include "MMURegAcM.h" ++#include <hw_defs.h> ++#include <hw_mmu.h> ++#include <linux/types.h> ++ ++#define MMU_BASE_VAL_MASK 0xFC00 ++#define MMU_PAGE_MAX 3 ++#define MMU_ELEMENTSIZE_MAX 3 ++#define MMU_ADDR_MASK 0xFFFFF000 ++#define MMU_TTB_MASK 0xFFFFC000 ++#define MMU_SECTION_ADDR_MASK 0xFFF00000 ++#define MMU_SSECTION_ADDR_MASK 0xFF000000 ++#define MMU_PAGE_TABLE_MASK 0xFFFFFC00 ++#define MMU_LARGE_PAGE_MASK 0xFFFF0000 ++#define MMU_SMALL_PAGE_MASK 0xFFFFF000 ++ ++#define MMU_LOAD_TLB 0x00000001 ++ ++/* HW_MMUPageSize_t: Enumerated Type used to specify the MMU Page Size(SLSS) */ ++enum HW_MMUPageSize_t { ++ HW_MMU_SECTION, ++ HW_MMU_LARGE_PAGE, ++ HW_MMU_SMALL_PAGE, ++ HW_MMU_SUPERSECTION ++} ; ++ ++/* ++* FUNCTION : MMU_FlushEntry ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of MMU module ++* ++* RETURNS: ++* ++* Type : HW_STATUS ++* Description : RET_OK -- No errors occured ++* RET_BAD_NULL_PARAM -- A Pointer ++* Paramater was set to NULL ++* ++* PURPOSE: : Flush the TLB entry pointed by the ++* lock counter register ++* even if this entry is set protected ++* ++* METHOD: : Check the Input parameter and Flush a ++* single entry in the TLB. ++*/ ++static HW_STATUS MMU_FlushEntry(const u32 baseAddress); ++ ++/* ++* FUNCTION : MMU_SetCAMEntry ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* TypE : const u32 ++* Description : Base Address of instance of MMU module ++* ++* Identifier : pageSize ++* TypE : const u32 ++* Description : It indicates the page size ++* ++* Identifier : preservedBit ++* Type : const u32 ++* Description : It indicates the TLB entry is preserved entry ++* or not ++* ++* Identifier : validBit ++* Type : const u32 ++* Description : It indicates the TLB entry is valid entry or not ++* ++* ++* Identifier : virtualAddrTag ++* Type : const u32 ++* Description : virtual Address ++* ++* RETURNS: ++* ++* Type : HW_STATUS ++* Description : RET_OK -- No errors occured ++* RET_BAD_NULL_PARAM -- A Pointer Paramater ++* was set to NULL ++* RET_PARAM_OUT_OF_RANGE -- Input Parameter out ++* of Range ++* ++* PURPOSE: : Set MMU_CAM reg ++* ++* METHOD: : Check the Input parameters and set the CAM entry. ++*/ ++static HW_STATUS MMU_SetCAMEntry(const u32 baseAddress, ++ const u32 pageSize, ++ const u32 preservedBit, ++ const u32 validBit, ++ const u32 virtualAddrTag); ++ ++/* ++* FUNCTION : MMU_SetRAMEntry ++* ++* INPUTS: ++* ++* Identifier : baseAddress ++* Type : const u32 ++* Description : Base Address of instance of MMU module ++* ++* Identifier : physicalAddr ++* Type : const u32 ++* Description : Physical Address to which the corresponding ++* virtual Address shouldpoint ++* ++* Identifier : endianism ++* Type : HW_Endianism_t ++* Description : endianism for the given page ++* ++* Identifier : elementSize ++* Type : HW_ElementSize_t ++* Description : The element size ( 8,16, 32 or 64 bit) ++* ++* Identifier : mixedSize ++* Type : HW_MMUMixedSize_t ++* Description : Element Size to follow CPU or TLB ++* ++* RETURNS: ++* ++* Type : HW_STATUS ++* Description : RET_OK -- No errors occured ++* RET_BAD_NULL_PARAM -- A Pointer Paramater ++* was set to NULL ++* RET_PARAM_OUT_OF_RANGE -- Input Parameter ++* out of Range ++* ++* PURPOSE: : Set MMU_CAM reg ++* ++* METHOD: : Check the Input parameters and set the RAM entry. ++*/ ++static HW_STATUS MMU_SetRAMEntry(const u32 baseAddress, ++ const u32 physicalAddr, ++ enum HW_Endianism_t endianism, ++ enum HW_ElementSize_t elementSize, ++ enum HW_MMUMixedSize_t mixedSize); ++ ++/* HW FUNCTIONS */ ++ ++HW_STATUS HW_MMU_Enable(const u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_CNTLMMUEnableWrite32(baseAddress, HW_SET); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_Disable(const u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_CNTLMMUEnableWrite32(baseAddress, HW_CLEAR); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_NumLockedSet(const u32 baseAddress, ++ u32 numLockedEntries) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_LOCKBaseValueWrite32(baseAddress, numLockedEntries); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_VictimNumSet(const u32 baseAddress, ++ u32 victimEntryNum) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_LOCKCurrentVictimWrite32(baseAddress, victimEntryNum); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_EventAck(const u32 baseAddress, u32 irqMask) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_IRQSTATUSWriteRegister32(baseAddress, irqMask); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_EventDisable(const u32 baseAddress, ++ u32 irqMask) ++{ ++ HW_STATUS status = RET_OK; ++ u32 irqReg; ++ ++ irqReg = MMUMMU_IRQENABLEReadRegister32(baseAddress); ++ ++ MMUMMU_IRQENABLEWriteRegister32(baseAddress, irqReg & ~irqMask); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_EventEnable(const u32 baseAddress, u32 irqMask) ++{ ++ HW_STATUS status = RET_OK; ++ u32 irqReg; ++ ++ irqReg = MMUMMU_IRQENABLEReadRegister32(baseAddress); ++ ++ MMUMMU_IRQENABLEWriteRegister32(baseAddress, irqReg | irqMask); ++ ++ return status; ++} ++ ++ ++HW_STATUS HW_MMU_EventStatus(const u32 baseAddress, u32 *irqMask) ++{ ++ HW_STATUS status = RET_OK; ++ ++ *irqMask = MMUMMU_IRQSTATUSReadRegister32(baseAddress); ++ ++ return status; ++} ++ ++ ++HW_STATUS HW_MMU_FaultAddrRead(const u32 baseAddress, u32 *addr) ++{ ++ HW_STATUS status = RET_OK; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* read values from register */ ++ *addr = MMUMMU_FAULT_ADReadRegister32(baseAddress); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_TTBSet(const u32 baseAddress, u32 TTBPhysAddr) ++{ ++ HW_STATUS status = RET_OK; ++ u32 loadTTB; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ ++ loadTTB = TTBPhysAddr & ~0x7FUL; ++ /* write values to register */ ++ MMUMMU_TTBWriteRegister32(baseAddress, loadTTB); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_TWLEnable(const u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_CNTLTWLEnableWrite32(baseAddress, HW_SET); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_TWLDisable(const u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ ++ MMUMMU_CNTLTWLEnableWrite32(baseAddress, HW_CLEAR); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_TLBFlush(const u32 baseAddress, u32 virtualAddr, ++ u32 pageSize) ++{ ++ HW_STATUS status = RET_OK; ++ u32 virtualAddrTag; ++ enum HW_MMUPageSize_t pgSizeBits; ++ ++ switch (pageSize) { ++ case HW_PAGE_SIZE_4KB: ++ pgSizeBits = HW_MMU_SMALL_PAGE; ++ break; ++ ++ case HW_PAGE_SIZE_64KB: ++ pgSizeBits = HW_MMU_LARGE_PAGE; ++ break; ++ ++ case HW_PAGE_SIZE_1MB: ++ pgSizeBits = HW_MMU_SECTION; ++ break; ++ ++ case HW_PAGE_SIZE_16MB: ++ pgSizeBits = HW_MMU_SUPERSECTION; ++ break; ++ ++ default: ++ return RET_FAIL; ++ } ++ ++ /* Generate the 20-bit tag from virtual address */ ++ virtualAddrTag = ((virtualAddr & MMU_ADDR_MASK) >> 12); ++ ++ MMU_SetCAMEntry(baseAddress, pgSizeBits, 0, 0, virtualAddrTag); ++ ++ MMU_FlushEntry(baseAddress); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_TLBAdd(const u32 baseAddress, ++ u32 physicalAddr, ++ u32 virtualAddr, ++ u32 pageSize, ++ u32 entryNum, ++ struct HW_MMUMapAttrs_t *mapAttrs, ++ enum HW_SetClear_t preservedBit, ++ enum HW_SetClear_t validBit) ++{ ++ HW_STATUS status = RET_OK; ++ u32 lockReg; ++ u32 virtualAddrTag; ++ enum HW_MMUPageSize_t mmuPgSize; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(pageSize, MMU_PAGE_MAX, RET_PARAM_OUT_OF_RANGE, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(mapAttrs->elementSize, MMU_ELEMENTSIZE_MAX, ++ RET_PARAM_OUT_OF_RANGE, RES_MMU_BASE + ++ RES_INVALID_INPUT_PARAM); ++ ++ switch (pageSize) { ++ case HW_PAGE_SIZE_4KB: ++ mmuPgSize = HW_MMU_SMALL_PAGE; ++ break; ++ ++ case HW_PAGE_SIZE_64KB: ++ mmuPgSize = HW_MMU_LARGE_PAGE; ++ break; ++ ++ case HW_PAGE_SIZE_1MB: ++ mmuPgSize = HW_MMU_SECTION; ++ break; ++ ++ case HW_PAGE_SIZE_16MB: ++ mmuPgSize = HW_MMU_SUPERSECTION; ++ break; ++ ++ default: ++ return RET_FAIL; ++ } ++ ++ lockReg = MMUMMU_LOCKReadRegister32(baseAddress); ++ ++ /* Generate the 20-bit tag from virtual address */ ++ virtualAddrTag = ((virtualAddr & MMU_ADDR_MASK) >> 12); ++ ++ /* Write the fields in the CAM Entry Register */ ++ MMU_SetCAMEntry(baseAddress, mmuPgSize, preservedBit, validBit, ++ virtualAddrTag); ++ ++ /* Write the different fields of the RAM Entry Register */ ++ /* endianism of the page,Element Size of the page (8, 16, 32, 64 bit)*/ ++ MMU_SetRAMEntry(baseAddress, physicalAddr, mapAttrs->endianism, ++ mapAttrs->elementSize, mapAttrs->mixedSize); ++ ++ /* Update the MMU Lock Register */ ++ /* currentVictim between lockedBaseValue and (MMU_Entries_Number - 1)*/ ++ MMUMMU_LOCKCurrentVictimWrite32(baseAddress, entryNum); ++ ++ /* Enable loading of an entry in TLB by writing 1 ++ into LD_TLB_REG register */ ++ MMUMMU_LD_TLBWriteRegister32(baseAddress, MMU_LOAD_TLB); ++ ++ ++ MMUMMU_LOCKWriteRegister32(baseAddress, lockReg); ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_PteSet(const u32 pgTblVa, ++ u32 physicalAddr, ++ u32 virtualAddr, ++ u32 pageSize, ++ struct HW_MMUMapAttrs_t *mapAttrs) ++{ ++ HW_STATUS status = RET_OK; ++ u32 pteAddr, pteVal; ++ s32 numEntries = 1; ++ ++ switch (pageSize) { ++ case HW_PAGE_SIZE_4KB: ++ pteAddr = HW_MMU_PteAddrL2(pgTblVa, ++ virtualAddr & MMU_SMALL_PAGE_MASK); ++ pteVal = ((physicalAddr & MMU_SMALL_PAGE_MASK) | ++ (mapAttrs->endianism << 9) | ++ (mapAttrs->elementSize << 4) | ++ (mapAttrs->mixedSize << 11) | 2 ++ ); ++ break; ++ ++ case HW_PAGE_SIZE_64KB: ++ numEntries = 16; ++ pteAddr = HW_MMU_PteAddrL2(pgTblVa, ++ virtualAddr & MMU_LARGE_PAGE_MASK); ++ pteVal = ((physicalAddr & MMU_LARGE_PAGE_MASK) | ++ (mapAttrs->endianism << 9) | ++ (mapAttrs->elementSize << 4) | ++ (mapAttrs->mixedSize << 11) | 1 ++ ); ++ break; ++ ++ case HW_PAGE_SIZE_1MB: ++ pteAddr = HW_MMU_PteAddrL1(pgTblVa, ++ virtualAddr & MMU_SECTION_ADDR_MASK); ++ pteVal = ((((physicalAddr & MMU_SECTION_ADDR_MASK) | ++ (mapAttrs->endianism << 15) | ++ (mapAttrs->elementSize << 10) | ++ (mapAttrs->mixedSize << 17)) & ++ ~0x40000) | 0x2 ++ ); ++ break; ++ ++ case HW_PAGE_SIZE_16MB: ++ numEntries = 16; ++ pteAddr = HW_MMU_PteAddrL1(pgTblVa, ++ virtualAddr & MMU_SSECTION_ADDR_MASK); ++ pteVal = (((physicalAddr & MMU_SSECTION_ADDR_MASK) | ++ (mapAttrs->endianism << 15) | ++ (mapAttrs->elementSize << 10) | ++ (mapAttrs->mixedSize << 17) ++ ) | 0x40000 | 0x2 ++ ); ++ break; ++ ++ case HW_MMU_COARSE_PAGE_SIZE: ++ pteAddr = HW_MMU_PteAddrL1(pgTblVa, ++ virtualAddr & MMU_SECTION_ADDR_MASK); ++ pteVal = (physicalAddr & MMU_PAGE_TABLE_MASK) | 1; ++ break; ++ ++ default: ++ return RET_FAIL; ++ } ++ ++ while (--numEntries >= 0) ++ ((u32 *)pteAddr)[numEntries] = pteVal; ++ ++ return status; ++} ++ ++HW_STATUS HW_MMU_PteClear(const u32 pgTblVa, ++ u32 virtualAddr, ++ u32 pgSize) ++{ ++ HW_STATUS status = RET_OK; ++ u32 pteAddr; ++ s32 numEntries = 1; ++ ++ switch (pgSize) { ++ case HW_PAGE_SIZE_4KB: ++ pteAddr = HW_MMU_PteAddrL2(pgTblVa, ++ virtualAddr & MMU_SMALL_PAGE_MASK); ++ break; ++ ++ case HW_PAGE_SIZE_64KB: ++ numEntries = 16; ++ pteAddr = HW_MMU_PteAddrL2(pgTblVa, ++ virtualAddr & MMU_LARGE_PAGE_MASK); ++ break; ++ ++ case HW_PAGE_SIZE_1MB: ++ case HW_MMU_COARSE_PAGE_SIZE: ++ pteAddr = HW_MMU_PteAddrL1(pgTblVa, ++ virtualAddr & MMU_SECTION_ADDR_MASK); ++ break; ++ ++ case HW_PAGE_SIZE_16MB: ++ numEntries = 16; ++ pteAddr = HW_MMU_PteAddrL1(pgTblVa, ++ virtualAddr & MMU_SSECTION_ADDR_MASK); ++ break; ++ ++ default: ++ return RET_FAIL; ++ } ++ ++ while (--numEntries >= 0) ++ ((u32 *)pteAddr)[numEntries] = 0; ++ ++ return status; ++} ++ ++/* MMU_FlushEntry */ ++static HW_STATUS MMU_FlushEntry(const u32 baseAddress) ++{ ++ HW_STATUS status = RET_OK; ++ u32 flushEntryData = 0x1; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ ++ /* write values to register */ ++ MMUMMU_FLUSH_ENTRYWriteRegister32(baseAddress, flushEntryData); ++ ++ return status; ++} ++ ++/* MMU_SetCAMEntry */ ++static HW_STATUS MMU_SetCAMEntry(const u32 baseAddress, ++ const u32 pageSize, ++ const u32 preservedBit, ++ const u32 validBit, ++ const u32 virtualAddrTag) ++{ ++ HW_STATUS status = RET_OK; ++ u32 mmuCamReg; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ ++ mmuCamReg = (virtualAddrTag << 12); ++ mmuCamReg = (mmuCamReg) | (pageSize) | (validBit << 2) | ++ (preservedBit << 3) ; ++ ++ /* write values to register */ ++ MMUMMU_CAMWriteRegister32(baseAddress, mmuCamReg); ++ ++ return status; ++} ++ ++/* MMU_SetRAMEntry */ ++static HW_STATUS MMU_SetRAMEntry(const u32 baseAddress, ++ const u32 physicalAddr, ++ enum HW_Endianism_t endianism, ++ enum HW_ElementSize_t elementSize, ++ enum HW_MMUMixedSize_t mixedSize) ++{ ++ HW_STATUS status = RET_OK; ++ u32 mmuRamReg; ++ ++ /*Check the input Parameters*/ ++ CHECK_INPUT_PARAM(baseAddress, 0, RET_BAD_NULL_PARAM, ++ RES_MMU_BASE + RES_INVALID_INPUT_PARAM); ++ CHECK_INPUT_RANGE_MIN0(elementSize, MMU_ELEMENTSIZE_MAX, ++ RET_PARAM_OUT_OF_RANGE, RES_MMU_BASE + ++ RES_INVALID_INPUT_PARAM); ++ ++ ++ mmuRamReg = (physicalAddr & MMU_ADDR_MASK); ++ mmuRamReg = (mmuRamReg) | ((endianism << 9) | (elementSize << 7) | ++ (mixedSize << 6)); ++ ++ /* write values to register */ ++ MMUMMU_RAMWriteRegister32(baseAddress, mmuRamReg); ++ ++ return status; ++ ++} +diff --git a/drivers/dsp/bridge/hw/hw_mmu.h b/drivers/dsp/bridge/hw/hw_mmu.h +new file mode 100644 +index 0000000..a3dd2a8 +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_mmu.h +@@ -0,0 +1,177 @@ ++/* ++ * hw_mmu.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== hw_mmu.h ======== ++ * Description: ++ * MMU types and API declarations ++ * ++ *! Revision History: ++ *! ================ ++ *! 19-Apr-2004 sb Moved & renamed endianness, page size, element size ++ TLBAdd takes in MMUMapAttrs instead of separate arguments ++ *! 08-Mar-2004 sb Added the Page Table management APIs ++ *! 16 Feb 2003 sb: Initial version ++ */ ++#ifndef __HW_MMU_H ++#define __HW_MMU_H ++ ++#include <linux/types.h> ++ ++/* Bitmasks for interrupt sources */ ++#define HW_MMU_TRANSLATION_FAULT 0x2 ++#define HW_MMU_ALL_INTERRUPTS 0x1F ++ ++#define HW_MMU_COARSE_PAGE_SIZE 0x400 ++ ++/* HW_MMUMixedSize_t: Enumerated Type used to specify whether to follow ++ CPU/TLB Element size */ ++enum HW_MMUMixedSize_t { ++ HW_MMU_TLBES, ++ HW_MMU_CPUES ++ ++} ; ++ ++/* HW_MMUMapAttrs_t: Struct containing MMU mapping attributes */ ++struct HW_MMUMapAttrs_t { ++ enum HW_Endianism_t endianism; ++ enum HW_ElementSize_t elementSize; ++ enum HW_MMUMixedSize_t mixedSize; ++ bool donotlockmpupage; ++} ; ++ ++extern HW_STATUS HW_MMU_Enable(const u32 baseAddress); ++ ++extern HW_STATUS HW_MMU_Disable(const u32 baseAddress); ++ ++extern HW_STATUS HW_MMU_NumLockedSet(const u32 baseAddress, ++ u32 numLockedEntries); ++ ++extern HW_STATUS HW_MMU_VictimNumSet(const u32 baseAddress, ++ u32 victimEntryNum); ++ ++/* For MMU faults */ ++extern HW_STATUS HW_MMU_EventAck(const u32 baseAddress, ++ u32 irqMask); ++ ++extern HW_STATUS HW_MMU_EventDisable(const u32 baseAddress, ++ u32 irqMask); ++ ++extern HW_STATUS HW_MMU_EventEnable(const u32 baseAddress, ++ u32 irqMask); ++ ++extern HW_STATUS HW_MMU_EventStatus(const u32 baseAddress, ++ u32 *irqMask); ++ ++extern HW_STATUS HW_MMU_FaultAddrRead(const u32 baseAddress, ++ u32 *addr); ++ ++/* Set the TT base address */ ++extern HW_STATUS HW_MMU_TTBSet(const u32 baseAddress, ++ u32 TTBPhysAddr); ++ ++extern HW_STATUS HW_MMU_TWLEnable(const u32 baseAddress); ++ ++extern HW_STATUS HW_MMU_TWLDisable(const u32 baseAddress); ++ ++extern HW_STATUS HW_MMU_TLBFlush(const u32 baseAddress, ++ u32 virtualAddr, ++ u32 pageSize); ++ ++extern HW_STATUS HW_MMU_TLBAdd(const u32 baseAddress, ++ u32 physicalAddr, ++ u32 virtualAddr, ++ u32 pageSize, ++ u32 entryNum, ++ struct HW_MMUMapAttrs_t *mapAttrs, ++ enum HW_SetClear_t preservedBit, ++ enum HW_SetClear_t validBit); ++ ++ ++/* For PTEs */ ++extern HW_STATUS HW_MMU_PteSet(const u32 pgTblVa, ++ u32 physicalAddr, ++ u32 virtualAddr, ++ u32 pageSize, ++ struct HW_MMUMapAttrs_t *mapAttrs); ++ ++extern HW_STATUS HW_MMU_PteClear(const u32 pgTblVa, ++ u32 pgSize, ++ u32 virtualAddr); ++ ++static inline u32 HW_MMU_PteAddrL1(u32 L1_base, u32 va) ++{ ++ u32 pteAddr; ++ u32 VA_31_to_20; ++ ++ VA_31_to_20 = va >> (20 - 2); /* Left-shift by 2 here itself */ ++ VA_31_to_20 &= 0xFFFFFFFCUL; ++ pteAddr = L1_base + VA_31_to_20; ++ ++ return pteAddr; ++} ++ ++static inline u32 HW_MMU_PteAddrL2(u32 L2_base, u32 va) ++{ ++ u32 pteAddr; ++ ++ pteAddr = (L2_base & 0xFFFFFC00) | ((va >> 10) & 0x3FC); ++ ++ return pteAddr; ++} ++ ++static inline u32 HW_MMU_PteCoarseL1(u32 pteVal) ++{ ++ u32 pteCoarse; ++ ++ pteCoarse = pteVal & 0xFFFFFC00; ++ ++ return pteCoarse; ++} ++ ++static inline u32 HW_MMU_PteSizeL1(u32 pteVal) ++{ ++ u32 pteSize = 0; ++ ++ if ((pteVal & 0x3) == 0x1) { ++ /* Points to L2 PT */ ++ pteSize = HW_MMU_COARSE_PAGE_SIZE; ++ } ++ ++ if ((pteVal & 0x3) == 0x2) { ++ if (pteVal & (1 << 18)) ++ pteSize = HW_PAGE_SIZE_16MB; ++ else ++ pteSize = HW_PAGE_SIZE_1MB; ++ } ++ ++ return pteSize; ++} ++ ++static inline u32 HW_MMU_PteSizeL2(u32 pteVal) ++{ ++ u32 pteSize = 0; ++ ++ if (pteVal & 0x2) ++ pteSize = HW_PAGE_SIZE_4KB; ++ else if (pteVal & 0x1) ++ pteSize = HW_PAGE_SIZE_64KB; ++ ++ return pteSize; ++} ++ ++#endif /* __HW_MMU_H */ +diff --git a/drivers/dsp/bridge/hw/hw_prcm.c b/drivers/dsp/bridge/hw/hw_prcm.c +new file mode 100644 +index 0000000..61ff08f +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_prcm.c +@@ -0,0 +1,167 @@ ++/* ++ * hw_prcm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== hw_prcm.c ======== ++ * Description: ++ * API definitions to configure PRCM (Power, Reset & Clocks Manager) ++ * ++ *! Revision History: ++ *! ================ ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++#include <GlobalTypes.h> ++#include "PRCMRegAcM.h" ++#include <hw_defs.h> ++#include <hw_prcm.h> ++ ++static HW_STATUS HW_RST_WriteVal(const u32 baseAddress, ++ enum HW_RstModule_t r, ++ enum HW_SetClear_t val); ++ ++HW_STATUS HW_RST_Reset(const u32 baseAddress, enum HW_RstModule_t r) ++{ ++ return HW_RST_WriteVal(baseAddress, r, HW_SET); ++} ++ ++HW_STATUS HW_RST_UnReset(const u32 baseAddress, enum HW_RstModule_t r) ++{ ++ return HW_RST_WriteVal(baseAddress, r, HW_CLEAR); ++} ++ ++static HW_STATUS HW_RST_WriteVal(const u32 baseAddress, ++ enum HW_RstModule_t r, ++ enum HW_SetClear_t val) ++{ ++ HW_STATUS status = RET_OK; ++ ++ switch (r) { ++ case HW_RST1_IVA2: ++ PRM_RSTCTRL_IVA2RST1_DSPWrite32(baseAddress, val); ++ break; ++ case HW_RST2_IVA2: ++ PRM_RSTCTRL_IVA2RST2_DSPWrite32(baseAddress, val); ++ break; ++ case HW_RST3_IVA2: ++ PRM_RSTCTRL_IVA2RST3_DSPWrite32(baseAddress, val); ++ break; ++ default: ++ status = RET_FAIL; ++ break; ++ } ++ return status; ++} ++ ++HW_STATUS HW_PWR_IVA2StateGet(const u32 baseAddress, enum HW_PwrModule_t p, ++ enum HW_PwrState_t *value) ++{ ++ HW_STATUS status = RET_OK; ++ u32 temp; ++ ++ switch (p) { ++ case HW_PWR_DOMAIN_DSP: ++ /* wait until Transition is complete */ ++ do { ++ /* mdelay(1); */ ++ temp = PRCMPM_PWSTST_IVA2InTransitionRead32 ++ (baseAddress); ++ ++ } while (temp); ++ ++ temp = PRCMPM_PWSTST_IVA2ReadRegister32(baseAddress); ++ *value = PRCMPM_PWSTST_IVA2PowerStateStGet32(temp); ++ break; ++ ++ default: ++ status = RET_FAIL; ++ break; ++ } ++ return status; ++} ++ ++HW_STATUS HW_PWRST_IVA2RegGet(const u32 baseAddress, u32 *value) ++{ ++ HW_STATUS status = RET_OK; ++ ++ *value = PRCMPM_PWSTST_IVA2ReadRegister32(baseAddress); ++ ++ return status; ++} ++ ++ ++HW_STATUS HW_PWR_IVA2PowerStateSet(const u32 baseAddress, ++ enum HW_PwrModule_t p, ++ enum HW_PwrState_t value) ++{ ++ HW_STATUS status = RET_OK; ++ ++ switch (p) { ++ case HW_PWR_DOMAIN_DSP: ++ switch (value) { ++ case HW_PWR_STATE_ON: ++ PRCMPM_PWSTCTRL_IVA2PowerStateWriteON32(baseAddress); ++ break; ++ case HW_PWR_STATE_RET: ++ PRCMPM_PWSTCTRL_DSPPowerStateWriteRET32(baseAddress); ++ break; ++ case HW_PWR_STATE_OFF: ++ PRCMPM_PWSTCTRL_IVA2PowerStateWriteOFF32(baseAddress); ++ break; ++ default: ++ status = RET_FAIL; ++ break; ++ } ++ break; ++ ++ default: ++ status = RET_FAIL; ++ break; ++ } ++ ++ return status; ++} ++ ++HW_STATUS HW_PWR_CLKCTRL_IVA2RegSet(const u32 baseAddress, ++ enum HW_TransitionState_t val) ++{ ++ HW_STATUS status = RET_OK; ++ ++ PRCMCM_CLKSTCTRL_IVA2WriteRegister32(baseAddress, val); ++ ++ return status; ++ ++} ++ ++HW_STATUS HW_RSTST_RegGet(const u32 baseAddress, enum HW_RstModule_t m, ++ u32 *value) ++{ ++ HW_STATUS status = RET_OK; ++ ++ *value = PRCMRM_RSTST_DSPReadRegister32(baseAddress); ++ ++ return status; ++} ++ ++HW_STATUS HW_RSTCTRL_RegGet(const u32 baseAddress, enum HW_RstModule_t m, ++ u32 *value) ++{ ++ HW_STATUS status = RET_OK; ++ ++ *value = PRCMRM_RSTCTRL_DSPReadRegister32(baseAddress); ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/hw/hw_prcm.h b/drivers/dsp/bridge/hw/hw_prcm.h +new file mode 100644 +index 0000000..928486c +--- /dev/null ++++ b/drivers/dsp/bridge/hw/hw_prcm.h +@@ -0,0 +1,168 @@ ++/* ++ * hw_prcm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== hw_prcm.h ======== ++ * Description: ++ * PRCM types and API declarations ++ * ++ *! Revision History: ++ *! ================ ++ *! 16 Feb 2003 sb: Initial version ++ */ ++ ++#ifndef __HW_PRCM_H ++#define __HW_PRCM_H ++ ++/* HW_ClkModule: Enumerated Type used to specify the clock domain */ ++ ++enum HW_ClkModule_t { ++/* DSP Domain */ ++ HW_CLK_DSP_CPU, ++ HW_CLK_DSP_IPI_MMU, ++ HW_CLK_IVA_ARM, ++ HW_CLK_IVA_COP, /* IVA Coprocessor */ ++ ++/* Core Domain */ ++ HW_CLK_FN_WDT4, /* Functional Clock */ ++ HW_CLK_FN_WDT3, ++ HW_CLK_FN_UART2, ++ HW_CLK_FN_UART1, ++ HW_CLK_GPT5, ++ HW_CLK_GPT6, ++ HW_CLK_GPT7, ++ HW_CLK_GPT8, ++ ++ HW_CLK_IF_WDT4, /* Interface Clock */ ++ HW_CLK_IF_WDT3, ++ HW_CLK_IF_UART2, ++ HW_CLK_IF_UART1, ++ HW_CLK_IF_MBOX ++ ++} ; ++ ++enum HW_ClkSubsys_t { ++ HW_CLK_DSPSS, ++ HW_CLK_IVASS ++} ; ++ ++/* HW_GPtimers: General purpose timers */ ++enum HW_GPtimer_t { ++ HW_GPT5 = 5, ++ HW_GPT6 = 6, ++ HW_GPT7 = 7, ++ HW_GPT8 = 8 ++} ; ++ ++ ++/* GP timers Input clock type: General purpose timers */ ++enum HW_Clocktype_t { ++ HW_CLK_32KHz = 0, ++ HW_CLK_SYS = 1, ++ HW_CLK_EXT = 2 ++} ; ++ ++/* HW_ClkDiv: Clock divisors */ ++enum HW_ClkDiv_t { ++ HW_CLK_DIV_1 = 0x1, ++ HW_CLK_DIV_2 = 0x2, ++ HW_CLK_DIV_3 = 0x3, ++ HW_CLK_DIV_4 = 0x4, ++ HW_CLK_DIV_6 = 0x6, ++ HW_CLK_DIV_8 = 0x8, ++ HW_CLK_DIV_12 = 0xC ++} ; ++ ++/* HW_RstModule: Enumerated Type used to specify the module to be reset */ ++enum HW_RstModule_t { ++ HW_RST1_IVA2, /* Reset the DSP */ ++ HW_RST2_IVA2, /* Reset MMU and LEON HWa */ ++ HW_RST3_IVA2 /* Reset LEON sequencer */ ++} ; ++ ++/* HW_PwrModule: Enumerated Type used to specify the power domain */ ++enum HW_PwrModule_t { ++/* Domains */ ++ HW_PWR_DOMAIN_CORE, ++ HW_PWR_DOMAIN_MPU, ++ HW_PWR_DOMAIN_WAKEUP, ++ HW_PWR_DOMAIN_DSP, ++ ++/* Sub-domains */ ++ HW_PWR_DSP_IPI, /* IPI = Intrusive Port Interface */ ++ HW_PWR_IVA_ISP /* ISP = Intrusive Slave Port */ ++} ; ++ ++enum HW_PwrState_t { ++ HW_PWR_STATE_OFF, ++ HW_PWR_STATE_RET, ++ HW_PWR_STATE_INACT, ++ HW_PWR_STATE_ON = 3 ++} ; ++ ++enum HW_ForceState_t { ++ HW_FORCE_OFF, ++ HW_FORCE_ON ++} ; ++ ++enum HW_IdleState_t { ++ HW_ACTIVE, ++ HW_STANDBY ++ ++} ; ++ ++enum HW_TransitionState_t { ++ HW_AUTOTRANS_DIS, ++ HW_SW_SUP_SLEEP, ++ HW_SW_SUP_WAKEUP, ++ HW_AUTOTRANS_EN ++} ; ++ ++ ++extern HW_STATUS HW_RST_Reset(const u32 baseAddress, ++ enum HW_RstModule_t r); ++ ++extern HW_STATUS HW_RST_UnReset(const u32 baseAddress, ++ enum HW_RstModule_t r); ++ ++extern HW_STATUS HW_RSTCTRL_RegGet(const u32 baseAddress, ++ enum HW_RstModule_t p, ++ u32 *value); ++extern HW_STATUS HW_RSTST_RegGet(const u32 baseAddress, ++ enum HW_RstModule_t p, u32 *value); ++ ++extern HW_STATUS HW_PWR_PowerStateSet(const u32 baseAddress, ++ enum HW_PwrModule_t p, ++ enum HW_PwrState_t value); ++ ++extern HW_STATUS HW_CLK_SetInputClock(const u32 baseAddress, ++ enum HW_GPtimer_t gpt, ++ enum HW_Clocktype_t c); ++ ++extern HW_STATUS HW_PWR_IVA2StateGet(const u32 baseAddress, ++ enum HW_PwrModule_t p, ++ enum HW_PwrState_t *value); ++ ++extern HW_STATUS HW_PWRST_IVA2RegGet(const u32 baseAddress, u32 *value); ++ ++extern HW_STATUS HW_PWR_IVA2PowerStateSet(const u32 baseAddress, ++ enum HW_PwrModule_t p, ++ enum HW_PwrState_t value); ++ ++extern HW_STATUS HW_PWR_CLKCTRL_IVA2RegSet(const u32 baseAddress, ++ enum HW_TransitionState_t val); ++ ++#endif /* __HW_PRCM_H */ +diff --git a/drivers/dsp/bridge/pmgr/chnl.c b/drivers/dsp/bridge/pmgr/chnl.c +new file mode 100644 +index 0000000..6b5a0d9 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/chnl.c +@@ -0,0 +1,260 @@ ++/* ++ * chnl.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnl.c ======== ++ * Description: ++ * WCD channel interface: multiplexes data streams through the single ++ * physical link managed by a 'Bridge mini-driver. ++ * ++ * Public Functions: ++ * CHNL_Close ++ * CHNL_CloseOrphans ++ * CHNL_Create ++ * CHNL_Destroy ++ * CHNL_Exit ++ * CHNL_GetHandle ++ * CHNL_GetProcessHandle ++ * CHNL_Init ++ * CHNL_Open ++ * ++ * Notes: ++ * This interface is basically a pass through to the WMD CHNL functions, ++ * except for the CHNL_Get() accessor functions which call ++ * WMD_CHNL_GetInfo(). ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 07-Jan-2002 ag CHNL_CloseOrphans() now closes supported # of channels. ++ *! 17-Nov-2000 jeh Removed IRQ, shared memory stuff from CHNL_Create. ++ *! 28-Feb-2000 rr: New GT USage Implementation ++ *! 03-Feb-2000 rr: GT and Module init/exit Changes.(Done up front from ++ *! SERVICES) ++ *! 21-Jan-2000 ag: Added code review comments. ++ *! 13-Jan-2000 rr: CFG_Get/SetPrivateDword renamed to CFG_Get/SetDevObject. ++ *! 08-Dec-1999 ag: CHNL_[Alloc|Free]Buffer bufs taken from client process heap. ++ *! 02-Dec-1999 ag: Implemented CHNL_GetEventHandle(). ++ *! 17-Nov-1999 ag: CHNL_AllocBuffer() allocs extra word for process mapping. ++ *! 28-Oct-1999 ag: WinCE port. Search for "WinCE" for changes(TBR). ++ *! 07-Jan-1998 gp: CHNL_[Alloc|Free]Buffer now call MEM_UMB functions. ++ *! 22-Oct-1997 gp: Removed requirement in CHNL_Open that hReserved1 != NULL. ++ *! 30-Aug-1997 cr: Renamed cfg.h wbwcd.h b/c of WINNT file name collision. ++ *! 10-Mar-1997 gp: Added GT trace. ++ *! 14-Jan-1997 gp: Updated based on code review feedback. ++ *! 03-Jan-1997 gp: Moved CHNL_AllocBuffer/CHNL_FreeBuffer code from udspsys. ++ *! 14-Dec-1996 gp: Added uChnlId parameter to CHNL_Open(). ++ *! 09-Sep-1996 gp: Added CHNL_GetProcessHandle(). ++ *! 15-Jul-1996 gp: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/dpc.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/proc.h> ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/chnlpriv.h> ++#include <chnlobj.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/chnl.h> ++ ++/* ----------------------------------- Globals */ ++static u32 cRefs; ++#if GT_TRACE ++static struct GT_Mask CHNL_DebugMask = { NULL, NULL }; /* WCD CHNL Mask */ ++#endif ++ ++ ++ ++/* ++ * ======== CHNL_Create ======== ++ * Purpose: ++ * Create a channel manager object, responsible for opening new channels ++ * and closing old ones for a given 'Bridge board. ++ */ ++DSP_STATUS CHNL_Create(OUT struct CHNL_MGR **phChnlMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CHNL_MGRATTRS *pMgrAttrs) ++{ ++ DSP_STATUS status; ++ struct CHNL_MGR *hChnlMgr; ++ struct CHNL_MGR_ *pChnlMgr = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phChnlMgr != NULL); ++ DBC_Require(pMgrAttrs != NULL); ++ ++ GT_3trace(CHNL_DebugMask, GT_ENTER, ++ "Entered CHNL_Create: phChnlMgr: 0x%x\t" ++ "hDevObject: 0x%x\tpMgrAttrs:0x%x\n", ++ phChnlMgr, hDevObject, pMgrAttrs); ++ ++ *phChnlMgr = NULL; ++ ++ /* Validate args: */ ++ if ((0 < pMgrAttrs->cChannels) && ++ (pMgrAttrs->cChannels <= CHNL_MAXCHANNELS)) { ++ status = DSP_SOK; ++ } else if (pMgrAttrs->cChannels == 0) { ++ status = DSP_EINVALIDARG; ++ GT_0trace(CHNL_DebugMask, GT_7CLASS, ++ "CHNL_Create:Invalid Args\n"); ++ } else { ++ status = CHNL_E_MAXCHANNELS; ++ GT_0trace(CHNL_DebugMask, GT_7CLASS, ++ "CHNL_Create:Error Max Channels\n"); ++ } ++ if (pMgrAttrs->uWordSize == 0) { ++ status = CHNL_E_INVALIDWORDSIZE; ++ GT_0trace(CHNL_DebugMask, GT_7CLASS, ++ "CHNL_Create:Invalid Word size\n"); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetChnlMgr(hDevObject, &hChnlMgr); ++ if (DSP_SUCCEEDED(status) && hChnlMgr != NULL) ++ status = CHNL_E_MGREXISTS; ++ ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DEV_GetIntfFxns(hDevObject, &pIntfFxns); ++ /* Let WMD channel module finish the create: */ ++ status = (*pIntfFxns->pfnChnlCreate)(&hChnlMgr, hDevObject, ++ pMgrAttrs); ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in WCD channel module's fields of the ++ * CHNL_MGR structure */ ++ pChnlMgr = (struct CHNL_MGR_ *)hChnlMgr; ++ pChnlMgr->pIntfFxns = pIntfFxns; ++ /* Finally, return the new channel manager handle: */ ++ *phChnlMgr = hChnlMgr; ++ GT_1trace(CHNL_DebugMask, GT_1CLASS, ++ "CHNL_Create: Success pChnlMgr:" ++ "0x%x\n", pChnlMgr); ++ } ++ } ++ ++ GT_2trace(CHNL_DebugMask, GT_ENTER, ++ "Exiting CHNL_Create: pChnlMgr: 0x%x," ++ "status: 0x%x\n", pChnlMgr, status); ++ DBC_Ensure(DSP_FAILED(status) || CHNL_IsValidMgr(pChnlMgr)); ++ ++ return status; ++} ++ ++/* ++ * ======== CHNL_Destroy ======== ++ * Purpose: ++ * Close all open channels, and destroy the channel manager. ++ */ ++DSP_STATUS CHNL_Destroy(struct CHNL_MGR *hChnlMgr) ++{ ++ struct CHNL_MGR_ *pChnlMgr = (struct CHNL_MGR_ *)hChnlMgr; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(CHNL_DebugMask, GT_ENTER, ++ "Entered CHNL_Destroy: hChnlMgr: 0x%x\n", hChnlMgr); ++ if (CHNL_IsValidMgr(pChnlMgr)) { ++ pIntfFxns = pChnlMgr->pIntfFxns; ++ /* Let WMD channel module destroy the CHNL_MGR: */ ++ status = (*pIntfFxns->pfnChnlDestroy)(hChnlMgr); ++ } else { ++ GT_0trace(CHNL_DebugMask, GT_7CLASS, ++ "CHNL_Destroy:Invalid Handle\n"); ++ status = DSP_EHANDLE; ++ } ++ ++ GT_2trace(CHNL_DebugMask, GT_ENTER, ++ "Exiting CHNL_Destroy: pChnlMgr: 0x%x," ++ " status:0x%x\n", pChnlMgr, status); ++ DBC_Ensure(DSP_FAILED(status) || !CHNL_IsValidMgr(pChnlMgr)); ++ ++ return status; ++} ++ ++/* ++ * ======== CHNL_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CHNL module. ++ */ ++void CHNL_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(CHNL_DebugMask, GT_5CLASS, ++ "Entered CHNL_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++ ++/* ++ * ======== CHNL_Init ======== ++ * Purpose: ++ * Initialize the CHNL module's private state. ++ */ ++bool CHNL_Init(void) ++{ ++ bool fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!CHNL_DebugMask.flags); ++ GT_create(&CHNL_DebugMask, "CH"); /* "CH" for CHannel */ ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ GT_1trace(CHNL_DebugMask, GT_5CLASS, ++ "Entered CHNL_Init, ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++ +diff --git a/drivers/dsp/bridge/pmgr/chnlobj.h b/drivers/dsp/bridge/pmgr/chnlobj.h +new file mode 100644 +index 0000000..da74c96 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/chnlobj.h +@@ -0,0 +1,71 @@ ++/* ++ * chnlobj.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnlobj.h ======== ++ * Description: ++ * Structure subcomponents of channel class library channel objects which ++ * are exposed to class driver from mini-driver. ++ * ++ * Public Functions: ++ * None. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 17-Nov-2000 jeh Removed some fields from CHNL_MGR_ to match CHNL_MGR ++ *! structure defined in _chnl_sm.h. ++ *! 16-Jan-1997 gp: Created from chnlpriv.h ++ */ ++ ++#ifndef CHNLOBJ_ ++#define CHNLOBJ_ ++ ++#include <dspbridge/chnldefs.h> ++#include <dspbridge/wmd.h> ++ ++/* Object validateion macros: */ ++#define CHNL_IsValidMgr(h) \ ++ ((h != NULL) && ((h)->dwSignature == CHNL_MGRSIGNATURE)) ++ ++#define CHNL_IsValidChnl(h)\ ++ ((h != NULL) && ((h)->dwSignature == CHNL_SIGNATURE)) ++ ++/* ++ * This struct is the first field in a CHNL_MGR struct, as implemented in ++ * a WMD channel class library. Other, implementation specific fields ++ * follow this structure in memory. ++ */ ++struct CHNL_MGR_ { ++ /* These must be the first fields in a CHNL_MGR struct: */ ++ u32 dwSignature; /* Used for object validation. */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD. */ ++} ; ++ ++/* ++ * This struct is the first field in a CHNL_OBJECT struct, as implemented in ++ * a WMD channel class library. Other, implementation specific fields ++ * follow this structure in memory. ++ */ ++struct CHNL_OBJECT_ { ++ /* These must be the first fields in a CHNL_OBJECT struct: */ ++ u32 dwSignature; /* Used for object validation. */ ++ struct CHNL_MGR_ *pChnlMgr; /* Pointer back to channel manager. */ ++} ; ++ ++#endif /* CHNLOBJ_ */ ++ +diff --git a/drivers/dsp/bridge/pmgr/cmm.c b/drivers/dsp/bridge/pmgr/cmm.c +new file mode 100644 +index 0000000..99a2432 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/cmm.c +@@ -0,0 +1,1291 @@ ++/* ++ * cmm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cmm.c ======== ++ * Purpose: ++ * The Communication(Shared) Memory Management(CMM) module provides ++ * shared memory management services for DSP/BIOS Bridge data streaming ++ * and messaging. ++ * ++ * Multiple shared memory segments can be registered with CMM. ++ * Each registered SM segment is represented by a SM "allocator" that ++ * describes a block of physically contiguous shared memory used for ++ * future allocations by CMM. ++ * ++ * Memory is coelesced back to the appropriate heap when a buffer is ++ * freed. ++ * ++ * Public Functions: ++ * CMM_CallocBuf ++ * CMM_Create ++ * CMM_Destroy ++ * CMM_Exit ++ * CMM_FreeBuf ++ * CMM_GetHandle ++ * CMM_GetInfo ++ * CMM_Init ++ * CMM_RegisterGPPSMSeg ++ * CMM_UnRegisterGPPSMSeg ++ * ++ * The CMM_Xlator[xxx] routines below are used by Node and Stream ++ * to perform SM address translation to the client process address space. ++ * A "translator" object is created by a node/stream for each SM seg used. ++ * ++ * Translator Routines: ++ * CMM_XlatorAllocBuf ++ * CMM_XlatorCreate ++ * CMM_XlatorDelete ++ * CMM_XlatorFreeBuf ++ * CMM_XlatorInfo ++ * CMM_XlatorTranslate ++ * ++ * Private Functions: ++ * AddToFreeList ++ * GetAllocator ++ * GetFreeBlock ++ * GetNode ++ * GetSlot ++ * UnRegisterGPPSMSeg ++ * ++ * Notes: ++ * Va: Virtual address. ++ * Pa: Physical or kernel system address. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 16-Feb-2002 ag Code review cleanup. ++ *! PreOMAP address translation no longner supported. ++ *! 30-Jan-2002 ag Updates to CMM_XlatorTranslate() per TII, ANSI C++ ++ *! warnings. ++ *! 27-Jan-2002 ag Removed unused CMM_[Alloc][Free]Desc() & #ifdef USELOOKUP, ++ *! & unused VALIDATECMM and VaPaConvert(). ++ *! Removed bFastXlate from CMM_XLATOR. Always fast lookup. ++ *! 03-Jan-2002 ag Clear SM in CMM_AllocBuf(). Renamed to CMM_CallocBuf(). ++ *! 13-Nov-2001 ag Now delete pNodeFreeListHead and nodes in CMM_Destroy(). ++ *! 28-Aug-2001 ag CMM_GetHandle() returns CMM Mgr hndle given HPROCESSOR. ++ *! Removed unused CMM_[Un]RegisterDSPSMSeg() & ++ * CMM_[Un}ReserveVirtSpace fxns. Some cleanup. ++ *! 12-Aug-2001 ag Exposed CMM_UnRegisterGPP[DSP]SMSeg. ++ *! 13-Feb-2001 kc DSP/BIOS Bridge name update. ++ *! 21-Dec-2000 rr GetFreeBlock checks for pAllocator. ++ *! 09-Dec-2000 ag Added GPPPA2DSPPA, DSPPA2GPPPA macros. ++ *! 05-Dec-2000 ag CMM_XlatorDelete() optionally frees SM bufs and descriptors. ++ *! 30-Oct-2000 ag Buf size bug fixed in CMM_AllocBuf() causing leak. ++ *! Revamped XlatorTranslate() routine. ++ *! 10-Oct-2000 ag Added CMM_Xlator[xxx] functions. ++ *! 02-Aug-2000 ag Created. ++ *! ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/errbase.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/util.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/proc.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/cmm.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++/* Object signatures */ ++#define CMMSIGNATURE 0x004d4d43 /* "CMM" (in reverse) */ ++#define SMEMSIGNATURE 0x4D454D53 /* "SMEM" SM space */ ++#define CMMXLATESIGNATURE 0x584d4d43 /* "CMMX" CMM Xlator */ ++ ++#define NEXT_PA(pNode) (pNode->dwPA + pNode->ulSize) ++ ++/* Other bus/platform translations */ ++#define DSPPA2GPPPA(base, x, y) ((x)+(y)) ++#define GPPPA2DSPPA(base, x, y) ((x)-(y)) ++ ++/* ++ * Allocators define a block of contiguous memory used for future allocations. ++ * ++ * sma - shared memory allocator. ++ * vma - virtual memory allocator.(not used). ++ */ ++struct CMM_ALLOCATOR { /* sma */ ++ u32 dwSignature; /* SMA allocator signature SMEMSIGNATURE */ ++ unsigned int dwSmBase; /* Start of physical SM block */ ++ u32 ulSmSize; /* Size of SM block in bytes */ ++ unsigned int dwVmBase; /* Start of VM block. (Dev driver ++ * context for 'sma') */ ++ u32 dwDSPPhysAddrOffset; /* DSP PA to GPP PA offset for this ++ * SM space */ ++ /* CMM_ADDTO[SUBFROM]DSPPA, _POMAPEMIF2DSPBUS */ ++ enum CMM_CNVTTYPE cFactor; ++ unsigned int dwDSPBase; /* DSP virt base byte address */ ++ u32 ulDSPSize; /* DSP seg size in bytes */ ++ struct CMM_OBJECT *hCmmMgr; /* back ref to parent mgr */ ++ struct LST_LIST *pFreeListHead; /* node list of available memory */ ++ struct LST_LIST *pInUseListHead; /* node list of memory in use */ ++} ; ++ ++struct CMM_XLATOR { /* Pa<->Va translator object */ ++ u32 dwSignature; /* "CMMX" */ ++ struct CMM_OBJECT *hCmmMgr; /* CMM object this translator associated */ ++ /* ++ * Client process virtual base address that corresponds to phys SM ++ * base address for translator's ulSegId. ++ * Only 1 segment ID currently supported. ++ */ ++ unsigned int dwVirtBase; /* virtual base address */ ++ u32 ulVirtSize; /* size of virt space in bytes */ ++ u32 ulSegId; /* Segment Id */ ++} ; ++ ++/* CMM Mgr */ ++struct CMM_OBJECT { ++ u32 dwSignature; /* Used for object validation */ ++ /* ++ * Cmm Lock is used to serialize access mem manager for multi-threads. ++ */ ++ struct SYNC_CSOBJECT *hCmmLock; /* Lock to access cmm mgr */ ++ struct LST_LIST *pNodeFreeListHead; /* Free list of memory nodes */ ++ u32 ulMinBlockSize; /* Min SM block; default 16 bytes */ ++ u32 dwPageSize; /* Memory Page size (1k/4k) */ ++ /* GPP SM segment ptrs */ ++ struct CMM_ALLOCATOR *paGPPSMSegTab[CMM_MAXGPPSEGS]; ++} ; ++ ++/* Default CMM Mgr attributes */ ++static struct CMM_MGRATTRS CMM_DFLTMGRATTRS = { ++ 16 /* ulMinBlockSize, min block size(bytes) allocated by cmm mgr */ ++}; ++ ++/* Default allocation attributes */ ++static struct CMM_ATTRS CMM_DFLTALCTATTRS = { ++ 1 /* ulSegId, default segment Id for allocator */ ++}; ++ ++/* Address translator default attrs */ ++static struct CMM_XLATORATTRS CMM_DFLTXLATORATTRS = { ++ 1, /* ulSegId, does not have to match CMM_DFLTALCTATTRS ulSegId */ ++ 0, /* dwDSPBufs */ ++ 0, /* dwDSPBufSize */ ++ NULL, /* pVmBase */ ++ 0, /* dwVmSize */ ++}; ++ ++/* SM node representing a block of memory. */ ++struct CMM_MNODE { ++ struct LST_ELEM link; /* must be 1st element */ ++ u32 dwPA; /* Phys addr */ ++ u32 dwVA; /* Virtual address in device process context */ ++ u32 ulSize; /* SM block size in bytes */ ++ u32 hClientProc; /* Process that allocated this mem block */ ++} ; ++ ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask CMM_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++/* ----------------------------------- Function Prototypes */ ++static void AddToFreeList(struct CMM_ALLOCATOR *pAllocator, ++ struct CMM_MNODE *pNode); ++static struct CMM_ALLOCATOR *GetAllocator(struct CMM_OBJECT *pCmmMgr, ++ u32 ulSegId); ++static struct CMM_MNODE *GetFreeBlock(struct CMM_ALLOCATOR *pAllocator, ++ u32 uSize); ++static struct CMM_MNODE *GetNode(struct CMM_OBJECT *pCmmMgr, u32 dwPA, ++ u32 dwVA, u32 ulSize); ++/* get available slot for new allocator */ ++static s32 GetSlot(struct CMM_OBJECT *hCmmMgr); ++static void UnRegisterGPPSMSeg(struct CMM_ALLOCATOR *pSMA); ++ ++/* ++ * ======== CMM_CallocBuf ======== ++ * Purpose: ++ * Allocate a SM buffer, zero contents, and return the physical address ++ * and optional driver context virtual address(ppBufVA). ++ * ++ * The freelist is sorted in increasing size order. Get the first ++ * block that satifies the request and sort the remaining back on ++ * the freelist; if large enough. The kept block is placed on the ++ * inUseList. ++ */ ++void *CMM_CallocBuf(struct CMM_OBJECT *hCmmMgr, u32 uSize, ++ struct CMM_ATTRS *pAttrs, OUT void **ppBufVA) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ void *pBufPA = NULL; ++ struct CMM_MNODE *pNode = NULL; ++ struct CMM_MNODE *pNewNode = NULL; ++ struct CMM_ALLOCATOR *pAllocator = NULL; ++ u32 uDeltaSize; ++ u8 *pByte = NULL; ++ s32 cnt; ++ ++ if (pAttrs == NULL) ++ pAttrs = &CMM_DFLTALCTATTRS; ++ ++ if (ppBufVA != NULL) ++ *ppBufVA = NULL; ++ ++ if ((MEM_IsValidHandle(pCmmMgr, CMMSIGNATURE)) && (uSize != 0)) { ++ if (pAttrs->ulSegId > 0) { ++ /* SegId > 0 is SM */ ++ /* get the allocator object for this segment id */ ++ pAllocator = GetAllocator(pCmmMgr, pAttrs->ulSegId); ++ /* keep block size a multiple of ulMinBlockSize */ ++ uSize = ((uSize - 1) & ~(pCmmMgr->ulMinBlockSize - 1)) ++ + pCmmMgr->ulMinBlockSize; ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ pNode = GetFreeBlock(pAllocator, uSize); ++ } ++ if (pNode) { ++ uDeltaSize = (pNode->ulSize - uSize); ++ if (uDeltaSize >= pCmmMgr->ulMinBlockSize) { ++ /* create a new block with the leftovers and ++ * add to freelist */ ++ pNewNode = GetNode(pCmmMgr, pNode->dwPA + uSize, ++ pNode->dwVA + uSize, ++ (u32)uDeltaSize); ++ /* leftovers go free */ ++ AddToFreeList(pAllocator, pNewNode); ++ /* adjust our node's size */ ++ pNode->ulSize = uSize; ++ } ++ /* Tag node with client process requesting allocation ++ * We'll need to free up a process's alloc'd SM if the ++ * client process goes away. ++ */ ++ /* Return PID instead of process handle */ ++ pNode->hClientProc = current->pid; ++ ++ /* put our node on InUse list */ ++ LST_PutTail(pAllocator->pInUseListHead, ++ (struct LST_ELEM *)pNode); ++ pBufPA = (void *)pNode->dwPA; /* physical address */ ++ /* clear mem */ ++ pByte = (u8 *)pNode->dwVA; ++ for (cnt = 0; cnt < (s32) uSize; cnt++, pByte++) ++ *pByte = 0; ++ ++ if (ppBufVA != NULL) { ++ /* Virtual address */ ++ *ppBufVA = (void *)pNode->dwVA; ++ } ++ } ++ GT_3trace(CMM_debugMask, GT_3CLASS, ++ "CMM_CallocBuf dwPA %x, dwVA %x uSize" ++ "%x\n", pNode->dwPA, pNode->dwVA, uSize); ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ } ++ return pBufPA; ++} ++ ++/* ++ * ======== CMM_Create ======== ++ * Purpose: ++ * Create a communication memory manager object. ++ */ ++DSP_STATUS CMM_Create(OUT struct CMM_OBJECT **phCmmMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CMM_MGRATTRS *pMgrAttrs) ++{ ++ struct CMM_OBJECT *pCmmObject = NULL; ++ DSP_STATUS status = DSP_SOK; ++ struct UTIL_SYSINFO sysInfo; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phCmmMgr != NULL); ++ ++ GT_3trace(CMM_debugMask, GT_ENTER, ++ "CMM_Create: phCmmMgr: 0x%x\thDevObject: " ++ "0x%x\tpMgrAttrs: 0x%x\n", phCmmMgr, hDevObject, pMgrAttrs); ++ *phCmmMgr = NULL; ++ /* create, zero, and tag a cmm mgr object */ ++ MEM_AllocObject(pCmmObject, struct CMM_OBJECT, CMMSIGNATURE); ++ if (pCmmObject != NULL) { ++ if (pMgrAttrs == NULL) ++ pMgrAttrs = &CMM_DFLTMGRATTRS; /* set defaults */ ++ ++ /* 4 bytes minimum */ ++ DBC_Assert(pMgrAttrs->ulMinBlockSize >= 4); ++ /* save away smallest block allocation for this cmm mgr */ ++ pCmmObject->ulMinBlockSize = pMgrAttrs->ulMinBlockSize; ++ /* save away the systems memory page size */ ++ sysInfo.dwPageSize = PAGE_SIZE; ++ sysInfo.dwAllocationGranularity = PAGE_SIZE; ++ sysInfo.dwNumberOfProcessors = 1; ++ if (DSP_SUCCEEDED(status)) { ++ GT_1trace(CMM_debugMask, GT_5CLASS, ++ "CMM_Create: Got system page size" ++ "= 0x%x\t\n", sysInfo.dwPageSize); ++ pCmmObject->dwPageSize = sysInfo.dwPageSize; ++ } else { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_Create: failed to get system" ++ "page size\n"); ++ pCmmObject->dwPageSize = 0; ++ status = DSP_EFAIL; ++ } ++ /* Note: DSP SM seg table(aDSPSMSegTab[]) zero'd by ++ * MEM_AllocObject */ ++ if (DSP_SUCCEEDED(status)) { ++ /* create node free list */ ++ pCmmObject->pNodeFreeListHead = LST_Create(); ++ if (pCmmObject->pNodeFreeListHead == NULL) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_Create: LST_Create() " ++ "failed \n"); ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_InitializeCS(&pCmmObject->hCmmLock); ++ ++ if (DSP_SUCCEEDED(status)) ++ *phCmmMgr = pCmmObject; ++ else ++ CMM_Destroy(pCmmObject, true); ++ ++ } else { ++ GT_0trace(CMM_debugMask, GT_6CLASS, ++ "CMM_Create: Object Allocation " ++ "Failure(CMM Object)\n"); ++ status = DSP_EMEMORY; ++ } ++ return status; ++} ++ ++/* ++ * ======== CMM_Destroy ======== ++ * Purpose: ++ * Release the communication memory manager resources. ++ */ ++DSP_STATUS CMM_Destroy(struct CMM_OBJECT *hCmmMgr, bool bForce) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ struct CMM_INFO tempInfo; ++ DSP_STATUS status = DSP_SOK; ++ s32 nSlot; ++ struct CMM_MNODE *pNode; ++ ++ DBC_Require(cRefs > 0); ++ if (!MEM_IsValidHandle(hCmmMgr, CMMSIGNATURE)) { ++ status = DSP_EHANDLE; ++ return status; ++ } ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ /* If not force then fail if outstanding allocations exist */ ++ if (!bForce) { ++ /* Check for outstanding memory allocations */ ++ status = CMM_GetInfo(hCmmMgr, &tempInfo); ++ if (DSP_SUCCEEDED(status)) { ++ if (tempInfo.ulTotalInUseCnt > 0) { ++ /* outstanding allocations */ ++ status = DSP_EFAIL; ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* UnRegister SM allocator */ ++ for (nSlot = 0; nSlot < CMM_MAXGPPSEGS; nSlot++) { ++ if (pCmmMgr->paGPPSMSegTab[nSlot] != NULL) { ++ UnRegisterGPPSMSeg(pCmmMgr-> ++ paGPPSMSegTab[nSlot]); ++ /* Set slot to NULL for future reuse */ ++ pCmmMgr->paGPPSMSegTab[nSlot] = NULL; ++ } ++ } ++ } ++ if (pCmmMgr->pNodeFreeListHead != NULL) { ++ /* Free the free nodes */ ++ while (!LST_IsEmpty(pCmmMgr->pNodeFreeListHead)) { ++ /* (struct LST_ELEM*) pNode = ++ * LST_GetHead(pCmmMgr->pNodeFreeListHead);*/ ++ pNode = (struct CMM_MNODE *)LST_GetHead(pCmmMgr-> ++ pNodeFreeListHead); ++ MEM_Free(pNode); ++ } ++ /* delete NodeFreeList list */ ++ LST_Delete(pCmmMgr->pNodeFreeListHead); ++ } ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ if (DSP_SUCCEEDED(status)) { ++ /* delete CS & cmm mgr object */ ++ SYNC_DeleteCS(pCmmMgr->hCmmLock); ++ MEM_FreeObject(pCmmMgr); ++ } ++ return status; ++} ++ ++/* ++ * ======== CMM_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ */ ++void CMM_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(CMM_debugMask, GT_ENTER, ++ "exiting CMM_Exit,ref count:0x%x\n", cRefs); ++} ++ ++/* ++ * ======== CMM_FreeBuf ======== ++ * Purpose: ++ * Free the given buffer. ++ */ ++DSP_STATUS CMM_FreeBuf(struct CMM_OBJECT *hCmmMgr, void *pBufPA, u32 ulSegId) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ DSP_STATUS status = DSP_EPOINTER; ++ struct CMM_MNODE *pCurNode = NULL; ++ struct CMM_ALLOCATOR *pAllocator = NULL; ++ struct CMM_ATTRS *pAttrs; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBufPA != NULL); ++ GT_1trace(CMM_debugMask, GT_ENTER, "CMM_FreeBuf pBufPA %x\n", pBufPA); ++ if (ulSegId == 0) { ++ pAttrs = &CMM_DFLTALCTATTRS; ++ ulSegId = pAttrs->ulSegId; ++ } ++ if (!(MEM_IsValidHandle(hCmmMgr, CMMSIGNATURE)) || !(ulSegId > 0)) { ++ status = DSP_EHANDLE; ++ return status; ++ } ++ /* get the allocator for this segment id */ ++ pAllocator = GetAllocator(pCmmMgr, ulSegId); ++ if (pAllocator != NULL) { ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ pCurNode = (struct CMM_MNODE *)LST_First(pAllocator-> ++ pInUseListHead); ++ while (pCurNode) { ++ if ((u32)pBufPA == pCurNode->dwPA) { ++ /* Found it */ ++ LST_RemoveElem(pAllocator->pInUseListHead, ++ (struct LST_ELEM *)pCurNode); ++ /* back to freelist */ ++ AddToFreeList(pAllocator, pCurNode); ++ status = DSP_SOK; /* all right! */ ++ break; ++ } ++ /* next node. */ ++ pCurNode = (struct CMM_MNODE *)LST_Next(pAllocator-> ++ pInUseListHead, (struct LST_ELEM *)pCurNode); ++ } ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ } ++ return status; ++} ++ ++/* ++ * ======== CMM_GetHandle ======== ++ * Purpose: ++ * Return the communication memory manager object for this device. ++ * This is typically called from the client process. ++ */ ++DSP_STATUS CMM_GetHandle(DSP_HPROCESSOR hProcessor, ++ OUT struct CMM_OBJECT **phCmmMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phCmmMgr != NULL); ++ if (hProcessor != NULL) ++ status = PROC_GetDevObject(hProcessor, &hDevObject); ++ else ++ hDevObject = DEV_GetFirst(); /* default */ ++ ++ if (DSP_SUCCEEDED(status)) ++ status = DEV_GetCmmMgr(hDevObject, phCmmMgr); ++ ++ return status; ++} ++ ++/* ++ * ======== CMM_GetInfo ======== ++ * Purpose: ++ * Return the current memory utilization information. ++ */ ++DSP_STATUS CMM_GetInfo(struct CMM_OBJECT *hCmmMgr, ++ OUT struct CMM_INFO *pCmmInfo) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ u32 ulSeg; ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_ALLOCATOR *pAltr; ++ struct CMM_MNODE *pCurNode = NULL; ++ ++ DBC_Require(pCmmInfo != NULL); ++ ++ if (!MEM_IsValidHandle(hCmmMgr, CMMSIGNATURE)) { ++ status = DSP_EHANDLE; ++ return status; ++ } ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ pCmmInfo->ulNumGPPSMSegs = 0; /* # of SM segments */ ++ pCmmInfo->ulTotalInUseCnt = 0; /* Total # of outstanding alloc */ ++ pCmmInfo->ulMinBlockSize = pCmmMgr->ulMinBlockSize; /* min block size */ ++ /* check SM memory segments */ ++ for (ulSeg = 1; ulSeg <= CMM_MAXGPPSEGS; ulSeg++) { ++ /* get the allocator object for this segment id */ ++ pAltr = GetAllocator(pCmmMgr, ulSeg); ++ if (pAltr != NULL) { ++ pCmmInfo->ulNumGPPSMSegs++; ++ pCmmInfo->segInfo[ulSeg - 1].dwSegBasePa = ++ pAltr->dwSmBase - pAltr->ulDSPSize; ++ pCmmInfo->segInfo[ulSeg - 1].ulTotalSegSize = ++ pAltr->ulDSPSize + pAltr->ulSmSize; ++ pCmmInfo->segInfo[ulSeg - 1].dwGPPBasePA = ++ pAltr->dwSmBase; ++ pCmmInfo->segInfo[ulSeg - 1].ulGPPSize = ++ pAltr->ulSmSize; ++ pCmmInfo->segInfo[ulSeg - 1].dwDSPBaseVA = ++ pAltr->dwDSPBase; ++ pCmmInfo->segInfo[ulSeg - 1].ulDSPSize = ++ pAltr->ulDSPSize; ++ pCmmInfo->segInfo[ulSeg - 1].dwSegBaseVa = ++ pAltr->dwVmBase - pAltr->ulDSPSize; ++ pCmmInfo->segInfo[ulSeg - 1].ulInUseCnt = 0; ++ pCurNode = (struct CMM_MNODE *)LST_First(pAltr-> ++ pInUseListHead); ++ /* Count inUse blocks */ ++ while (pCurNode) { ++ pCmmInfo->ulTotalInUseCnt++; ++ pCmmInfo->segInfo[ulSeg - 1].ulInUseCnt++; ++ /* next node. */ ++ pCurNode = (struct CMM_MNODE *)LST_Next(pAltr-> ++ pInUseListHead, ++ (struct LST_ELEM *)pCurNode); ++ } ++ } ++ } /* end for */ ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ return status; ++} ++ ++/* ++ * ======== CMM_Init ======== ++ * Purpose: ++ * Initializes private state of CMM module. ++ */ ++bool CMM_Init(void) ++{ ++ bool fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ if (cRefs == 0) { ++ /* Set the Trace mask */ ++ /* "CM" for Comm Memory manager */ ++ GT_create(&CMM_debugMask, "CM"); ++ } ++ if (fRetval) ++ cRefs++; ++ ++ GT_1trace(CMM_debugMask, GT_ENTER, ++ "Entered CMM_Init,ref count:0x%x\n", cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++/* ++ * ======== CMM_RegisterGPPSMSeg ======== ++ * Purpose: ++ * Register a block of SM with the CMM to be used for later GPP SM ++ * allocations. ++ */ ++DSP_STATUS CMM_RegisterGPPSMSeg(struct CMM_OBJECT *hCmmMgr, u32 dwGPPBasePA, ++ u32 ulSize, u32 dwDSPAddrOffset, ++ enum CMM_CNVTTYPE cFactor, u32 dwDSPBase, ++ u32 ulDSPSize, u32 *pulSegId, ++ u32 dwGPPBaseVA) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ struct CMM_ALLOCATOR *pSMA = NULL; ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_MNODE *pNewNode; ++ s32 nSlot; ++ ++ DBC_Require(ulSize > 0); ++ DBC_Require(pulSegId != NULL); ++ DBC_Require(dwGPPBasePA != 0); ++ DBC_Require(dwGPPBaseVA != 0); ++ DBC_Require((cFactor <= CMM_ADDTODSPPA) && ++ (cFactor >= CMM_SUBFROMDSPPA)); ++ GT_6trace(CMM_debugMask, GT_ENTER, ++ "CMM_RegisterGPPSMSeg dwGPPBasePA %x " ++ "ulSize %x dwDSPAddrOffset %x dwDSPBase %x ulDSPSize %x " ++ "dwGPPBaseVA %x\n", dwGPPBasePA, ulSize, dwDSPAddrOffset, ++ dwDSPBase, ulDSPSize, dwGPPBaseVA); ++ if (!MEM_IsValidHandle(hCmmMgr, CMMSIGNATURE)) { ++ status = DSP_EHANDLE; ++ return status; ++ } ++ /* make sure we have room for another allocator */ ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ nSlot = GetSlot(pCmmMgr); ++ if (nSlot < 0) { ++ /* get a slot number */ ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ /* Check if input ulSize is big enough to alloc at least one block */ ++ if (DSP_SUCCEEDED(status)) { ++ if (ulSize < pCmmMgr->ulMinBlockSize) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_RegisterGPPSMSeg: " ++ "ulSize too small\n"); ++ status = DSP_EINVALIDARG; ++ goto func_end; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* create, zero, and tag an SM allocator object */ ++ MEM_AllocObject(pSMA, struct CMM_ALLOCATOR, SMEMSIGNATURE); ++ } ++ if (pSMA != NULL) { ++ pSMA->hCmmMgr = hCmmMgr; /* ref to parent */ ++ pSMA->dwSmBase = dwGPPBasePA; /* SM Base phys */ ++ pSMA->ulSmSize = ulSize; /* SM segment size in bytes */ ++ pSMA->dwVmBase = dwGPPBaseVA; ++ pSMA->dwDSPPhysAddrOffset = dwDSPAddrOffset; ++ pSMA->cFactor = cFactor; ++ pSMA->dwDSPBase = dwDSPBase; ++ pSMA->ulDSPSize = ulDSPSize; ++ if (pSMA->dwVmBase == 0) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_RegisterGPPSMSeg: Error" ++ "MEM_LinearAddress()\n"); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* return the actual segment identifier */ ++ *pulSegId = (u32) nSlot + 1; ++ /* create memory free list */ ++ pSMA->pFreeListHead = LST_Create(); ++ if (pSMA->pFreeListHead == NULL) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_RegisterGPPSMSeg: " ++ "Out Of Memory \n"); ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* create memory in-use list */ ++ pSMA->pInUseListHead = LST_Create(); ++ if (pSMA->pInUseListHead == NULL) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_RegisterGPPSMSeg: " ++ "LST_Create failed\n"); ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get a mem node for this hunk-o-memory */ ++ pNewNode = GetNode(pCmmMgr, dwGPPBasePA, ++ pSMA->dwVmBase, ulSize); ++ /* Place node on the SM allocator's free list */ ++ if (pNewNode) { ++ LST_PutTail(pSMA->pFreeListHead, ++ (struct LST_ELEM *)pNewNode); ++ } else { ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ } ++ if (DSP_FAILED(status)) { ++ /* Cleanup allocator */ ++ UnRegisterGPPSMSeg(pSMA); ++ } ++ } else { ++ GT_0trace(CMM_debugMask, GT_6CLASS, ++ "CMM_RegisterGPPSMSeg: SMA Object " ++ "Allocation Failure\n"); ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ /* make entry */ ++ if (DSP_SUCCEEDED(status)) ++ pCmmMgr->paGPPSMSegTab[nSlot] = pSMA; ++ ++func_end: ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ return status; ++} ++ ++/* ++ * ======== CMM_UnRegisterGPPSMSeg ======== ++ * Purpose: ++ * UnRegister GPP SM segments with the CMM. ++ */ ++DSP_STATUS CMM_UnRegisterGPPSMSeg(struct CMM_OBJECT *hCmmMgr, u32 ulSegId) ++{ ++ struct CMM_OBJECT *pCmmMgr = (struct CMM_OBJECT *)hCmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_ALLOCATOR *pSMA; ++ u32 ulId = ulSegId; ++ ++ DBC_Require(ulSegId > 0); ++ if (MEM_IsValidHandle(hCmmMgr, CMMSIGNATURE)) { ++ if (ulSegId == CMM_ALLSEGMENTS) ++ ulId = 1; ++ ++ if ((ulId > 0) && (ulId <= CMM_MAXGPPSEGS)) { ++ while (ulId <= CMM_MAXGPPSEGS) { ++ SYNC_EnterCS(pCmmMgr->hCmmLock); ++ /* slot = segId-1 */ ++ pSMA = pCmmMgr->paGPPSMSegTab[ulId - 1]; ++ if (pSMA != NULL) { ++ UnRegisterGPPSMSeg(pSMA); ++ /* Set alctr ptr to NULL for future ++ * reuse */ ++ pCmmMgr->paGPPSMSegTab[ulId - 1] = NULL; ++ } else if (ulSegId != CMM_ALLSEGMENTS) { ++ status = DSP_EFAIL; ++ } ++ SYNC_LeaveCS(pCmmMgr->hCmmLock); ++ if (ulSegId != CMM_ALLSEGMENTS) ++ break; ++ ++ ulId++; ++ } /* end while */ ++ } else { ++ status = DSP_EINVALIDARG; ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_UnRegisterGPPSMSeg: Bad " ++ "segment Id\n"); ++ } ++ } else { ++ status = DSP_EHANDLE; ++ } ++ return status; ++} ++ ++/* ++ * ======== UnRegisterGPPSMSeg ======== ++ * Purpose: ++ * UnRegister the SM allocator by freeing all its resources and ++ * nulling cmm mgr table entry. ++ * Note: ++ * This routine is always called within cmm lock crit sect. ++ */ ++static void UnRegisterGPPSMSeg(struct CMM_ALLOCATOR *pSMA) ++{ ++ struct CMM_MNODE *pCurNode = NULL; ++ struct CMM_MNODE *pNextNode = NULL; ++ ++ DBC_Require(pSMA != NULL); ++ if (pSMA->pFreeListHead != NULL) { ++ /* free nodes on free list */ ++ pCurNode = (struct CMM_MNODE *)LST_First(pSMA->pFreeListHead); ++ while (pCurNode) { ++ pNextNode = (struct CMM_MNODE *)LST_Next(pSMA-> ++ pFreeListHead, ++ (struct LST_ELEM *)pCurNode); ++ LST_RemoveElem(pSMA->pFreeListHead, ++ (struct LST_ELEM *)pCurNode); ++ MEM_Free((void *) pCurNode); ++ /* next node. */ ++ pCurNode = pNextNode; ++ } ++ LST_Delete(pSMA->pFreeListHead); /* delete freelist */ ++ /* free nodes on InUse list */ ++ pCurNode = (struct CMM_MNODE *)LST_First(pSMA->pInUseListHead); ++ while (pCurNode) { ++ pNextNode = (struct CMM_MNODE *)LST_Next(pSMA-> ++ pInUseListHead, ++ (struct LST_ELEM *)pCurNode); ++ LST_RemoveElem(pSMA->pInUseListHead, ++ (struct LST_ELEM *)pCurNode); ++ MEM_Free((void *) pCurNode); ++ /* next node. */ ++ pCurNode = pNextNode; ++ } ++ LST_Delete(pSMA->pInUseListHead); /* delete InUse list */ ++ } ++ if ((void *) pSMA->dwVmBase != NULL) ++ MEM_UnmapLinearAddress((void *) pSMA->dwVmBase); ++ ++ /* Free allocator itself */ ++ MEM_FreeObject(pSMA); ++} ++ ++/* ++ * ======== GetSlot ======== ++ * Purpose: ++ * An available slot # is returned. Returns negative on failure. ++ */ ++static s32 GetSlot(struct CMM_OBJECT *pCmmMgr) ++{ ++ s32 nSlot = -1; /* neg on failure */ ++ DBC_Require(pCmmMgr != NULL); ++ /* get first available slot in cmm mgr SMSegTab[] */ ++ for (nSlot = 0; nSlot < CMM_MAXGPPSEGS; nSlot++) { ++ if (pCmmMgr->paGPPSMSegTab[nSlot] == NULL) ++ break; ++ ++ } ++ if (nSlot == CMM_MAXGPPSEGS) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_RegisterGPPSMSeg: Allocator " ++ "entry failure, max exceeded\n"); ++ nSlot = -1; /* failed */ ++ } ++ return nSlot; ++} ++ ++/* ++ * ======== GetNode ======== ++ * Purpose: ++ * Get a memory node from freelist or create a new one. ++ */ ++static struct CMM_MNODE *GetNode(struct CMM_OBJECT *pCmmMgr, u32 dwPA, ++ u32 dwVA, u32 ulSize) ++{ ++ struct CMM_MNODE *pNode = NULL; ++ ++ DBC_Require(pCmmMgr != NULL); ++ DBC_Require(dwPA != 0); ++ DBC_Require(dwVA != 0); ++ DBC_Require(ulSize != 0); ++ /* Check cmm mgr's node freelist */ ++ if (LST_IsEmpty(pCmmMgr->pNodeFreeListHead)) { ++ pNode = (struct CMM_MNODE *)MEM_Calloc(sizeof(struct CMM_MNODE), ++ MEM_PAGED); ++ } else { ++ /* surely a valid element */ ++ /* (struct LST_ELEM*) pNode = LST_GetHead(pCmmMgr-> ++ * pNodeFreeListHead);*/ ++ pNode = (struct CMM_MNODE *)LST_GetHead(pCmmMgr-> ++ pNodeFreeListHead); ++ } ++ if (pNode == NULL) { ++ GT_0trace(CMM_debugMask, GT_7CLASS, "GetNode: Out Of Memory\n"); ++ } else { ++ LST_InitElem((struct LST_ELEM *) pNode); /* set self */ ++ pNode->dwPA = dwPA; /* Physical addr of start of block */ ++ pNode->dwVA = dwVA; /* Virtual " " */ ++ pNode->ulSize = ulSize; /* Size of block */ ++ } ++ return pNode; ++} ++ ++/* ++ * ======== DeleteNode ======== ++ * Purpose: ++ * Put a memory node on the cmm nodelist for later use. ++ * Doesn't actually delete the node. Heap thrashing friendly. ++ */ ++static void DeleteNode(struct CMM_OBJECT *pCmmMgr, struct CMM_MNODE *pNode) ++{ ++ DBC_Require(pNode != NULL); ++ LST_InitElem((struct LST_ELEM *) pNode); /* init .self ptr */ ++ LST_PutTail(pCmmMgr->pNodeFreeListHead, (struct LST_ELEM *) pNode); ++} ++ ++/* ++ * ====== GetFreeBlock ======== ++ * Purpose: ++ * Scan the free block list and return the first block that satisfies ++ * the size. ++ */ ++static struct CMM_MNODE *GetFreeBlock(struct CMM_ALLOCATOR *pAllocator, ++ u32 uSize) ++{ ++ if (pAllocator) { ++ struct CMM_MNODE *pCurNode = (struct CMM_MNODE *) ++ LST_First(pAllocator->pFreeListHead); ++ while (pCurNode) { ++ if (uSize <= (u32) pCurNode->ulSize) { ++ LST_RemoveElem(pAllocator->pFreeListHead, ++ (struct LST_ELEM *)pCurNode); ++ return pCurNode; ++ } ++ /* next node. */ ++ pCurNode = (struct CMM_MNODE *)LST_Next(pAllocator-> ++ pFreeListHead, (struct LST_ELEM *)pCurNode); ++ } ++ } ++ return NULL; ++} ++ ++/* ++ * ======== AddToFreeList ======== ++ * Purpose: ++ * Coelesce node into the freelist in ascending size order. ++ */ ++static void AddToFreeList(struct CMM_ALLOCATOR *pAllocator, ++ struct CMM_MNODE *pNode) ++{ ++ struct CMM_MNODE *pNodePrev = NULL; ++ struct CMM_MNODE *pNodeNext = NULL; ++ struct CMM_MNODE *pCurNode; ++ u32 dwThisPA; ++ u32 dwNextPA; ++ ++ DBC_Require(pNode != NULL); ++ DBC_Require(pAllocator != NULL); ++ dwThisPA = pNode->dwPA; ++ dwNextPA = NEXT_PA(pNode); ++ pCurNode = (struct CMM_MNODE *)LST_First(pAllocator->pFreeListHead); ++ while (pCurNode) { ++ if (dwThisPA == NEXT_PA(pCurNode)) { ++ /* found the block ahead of this one */ ++ pNodePrev = pCurNode; ++ } else if (dwNextPA == pCurNode->dwPA) { ++ pNodeNext = pCurNode; ++ } ++ if ((pNodePrev == NULL) || (pNodeNext == NULL)) { ++ /* next node. */ ++ pCurNode = (struct CMM_MNODE *)LST_Next(pAllocator-> ++ pFreeListHead, (struct LST_ELEM *)pCurNode); ++ } else { ++ /* got 'em */ ++ break; ++ } ++ } /* while */ ++ if (pNodePrev != NULL) { ++ /* combine with previous block */ ++ LST_RemoveElem(pAllocator->pFreeListHead, ++ (struct LST_ELEM *)pNodePrev); ++ /* grow node to hold both */ ++ pNode->ulSize += pNodePrev->ulSize; ++ pNode->dwPA = pNodePrev->dwPA; ++ pNode->dwVA = pNodePrev->dwVA; ++ /* place node on mgr nodeFreeList */ ++ DeleteNode((struct CMM_OBJECT *)pAllocator->hCmmMgr, pNodePrev); ++ } ++ if (pNodeNext != NULL) { ++ /* combine with next block */ ++ LST_RemoveElem(pAllocator->pFreeListHead, ++ (struct LST_ELEM *)pNodeNext); ++ /* grow da node */ ++ pNode->ulSize += pNodeNext->ulSize; ++ /* place node on mgr nodeFreeList */ ++ DeleteNode((struct CMM_OBJECT *)pAllocator->hCmmMgr, pNodeNext); ++ } ++ /* Now, let's add to freelist in increasing size order */ ++ pCurNode = (struct CMM_MNODE *)LST_First(pAllocator->pFreeListHead); ++ while (pCurNode) { ++ if (pNode->ulSize <= pCurNode->ulSize) ++ break; ++ ++ /* next node. */ ++ pCurNode = (struct CMM_MNODE *)LST_Next(pAllocator-> ++ pFreeListHead, (struct LST_ELEM *)pCurNode); ++ } ++ /* if pCurNode is NULL then add our pNode to the end of the freelist */ ++ if (pCurNode == NULL) { ++ LST_PutTail(pAllocator->pFreeListHead, ++ (struct LST_ELEM *)pNode); ++ } else { ++ /* insert our node before the current traversed node */ ++ LST_InsertBefore(pAllocator->pFreeListHead, ++ (struct LST_ELEM *)pNode, ++ (struct LST_ELEM *)pCurNode); ++ } ++} ++ ++/* ++ * ======== GetAllocator ======== ++ * Purpose: ++ * Return the allocator for the given SM Segid. ++ * SegIds: 1,2,3..max. ++ */ ++static struct CMM_ALLOCATOR *GetAllocator(struct CMM_OBJECT *pCmmMgr, ++ u32 ulSegId) ++{ ++ struct CMM_ALLOCATOR *pAllocator = NULL; ++ ++ DBC_Require(pCmmMgr != NULL); ++ DBC_Require((ulSegId > 0) && (ulSegId <= CMM_MAXGPPSEGS)); ++ pAllocator = pCmmMgr->paGPPSMSegTab[ulSegId - 1]; ++ if (pAllocator != NULL) { ++ /* make sure it's for real */ ++ if (!MEM_IsValidHandle(pAllocator, SMEMSIGNATURE)) { ++ pAllocator = NULL; ++ DBC_Assert(false); ++ } ++ } ++ return pAllocator; ++} ++ ++/* ++ * ======== CMM_XlatorCreate ======== ++ * Purpose: ++ * Create an address translator object. ++ */ ++DSP_STATUS CMM_XlatorCreate(OUT struct CMM_XLATOROBJECT **phXlator, ++ struct CMM_OBJECT *hCmmMgr, ++ struct CMM_XLATORATTRS *pXlatorAttrs) ++{ ++ struct CMM_XLATOR *pXlatorObject = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phXlator != NULL); ++ DBC_Require(hCmmMgr != NULL); ++ GT_3trace(CMM_debugMask, GT_ENTER, ++ "CMM_XlatorCreate: phXlator: 0x%x\t" ++ "phCmmMgr: 0x%x\tpXlAttrs: 0x%x\n", phXlator, ++ hCmmMgr, pXlatorAttrs); ++ *phXlator = NULL; ++ if (pXlatorAttrs == NULL) ++ pXlatorAttrs = &CMM_DFLTXLATORATTRS; /* set defaults */ ++ ++ MEM_AllocObject(pXlatorObject, struct CMM_XLATOR, CMMXLATESIGNATURE); ++ if (pXlatorObject != NULL) { ++ pXlatorObject->hCmmMgr = hCmmMgr; /* ref back to CMM */ ++ pXlatorObject->ulSegId = pXlatorAttrs->ulSegId; /* SM segId */ ++ } else { ++ GT_0trace(CMM_debugMask, GT_6CLASS, ++ "CMM_XlatorCreate: Object Allocation" ++ "Failure(CMM Xlator)\n"); ++ status = DSP_EMEMORY; ++ } ++ if (DSP_SUCCEEDED(status)) ++ *phXlator = (struct CMM_XLATOROBJECT *) pXlatorObject; ++ ++ return status; ++} ++ ++/* ++ * ======== CMM_XlatorDelete ======== ++ * Purpose: ++ * Free the Xlator resources. ++ * VM gets freed later. ++ */ ++DSP_STATUS CMM_XlatorDelete(struct CMM_XLATOROBJECT *hXlator, bool bForce) ++{ ++ struct CMM_XLATOR *pXlator = (struct CMM_XLATOR *)hXlator; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ if (MEM_IsValidHandle(pXlator, CMMXLATESIGNATURE)) { ++ MEM_FreeObject(pXlator); ++ } else { ++ status = DSP_EHANDLE; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== CMM_XlatorAllocBuf ======== ++ */ ++void *CMM_XlatorAllocBuf(struct CMM_XLATOROBJECT *hXlator, void *pVaBuf, ++ u32 uPaSize) ++{ ++ struct CMM_XLATOR *pXlator = (struct CMM_XLATOR *)hXlator; ++ void *pBuf = NULL; ++ struct CMM_ATTRS attrs; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hXlator != NULL); ++ DBC_Require(pXlator->hCmmMgr != NULL); ++ DBC_Require(pVaBuf != NULL); ++ DBC_Require(uPaSize > 0); ++ DBC_Require(pXlator->ulSegId > 0); ++ ++ if (MEM_IsValidHandle(pXlator, CMMXLATESIGNATURE)) { ++ attrs.ulSegId = pXlator->ulSegId; ++ *(volatile u32 *)pVaBuf = 0; ++ /* Alloc SM */ ++ pBuf = CMM_CallocBuf(pXlator->hCmmMgr, uPaSize, &attrs, NULL); ++ if (pBuf) { ++ /* convert to translator(node/strm) process Virtual ++ * address */ ++ *(volatile u32 **)pVaBuf = ++ (u32 *)CMM_XlatorTranslate(hXlator, ++ pBuf, CMM_PA2VA); ++ } ++ } ++ return pBuf; ++} ++ ++/* ++ * ======== CMM_XlatorFreeBuf ======== ++ * Purpose: ++ * Free the given SM buffer and descriptor. ++ * Does not free virtual memory. ++ */ ++DSP_STATUS CMM_XlatorFreeBuf(struct CMM_XLATOROBJECT *hXlator, void *pBufVa) ++{ ++ struct CMM_XLATOR *pXlator = (struct CMM_XLATOR *)hXlator; ++ DSP_STATUS status = DSP_EFAIL; ++ void *pBufPa = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBufVa != NULL); ++ DBC_Require(pXlator->ulSegId > 0); ++ ++ if (MEM_IsValidHandle(pXlator, CMMXLATESIGNATURE)) { ++ /* convert Va to Pa so we can free it. */ ++ pBufPa = CMM_XlatorTranslate(hXlator, pBufVa, CMM_VA2PA); ++ if (pBufPa) { ++ status = CMM_FreeBuf(pXlator->hCmmMgr, pBufPa, ++ pXlator->ulSegId); ++ if (DSP_FAILED(status)) { ++ /* Uh oh, this shouldn't happen. Descriptor ++ * gone! */ ++ GT_2trace(CMM_debugMask, GT_7CLASS, ++ "Cannot free DMA/ZCPY buffer" ++ "not allocated by MPU. PA %x, VA %x\n", ++ pBufPa, pBufVa); ++ DBC_Assert(false); /* CMM is leaking mem! */ ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== CMM_XlatorInfo ======== ++ * Purpose: ++ * Set/Get translator info. ++ */ ++DSP_STATUS CMM_XlatorInfo(struct CMM_XLATOROBJECT *hXlator, IN OUT u8 **pAddr, ++ u32 ulSize, u32 uSegId, bool bSetInfo) ++{ ++ struct CMM_XLATOR *pXlator = (struct CMM_XLATOR *)hXlator; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pAddr != NULL); ++ DBC_Require((uSegId > 0) && (uSegId <= CMM_MAXGPPSEGS)); ++ ++ if (MEM_IsValidHandle(pXlator, CMMXLATESIGNATURE)) { ++ if (bSetInfo) { ++ /* set translators virtual address range */ ++ pXlator->dwVirtBase = (u32)*pAddr; ++ pXlator->ulVirtSize = ulSize; ++ GT_2trace(CMM_debugMask, GT_3CLASS, ++ "pXlator->dwVirtBase %x, " ++ "ulVirtSize %x\n", pXlator->dwVirtBase, ++ pXlator->ulVirtSize); ++ } else { /* return virt base address */ ++ *pAddr = (u8 *)pXlator->dwVirtBase; ++ } ++ } else { ++ status = DSP_EHANDLE; ++ } ++ return status; ++} ++ ++/* ++ * ======== CMM_XlatorTranslate ======== ++ */ ++void *CMM_XlatorTranslate(struct CMM_XLATOROBJECT *hXlator, void *pAddr, ++ enum CMM_XLATETYPE xType) ++{ ++ u32 dwAddrXlate = 0; ++ struct CMM_XLATOR *pXlator = (struct CMM_XLATOR *)hXlator; ++ struct CMM_OBJECT *pCmmMgr = NULL; ++ struct CMM_ALLOCATOR *pAlctr = NULL; ++ u32 dwOffset = 0; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pAddr != NULL); ++ DBC_Require((xType >= CMM_VA2PA) && (xType <= CMM_DSPPA2PA)); ++ ++ if (!MEM_IsValidHandle(pXlator, CMMXLATESIGNATURE)) ++ goto loop_cont; ++ ++ pCmmMgr = (struct CMM_OBJECT *)pXlator->hCmmMgr; ++ /* get this translator's default SM allocator */ ++ DBC_Assert(pXlator->ulSegId > 0); ++ pAlctr = pCmmMgr->paGPPSMSegTab[pXlator->ulSegId - 1]; ++ if (!MEM_IsValidHandle(pAlctr, SMEMSIGNATURE)) ++ goto loop_cont; ++ ++ if ((xType == CMM_VA2DSPPA) || (xType == CMM_VA2PA) || ++ (xType == CMM_PA2VA)) { ++ if (xType == CMM_PA2VA) { ++ /* Gpp Va = Va Base + offset */ ++ dwOffset = (u8 *)pAddr - (u8 *)(pAlctr->dwSmBase - ++ pAlctr->ulDSPSize); ++ dwAddrXlate = pXlator->dwVirtBase + dwOffset; ++ /* Check if translated Va base is in range */ ++ if ((dwAddrXlate < pXlator->dwVirtBase) || ++ (dwAddrXlate >= ++ (pXlator->dwVirtBase + pXlator->ulVirtSize))) { ++ dwAddrXlate = 0; /* bad address */ ++ GT_0trace(CMM_debugMask, GT_7CLASS, ++ "CMM_XlatorTranslate: " ++ "Virt addr out of range\n"); ++ } ++ } else { ++ /* Gpp PA = Gpp Base + offset */ ++ dwOffset = (u8 *)pAddr - (u8 *)pXlator->dwVirtBase; ++ dwAddrXlate = pAlctr->dwSmBase - pAlctr->ulDSPSize + ++ dwOffset; ++ } ++ } else { ++ dwAddrXlate = (u32)pAddr; ++ } ++ /*Now convert address to proper target physical address if needed*/ ++ if ((xType == CMM_VA2DSPPA) || (xType == CMM_PA2DSPPA)) { ++ /* Got Gpp Pa now, convert to DSP Pa */ ++ dwAddrXlate = GPPPA2DSPPA((pAlctr->dwSmBase - pAlctr-> ++ ulDSPSize), dwAddrXlate, ++ pAlctr->dwDSPPhysAddrOffset * ++ pAlctr->cFactor); ++ } else if (xType == CMM_DSPPA2PA) { ++ /* Got DSP Pa, convert to GPP Pa */ ++ dwAddrXlate = DSPPA2GPPPA(pAlctr->dwSmBase - pAlctr->ulDSPSize, ++ dwAddrXlate, ++ pAlctr->dwDSPPhysAddrOffset * ++ pAlctr->cFactor); ++ } ++loop_cont: ++ if (!dwAddrXlate) { ++ GT_2trace(CMM_debugMask, GT_7CLASS, ++ "CMM_XlatorTranslate: Can't translate" ++ " address: 0x%x xType %x\n", pAddr, xType); ++ } else { ++ GT_3trace(CMM_debugMask, GT_3CLASS, ++ "CMM_XlatorTranslate: pAddr %x, xType" ++ " %x, dwAddrXlate %x\n", pAddr, xType, dwAddrXlate); ++ } ++ return (void *)dwAddrXlate; ++} +diff --git a/drivers/dsp/bridge/pmgr/cod.c b/drivers/dsp/bridge/pmgr/cod.c +new file mode 100644 +index 0000000..6363f1e +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/cod.c +@@ -0,0 +1,683 @@ ++/* ++ * cod.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cod.c ======== ++ * This module implements DSP code management for the DSP/BIOS Bridge ++ * environment. It is mostly a thin wrapper. ++ * ++ * This module provides an interface for loading both static and ++ * dynamic code objects onto DSP systems. ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Apr-2003 map: Consolidated DBL to DBLL loader name ++ *! 24-Feb-2003 swa: PMGR Code review comments incorporated. ++ *! 18-Apr-2002 jeh: Added DBL function tables. ++ *! 20-Nov-2001 jeh: Removed call to ZL_loadArgs function. ++ *! 19-Oct-2001 jeh: Access DBL as a static library. Added COD_GetBaseLib, ++ *! COD_GetLoader, removed COD_LoadSection, COD_UnloadSection. ++ *! 07-Sep-2001 jeh: Added COD_LoadSection(), COD_UnloadSection(). ++ *! 07-Aug-2001 rr: hMgr->baseLib is updated after zlopen in COD_LoadBase. ++ *! 18-Apr-2001 jeh: Check for fLoaded flag before ZL_unload, to allow ++ *! COD_OpenBase to be used. ++ *! 11-Jan-2001 jeh: Added COD_OpenBase (not used yet, since there is an ++ *! occasional crash). ++ *! 02-Aug-2000 kc: Added COD_ReadSection to COD module. Incorporates use ++ *! of ZL_readSect (new function in ZL module). ++ *! 28-Feb-2000 rr: New GT Usage Implementation ++ *! 08-Dec-1999 ag: Removed x86 specific __asm int 3. ++ *! 02-Oct-1999 ag: Added #ifdef DEBUGINT3COD for debug. ++ *! 20-Sep-1999 ag: Removed call to GT_set(). ++ *! 04-Jun-1997 cr: Added validation of argc/argv pair in COD_LoadBase, as it ++ *! is a requirement to ZL_loadArgs. ++ *! 31-May-1997 cr: Changed COD_LoadBase argc value from u32 to int, added ++ *! DSP_ENOTIMPL return value to COD_Create when attrs != NULL. ++ *! 29-May-1997 cr: Added debugging support. ++ *! 24-Oct-1996 gp: Added COD_GetSection(). ++ *! 18-Jun-1996 gp: Updated GetSymValue() to check for lib; updated E_ codes. ++ *! 12-Jun-1996 gp: Imported CSL_ services for strcpyn(); Added ref counting. ++ *! 20-May-1996 mg: Adapted for new MEM and LDR modules. ++ *! 08-May-1996 mg: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/kfile.h> ++#include <dspbridge/ldr.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- Platform Manager */ ++/* Include appropriate loader header file */ ++#include <dspbridge/dbll.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/cod.h> ++ ++/* magic number for handle validation */ ++#define MAGIC 0xc001beef ++ ++/* macro to validate COD manager handles */ ++#define IsValid(h) ((h) != NULL && (h)->ulMagic == MAGIC) ++ ++/* ++ * ======== COD_MANAGER ======== ++ */ ++struct COD_MANAGER { ++ struct DBLL_TarObj *target; ++ struct DBLL_LibraryObj *baseLib; ++ bool fLoaded; /* Base library loaded? */ ++ u32 ulEntry; ++ struct LDR_MODULE *hDll; ++ struct DBLL_Fxns fxns; ++ struct DBLL_Attrs attrs; ++ char szZLFile[COD_MAXPATHLENGTH]; ++ u32 ulMagic; ++} ; ++ ++/* ++ * ======== COD_LIBRARYOBJ ======== ++ */ ++struct COD_LIBRARYOBJ { ++ struct DBLL_LibraryObj *dbllLib; ++ struct COD_MANAGER *hCodMgr; ++} ; ++ ++static u32 cRefs = 0L; ++ ++#if GT_TRACE ++static struct GT_Mask COD_debugMask = { NULL, NULL }; ++#endif ++ ++static struct DBLL_Fxns dbllFxns = { ++ (DBLL_CloseFxn) DBLL_close, ++ (DBLL_CreateFxn) DBLL_create, ++ (DBLL_DeleteFxn) DBLL_delete, ++ (DBLL_ExitFxn) DBLL_exit, ++ (DBLL_GetAttrsFxn) DBLL_getAttrs, ++ (DBLL_GetAddrFxn) DBLL_getAddr, ++ (DBLL_GetCAddrFxn) DBLL_getCAddr, ++ (DBLL_GetSectFxn) DBLL_getSect, ++ (DBLL_InitFxn) DBLL_init, ++ (DBLL_LoadFxn) DBLL_load, ++ (DBLL_LoadSectFxn) DBLL_loadSect, ++ (DBLL_OpenFxn) DBLL_open, ++ (DBLL_ReadSectFxn) DBLL_readSect, ++ (DBLL_SetAttrsFxn) DBLL_setAttrs, ++ (DBLL_UnloadFxn) DBLL_unload, ++ (DBLL_UnloadSectFxn) DBLL_unloadSect, ++}; ++ ++static bool NoOp(void); ++ ++/* ++ * ======== COD_Close ======== ++ */ ++void COD_Close(struct COD_LIBRARYOBJ *lib) ++{ ++ struct COD_MANAGER *hMgr; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(lib != NULL); ++ DBC_Require(IsValid(((struct COD_LIBRARYOBJ *)lib)->hCodMgr)); ++ ++ hMgr = lib->hCodMgr; ++ hMgr->fxns.closeFxn(lib->dbllLib); ++ ++ MEM_Free(lib); ++} ++ ++/* ++ * ======== COD_Create ======== ++ * Purpose: ++ * Create an object to manage code on a DSP system. ++ * This object can be used to load an initial program image with ++ * arguments that can later be expanded with ++ * dynamically loaded object files. ++ * ++ */ ++DSP_STATUS COD_Create(OUT struct COD_MANAGER **phMgr, char *pstrDummyFile, ++ IN OPTIONAL CONST struct COD_ATTRS *attrs) ++{ ++ struct COD_MANAGER *hMgrNew; ++ struct DBLL_Attrs zlAttrs; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMgr != NULL); ++ ++ GT_3trace(COD_debugMask, GT_ENTER, ++ "Entered COD_Create, Args: \t\nphMgr: " ++ "0x%x\t\npstrDummyFile: 0x%x\t\nattr: 0x%x\n", ++ phMgr, pstrDummyFile, attrs); ++ /* assume failure */ ++ *phMgr = NULL; ++ ++ /* we don't support non-default attrs yet */ ++ if (attrs != NULL) ++ return DSP_ENOTIMPL; ++ ++ hMgrNew = MEM_Calloc(sizeof(struct COD_MANAGER), MEM_NONPAGED); ++ if (hMgrNew == NULL) { ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_Create: Out Of Memory\n"); ++ return DSP_EMEMORY; ++ } ++ ++ hMgrNew->ulMagic = MAGIC; ++ ++ /* Set up loader functions */ ++ hMgrNew->fxns = dbllFxns; ++ ++ /* initialize the ZL module */ ++ hMgrNew->fxns.initFxn(); ++ ++ zlAttrs.alloc = (DBLL_AllocFxn)NoOp; ++ zlAttrs.free = (DBLL_FreeFxn)NoOp; ++ zlAttrs.fread = (DBLL_ReadFxn)KFILE_Read; ++ zlAttrs.fseek = (DBLL_SeekFxn)KFILE_Seek; ++ zlAttrs.ftell = (DBLL_TellFxn)KFILE_Tell; ++ zlAttrs.fclose = (DBLL_FCloseFxn)KFILE_Close; ++ zlAttrs.fopen = (DBLL_FOpenFxn)KFILE_Open; ++ zlAttrs.symLookup = NULL; ++ zlAttrs.baseImage = true; ++ zlAttrs.logWrite = NULL; ++ zlAttrs.logWriteHandle = NULL; ++ zlAttrs.write = NULL; ++ zlAttrs.rmmHandle = NULL; ++ zlAttrs.wHandle = NULL; ++ zlAttrs.symHandle = NULL; ++ zlAttrs.symArg = NULL; ++ ++ hMgrNew->attrs = zlAttrs; ++ ++ status = hMgrNew->fxns.createFxn(&hMgrNew->target, &zlAttrs); ++ ++ if (DSP_FAILED(status)) { ++ COD_Delete(hMgrNew); ++ GT_1trace(COD_debugMask, GT_7CLASS, ++ "COD_Create:ZL Create Failed: 0x%x\n", status); ++ return COD_E_ZLCREATEFAILED; ++ } ++ ++ /* return the new manager */ ++ *phMgr = hMgrNew; ++ GT_1trace(COD_debugMask, GT_1CLASS, ++ "COD_Create: Success CodMgr: 0x%x\n", *phMgr); ++ return DSP_SOK; ++} ++ ++/* ++ * ======== COD_Delete ======== ++ * Purpose: ++ * Delete a code manager object. ++ */ ++void COD_Delete(struct COD_MANAGER *hMgr) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hMgr)); ++ ++ GT_1trace(COD_debugMask, GT_ENTER, "COD_Delete:hMgr 0x%x\n", hMgr); ++ if (hMgr->baseLib) { ++ if (hMgr->fLoaded) ++ hMgr->fxns.unloadFxn(hMgr->baseLib, &hMgr->attrs); ++ ++ hMgr->fxns.closeFxn(hMgr->baseLib); ++ } ++ if (hMgr->target) { ++ hMgr->fxns.deleteFxn(hMgr->target); ++ hMgr->fxns.exitFxn(); ++ } ++ hMgr->ulMagic = ~MAGIC; ++ MEM_Free(hMgr); ++} ++ ++/* ++ * ======== COD_Exit ======== ++ * Purpose: ++ * Discontinue usage of the COD module. ++ * ++ */ ++void COD_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(COD_debugMask, GT_ENTER, ++ "Entered COD_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== COD_GetBaseLib ======== ++ * Purpose: ++ * Get handle to the base image DBL library. ++ */ ++DSP_STATUS COD_GetBaseLib(struct COD_MANAGER *hManager, ++ struct DBLL_LibraryObj **plib) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hManager)); ++ DBC_Require(plib != NULL); ++ ++ *plib = (struct DBLL_LibraryObj *) hManager->baseLib; ++ ++ return status; ++} ++ ++/* ++ * ======== COD_GetBaseName ======== ++ */ ++DSP_STATUS COD_GetBaseName(struct COD_MANAGER *hManager, char *pszName, ++ u32 uSize) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hManager)); ++ DBC_Require(pszName != NULL); ++ ++ if (uSize <= COD_MAXPATHLENGTH) ++ strncpy(pszName, hManager->szZLFile, uSize); ++ else ++ status = DSP_EFAIL; ++ ++ return status; ++} ++ ++/* ++ * ======== COD_GetEntry ======== ++ * Purpose: ++ * Retrieve the entry point of a loaded DSP program image ++ * ++ */ ++DSP_STATUS COD_GetEntry(struct COD_MANAGER *hManager, u32 *pulEntry) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hManager)); ++ DBC_Require(pulEntry != NULL); ++ ++ *pulEntry = hManager->ulEntry; ++ ++ GT_1trace(COD_debugMask, GT_ENTER, "COD_GetEntry:ulEntr 0x%x\n", ++ *pulEntry); ++ ++ return DSP_SOK; ++} ++ ++/* ++ * ======== COD_GetLoader ======== ++ * Purpose: ++ * Get handle to the DBLL loader. ++ */ ++DSP_STATUS COD_GetLoader(struct COD_MANAGER *hManager, ++ struct DBLL_TarObj **phLoader) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hManager)); ++ DBC_Require(phLoader != NULL); ++ ++ *phLoader = (struct DBLL_TarObj *)hManager->target; ++ ++ return status; ++} ++ ++/* ++ * ======== COD_GetSection ======== ++ * Purpose: ++ * Retrieve the starting address and length of a section in the COFF file ++ * given the section name. ++ */ ++DSP_STATUS COD_GetSection(struct COD_LIBRARYOBJ *lib, IN char *pstrSect, ++ OUT u32 *puAddr, OUT u32 *puLen) ++{ ++ struct COD_MANAGER *hManager; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(lib != NULL); ++ DBC_Require(IsValid(lib->hCodMgr)); ++ DBC_Require(pstrSect != NULL); ++ DBC_Require(puAddr != NULL); ++ DBC_Require(puLen != NULL); ++ ++ GT_4trace(COD_debugMask, GT_ENTER, ++ "Entered COD_GetSection Args \t\n lib: " ++ "0x%x\t\npstrsect: 0x%x\t\npuAddr: 0x%x\t\npuLen: 0x%x\n", ++ lib, pstrSect, puAddr, puLen); ++ *puAddr = 0; ++ *puLen = 0; ++ if (lib != NULL) { ++ hManager = lib->hCodMgr; ++ status = hManager->fxns.getSectFxn(lib->dbllLib, pstrSect, ++ puAddr, puLen); ++ if (DSP_FAILED(status)) { ++ GT_1trace(COD_debugMask, GT_7CLASS, ++ "COD_GetSection: Section %s not" ++ "found\n", pstrSect); ++ } ++ } else { ++ status = COD_E_NOSYMBOLSLOADED; ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_GetSection:No Symbols loaded\n"); ++ } ++ ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((*puAddr == 0) && (*puLen == 0))); ++ ++ return status; ++} ++ ++/* ++ * ======== COD_GetSymValue ======== ++ * Purpose: ++ * Retrieve the value for the specified symbol. The symbol is first ++ * searched for literally and then, if not found, searched for as a ++ * C symbol. ++ * ++ */ ++DSP_STATUS COD_GetSymValue(struct COD_MANAGER *hMgr, char *pstrSym, ++ u32 *pulValue) ++{ ++ struct DBLL_Symbol *pSym; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hMgr)); ++ DBC_Require(pstrSym != NULL); ++ DBC_Require(pulValue != NULL); ++ ++ GT_3trace(COD_debugMask, GT_ENTER, "Entered COD_GetSymValue Args \t\n" ++ "hMgr: 0x%x\t\npstrSym: 0x%x\t\npulValue: 0x%x\n", ++ hMgr, pstrSym, pulValue); ++ if (hMgr->baseLib) { ++ if (!hMgr->fxns.getAddrFxn(hMgr->baseLib, pstrSym, &pSym)) { ++ if (!hMgr->fxns.getCAddrFxn(hMgr->baseLib, pstrSym, ++ &pSym)) { ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_GetSymValue: " ++ "Symbols not found\n"); ++ return COD_E_SYMBOLNOTFOUND; ++ } ++ } ++ } else { ++ GT_0trace(COD_debugMask, GT_7CLASS, "COD_GetSymValue: " ++ "No Symbols loaded\n"); ++ return COD_E_NOSYMBOLSLOADED; ++ } ++ ++ *pulValue = pSym->value; ++ ++ return DSP_SOK; ++} ++ ++/* ++ * ======== COD_Init ======== ++ * Purpose: ++ * Initialize the COD module's private state. ++ * ++ */ ++bool COD_Init(void) ++{ ++ bool fRetVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!COD_debugMask.flags); ++ GT_create(&COD_debugMask, "CO"); ++ } ++ ++ if (fRetVal) ++ cRefs++; ++ ++ ++ GT_1trace(COD_debugMask, GT_1CLASS, ++ "Entered COD_Init, ref count: 0x%x\n", cRefs); ++ DBC_Ensure((fRetVal && cRefs > 0) || (!fRetVal && cRefs >= 0)); ++ return fRetVal; ++} ++ ++/* ++ * ======== COD_LoadBase ======== ++ * Purpose: ++ * Load the initial program image, optionally with command-line arguments, ++ * on the DSP system managed by the supplied handle. The program to be ++ * loaded must be the first element of the args array and must be a fully ++ * qualified pathname. ++ * Details: ++ * if nArgc doesn't match the number of arguments in the aArgs array, the ++ * aArgs array is searched for a NULL terminating entry, and argc is ++ * recalculated to reflect this. In this way, we can support NULL ++ * terminating aArgs arrays, if nArgc is very large. ++ */ ++DSP_STATUS COD_LoadBase(struct COD_MANAGER *hMgr, u32 nArgc, char *aArgs[], ++ COD_WRITEFXN pfnWrite, void *pArb, char *envp[]) ++{ ++ DBLL_Flags flags; ++ struct DBLL_Attrs saveAttrs; ++ struct DBLL_Attrs newAttrs; ++ DSP_STATUS status; ++ u32 i; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hMgr)); ++ DBC_Require(nArgc > 0); ++ DBC_Require(aArgs != NULL); ++ DBC_Require(aArgs[0] != NULL); ++ DBC_Require(pfnWrite != NULL); ++ DBC_Require(hMgr->baseLib != NULL); ++ ++ GT_6trace(COD_debugMask, GT_ENTER, ++ "Entered COD_LoadBase, hMgr: 0x%x\n \t" ++ "nArgc: 0x%x\n\taArgs: 0x%x\n\tpfnWrite: 0x%x\n\tpArb:" ++ " 0x%x\n \tenvp: 0x%x\n", hMgr, nArgc, aArgs, pfnWrite, ++ pArb, envp); ++ /* ++ * Make sure every argv[] stated in argc has a value, or change argc to ++ * reflect true number in NULL terminated argv array. ++ */ ++ for (i = 0; i < nArgc; i++) { ++ if (aArgs[i] == NULL) { ++ nArgc = i; ++ break; ++ } ++ } ++ ++ /* set the write function for this operation */ ++ hMgr->fxns.getAttrsFxn(hMgr->target, &saveAttrs); ++ ++ newAttrs = saveAttrs; ++ newAttrs.write = (DBLL_WriteFxn)pfnWrite; ++ newAttrs.wHandle = pArb; ++ newAttrs.alloc = (DBLL_AllocFxn)NoOp; ++ newAttrs.free = (DBLL_FreeFxn)NoOp; ++ newAttrs.logWrite = NULL; ++ newAttrs.logWriteHandle = NULL; ++ ++ /* Load the image */ ++ flags = DBLL_CODE | DBLL_DATA | DBLL_SYMB; ++ status = hMgr->fxns.loadFxn(hMgr->baseLib, flags, &newAttrs, ++ &hMgr->ulEntry); ++ if (DSP_FAILED(status)) { ++ hMgr->fxns.closeFxn(hMgr->baseLib); ++ GT_1trace(COD_debugMask, GT_7CLASS, ++ "COD_LoadBase: COD Load failed: " ++ "0x%x\n", status); ++ } ++ if (DSP_SUCCEEDED(status)) ++ hMgr->fLoaded = true; ++ else ++ hMgr->baseLib = NULL; ++ ++ return status; ++} ++ ++/* ++ * ======== COD_Open ======== ++ * Open library for reading sections. ++ */ ++DSP_STATUS COD_Open(struct COD_MANAGER *hMgr, IN char *pszCoffPath, ++ COD_FLAGS flags, struct COD_LIBRARYOBJ **pLib) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct COD_LIBRARYOBJ *lib = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hMgr)); ++ DBC_Require(pszCoffPath != NULL); ++ DBC_Require(flags == COD_NOLOAD || flags == COD_SYMB); ++ DBC_Require(pLib != NULL); ++ ++ GT_4trace(COD_debugMask, GT_ENTER, "Entered COD_Open, hMgr: 0x%x\n\t " ++ "pszCoffPath: 0x%x\tflags: 0x%x\tlib: 0x%x\n", hMgr, ++ pszCoffPath, flags, pLib); ++ ++ *pLib = NULL; ++ ++ lib = MEM_Calloc(sizeof(struct COD_LIBRARYOBJ), MEM_NONPAGED); ++ if (lib == NULL) { ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_Open: Out Of Memory\n"); ++ status = DSP_EMEMORY; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ lib->hCodMgr = hMgr; ++ status = hMgr->fxns.openFxn(hMgr->target, pszCoffPath, flags, ++ &lib->dbllLib); ++ if (DSP_FAILED(status)) { ++ GT_1trace(COD_debugMask, GT_7CLASS, ++ "COD_Open failed: 0x%x\n", status); ++ } else { ++ *pLib = lib; ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== COD_OpenBase ======== ++ * Purpose: ++ * Open base image for reading sections. ++ */ ++DSP_STATUS COD_OpenBase(struct COD_MANAGER *hMgr, IN char *pszCoffPath, ++ DBLL_Flags flags) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DBLL_LibraryObj *lib; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValid(hMgr)); ++ DBC_Require(pszCoffPath != NULL); ++ ++ GT_2trace(COD_debugMask, GT_ENTER, ++ "Entered COD_OpenBase, hMgr: 0x%x\n\t" ++ "pszCoffPath: 0x%x\n", hMgr, pszCoffPath); ++ ++ /* if we previously opened a base image, close it now */ ++ if (hMgr->baseLib) { ++ if (hMgr->fLoaded) { ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "Base Image is already loaded. " ++ "Unloading it...\n"); ++ hMgr->fxns.unloadFxn(hMgr->baseLib, &hMgr->attrs); ++ hMgr->fLoaded = false; ++ } ++ hMgr->fxns.closeFxn(hMgr->baseLib); ++ hMgr->baseLib = NULL; ++ } else { ++ GT_0trace(COD_debugMask, GT_1CLASS, ++ "COD_OpenBase: Opening the base image ...\n"); ++ } ++ status = hMgr->fxns.openFxn(hMgr->target, pszCoffPath, flags, &lib); ++ if (DSP_FAILED(status)) { ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_OpenBase: COD Open failed\n"); ++ } else { ++ /* hang onto the library for subsequent sym table usage */ ++ hMgr->baseLib = lib; ++ strncpy(hMgr->szZLFile, pszCoffPath, COD_MAXPATHLENGTH); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== COD_ReadSection ======== ++ * Purpose: ++ * Retrieve the content of a code section given the section name. ++ */ ++DSP_STATUS COD_ReadSection(struct COD_LIBRARYOBJ *lib, IN char *pstrSect, ++ OUT char *pstrContent, IN u32 cContentSize) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(lib != NULL); ++ DBC_Require(IsValid(lib->hCodMgr)); ++ DBC_Require(pstrSect != NULL); ++ DBC_Require(pstrContent != NULL); ++ ++ GT_4trace(COD_debugMask, GT_ENTER, "Entered COD_ReadSection Args: 0x%x," ++ " 0x%x, 0x%x, 0x%x\n", lib, pstrSect, pstrContent, ++ cContentSize); ++ ++ if (lib != NULL) { ++ status = lib->hCodMgr->fxns.readSectFxn(lib->dbllLib, pstrSect, ++ pstrContent, ++ cContentSize); ++ if (DSP_FAILED(status)) { ++ GT_1trace(COD_debugMask, GT_7CLASS, ++ "COD_ReadSection failed: 0x%lx\n", status); ++ } ++ } else { ++ status = COD_E_NOSYMBOLSLOADED; ++ GT_0trace(COD_debugMask, GT_7CLASS, ++ "COD_ReadSection: No Symbols loaded\n"); ++ } ++ return status; ++} ++ ++/* ++ * ======== NoOp ======== ++ * Purpose: ++ * No Operation. ++ * ++ */ ++static bool NoOp(void) ++{ ++ return true; ++} ++ +diff --git a/drivers/dsp/bridge/pmgr/dbl.c b/drivers/dsp/bridge/pmgr/dbl.c +new file mode 100644 +index 0000000..641b011 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/dbl.c +@@ -0,0 +1,1385 @@ ++/* ++ * dbl.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbl.c ======== ++ * Dynamic BOF Loader library. Contains functions related to ++ * loading and unloading symbols/code/data on DSP. ++ * Also contains other support functions. ++ * ++ *! Revision History ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 24-May-2002 jeh Free DCD sects in DBL_close(). ++ *! 19-Mar-2002 jeh Changes made to match dynamic loader (dbll.c): Pass ++ *! DBL_Library to DBL_getAddr() instead of DBL_Target, ++ *! eliminate scope param, use DBL_Symbol. Pass attrs to ++ *! DBL_load(), DBL_unload(). ++ *! 20-Nov-2001 jeh Removed DBL_loadArgs(). ++ *! 07-Sep-2001 jeh Added overlay support. ++ *! 31-Jul-2001 jeh Include windows.h. ++ *! 06-Jun-2001 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/kfile.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dbof.h> ++#include <dspbridge/dbl.h> ++ ++#define DBL_TARGSIGNATURE 0x544c4244 /* "TLBD" */ ++#define DBL_LIBSIGNATURE 0x4c4c4244 /* "LLBD" */ ++ ++#define C54TARG 0 ++#define C55TARG 1 ++#define NUMTARGS 2 ++ ++#define C54MAGIC 0x98 /* Magic number for TI C54 COF */ ++#define C55MAGIC 0x9c /* Magic number for LEAD3 (C55) COF */ ++ ++/* Three task phases */ ++#define CREATEPHASE 0 ++#define DELETEPHASE 1 ++#define EXECUTEPHASE 2 ++#define NONE 3 /* For overlay section with phase not specified */ ++ ++/* Default load buffer size */ ++#define LOADBUFSIZE 0x800 ++ ++#define SWAPLONG(x) ((((x) << 24) & 0xFF000000) | (((x) << 8) & 0xFF0000L) | \ ++ (((x) >> 8) & 0xFF00L) | (((x) >> 24) & 0xFF)) ++ ++#define SWAPWORD(x) ((((x) << 8) & 0xFF00) | (((x) >> 8) & 0xFF)) ++ ++/* ++ * Macros for accessing the following types of overlay data within a ++ * structure of type OvlyData: ++ * - Overlay data not associated with a particular phase ++ * - Create phase overlay data ++ * - Delete phase overlay data ++ * - Execute phase overlay data ++ */ ++#define numOtherSects(pOvlyData) ((pOvlyData)->hdr.dbofHdr.numOtherSects) ++#define numCreateSects(pOvlyData) ((pOvlyData)->hdr.dbofHdr.numCreateSects) ++#define numDeleteSects(pOvlyData) ((pOvlyData)->hdr.dbofHdr.numDeleteSects) ++#define numExecuteSects(pOvlyData) ((pOvlyData)->hdr.dbofHdr.numExecuteSects) ++#define otherOffset(pOvlyData) 0 ++#define createOffset(pOvlyData) ((pOvlyData)->hdr.dbofHdr.numOtherSects) ++#define deleteOffset(pOvlyData) (createOffset(pOvlyData) + \ ++ (pOvlyData->hdr.dbofHdr.numCreateSects)) ++#define executeOffset(pOvlyData) (deleteOffset(pOvlyData) + \ ++ (pOvlyData->hdr.dbofHdr.numDeleteSects)) ++/* ++ * ======== OvlyHdr ======== ++ */ ++struct OvlyHdr { ++ struct DBOF_OvlySectHdr dbofHdr; ++ char *pName; /* Name of overlay section */ ++ u16 createRef; /* Reference count for create phase */ ++ u16 deleteRef; /* Reference count for delete phase */ ++ u16 executeRef; /* Execute phase ref count */ ++ u16 otherRef; /* Unspecified phase ref count */ ++} ; ++ ++/* ++ * ======== OvlyData ======== ++ */ ++struct OvlyData { ++ struct OvlyHdr hdr; ++ struct DBOF_OvlySectData data[1]; ++} ; ++ ++/* ++ * ======== Symbol ======== ++ */ ++struct Symbol { ++ struct DBL_Symbol sym; ++ char *pSymName; ++}; ++ ++/* ++ * ======== DCDSect ======== ++ */ ++struct DCDSect { ++ struct DBOF_DCDSectHdr sectHdr; ++ char *pData; ++} ; ++ ++/* ++ * ======== DBL_TargetObj ======== ++ */ ++struct DBL_TargetObj { ++ u32 dwSignature; /* For object validation */ ++ struct DBL_Attrs dblAttrs; /* file read, write, etc. functions */ ++ char *pBuf; /* Load buffer */ ++}; ++ ++/* ++ * ======== TargetInfo ======== ++ */ ++struct TargetInfo { ++ u16 dspType; /* eg, C54TARG, C55TARG */ ++ u32 magic; /* COFF magic number, identifies target type */ ++ u16 wordSize; /* Size of a DSP word */ ++ u16 mauSize; /* Size of minimum addressable unit */ ++ u16 charSize; /* For C55x, mausize = 1, but charsize = 2 */ ++} ; ++ ++/* ++ * ======== DBL_LibraryObj ======== ++ * Represents a library loaded on a target. ++ */ ++struct DBL_LibraryObj { ++ u32 dwSignature; /* For object validation */ ++ struct DBL_TargetObj *pTarget; /* Target for this library */ ++ struct KFILE_FileObj *file; /* DBOF file handle */ ++ bool byteSwapped; /* Are bytes swapped? */ ++ struct DBOF_FileHdr fileHdr; /* Header of DBOF file */ ++ u16 nSymbols; /* Number of DSP/Bridge symbols */ ++ struct Symbol *symbols; /* Table of DSP/Bridge symbols */ ++ u16 nDCDSects; /* Number of DCD sections */ ++ u16 nOvlySects; /* Number of overlay nodes */ ++ struct DCDSect *dcdSects; /* DCD section data */ ++ struct OvlyData **ppOvlyData; /* Array of overlay section data */ ++ struct TargetInfo *pTargetInfo; /* Entry in targetTab[] below */ ++} ; ++ ++#if GT_TRACE ++static struct GT_Mask DBL_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++static u32 magicTab[NUMTARGS] = { C54MAGIC, C55MAGIC }; ++ ++static struct TargetInfo targetTab[] = { ++ /* targ magic wordsize mausize charsize */ ++ {C54TARG, C54MAGIC, 2, 2, 2}, /* C54 */ ++ {C55TARG, C55MAGIC, 2, 1, 2}, /* C55 */ ++}; ++ ++static void freeSects(struct DBL_TargetObj *dbl, struct OvlyData *pOvlyData, ++ s32 offset, s32 nSects); ++static DSP_STATUS loadSect(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib); ++static DSP_STATUS readDCDSects(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib); ++static DSP_STATUS readHeader(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib); ++static DSP_STATUS readOvlySects(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib); ++static DSP_STATUS readSymbols(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib); ++ ++/* ++ * ======== DBL_close ======== ++ * Purpose: ++ * Close library opened with DBL_open. ++ */ ++void DBL_close(struct DBL_LibraryObj *lib) ++{ ++ struct DBL_LibraryObj *pdblLib = (struct DBL_LibraryObj *)lib; ++ u16 i; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pdblLib, DBL_LIBSIGNATURE)); ++ ++ GT_1trace(DBL_debugMask, GT_ENTER, "DBL_close: lib: 0x%x\n", lib); ++ ++ /* Free symbols */ ++ if (pdblLib->symbols) { ++ for (i = 0; i < pdblLib->nSymbols; i++) { ++ if (pdblLib->symbols[i].pSymName) ++ MEM_Free(pdblLib->symbols[i].pSymName); ++ ++ } ++ MEM_Free(pdblLib->symbols); ++ } ++ ++ /* Free DCD sects */ ++ if (pdblLib->dcdSects) { ++ for (i = 0; i < pdblLib->nDCDSects; i++) { ++ if (pdblLib->dcdSects[i].pData) ++ MEM_Free(pdblLib->dcdSects[i].pData); ++ ++ } ++ MEM_Free(pdblLib->dcdSects); ++ } ++ ++ /* Free overlay sects */ ++ if (pdblLib->ppOvlyData) { ++ for (i = 0; i < pdblLib->nOvlySects; i++) { ++ if (pdblLib->ppOvlyData[i]) { ++ if (pdblLib->ppOvlyData[i]->hdr.pName) { ++ MEM_Free(pdblLib->ppOvlyData[i]-> ++ hdr.pName); ++ } ++ MEM_Free(pdblLib->ppOvlyData[i]); ++ } ++ } ++ MEM_Free(pdblLib->ppOvlyData); ++ } ++ ++ /* Close the file */ ++ if (pdblLib->file) ++ (*pdblLib->pTarget->dblAttrs.fclose) (pdblLib->file); ++ ++ ++ MEM_FreeObject(pdblLib); ++} ++ ++/* ++ * ======== DBL_create ======== ++ * Purpose: ++ * Create a target object by specifying the alloc, free, and ++ * write functions for the target. ++ */ ++DSP_STATUS DBL_create(struct DBL_TargetObj **pTarget, struct DBL_Attrs *pAttrs) ++{ ++ struct DBL_TargetObj *pdblTarget = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pAttrs != NULL); ++ DBC_Require(pTarget != NULL); ++ ++ GT_2trace(DBL_debugMask, GT_ENTER, ++ "DBL_create: pTarget: 0x%x pAttrs: 0x%x\n", ++ pTarget, pAttrs); ++ /* Allocate DBL target object */ ++ MEM_AllocObject(pdblTarget, struct DBL_TargetObj, DBL_TARGSIGNATURE); ++ if (pdblTarget == NULL) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "DBL_create: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ pdblTarget->dblAttrs = *pAttrs; ++ /* Allocate buffer for loading target */ ++ pdblTarget->pBuf = MEM_Calloc(LOADBUFSIZE, MEM_PAGED); ++ if (pdblTarget->pBuf == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ *pTarget = pdblTarget; ++ } else { ++ *pTarget = NULL; ++ if (pdblTarget) ++ DBL_delete(pdblTarget); ++ ++ } ++ DBC_Ensure(DSP_SUCCEEDED(status) && ++ ((MEM_IsValidHandle((*pTarget), DBL_TARGSIGNATURE)) || ++ (DSP_FAILED(status) && *pTarget == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DBL_delete ======== ++ * Purpose: ++ * Delete target object and free resources for any loaded libraries. ++ */ ++void DBL_delete(struct DBL_TargetObj *target) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(target, DBL_TARGSIGNATURE)); ++ ++ GT_1trace(DBL_debugMask, GT_ENTER, ++ "DBL_delete: target: 0x%x\n", target); ++ ++ if (target->pBuf) ++ MEM_Free(target->pBuf); ++ ++ MEM_FreeObject(target); ++} ++ ++/* ++ * ======== DBL_exit ======== ++ * Purpose ++ * Discontinue usage of DBL module. ++ */ ++void DBL_exit() ++{ ++ DBC_Require(cRefs > 0); ++ cRefs--; ++ GT_1trace(DBL_debugMask, GT_5CLASS, ++ "DBL_exit() ref count: 0x%x\n", cRefs); ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== DBL_getAddr ======== ++ * Purpose: ++ * Get address of name in the specified library. ++ */ ++bool DBL_getAddr(struct DBL_LibraryObj *lib, char *name, ++ struct DBL_Symbol **ppSym) ++{ ++ bool retVal = false; ++ struct Symbol *symbol; ++ u16 i; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(lib, DBL_LIBSIGNATURE)); ++ DBC_Require(name != NULL); ++ DBC_Require(ppSym != NULL); ++ ++ GT_3trace(DBL_debugMask, GT_ENTER, ++ "DBL_getAddr: libt: 0x%x name: %s pAddr: " ++ "0x%x\n", lib, name, ppSym); ++ for (i = 0; i < lib->nSymbols; i++) { ++ symbol = &lib->symbols[i]; ++ if (CSL_Strcmp(name, symbol->pSymName) == 0) { ++ /* Found it */ ++ *ppSym = &lib->symbols[i].sym; ++ retVal = true; ++ break; ++ } ++ } ++ return retVal; ++} ++ ++/* ++ * ======== DBL_getAttrs ======== ++ * Purpose: ++ * Retrieve the attributes of the target. ++ */ ++void DBL_getAttrs(struct DBL_TargetObj *target, struct DBL_Attrs *pAttrs) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(target, DBL_TARGSIGNATURE)); ++ DBC_Require(pAttrs != NULL); ++ GT_2trace(DBL_debugMask, GT_ENTER, "DBL_getAttrs: target: 0x%x pAttrs: " ++ "0x%x\n", target, pAttrs); ++ *pAttrs = target->dblAttrs; ++} ++ ++/* ++ * ======== DBL_getCAddr ======== ++ * Purpose: ++ * Get address of "C" name in the specified library. ++ */ ++bool DBL_getCAddr(struct DBL_LibraryObj *lib, char *name, ++ struct DBL_Symbol **ppSym) ++{ ++ bool retVal = false; ++ struct Symbol *symbol; ++ u16 i; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(lib, DBL_LIBSIGNATURE)); ++ DBC_Require(name != NULL); ++ DBC_Require(ppSym != NULL); ++ ++ GT_3trace(DBL_debugMask, GT_ENTER, ++ "DBL_getCAddr: target: 0x%x name:%s pAddr:" ++ " 0x%x\n", lib, name, ppSym); ++ for (i = 0; i < lib->nSymbols; i++) { ++ symbol = &lib->symbols[i]; ++ if ((CSL_Strcmp(name, symbol->pSymName) == 0) || ++ (CSL_Strcmp(name, symbol->pSymName + 1) == 0 && ++ symbol->pSymName[0] == '_')) { ++ /* Found it */ ++ *ppSym = &lib->symbols[i].sym; ++ retVal = true; ++ break; ++ } ++ } ++ return retVal; ++} ++ ++/* ++ * ======== DBL_getEntry ======== ++ * Purpose: ++ * Get program entry point. ++ * ++ */ ++bool DBL_getEntry(struct DBL_LibraryObj *lib, u32 *pEntry) ++{ ++ struct DBL_LibraryObj *pdblLib = (struct DBL_LibraryObj *)lib; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pdblLib, DBL_LIBSIGNATURE)); ++ DBC_Require(pEntry != NULL); ++ ++ GT_2trace(DBL_debugMask, GT_ENTER, ++ "DBL_getEntry: lib: 0x%x pEntry: 0x%x\n", lib, pEntry); ++ *pEntry = pdblLib->fileHdr.entry; ++ ++ return true; ++} ++ ++/* ++ * ======== DBL_getSect ======== ++ * Purpose: ++ * Get address and size of a named section. ++ */ ++DSP_STATUS DBL_getSect(struct DBL_LibraryObj *lib, char *name, u32 *pAddr, ++ u32 *pSize) ++{ ++ struct DBL_LibraryObj *pdblLib = (struct DBL_LibraryObj *)lib; ++ u16 i; ++ DSP_STATUS status = DSP_ENOSECT; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(name != NULL); ++ DBC_Require(pAddr != NULL); ++ DBC_Require(pSize != NULL); ++ DBC_Require(MEM_IsValidHandle(pdblLib, DBL_LIBSIGNATURE)); ++ ++ GT_4trace(DBL_debugMask, GT_ENTER, ++ "DBL_getSect: lib: 0x%x name: %s pAddr:" ++ " 0x%x pSize: 0x%x\n", lib, name, pAddr, pSize); ++ ++ /* ++ * Check for DCD and overlay sections. Overlay loader uses DBL_getSect ++ * to determine whether or not a node has overlay sections. ++ * DCD section names begin with '.' ++ */ ++ if (name[0] == '.') { ++ /* Get DCD section size (address is 0, since it's a NOLOAD). */ ++ for (i = 0; i < pdblLib->nDCDSects; i++) { ++ if (CSL_Strcmp(pdblLib->dcdSects[i].sectHdr.name, ++ name) == 0) { ++ *pAddr = 0; ++ *pSize = pdblLib->dcdSects[i].sectHdr.size * ++ pdblLib->pTargetInfo->mauSize; ++ status = DSP_SOK; ++ break; ++ } ++ } ++ } else { ++ /* Check for overlay section */ ++ for (i = 0; i < pdblLib->nOvlySects; i++) { ++ if (CSL_Strcmp(pdblLib->ppOvlyData[i]->hdr.pName, ++ name) == 0) { ++ /* Address and size are meaningless */ ++ *pAddr = 0; ++ *pSize = 0; ++ status = DSP_SOK; ++ break; ++ } ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DBL_init ======== ++ * Purpose: ++ * Initialize DBL module. ++ */ ++bool DBL_init(void) ++{ ++ bool retVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!DBL_debugMask.flags); ++ GT_create(&DBL_debugMask, "BL"); /* "BL" for dBL */ ++ ++ } ++ ++ if (retVal) ++ cRefs++; ++ ++ ++ GT_1trace(DBL_debugMask, GT_5CLASS, "DBL_init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((retVal && (cRefs > 0)) || (!retVal && (cRefs >= 0))); ++ ++ return retVal; ++} ++ ++/* ++ * ======== DBL_load ======== ++ * Purpose: ++ * Add symbols/code/data defined in file to that already present ++ * on the target. ++ */ ++DSP_STATUS DBL_load(struct DBL_LibraryObj *lib, DBL_Flags flags, ++ struct DBL_Attrs *attrs, u32 *pEntry) ++{ ++ struct DBL_LibraryObj *pdblLib = (struct DBL_LibraryObj *)lib; ++ struct DBL_TargetObj *dbl; ++ u16 i; ++ u16 nSects; ++ DSP_STATUS status = DSP_EFAIL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pdblLib, DBL_LIBSIGNATURE)); ++ DBC_Require(pEntry != NULL); ++ DBC_Require(attrs != NULL); ++ ++ GT_4trace(DBL_debugMask, GT_ENTER, "DBL_load: lib: 0x%x flags: " ++ "0x%x attrs: 0x%x pEntry: 0x%x\n", lib, flags, attrs, pEntry); ++ ++ dbl = pdblLib->pTarget; ++ *pEntry = pdblLib->fileHdr.entry; ++ nSects = pdblLib->fileHdr.numSects; ++ dbl->dblAttrs = *attrs; ++ ++ for (i = 0; i < nSects; i++) { ++ /* Load the section at the current file offset */ ++ status = loadSect(dbl, lib); ++ if (DSP_FAILED(status)) ++ break; ++ ++ } ++ ++ /* Done with file, we can close it */ ++ if (pdblLib->file) { ++ (*pdblLib->pTarget->dblAttrs.fclose) (pdblLib->file); ++ pdblLib->file = NULL; ++ } ++ return status; ++} ++ ++/* ++ * ======== DBL_loadSect ======== ++ * Purpose: ++ * Load a named section from an library (for overlay support). ++ */ ++DSP_STATUS DBL_loadSect(struct DBL_LibraryObj *lib, char *sectName, ++ struct DBL_Attrs *attrs) ++{ ++ struct DBL_TargetObj *dbl; ++ s32 i; ++ s32 phase; ++ s32 offset = -1; ++ s32 nSects = -1; ++ s32 allocdSects = 0; ++ u32 loadAddr; ++ u32 runAddr; ++ u32 size; ++ u32 space; ++ u32 ulBytes; ++ u16 mauSize; ++ u16 wordSize; ++ u16 *phaseRef = NULL; ++ u16 *otherRef = NULL; ++ char *name = NULL; ++ struct OvlyData *pOvlyData; ++ DSP_STATUS status = DSP_ENOSECT; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(lib, DBL_LIBSIGNATURE)); ++ DBC_Require(sectName != NULL); ++ DBC_Require(attrs != NULL); ++ DBC_Require(attrs->write != NULL); ++ GT_3trace(DBL_debugMask, GT_ENTER, ++ "DBL_loadSect: lib: 0x%x sectName: %s " ++ "attrs: 0x%x\n", lib, sectName, attrs); ++ dbl = lib->pTarget; ++ mauSize = lib->pTargetInfo->mauSize; ++ wordSize = lib->pTargetInfo->wordSize; ++ /* Check for match of sect name in overlay table */ ++ for (i = 0; i < lib->nOvlySects; i++) { ++ name = lib->ppOvlyData[i]->hdr.pName; ++ if (!CSL_Strncmp(name, sectName, CSL_Strlen(name))) { ++ /* Match found */ ++ status = DSP_SOK; ++ break; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(i < lib->nOvlySects); ++ pOvlyData = lib->ppOvlyData[i]; ++ /* ++ * If node overlay, phase will be encoded in name. If not node ++ * overlay, set phase to NONE. ++ */ ++ phase = (CSL_Strcmp(name, sectName)) ? ++ CSL_Atoi(sectName + CSL_Strlen(sectName) - 1) : NONE; ++ /* Get reference count of node phase to be loaded, offset into ++ * overlay data array, and number of sections to overlay. */ ++ switch (phase) { ++ case NONE: ++ /* Not a node overlay */ ++ phaseRef = &pOvlyData->hdr.otherRef; ++ nSects = numOtherSects(pOvlyData); ++ offset = otherOffset(pOvlyData); ++ break; ++ case CREATEPHASE: ++ phaseRef = &pOvlyData->hdr.createRef; ++ otherRef = &pOvlyData->hdr.otherRef; ++ if (*otherRef) { ++ /* The overlay sections where node phase was ++ * not specified, have already been loaded. */ ++ nSects = numCreateSects(pOvlyData); ++ offset = createOffset(pOvlyData); ++ } else { ++ /* Overlay sections where node phase was not ++ * specified get loaded at create time, along ++ * with create sects. */ ++ nSects = numCreateSects(pOvlyData) + ++ numOtherSects(pOvlyData); ++ offset = otherOffset(pOvlyData); ++ } ++ break; ++ case DELETEPHASE: ++ phaseRef = &pOvlyData->hdr.deleteRef; ++ nSects = numDeleteSects(pOvlyData); ++ offset = deleteOffset(pOvlyData); ++ break; ++ case EXECUTEPHASE: ++ phaseRef = &pOvlyData->hdr.executeRef; ++ nSects = numExecuteSects(pOvlyData); ++ offset = executeOffset(pOvlyData); ++ break; ++ default: ++ /* ERROR */ ++ DBC_Assert(false); ++ break; ++ } ++ /* Do overlay if reference count is 0 */ ++ if (!(*phaseRef)) { ++ /* "Allocate" all sections */ ++ for (i = 0; i < nSects; i++) { ++ runAddr = pOvlyData->data[offset + i].runAddr; ++ size = pOvlyData->data[offset + i].size; ++ space = pOvlyData->data[offset + i].page; ++ status = (dbl->dblAttrs.alloc)(dbl->dblAttrs. ++ rmmHandle, space, size, 0, ++ &runAddr, true); ++ if (DSP_FAILED(status)) ++ break; ++ ++ allocdSects++; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Load sections */ ++ for (i = 0; i < nSects; i++) { ++ loadAddr = pOvlyData->data[offset + i]. ++ loadAddr; ++ runAddr = pOvlyData->data[offset + i]. ++ runAddr; ++ size = pOvlyData->data[offset + i]. ++ size; ++ space = pOvlyData->data[offset + i]. ++ page; ++ /* Convert to word address, call ++ * write function */ ++ loadAddr /= (wordSize / mauSize); ++ runAddr /= (wordSize / mauSize); ++ ulBytes = size * mauSize; ++ if ((*attrs->write)(attrs->wHandle, ++ runAddr, (void *)loadAddr, ulBytes, ++ space) != ulBytes) { ++ GT_0trace(DBL_debugMask, ++ GT_6CLASS, ++ "DBL_loadSect: write" ++ " failed\n"); ++ status = DSP_EFWRITE; ++ break; ++ } ++ } ++ } ++ /* Free sections on failure */ ++ if (DSP_FAILED(status)) ++ freeSects(dbl, pOvlyData, offset, allocdSects); ++ ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Increment reference counts */ ++ if (otherRef) ++ *otherRef = *otherRef + 1; ++ ++ *phaseRef = *phaseRef + 1; ++ } ++ return status; ++} ++ ++/* ++ * ======== DBL_open ======== ++ * Purpose: ++ * DBL_open() returns a library handle that can be used to ++ * load/unload the symbols/code/data via DBL_load()/DBL_unload(). ++ */ ++DSP_STATUS DBL_open(struct DBL_TargetObj *target, char *file, DBL_Flags flags, ++ struct DBL_LibraryObj **pLib) ++{ ++ struct DBL_LibraryObj *pdblLib = NULL; ++ u16 nSymbols; ++ u16 nDCDSects; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(target, DBL_TARGSIGNATURE)); ++ DBC_Require(target->dblAttrs.fopen != NULL); ++ DBC_Require(file != NULL); ++ DBC_Require(pLib != NULL); ++ ++ GT_3trace(DBL_debugMask, GT_ENTER, "DBL_open: target: 0x%x file: %s " ++ "pLib: 0x%x\n", target, file, pLib); ++ /* Allocate DBL library object */ ++ MEM_AllocObject(pdblLib, struct DBL_LibraryObj, DBL_LIBSIGNATURE); ++ if (pdblLib == NULL) ++ status = DSP_EMEMORY; ++ ++ /* Open the file */ ++ if (DSP_SUCCEEDED(status)) { ++ pdblLib->pTarget = target; ++ pdblLib->file = (*target->dblAttrs.fopen)(file, "rb"); ++ if (pdblLib->file == NULL) ++ status = DSP_EFOPEN; ++ ++ } ++ /* Read file header */ ++ if (DSP_SUCCEEDED(status)) { ++ status = readHeader(target, pdblLib); ++ if (DSP_FAILED(status)) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "DBL_open(): Failed to read file header\n"); ++ } ++ } ++ /* Allocate symbol table */ ++ if (DSP_SUCCEEDED(status)) { ++ nSymbols = pdblLib->nSymbols = pdblLib->fileHdr.numSymbols; ++ pdblLib->symbols = MEM_Calloc(nSymbols * sizeof(struct Symbol), ++ MEM_PAGED); ++ if (pdblLib->symbols == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ /* Read all the symbols */ ++ if (DSP_SUCCEEDED(status)) { ++ status = readSymbols(target, pdblLib); ++ if (DSP_FAILED(status)) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "DBL_open(): Failed to read symbols\n"); ++ } ++ } ++ /* Allocate DCD sect table */ ++ if (DSP_SUCCEEDED(status)) { ++ nDCDSects = pdblLib->nDCDSects = pdblLib->fileHdr.numDCDSects; ++ pdblLib->dcdSects = MEM_Calloc(nDCDSects * ++ sizeof(struct DCDSect), MEM_PAGED); ++ if (pdblLib->dcdSects == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ /* Read DCD sections */ ++ if (DSP_SUCCEEDED(status)) { ++ status = readDCDSects(target, pdblLib); ++ if (DSP_FAILED(status)) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "DBL_open(): Failed to read DCD sections\n"); ++ } ++ } ++ /* Read overlay sections */ ++ if (DSP_SUCCEEDED(status)) { ++ status = readOvlySects(target, pdblLib); ++ if (DSP_FAILED(status)) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "DBL_open(): Failed to read " ++ "overlay sections\n"); ++ } ++ } ++ if (DSP_FAILED(status)) { ++ *pLib = NULL; ++ if (pdblLib != NULL) ++ DBL_close((struct DBL_LibraryObj *) pdblLib); ++ ++ } else { ++ *pLib = pdblLib; ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ (MEM_IsValidHandle((*pLib), DBL_LIBSIGNATURE))) || ++ (DSP_FAILED(status) && *pLib == NULL)); ++ return status; ++} ++ ++/* ++ * ======== DBL_readSect ======== ++ * Purpose: ++ * Read COFF section into a character buffer. ++ */ ++DSP_STATUS DBL_readSect(struct DBL_LibraryObj *lib, char *name, char *pContent, ++ u32 size) ++{ ++ struct DBL_LibraryObj *pdblLib = (struct DBL_LibraryObj *)lib; ++ u16 i; ++ u32 mauSize; ++ u32 max; ++ DSP_STATUS status = DSP_ENOSECT; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pdblLib, DBL_LIBSIGNATURE)); ++ DBC_Require(name != NULL); ++ DBC_Require(pContent != NULL); ++ DBC_Require(size != 0); ++ GT_4trace(DBL_debugMask, GT_ENTER, "DBL_readSect: lib: 0x%x name: %s " ++ "pContent: 0x%x size: 0x%x\n", lib, name, pContent, size); ++ ++ mauSize = pdblLib->pTargetInfo->mauSize; ++ ++ /* Attempt to find match with DCD section names. */ ++ for (i = 0; i < pdblLib->nDCDSects; i++) { ++ if (CSL_Strcmp(pdblLib->dcdSects[i].sectHdr.name, name) == 0) { ++ /* Match found */ ++ max = pdblLib->dcdSects[i].sectHdr.size * mauSize; ++ max = (max > size) ? size : max; ++ memcpy(pContent, pdblLib->dcdSects[i].pData, max); ++ status = DSP_SOK; ++ break; ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DBL_setAttrs ======== ++ * Purpose: ++ * Set the attributes of the target. ++ */ ++void DBL_setAttrs(struct DBL_TargetObj *target, struct DBL_Attrs *pAttrs) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(target, DBL_TARGSIGNATURE)); ++ DBC_Require(pAttrs != NULL); ++ ++ GT_2trace(DBL_debugMask, GT_ENTER, "DBL_setAttrs: target: 0x%x pAttrs: " ++ "0x%x\n", target, pAttrs); ++ ++ target->dblAttrs = *pAttrs; ++} ++ ++/* ++ * ======== DBL_unload ======== ++ * Purpose: ++ * Remove the symbols/code/data corresponding to the library lib. ++ */ ++void DBL_unload(struct DBL_LibraryObj *lib, struct DBL_Attrs *attrs) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(lib, DBL_LIBSIGNATURE)); ++ ++ GT_1trace(DBL_debugMask, GT_ENTER, "DBL_unload: lib: 0x%x\n", lib); ++ ++ /* Nothing to do for static loading */ ++} ++ ++/* ++ * ======== DBL_unloadSect ======== ++ * Purpose: ++ * Unload a named section from an library (for overlay support). ++ */ ++DSP_STATUS DBL_unloadSect(struct DBL_LibraryObj *lib, char *sectName, ++ struct DBL_Attrs *attrs) ++{ ++ struct DBL_TargetObj *dbl; ++ s32 i; ++ s32 phase; ++ s32 offset = -1; ++ s32 nSects = -1; ++ u16 *phaseRef = NULL; ++ u16 *otherRef = NULL; ++ char *pName = NULL; ++ struct OvlyData *pOvlyData; ++ DSP_STATUS status = DSP_ENOSECT; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(lib, DBL_LIBSIGNATURE)); ++ DBC_Require(sectName != NULL); ++ ++ GT_2trace(DBL_debugMask, GT_ENTER, ++ "DBL_unloadSect: lib: 0x%x sectName: %s\n", lib, sectName); ++ dbl = lib->pTarget; ++ /* Check for match of sect name in overlay table */ ++ for (i = 0; i < lib->nOvlySects; i++) { ++ pName = lib->ppOvlyData[i]->hdr.pName; ++ if (!CSL_Strncmp(pName, sectName, CSL_Strlen(pName))) { ++ /* Match found */ ++ status = DSP_SOK; ++ break; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(i < lib->nOvlySects); ++ pOvlyData = lib->ppOvlyData[i]; ++ /* If node overlay, phase will be encoded in name. */ ++ phase = (CSL_Strcmp(pName, sectName)) ? ++ CSL_Atoi(sectName + CSL_Strlen(sectName) - 1) : NONE; ++ switch (phase) { ++ case NONE: ++ nSects = numOtherSects(pOvlyData); ++ phaseRef = &pOvlyData->hdr.otherRef; ++ offset = otherOffset(pOvlyData); ++ break; ++ case CREATEPHASE: ++ nSects = numCreateSects(pOvlyData); ++ offset = createOffset(pOvlyData); ++ phaseRef = &pOvlyData->hdr.createRef; ++ break; ++ case DELETEPHASE: ++ nSects = numDeleteSects(pOvlyData); ++ offset = deleteOffset(pOvlyData); ++ phaseRef = &pOvlyData->hdr.deleteRef; ++ otherRef = &pOvlyData->hdr.otherRef; ++ break; ++ case EXECUTEPHASE: ++ nSects = numExecuteSects(pOvlyData); ++ offset = executeOffset(pOvlyData); ++ phaseRef = &pOvlyData->hdr.executeRef; ++ break; ++ default: ++ /* ERROR */ ++ DBC_Assert(false); ++ break; ++ } ++ if (*phaseRef) { ++ *phaseRef = *phaseRef - 1; ++ if (*phaseRef == 0) { ++ /* Unload overlay sections for phase */ ++ freeSects(dbl, pOvlyData, offset, nSects); ++ } ++ if (phase == DELETEPHASE) { ++ DBC_Assert(*otherRef); ++ *otherRef = *otherRef - 1; ++ if (*otherRef == 0) { ++ /* Unload other overlay sections */ ++ nSects = numOtherSects(pOvlyData); ++ offset = otherOffset(pOvlyData); ++ freeSects(dbl, pOvlyData, offset, ++ nSects); ++ } ++ } ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== freeSects ======== ++ * Purpose: ++ * Free section ++ */ ++static void freeSects(struct DBL_TargetObj *dbl, struct OvlyData *pOvlyData, ++ s32 offset, s32 nSects) ++{ ++ u32 runAddr; ++ u32 size; ++ u32 space; ++ s32 i; ++ ++ for (i = 0; i < nSects; i++) { ++ runAddr = pOvlyData->data[offset + i].runAddr; ++ size = pOvlyData->data[offset + i].size; ++ space = pOvlyData->data[offset + i].page; ++ if (!(dbl->dblAttrs.free) ++ (dbl->dblAttrs.rmmHandle, space, runAddr, size, true)) { ++ /* ++ * Free function will not fail for overlay, unless ++ * address passed in is bad. ++ */ ++ DBC_Assert(false); ++ } ++ } ++} ++ ++/* ++ * ======== loadSect ======== ++ * Purpose: ++ * Load section to target ++ */ ++static DSP_STATUS loadSect(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib) ++{ ++ struct DBOF_SectHdr sectHdr; ++ char *pBuf; ++ struct KFILE_FileObj *file; ++ u32 space; ++ u32 addr; ++ u32 total; ++ u32 nWords = 0; ++ u32 nBytes = 0; ++ u16 mauSize; ++ u32 bufSize; ++ DSP_STATUS status = DSP_SOK; ++ ++ file = pdblLib->file; ++ mauSize = pdblLib->pTargetInfo->mauSize; ++ bufSize = LOADBUFSIZE / mauSize; ++ pBuf = dbl->pBuf; ++ ++ /* Read the section header */ ++ if ((*dbl->dblAttrs.fread)(§Hdr, sizeof(struct DBOF_SectHdr), ++ 1, file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read DCD sect header\n"); ++ status = DSP_EFREAD; ++ } else { ++ if (pdblLib->byteSwapped) { ++ sectHdr.size = SWAPLONG(sectHdr.size); ++ sectHdr.addr = SWAPLONG(sectHdr.addr); ++ sectHdr.page = SWAPWORD(sectHdr.page); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ addr = sectHdr.addr; ++ space = sectHdr.page; ++ for (total = sectHdr.size; total > 0; total -= nWords) { ++ nWords = min(total, bufSize); ++ nBytes = nWords * mauSize; ++ /* Read section data */ ++ if ((*dbl->dblAttrs.fread)(pBuf, nBytes, 1, ++ file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read DCD sect header\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ /* Write section to target */ ++ if (!(*dbl->dblAttrs.write)(dbl->dblAttrs.wHandle, ++ addr, pBuf, nBytes, space)) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to write section data\n"); ++ status = DSP_EFWRITE; ++ break; ++ } ++ addr += nWords; ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== readDCDSects ======== ++ * Purpose: ++ * Read DCD sections. ++ */ ++static DSP_STATUS readDCDSects(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib) ++{ ++ struct DBOF_DCDSectHdr *pSectHdr; ++ struct DCDSect *pSect; ++ struct KFILE_FileObj *file; ++ u16 nSects; ++ u16 i; ++ u16 mauSize; ++ DSP_STATUS status = DSP_SOK; ++ ++ file = pdblLib->file; ++ mauSize = pdblLib->pTargetInfo->mauSize; ++ nSects = pdblLib->fileHdr.numDCDSects; ++ for (i = 0; i < nSects; i++) { ++ pSect = &pdblLib->dcdSects[i]; ++ pSectHdr = &pdblLib->dcdSects[i].sectHdr; ++ /* Read sect header */ ++ if ((*dbl->dblAttrs.fread)(pSectHdr, ++ sizeof(struct DBOF_DCDSectHdr), 1, file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read DCD sect header\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ if (pdblLib->byteSwapped) ++ pSectHdr->size = SWAPLONG(pSectHdr->size); ++ ++ pSect->pData = (char *)MEM_Calloc(pSectHdr->size * ++ mauSize, MEM_PAGED); ++ if (pSect->pData == NULL) { ++ GT_2trace(DBL_debugMask, GT_6CLASS, ++ "Memory allocation for sect %s " ++ "data failed: Size: 0x%lx\n", pSectHdr->name, ++ pSectHdr->size); ++ status = DSP_EMEMORY; ++ break; ++ } ++ /* Read DCD sect data */ ++ if ((*dbl->dblAttrs.fread)(pSect->pData, mauSize, ++ pSectHdr->size, file) != pSectHdr->size) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read DCD sect data\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== readHeader ======== ++ * Purpose: ++ * Read Header. ++ */ ++static DSP_STATUS readHeader(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib) ++{ ++ struct KFILE_FileObj *file; ++ s32 i; ++ struct DBOF_FileHdr *pHdr; ++ u32 swapMagic; ++ DSP_STATUS status = DSP_SOK; ++ ++ pdblLib->byteSwapped = false; ++ file = pdblLib->file; ++ pHdr = &pdblLib->fileHdr; ++ if ((*dbl->dblAttrs.fread)(pHdr, sizeof(struct DBOF_FileHdr), 1, ++ file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "readHeader: Failed to read file header\n"); ++ status = DSP_EFREAD; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Determine if byte swapped */ ++ for (i = 0; i < NUMTARGS; i++) { ++ swapMagic = SWAPLONG(pHdr->magic); ++ if (pHdr->magic == magicTab[i] || swapMagic == ++ magicTab[i]) { ++ if (swapMagic == magicTab[i]) { ++ pdblLib->byteSwapped = true; ++ pHdr->magic = SWAPLONG(pHdr->magic); ++ pHdr->entry = SWAPLONG(pHdr->entry); ++ pHdr->symOffset = SWAPLONG(pHdr-> ++ symOffset); ++ pHdr->dcdSectOffset = SWAPLONG(pHdr-> ++ dcdSectOffset); ++ pHdr->loadSectOffset = SWAPLONG(pHdr-> ++ loadSectOffset); ++ pHdr->ovlySectOffset = SWAPLONG(pHdr-> ++ ovlySectOffset); ++ pHdr->numSymbols = SWAPWORD(pHdr-> ++ numSymbols); ++ pHdr->numDCDSects = SWAPWORD(pHdr-> ++ numDCDSects); ++ pHdr->numSects = SWAPWORD(pHdr-> ++ numSects); ++ pHdr->numOvlySects = SWAPWORD(pHdr-> ++ numOvlySects); ++ } ++ break; ++ } ++ } ++ if (i == NUMTARGS) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "readHeader: Failed to determine" ++ " target type\n"); ++ status = DSP_ECORRUPTFILE; ++ } else { ++ pdblLib->pTargetInfo = &targetTab[i]; ++ GT_1trace(DBL_debugMask, GT_ENTER, ++ "COF type: 0x%lx\n", pHdr->magic); ++ GT_1trace(DBL_debugMask, GT_ENTER, ++ "Entry point:0x%lx\n", pHdr->entry); ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== readOvlySects ======== ++ * Purpose: ++ * Read Overlay Sections ++ */ ++static DSP_STATUS readOvlySects(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib) ++{ ++ struct DBOF_OvlySectHdr hdr; ++ struct DBOF_OvlySectData *pData; ++ struct OvlyData *pOvlyData; ++ char *pName; ++ struct KFILE_FileObj *file; ++ u16 i, j; ++ u16 nSects; ++ u16 n; ++ DSP_STATUS status = DSP_SOK; ++ ++ pdblLib->nOvlySects = nSects = pdblLib->fileHdr.numOvlySects; ++ file = pdblLib->file; ++ if (nSects > 0) { ++ pdblLib->ppOvlyData = MEM_Calloc(nSects * sizeof(OvlyData *), ++ MEM_PAGED); ++ if (pdblLib->ppOvlyData == NULL) { ++ GT_0trace(DBL_debugMask, GT_7CLASS, ++ "Failed to allocatate overlay " ++ "data memory\n"); ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Read overlay data for each node */ ++ for (i = 0; i < nSects; i++) { ++ /* Read overlay section header */ ++ if ((*dbl->dblAttrs.fread)(&hdr, ++ sizeof(struct DBOF_OvlySectHdr), 1, file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read overlay sect" ++ " header\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ if (pdblLib->byteSwapped) { ++ hdr.nameLen = SWAPWORD(hdr.nameLen); ++ hdr.numCreateSects = ++ SWAPWORD(hdr.numCreateSects); ++ hdr.numDeleteSects = ++ SWAPWORD(hdr.numDeleteSects); ++ hdr.numExecuteSects = ++ SWAPWORD(hdr.numExecuteSects); ++ hdr.numOtherSects = ++ SWAPWORD(hdr.numOtherSects); ++ hdr.resvd = SWAPWORD(hdr.resvd); ++ } ++ n = hdr.numCreateSects + hdr.numDeleteSects + ++ hdr.numExecuteSects + hdr.numOtherSects; ++ ++ /* Allocate memory for node's overlay data */ ++ pOvlyData = (struct OvlyData *)MEM_Calloc ++ (sizeof(struct OvlyHdr) + ++ n * sizeof(struct DBOF_OvlySectData), ++ MEM_PAGED); ++ if (pOvlyData == NULL) { ++ GT_0trace(DBL_debugMask, GT_7CLASS, ++ "Failed to allocatate ovlyay" ++ " data memory\n"); ++ status = DSP_EMEMORY; ++ break; ++ } ++ pOvlyData->hdr.dbofHdr = hdr; ++ pdblLib->ppOvlyData[i] = pOvlyData; ++ /* Allocate memory for section name */ ++ pName = (char *)MEM_Calloc(hdr.nameLen + 1, MEM_PAGED); ++ if (pName == NULL) { ++ GT_0trace(DBL_debugMask, GT_7CLASS, ++ "Failed to allocatate ovlyay" ++ " section name\n"); ++ status = DSP_EMEMORY; ++ break; ++ } ++ pOvlyData->hdr.pName = pName; ++ /* Read the overlay section name */ ++ if ((*dbl->dblAttrs.fread)(pName, sizeof(char), ++ hdr.nameLen, file) != hdr.nameLen) { ++ GT_0trace(DBL_debugMask, GT_7CLASS, ++ "readOvlySects: Unable to " ++ "read overlay name.\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ /* Read the overlay section data */ ++ pData = pOvlyData->data; ++ if ((*dbl->dblAttrs.fread)(pData, ++ sizeof(struct DBOF_OvlySectData), n, file) != n) { ++ GT_0trace(DBL_debugMask, GT_7CLASS, ++ "readOvlySects: Unable to " ++ "read overlay data.\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ /* Swap overlay data, if necessary */ ++ if (pdblLib->byteSwapped) { ++ for (j = 0; j < n; j++) { ++ pData[j].loadAddr = ++ SWAPLONG(pData[j].loadAddr); ++ pData[j].runAddr = ++ SWAPLONG(pData[j].runAddr); ++ pData[j].size = ++ SWAPLONG(pData[j].size); ++ pData[j].page = ++ SWAPWORD(pData[j].page); ++ } ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== readSymbols ======== ++ * Purpose: ++ * Read Symbols ++ */ ++static DSP_STATUS readSymbols(struct DBL_TargetObj *dbl, ++ struct DBL_LibraryObj *pdblLib) ++{ ++ struct DBOF_SymbolHdr symHdr; ++ struct KFILE_FileObj *file; ++ u16 i; ++ u16 nSymbols; ++ u16 len; ++ char *pName = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ file = pdblLib->file; ++ ++ nSymbols = pdblLib->fileHdr.numSymbols; ++ ++ for (i = 0; i < nSymbols; i++) { ++ /* Read symbol value */ ++ if ((*dbl->dblAttrs.fread)(&symHdr, ++ sizeof(struct DBOF_SymbolHdr), 1, file) != 1) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read symbol value\n"); ++ status = DSP_EFREAD; ++ break; ++ } ++ if (pdblLib->byteSwapped) { ++ symHdr.nameLen = SWAPWORD(symHdr.nameLen); ++ symHdr.value = SWAPLONG(symHdr.value); ++ } ++ /* Allocate buffer for symbol name */ ++ len = symHdr.nameLen; ++ pName = (char *)MEM_Calloc(len + 1, MEM_PAGED); ++ if (pName == NULL) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ break; ++ } ++ pdblLib->symbols[i].pSymName = pName; ++ pdblLib->symbols[i].sym.value = symHdr.value; ++ /* Read symbol name */ ++ if ((*dbl->dblAttrs.fread) (pName, sizeof(char), len, file) != ++ len) { ++ GT_0trace(DBL_debugMask, GT_6CLASS, ++ "Failed to read symbol value\n"); ++ status = DSP_EFREAD; ++ break; ++ } else { ++ pName[len] = '\0'; ++ GT_2trace(DBL_debugMask, GT_ENTER, ++ "Symbol: %s Value: 0x%lx\n", ++ pName, symHdr.value); ++ } ++ } ++ return status; ++} ++ +diff --git a/drivers/dsp/bridge/pmgr/dbll.c b/drivers/dsp/bridge/pmgr/dbll.c +new file mode 100644 +index 0000000..82430a3 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/dbll.c +@@ -0,0 +1,1564 @@ ++/* ++ * dbll.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dbll.c ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 25-Apr-2030 map: Fixed symbol redefinition bug + unload and return error ++ *! 08-Apr-2003 map: Consolidated DBL with DBLL loader name ++ *! 24-Mar-2003 map: Updated findSymbol to support dllview update ++ *! 23-Jan-2003 map: Updated rmmAlloc to support memory granularity ++ *! 21-Nov-2002 map: Combine fopen and DLOAD_module_open to increase ++ *! performance on start. ++ *! 04-Oct-2002 map: Integrated new TIP dynamic loader w/ DOF api. ++ *! 27-Sep-2002 map: Changed handle passed to RemoteFree, instead of ++ *! RMM_free; added GT_trace to rmmDealloc ++ *! 20-Sep-2002 map: Updated from Code Review ++ *! 08-Aug-2002 jeh: Updated to support overlays. ++ *! 25-Jun-2002 jeh: Pass RMM_Addr object to alloc function in rmmAlloc(). ++ *! 20-Mar-2002 jeh: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/gt.h> ++#include <dspbridge/dbc.h> ++#include <dspbridge/gh.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* Dynamic loader library interface */ ++#include <dspbridge/dynamic_loader.h> ++#include <dspbridge/getsection.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dbll.h> ++#include <dspbridge/rmm.h> ++ ++#define DBLL_TARGSIGNATURE 0x544c4c44 /* "TLLD" */ ++#define DBLL_LIBSIGNATURE 0x4c4c4c44 /* "LLLD" */ ++ ++/* Number of buckets for symbol hash table */ ++#define MAXBUCKETS 211 ++ ++/* Max buffer length */ ++#define MAXEXPR 128 ++ ++#ifndef UINT32_C ++#define UINT32_C(zzz) ((uint32_t)zzz) ++#endif ++#define DOFF_ALIGN(x) (((x) + 3) & ~UINT32_C(3)) ++ ++/* ++ * ======== struct DBLL_TarObj* ======== ++ * A target may have one or more libraries of symbols/code/data loaded ++ * onto it, where a library is simply the symbols/code/data contained ++ * in a DOFF file. ++ */ ++/* ++ * ======== DBLL_TarObj ======== ++ */ ++struct DBLL_TarObj { ++ u32 dwSignature; /* For object validation */ ++ struct DBLL_Attrs attrs; ++ struct DBLL_LibraryObj *head; /* List of all opened libraries */ ++} ; ++ ++/* ++ * The following 4 typedefs are "super classes" of the dynamic loader ++ * library types used in dynamic loader functions (dynamic_loader.h). ++ */ ++/* ++ * ======== DBLLStream ======== ++ * Contains Dynamic_Loader_Stream ++ */ ++struct DBLLStream { ++ struct Dynamic_Loader_Stream dlStream; ++ struct DBLL_LibraryObj *lib; ++} ; ++ ++/* ++ * ======== DBLLSymbol ======== ++ */ ++struct DBLLSymbol { ++ struct Dynamic_Loader_Sym dlSymbol; ++ struct DBLL_LibraryObj *lib; ++} ; ++ ++/* ++ * ======== DBLLAlloc ======== ++ */ ++ struct DBLLAlloc { ++ struct Dynamic_Loader_Allocate dlAlloc; ++ struct DBLL_LibraryObj *lib; ++} ; ++ ++/* ++ * ======== DBLLInit ======== ++ */ ++struct DBLLInit { ++ struct Dynamic_Loader_Initialize dlInit; ++ struct DBLL_LibraryObj *lib; ++}; ++ ++/* ++ * ======== DBLL_Library ======== ++ * A library handle is returned by DBLL_Open() and is passed to DBLL_load() ++ * to load symbols/code/data, and to DBLL_unload(), to remove the ++ * symbols/code/data loaded by DBLL_load(). ++ */ ++ ++/* ++ * ======== DBLL_LibraryObj ======== ++ */ ++ struct DBLL_LibraryObj { ++ u32 dwSignature; /* For object validation */ ++ struct DBLL_LibraryObj *next; /* Next library in target's list */ ++ struct DBLL_LibraryObj *prev; /* Previous in the list */ ++ struct DBLL_TarObj *pTarget; /* target for this library */ ++ ++ /* Objects needed by dynamic loader */ ++ struct DBLLStream stream; ++ struct DBLLSymbol symbol; ++ struct DBLLAlloc allocate; ++ struct DBLLInit init; ++ DLOAD_mhandle mHandle; ++ ++ char *fileName; /* COFF file name */ ++ void *fp; /* Opaque file handle */ ++ u32 entry; /* Entry point */ ++ DLOAD_mhandle desc; /* desc of DOFF file loaded */ ++ u32 openRef; /* Number of times opened */ ++ u32 loadRef; /* Number of times loaded */ ++ struct GH_THashTab *symTab; /* Hash table of symbols */ ++ u32 ulPos; ++} ; ++ ++/* ++ * ======== Symbol ======== ++ */ ++struct Symbol { ++ struct DBLL_Symbol value; ++ char *name; ++} ; ++extern bool bSymbolsReloaded; ++ ++static void dofClose(struct DBLL_LibraryObj *zlLib); ++static DSP_STATUS dofOpen(struct DBLL_LibraryObj *zlLib); ++static s32 NoOp(struct Dynamic_Loader_Initialize *thisptr, void *bufr, ++ LDR_ADDR locn, struct LDR_SECTION_INFO *info, unsigned bytsiz); ++ ++/* ++ * Functions called by dynamic loader ++ * ++ */ ++/* Dynamic_Loader_Stream */ ++static int readBuffer(struct Dynamic_Loader_Stream *this, void *buffer, ++ unsigned bufsize); ++static int setFilePosn(struct Dynamic_Loader_Stream *this, unsigned int pos); ++/* Dynamic_Loader_Sym */ ++static struct dynload_symbol *findSymbol(struct Dynamic_Loader_Sym *this, ++ const char *name); ++static struct dynload_symbol *addToSymbolTable(struct Dynamic_Loader_Sym *this, ++ const char *name, ++ unsigned moduleId); ++static struct dynload_symbol *findInSymbolTable(struct Dynamic_Loader_Sym *this, ++ const char *name, ++ unsigned moduleid); ++static void purgeSymbolTable(struct Dynamic_Loader_Sym *this, ++ unsigned moduleId); ++static void *allocate(struct Dynamic_Loader_Sym *this, unsigned memsize); ++static void deallocate(struct Dynamic_Loader_Sym *this, void *memPtr); ++static void errorReport(struct Dynamic_Loader_Sym *this, const char *errstr, ++ va_list args); ++/* Dynamic_Loader_Allocate */ ++static int rmmAlloc(struct Dynamic_Loader_Allocate *this, ++ struct LDR_SECTION_INFO *info, unsigned align); ++static void rmmDealloc(struct Dynamic_Loader_Allocate *this, ++ struct LDR_SECTION_INFO *info); ++ ++/* Dynamic_Loader_Initialize */ ++static int connect(struct Dynamic_Loader_Initialize *this); ++static int readMem(struct Dynamic_Loader_Initialize *this, void *buf, ++ LDR_ADDR addr, struct LDR_SECTION_INFO *info, ++ unsigned nbytes); ++static int writeMem(struct Dynamic_Loader_Initialize *this, void *buf, ++ LDR_ADDR addr, struct LDR_SECTION_INFO *info, ++ unsigned nbytes); ++static int fillMem(struct Dynamic_Loader_Initialize *this, LDR_ADDR addr, ++ struct LDR_SECTION_INFO *info, unsigned nbytes, ++ unsigned val); ++static int execute(struct Dynamic_Loader_Initialize *this, LDR_ADDR start); ++static void release(struct Dynamic_Loader_Initialize *this); ++ ++/* symbol table hash functions */ ++static u16 nameHash(void *name, u16 maxBucket); ++static bool nameMatch(void *name, void *sp); ++static void symDelete(void *sp); ++ ++#if GT_TRACE ++static struct GT_Mask DBLL_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++/* Symbol Redefinition */ ++static int bRedefinedSymbol; ++static int bGblSearch = 1; ++ ++/* ++ * ======== DBLL_close ======== ++ */ ++void DBLL_close(struct DBLL_LibraryObj *zlLib) ++{ ++ struct DBLL_TarObj *zlTarget; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(zlLib->openRef > 0); ++ zlTarget = zlLib->pTarget; ++ GT_1trace(DBLL_debugMask, GT_ENTER, "DBLL_close: lib: 0x%x\n", zlLib); ++ zlLib->openRef--; ++ if (zlLib->openRef == 0) { ++ /* Remove library from list */ ++ if (zlTarget->head == zlLib) ++ zlTarget->head = zlLib->next; ++ ++ if (zlLib->prev) ++ (zlLib->prev)->next = zlLib->next; ++ ++ if (zlLib->next) ++ (zlLib->next)->prev = zlLib->prev; ++ ++ /* Free DOF resources */ ++ dofClose(zlLib); ++ if (zlLib->fileName) ++ MEM_Free(zlLib->fileName); ++ ++ /* remove symbols from symbol table */ ++ if (zlLib->symTab) ++ GH_delete(zlLib->symTab); ++ ++ /* remove the library object itself */ ++ MEM_FreeObject(zlLib); ++ zlLib = NULL; ++ } ++} ++ ++/* ++ * ======== DBLL_create ======== ++ */ ++DSP_STATUS DBLL_create(struct DBLL_TarObj **pTarget, struct DBLL_Attrs *pAttrs) ++{ ++ struct DBLL_TarObj *pzlTarget; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pAttrs != NULL); ++ DBC_Require(pTarget != NULL); ++ ++ GT_2trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_create: pTarget: 0x%x pAttrs: " ++ "0x%x\n", pTarget, pAttrs); ++ /* Allocate DBL target object */ ++ MEM_AllocObject(pzlTarget, struct DBLL_TarObj, DBLL_TARGSIGNATURE); ++ if (pTarget != NULL) { ++ if (pzlTarget == NULL) { ++ GT_0trace(DBLL_debugMask, GT_6CLASS, ++ "DBLL_create: Memory allocation" ++ " failed\n"); ++ *pTarget = NULL; ++ status = DSP_EMEMORY; ++ } else { ++ pzlTarget->attrs = *pAttrs; ++ *pTarget = (struct DBLL_TarObj *)pzlTarget; ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle(((struct DBLL_TarObj *)(*pTarget)), ++ DBLL_TARGSIGNATURE)) || (DSP_FAILED(status) && ++ *pTarget == NULL)); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DBLL_delete ======== ++ */ ++void DBLL_delete(struct DBLL_TarObj *target) ++{ ++ struct DBLL_TarObj *zlTarget = (struct DBLL_TarObj *)target; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlTarget, DBLL_TARGSIGNATURE)); ++ ++ GT_1trace(DBLL_debugMask, GT_ENTER, "DBLL_delete: target: 0x%x\n", ++ target); ++ ++ if (zlTarget != NULL) ++ MEM_FreeObject(zlTarget); ++ ++} ++ ++/* ++ * ======== DBLL_exit ======== ++ * Discontinue usage of DBL module. ++ */ ++void DBLL_exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(DBLL_debugMask, GT_5CLASS, "DBLL_exit() ref count: 0x%x\n", ++ cRefs); ++ ++ if (cRefs == 0) { ++ MEM_Exit(); ++ CSL_Exit(); ++ GH_exit(); ++#if GT_TRACE ++ DBLL_debugMask.flags = NULL; ++#endif ++ } ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== DBLL_getAddr ======== ++ * Get address of name in the specified library. ++ */ ++bool DBLL_getAddr(struct DBLL_LibraryObj *zlLib, char *name, ++ struct DBLL_Symbol **ppSym) ++{ ++ struct Symbol *sym; ++ bool status = false; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(name != NULL); ++ DBC_Require(ppSym != NULL); ++ DBC_Require(zlLib->symTab != NULL); ++ ++ GT_3trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_getAddr: lib: 0x%x name: %s pAddr:" ++ " 0x%x\n", zlLib, name, ppSym); ++ sym = (struct Symbol *)GH_find(zlLib->symTab, name); ++ if (sym != NULL) { ++ *ppSym = &sym->value; ++ status = true; ++ } ++ return status; ++} ++ ++/* ++ * ======== DBLL_getAttrs ======== ++ * Retrieve the attributes of the target. ++ */ ++void DBLL_getAttrs(struct DBLL_TarObj *target, struct DBLL_Attrs *pAttrs) ++{ ++ struct DBLL_TarObj *zlTarget = (struct DBLL_TarObj *)target; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlTarget, DBLL_TARGSIGNATURE)); ++ DBC_Require(pAttrs != NULL); ++ ++ if ((pAttrs != NULL) && (zlTarget != NULL)) ++ *pAttrs = zlTarget->attrs; ++ ++} ++ ++/* ++ * ======== DBLL_getCAddr ======== ++ * Get address of a "C" name in the specified library. ++ */ ++bool DBLL_getCAddr(struct DBLL_LibraryObj *zlLib, char *name, ++ struct DBLL_Symbol **ppSym) ++{ ++ struct Symbol *sym; ++ char cname[MAXEXPR + 1]; ++ bool status = false; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(ppSym != NULL); ++ DBC_Require(zlLib->symTab != NULL); ++ DBC_Require(name != NULL); ++ ++ cname[0] = '_'; ++ ++ strncpy(cname + 1, name, sizeof(cname) - 2); ++ cname[MAXEXPR] = '\0'; /* insure '\0' string termination */ ++ ++ /* Check for C name, if not found */ ++ sym = (struct Symbol *)GH_find(zlLib->symTab, cname); ++ ++ if (sym != NULL) { ++ *ppSym = &sym->value; ++ status = true; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DBLL_getSect ======== ++ * Get the base address and size (in bytes) of a COFF section. ++ */ ++DSP_STATUS DBLL_getSect(struct DBLL_LibraryObj *lib, char *name, u32 *pAddr, ++ u32 *pSize) ++{ ++ u32 uByteSize; ++ bool fOpenedDoff = false; ++ const struct LDR_SECTION_INFO *sect = NULL; ++ struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(name != NULL); ++ DBC_Require(pAddr != NULL); ++ DBC_Require(pSize != NULL); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ ++ GT_4trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_getSect: lib: 0x%x name: %s pAddr:" ++ " 0x%x pSize: 0x%x\n", lib, name, pAddr, pSize); ++ /* If DOFF file is not open, we open it. */ ++ if (zlLib != NULL) { ++ if (zlLib->fp == NULL) { ++ status = dofOpen(zlLib); ++ if (DSP_SUCCEEDED(status)) ++ fOpenedDoff = true; ++ ++ } else { ++ (*(zlLib->pTarget->attrs.fseek))(zlLib->fp, ++ zlLib->ulPos, SEEK_SET); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ uByteSize = 1; ++ if (DLOAD_GetSectionInfo(zlLib->desc, name, §)) { ++ *pAddr = sect->load_addr; ++ *pSize = sect->size * uByteSize; ++ /* Make sure size is even for good swap */ ++ if (*pSize % 2) ++ (*pSize)++; ++ ++ /* Align size */ ++ *pSize = DOFF_ALIGN(*pSize); ++ } else { ++ status = DSP_ENOSECT; ++ } ++ } ++ if (fOpenedDoff) { ++ dofClose(zlLib); ++ fOpenedDoff = false; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DBLL_init ======== ++ */ ++bool DBLL_init(void) ++{ ++ bool retVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!DBLL_debugMask.flags); ++ GT_create(&DBLL_debugMask, "DL"); /* "DL" for dbDL */ ++ GH_init(); ++ CSL_Init(); ++ retVal = MEM_Init(); ++ if (!retVal) ++ MEM_Exit(); ++ ++ } ++ ++ if (retVal) ++ cRefs++; ++ ++ ++ GT_1trace(DBLL_debugMask, GT_5CLASS, "DBLL_init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((retVal && (cRefs > 0)) || (!retVal && (cRefs >= 0))); ++ ++ return retVal; ++} ++ ++/* ++ * ======== DBLL_load ======== ++ */ ++DSP_STATUS DBLL_load(struct DBLL_LibraryObj *lib, DBLL_Flags flags, ++ struct DBLL_Attrs *attrs, u32 *pEntry) ++{ ++ struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib; ++ struct DBLL_TarObj *dbzl; ++ bool gotSymbols = true; ++ s32 err; ++ DSP_STATUS status = DSP_SOK; ++ bool fOpenedDoff = false; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(pEntry != NULL); ++ DBC_Require(attrs != NULL); ++ ++ GT_4trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_load: lib: 0x%x flags: 0x%x pEntry:" ++ " 0x%x\n", lib, flags, attrs, pEntry); ++ /* ++ * Load if not already loaded. ++ */ ++ if (zlLib->loadRef == 0 || !(flags & DBLL_DYNAMIC)) { ++ dbzl = zlLib->pTarget; ++ dbzl->attrs = *attrs; ++ /* Create a hash table for symbols if not already created */ ++ if (zlLib->symTab == NULL) { ++ gotSymbols = false; ++ zlLib->symTab = GH_create(MAXBUCKETS, ++ sizeof(struct Symbol), ++ nameHash, ++ nameMatch, symDelete); ++ if (zlLib->symTab == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ /* ++ * Set up objects needed by the dynamic loader ++ */ ++ /* Stream */ ++ zlLib->stream.dlStream.read_buffer = readBuffer; ++ zlLib->stream.dlStream.set_file_posn = setFilePosn; ++ zlLib->stream.lib = zlLib; ++ /* Symbol */ ++ zlLib->symbol.dlSymbol.Find_Matching_Symbol = findSymbol; ++ if (gotSymbols) { ++ zlLib->symbol.dlSymbol.Add_To_Symbol_Table = ++ findInSymbolTable; ++ } else { ++ zlLib->symbol.dlSymbol.Add_To_Symbol_Table = ++ addToSymbolTable; ++ } ++ zlLib->symbol.dlSymbol.Purge_Symbol_Table = purgeSymbolTable; ++ zlLib->symbol.dlSymbol.Allocate = allocate; ++ zlLib->symbol.dlSymbol.Deallocate = deallocate; ++ zlLib->symbol.dlSymbol.Error_Report = errorReport; ++ zlLib->symbol.lib = zlLib; ++ /* Allocate */ ++ zlLib->allocate.dlAlloc.Allocate = rmmAlloc; ++ zlLib->allocate.dlAlloc.Deallocate = rmmDealloc; ++ zlLib->allocate.lib = zlLib; ++ /* Init */ ++ zlLib->init.dlInit.connect = connect; ++ zlLib->init.dlInit.readmem = readMem; ++ zlLib->init.dlInit.writemem = writeMem; ++ zlLib->init.dlInit.fillmem = fillMem; ++ zlLib->init.dlInit.execute = execute; ++ zlLib->init.dlInit.release = release; ++ zlLib->init.lib = zlLib; ++ /* If COFF file is not open, we open it. */ ++ if (zlLib->fp == NULL) { ++ status = dofOpen(zlLib); ++ if (DSP_SUCCEEDED(status)) ++ fOpenedDoff = true; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ zlLib->ulPos = (*(zlLib->pTarget->attrs.ftell)) ++ (zlLib->fp); ++ /* Reset file cursor */ ++ (*(zlLib->pTarget->attrs.fseek))(zlLib->fp, (long)0, ++ SEEK_SET); ++ bSymbolsReloaded = true; ++ /* The 5th argument, DLOAD_INITBSS, tells the DLL ++ * module to zero-init all BSS sections. In general, ++ * this is not necessary and also increases load time. ++ * We may want to make this configurable by the user */ ++ err = Dynamic_Load_Module(&zlLib->stream.dlStream, ++ &zlLib->symbol.dlSymbol, &zlLib->allocate.dlAlloc, ++ &zlLib->init.dlInit, DLOAD_INITBSS, ++ &zlLib->mHandle); ++ ++ if (err != 0) { ++ GT_1trace(DBLL_debugMask, GT_6CLASS, ++ "DBLL_load: " ++ "Dynamic_Load_Module failed: 0x%lx\n", ++ err); ++ status = DSP_EDYNLOAD; ++ } else if (bRedefinedSymbol) { ++ zlLib->loadRef++; ++ DBLL_unload(zlLib, (struct DBLL_Attrs *) attrs); ++ bRedefinedSymbol = false; ++ status = DSP_EDYNLOAD; ++ } else { ++ *pEntry = zlLib->entry; ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) ++ zlLib->loadRef++; ++ ++ /* Clean up DOFF resources */ ++ if (fOpenedDoff) ++ dofClose(zlLib); ++ ++ DBC_Ensure(DSP_FAILED(status) || zlLib->loadRef > 0); ++ return status; ++} ++ ++/* ++ * ======== DBLL_loadSect ======== ++ * Not supported for COFF. ++ */ ++DSP_STATUS DBLL_loadSect(struct DBLL_LibraryObj *zlLib, char *sectName, ++ struct DBLL_Attrs *attrs) ++{ ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== DBLL_open ======== ++ */ ++DSP_STATUS DBLL_open(struct DBLL_TarObj *target, char *file, DBLL_Flags flags, ++ struct DBLL_LibraryObj **pLib) ++{ ++ struct DBLL_TarObj *zlTarget = (struct DBLL_TarObj *)target; ++ struct DBLL_LibraryObj *zlLib = NULL; ++ s32 err; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlTarget, DBLL_TARGSIGNATURE)); ++ DBC_Require(zlTarget->attrs.fopen != NULL); ++ DBC_Require(file != NULL); ++ DBC_Require(pLib != NULL); ++ ++ GT_3trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_open: target: 0x%x file: %s pLib:" ++ " 0x%x\n", target, file, pLib); ++ zlLib = zlTarget->head; ++ while (zlLib != NULL) { ++ if (strcmp(zlLib->fileName, file) == 0) { ++ /* Library is already opened */ ++ zlLib->openRef++; ++ break; ++ } ++ zlLib = zlLib->next; ++ } ++ if (zlLib == NULL) { ++ /* Allocate DBL library object */ ++ MEM_AllocObject(zlLib, struct DBLL_LibraryObj, ++ DBLL_LIBSIGNATURE); ++ if (zlLib == NULL) { ++ GT_0trace(DBLL_debugMask, GT_6CLASS, ++ "DBLL_open: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ zlLib->ulPos = 0; ++ /* Increment ref count to allow close on failure ++ * later on */ ++ zlLib->openRef++; ++ zlLib->pTarget = zlTarget; ++ /* Keep a copy of the file name */ ++ zlLib->fileName = MEM_Calloc(strlen(file) + 1, ++ MEM_PAGED); ++ if (zlLib->fileName == NULL) { ++ GT_0trace(DBLL_debugMask, GT_6CLASS, ++ "DBLL_open: Memory " ++ "allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ strncpy(zlLib->fileName, file, ++ strlen(file) + 1); ++ } ++ zlLib->symTab = NULL; ++ } ++ } ++ /* ++ * Set up objects needed by the dynamic loader ++ */ ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* Stream */ ++ zlLib->stream.dlStream.read_buffer = readBuffer; ++ zlLib->stream.dlStream.set_file_posn = setFilePosn; ++ zlLib->stream.lib = zlLib; ++ /* Symbol */ ++ zlLib->symbol.dlSymbol.Add_To_Symbol_Table = addToSymbolTable; ++ zlLib->symbol.dlSymbol.Find_Matching_Symbol = findSymbol; ++ zlLib->symbol.dlSymbol.Purge_Symbol_Table = purgeSymbolTable; ++ zlLib->symbol.dlSymbol.Allocate = allocate; ++ zlLib->symbol.dlSymbol.Deallocate = deallocate; ++ zlLib->symbol.dlSymbol.Error_Report = errorReport; ++ zlLib->symbol.lib = zlLib; ++ /* Allocate */ ++ zlLib->allocate.dlAlloc.Allocate = rmmAlloc; ++ zlLib->allocate.dlAlloc.Deallocate = rmmDealloc; ++ zlLib->allocate.lib = zlLib; ++ /* Init */ ++ zlLib->init.dlInit.connect = connect; ++ zlLib->init.dlInit.readmem = readMem; ++ zlLib->init.dlInit.writemem = writeMem; ++ zlLib->init.dlInit.fillmem = fillMem; ++ zlLib->init.dlInit.execute = execute; ++ zlLib->init.dlInit.release = release; ++ zlLib->init.lib = zlLib; ++ if (DSP_SUCCEEDED(status) && zlLib->fp == NULL) ++ status = dofOpen(zlLib); ++ ++ zlLib->ulPos = (*(zlLib->pTarget->attrs.ftell)) (zlLib->fp); ++ (*(zlLib->pTarget->attrs.fseek))(zlLib->fp, (long) 0, SEEK_SET); ++ /* Create a hash table for symbols if flag is set */ ++ if (zlLib->symTab != NULL || !(flags & DBLL_SYMB)) ++ goto func_cont; ++ ++ zlLib->symTab = GH_create(MAXBUCKETS, sizeof(struct Symbol), nameHash, ++ nameMatch, symDelete); ++ if (zlLib->symTab == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Do a fake load to get symbols - set write function to NoOp */ ++ zlLib->init.dlInit.writemem = NoOp; ++ err = Dynamic_Open_Module(&zlLib->stream.dlStream, ++ &zlLib->symbol.dlSymbol, ++ &zlLib->allocate.dlAlloc, ++ &zlLib->init.dlInit, 0, ++ &zlLib->mHandle); ++ if (err != 0) { ++ GT_1trace(DBLL_debugMask, GT_6CLASS, "DBLL_open: " ++ "Dynamic_Load_Module failed: 0x%lx\n", err); ++ status = DSP_EDYNLOAD; ++ } else { ++ /* Now that we have the symbol table, we can unload */ ++ err = Dynamic_Unload_Module(zlLib->mHandle, ++ &zlLib->symbol.dlSymbol, ++ &zlLib->allocate.dlAlloc, ++ &zlLib->init.dlInit); ++ if (err != 0) { ++ GT_1trace(DBLL_debugMask, GT_6CLASS, ++ "DBLL_open: " ++ "Dynamic_Unload_Module failed: 0x%lx\n", ++ err); ++ status = DSP_EDYNLOAD; ++ } ++ zlLib->mHandle = NULL; ++ } ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) { ++ if (zlLib->openRef == 1) { ++ /* First time opened - insert in list */ ++ if (zlTarget->head) ++ (zlTarget->head)->prev = zlLib; ++ ++ zlLib->prev = NULL; ++ zlLib->next = zlTarget->head; ++ zlTarget->head = zlLib; ++ } ++ *pLib = (struct DBLL_LibraryObj *)zlLib; ++ } else { ++ *pLib = NULL; ++ if (zlLib != NULL) ++ DBLL_close((struct DBLL_LibraryObj *)zlLib); ++ ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && (zlLib->openRef > 0) && ++ MEM_IsValidHandle(((struct DBLL_LibraryObj *)(*pLib)), ++ DBLL_LIBSIGNATURE)) || (DSP_FAILED(status) && *pLib == NULL)); ++ return status; ++} ++ ++/* ++ * ======== DBLL_readSect ======== ++ * Get the content of a COFF section. ++ */ ++DSP_STATUS DBLL_readSect(struct DBLL_LibraryObj *lib, char *name, ++ char *pContent, u32 size) ++{ ++ struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib; ++ bool fOpenedDoff = false; ++ u32 uByteSize; /* size of bytes */ ++ u32 ulSectSize; /* size of section */ ++ const struct LDR_SECTION_INFO *sect = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(name != NULL); ++ DBC_Require(pContent != NULL); ++ DBC_Require(size != 0); ++ ++ GT_4trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_readSect: lib: 0x%x name: %s " ++ "pContent: 0x%x size: 0x%x\n", lib, name, pContent, size); ++ /* If DOFF file is not open, we open it. */ ++ if (zlLib != NULL) { ++ if (zlLib->fp == NULL) { ++ status = dofOpen(zlLib); ++ if (DSP_SUCCEEDED(status)) ++ fOpenedDoff = true; ++ ++ } else { ++ (*(zlLib->pTarget->attrs.fseek))(zlLib->fp, ++ zlLib->ulPos, SEEK_SET); ++ } ++ } ++ ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ uByteSize = 1; ++ if (!DLOAD_GetSectionInfo(zlLib->desc, name, §)) { ++ status = DSP_ENOSECT; ++ goto func_cont; ++ } ++ /* ++ * Ensure the supplied buffer size is sufficient to store ++ * the section content to be read. ++ */ ++ ulSectSize = sect->size * uByteSize; ++ /* Make sure size is even for good swap */ ++ if (ulSectSize % 2) ++ ulSectSize++; ++ ++ /* Align size */ ++ ulSectSize = DOFF_ALIGN(ulSectSize); ++ if (ulSectSize > size) { ++ status = DSP_EFAIL; ++ } else { ++ if (!DLOAD_GetSection(zlLib->desc, sect, pContent)) ++ status = DSP_EFREAD; ++ ++ } ++func_cont: ++ if (fOpenedDoff) { ++ dofClose(zlLib); ++ fOpenedDoff = false; ++ } ++ return status; ++} ++ ++/* ++ * ======== DBLL_setAttrs ======== ++ * Set the attributes of the target. ++ */ ++void DBLL_setAttrs(struct DBLL_TarObj *target, struct DBLL_Attrs *pAttrs) ++{ ++ struct DBLL_TarObj *zlTarget = (struct DBLL_TarObj *)target; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlTarget, DBLL_TARGSIGNATURE)); ++ DBC_Require(pAttrs != NULL); ++ GT_2trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_setAttrs: target: 0x%x pAttrs: " ++ "0x%x\n", target, pAttrs); ++ if ((pAttrs != NULL) && (zlTarget != NULL)) ++ zlTarget->attrs = *pAttrs; ++ ++} ++ ++/* ++ * ======== DBLL_unload ======== ++ */ ++void DBLL_unload(struct DBLL_LibraryObj *lib, struct DBLL_Attrs *attrs) ++{ ++ struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib; ++ s32 err = 0; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE)); ++ DBC_Require(zlLib->loadRef > 0); ++ GT_1trace(DBLL_debugMask, GT_ENTER, "DBLL_unload: lib: 0x%x\n", lib); ++ zlLib->loadRef--; ++ /* Unload only if reference count is 0 */ ++ if (zlLib->loadRef != 0) ++ goto func_end; ++ ++ zlLib->pTarget->attrs = *attrs; ++ if (zlLib != NULL) { ++ if (zlLib->mHandle) { ++ err = Dynamic_Unload_Module(zlLib->mHandle, ++ &zlLib->symbol.dlSymbol, ++ &zlLib->allocate.dlAlloc, &zlLib->init.dlInit); ++ if (err != 0) { ++ GT_1trace(DBLL_debugMask, GT_5CLASS, ++ "Dynamic_Unload_Module " ++ "failed: 0x%x\n", err); ++ } ++ } ++ /* remove symbols from symbol table */ ++ if (zlLib->symTab != NULL) { ++ GH_delete(zlLib->symTab); ++ zlLib->symTab = NULL; ++ } ++ /* delete DOFF desc since it holds *lots* of host OS ++ * resources */ ++ dofClose(zlLib); ++ } ++func_end: ++ DBC_Ensure(zlLib->loadRef >= 0); ++} ++ ++/* ++ * ======== DBLL_unloadSect ======== ++ * Not supported for COFF. ++ */ ++DSP_STATUS DBLL_unloadSect(struct DBLL_LibraryObj *lib, char *sectName, ++ struct DBLL_Attrs *attrs) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(sectName != NULL); ++ GT_2trace(DBLL_debugMask, GT_ENTER, ++ "DBLL_unloadSect: lib: 0x%x sectName: " ++ "%s\n", lib, sectName); ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== dofClose ======== ++ */ ++static void dofClose(struct DBLL_LibraryObj *zlLib) ++{ ++ if (zlLib->desc) { ++ DLOAD_module_close(zlLib->desc); ++ zlLib->desc = NULL; ++ } ++ /* close file */ ++ if (zlLib->fp) { ++ (zlLib->pTarget->attrs.fclose) (zlLib->fp); ++ zlLib->fp = NULL; ++ } ++} ++ ++/* ++ * ======== dofOpen ======== ++ */ ++static DSP_STATUS dofOpen(struct DBLL_LibraryObj *zlLib) ++{ ++ void *open = *(zlLib->pTarget->attrs.fopen); ++ DSP_STATUS status = DSP_SOK; ++ ++ /* First open the file for the dynamic loader, then open COF */ ++ zlLib->fp = (void *)((DBLL_FOpenFxn)(open))(zlLib->fileName, "rb"); ++ ++ /* Open DOFF module */ ++ if (zlLib->fp && zlLib->desc == NULL) { ++ (*(zlLib->pTarget->attrs.fseek))(zlLib->fp, (long)0, SEEK_SET); ++ zlLib->desc = DLOAD_module_open(&zlLib->stream.dlStream, ++ &zlLib->symbol.dlSymbol); ++ if (zlLib->desc == NULL) { ++ (zlLib->pTarget->attrs.fclose)(zlLib->fp); ++ zlLib->fp = NULL; ++ status = DSP_EFOPEN; ++ } ++ } else { ++ status = DSP_EFOPEN; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== nameHash ======== ++ */ ++static u16 nameHash(void *key, u16 maxBucket) ++{ ++ u16 ret; ++ u16 hash; ++ char *name = (char *)key; ++ ++ DBC_Require(name != NULL); ++ ++ hash = 0; ++ ++ while (*name) { ++ hash <<= 1; ++ hash ^= *name++; ++ } ++ ++ ret = hash % maxBucket; ++ ++ return ret; ++} ++ ++/* ++ * ======== nameMatch ======== ++ */ ++static bool nameMatch(void *key, void *value) ++{ ++ DBC_Require(key != NULL); ++ DBC_Require(value != NULL); ++ ++ if ((key != NULL) && (value != NULL)) { ++ if (strcmp((char *)key, ((struct Symbol *)value)->name) == 0) ++ return true; ++ } ++ return false; ++} ++ ++/* ++ * ======== NoOp ======== ++ */ ++static int NoOp(struct Dynamic_Loader_Initialize *thisptr, void *bufr, ++ LDR_ADDR locn, struct LDR_SECTION_INFO *info, unsigned bytsize) ++{ ++ return 1; ++} ++ ++/* ++ * ======== symDelete ======== ++ */ ++static void symDelete(void *value) ++{ ++ struct Symbol *sp = (struct Symbol *)value; ++ ++ MEM_Free(sp->name); ++} ++ ++/* ++ * Dynamic Loader Functions ++ */ ++ ++/* Dynamic_Loader_Stream */ ++/* ++ * ======== readBuffer ======== ++ */ ++static int readBuffer(struct Dynamic_Loader_Stream *this, void *buffer, ++ unsigned bufsize) ++{ ++ struct DBLLStream *pStream = (struct DBLLStream *)this; ++ struct DBLL_LibraryObj *lib; ++ int bytesRead = 0; ++ ++ DBC_Require(this != NULL); ++ lib = pStream->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ if (lib != NULL) { ++ bytesRead = (*(lib->pTarget->attrs.fread))(buffer, 1, bufsize, ++ lib->fp); ++ } ++ return bytesRead; ++} ++ ++/* ++ * ======== setFilePosn ======== ++ */ ++static int setFilePosn(struct Dynamic_Loader_Stream *this, unsigned int pos) ++{ ++ struct DBLLStream *pStream = (struct DBLLStream *)this; ++ struct DBLL_LibraryObj *lib; ++ int status = 0; /* Success */ ++ ++ DBC_Require(this != NULL); ++ lib = pStream->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ if (lib != NULL) { ++ status = (*(lib->pTarget->attrs.fseek))(lib->fp, (long)pos, ++ SEEK_SET); ++ } ++ ++ return status; ++} ++ ++/* Dynamic_Loader_Sym */ ++ ++/* ++ * ======== findSymbol ======== ++ */ ++static struct dynload_symbol *findSymbol(struct Dynamic_Loader_Sym *this, ++ const char *name) ++{ ++ struct dynload_symbol *retSym; ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ struct DBLL_Symbol *pSym = NULL; ++ bool status = false; /* Symbol not found yet */ ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ if (lib != NULL) { ++ if (lib->pTarget->attrs.symLookup) { ++ /* Check current lib + base lib + dep lib + ++ * persistent lib */ ++ status = (*(lib->pTarget->attrs.symLookup)) ++ (lib->pTarget->attrs.symHandle, ++ lib->pTarget->attrs.symArg, ++ lib->pTarget->attrs.rmmHandle, name, &pSym); ++ } else { ++ /* Just check current lib for symbol */ ++ status = DBLL_getAddr((struct DBLL_LibraryObj *)lib, ++ (char *)name, &pSym); ++ if (!status) { ++ status = ++ DBLL_getCAddr((struct DBLL_LibraryObj *)lib, ++ (char *)name, &pSym); ++ } ++ } ++ } ++ ++ if (!status && bGblSearch) { ++ GT_1trace(DBLL_debugMask, GT_6CLASS, ++ "findSymbol: Symbol not found: %s\n", name); ++ } ++ ++ DBC_Assert((status && (pSym != NULL)) || (!status && (pSym == NULL))); ++ ++ retSym = (struct dynload_symbol *)pSym; ++ return retSym; ++} ++ ++/* ++ * ======== findInSymbolTable ======== ++ */ ++static struct dynload_symbol *findInSymbolTable(struct Dynamic_Loader_Sym *this, ++ const char *name, ++ unsigned moduleid) ++{ ++ struct dynload_symbol *retSym; ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ struct Symbol *sym; ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ DBC_Require(lib->symTab != NULL); ++ ++ sym = (struct Symbol *)GH_find(lib->symTab, (char *) name); ++ ++ retSym = (struct dynload_symbol *)&sym->value; ++ return retSym; ++} ++ ++/* ++ * ======== addToSymbolTable ======== ++ */ ++static struct dynload_symbol *addToSymbolTable(struct Dynamic_Loader_Sym *this, ++ const char *name, ++ unsigned moduleId) ++{ ++ struct Symbol *symPtr = NULL; ++ struct Symbol symbol; ++ struct dynload_symbol *pSym = NULL; ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ struct dynload_symbol *retVal; ++ ++ DBC_Require(this != NULL); ++ DBC_Require(name); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ /* Check to see if symbol is already defined in symbol table */ ++ if (!(lib->pTarget->attrs.baseImage)) { ++ bGblSearch = false; ++ pSym = findSymbol(this, name); ++ bGblSearch = true; ++ if (pSym) { ++ bRedefinedSymbol = true; ++ GT_1trace(DBLL_debugMask, GT_6CLASS, ++ "Symbol already defined in " ++ "symbol table: %s\n", name); ++ return NULL; ++ } ++ } ++ /* Allocate string to copy symbol name */ ++ symbol.name = (char *)MEM_Calloc(strlen((char *const)name) + 1, ++ MEM_PAGED); ++ if (symbol.name == NULL) ++ return NULL; ++ ++ if (symbol.name != NULL) { ++ /* Just copy name (value will be filled in by dynamic loader) */ ++ strncpy(symbol.name, (char *const)name, ++ strlen((char *const)name) + 1); ++ ++ /* Add symbol to symbol table */ ++ symPtr = (struct Symbol *)GH_insert(lib->symTab, (void *)name, ++ (void *)&symbol); ++ if (symPtr == NULL) ++ MEM_Free(symbol.name); ++ ++ } ++ if (symPtr != NULL) ++ retVal = (struct dynload_symbol *)&symPtr->value; ++ else ++ retVal = NULL; ++ ++ return retVal; ++} ++ ++/* ++ * ======== purgeSymbolTable ======== ++ */ ++static void purgeSymbolTable(struct Dynamic_Loader_Sym *this, unsigned moduleId) ++{ ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ /* May not need to do anything */ ++} ++ ++/* ++ * ======== allocate ======== ++ */ ++static void *allocate(struct Dynamic_Loader_Sym *this, unsigned memsize) ++{ ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ void *buf; ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ buf = MEM_Calloc(memsize, MEM_PAGED); ++ ++ return buf; ++} ++ ++/* ++ * ======== deallocate ======== ++ */ ++static void deallocate(struct Dynamic_Loader_Sym *this, void *memPtr) ++{ ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ MEM_Free(memPtr); ++} ++ ++/* ++ * ======== errorReport ======== ++ */ ++static void errorReport(struct Dynamic_Loader_Sym *this, const char *errstr, ++ va_list args) ++{ ++ struct DBLLSymbol *pSymbol = (struct DBLLSymbol *)this; ++ struct DBLL_LibraryObj *lib; ++ char tempBuf[MAXEXPR]; ++ ++ DBC_Require(this != NULL); ++ lib = pSymbol->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ vsnprintf((char *)tempBuf, MAXEXPR, (char *)errstr, args); ++ GT_1trace(DBLL_debugMask, GT_5CLASS, "%s\n", tempBuf); ++} ++ ++/* Dynamic_Loader_Allocate */ ++ ++/* ++ * ======== rmmAlloc ======== ++ */ ++static int rmmAlloc(struct Dynamic_Loader_Allocate *this, ++ struct LDR_SECTION_INFO *info, unsigned align) ++{ ++ struct DBLLAlloc *pAlloc = (struct DBLLAlloc *)this; ++ struct DBLL_LibraryObj *lib; ++ DSP_STATUS status = DSP_SOK; ++ u32 memType; ++ struct RMM_Addr rmmAddr; ++ s32 retVal = TRUE; ++ unsigned stype = DLOAD_SECTION_TYPE(info->type); ++ char *pToken = NULL; ++ char *szSecLastToken = NULL; ++ char *szLastToken = NULL; ++ char *szSectName = NULL; ++ char *pszCur; ++ s32 tokenLen = 0; ++ s32 segId = -1; ++ s32 req = -1; ++ s32 count = 0; ++ u32 allocSize = 0; ++ ++ DBC_Require(this != NULL); ++ lib = pAlloc->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ memType = (stype == DLOAD_TEXT) ? DBLL_CODE : (stype == DLOAD_BSS) ? ++ DBLL_BSS : DBLL_DATA; ++ ++ /* Attempt to extract the segment ID and requirement information from ++ the name of the section */ ++ DBC_Require(info->name); ++ tokenLen = strlen((char *)(info->name)) + 1; ++ ++ szSectName = MEM_Calloc(tokenLen, MEM_PAGED); ++ szLastToken = MEM_Calloc(tokenLen, MEM_PAGED); ++ szSecLastToken = MEM_Calloc(tokenLen, MEM_PAGED); ++ ++ if (szSectName == NULL || szSecLastToken == NULL || ++ szLastToken == NULL) { ++ status = DSP_EMEMORY; ++ goto func_cont; ++ } ++ strncpy(szSectName, (char *)(info->name), tokenLen); ++ pszCur = szSectName; ++ while ((pToken = strsep(&pszCur, ":")) && *pToken != '\0') { ++ strncpy(szSecLastToken, szLastToken, strlen(szLastToken) + 1); ++ strncpy(szLastToken, pToken, strlen(pToken) + 1); ++ pToken = strsep(&pszCur, ":"); ++ count++; /* optimizes processing*/ ++ } ++ /* If pToken is 0 or 1, and szSecLastToken is DYN_DARAM or DYN_SARAM, ++ or DYN_EXTERNAL, then mem granularity information is present ++ within the section name - only process if there are at least three ++ tokens within the section name (just a minor optimization)*/ ++ if (count >= 3) ++ strict_strtol(szLastToken, 10, (long *)&req); ++ ++ if ((req == 0) || (req == 1)) { ++ if (strcmp(szSecLastToken, "DYN_DARAM") == 0) { ++ segId = 0; ++ } else { ++ if (strcmp(szSecLastToken, "DYN_SARAM") == 0) { ++ segId = 1; ++ } else { ++ if (strcmp(szSecLastToken, ++ "DYN_EXTERNAL") == 0) { ++ segId = 2; ++ } ++ } ++ } ++ if (segId != -1) { ++ GT_2trace(DBLL_debugMask, GT_5CLASS, ++ "Extracted values for memory" ++ " granularity req [%d] segId [%d]\n", ++ req, segId); ++ } ++ } ++ MEM_Free(szSectName); ++ szSectName = NULL; ++ MEM_Free(szLastToken); ++ szLastToken = NULL; ++ MEM_Free(szSecLastToken); ++ szSecLastToken = NULL; ++func_cont: ++ if (memType == DBLL_CODE) ++ allocSize = info->size + GEM_L1P_PREFETCH_SIZE; ++ else ++ allocSize = info->size; ++ /* TODO - ideally, we can pass the alignment requirement also ++ * from here */ ++ if (lib != NULL) { ++ status = (lib->pTarget->attrs.alloc)(lib->pTarget-> ++ attrs.rmmHandle, memType, allocSize, align, ++ (u32 *)&rmmAddr, segId, req, FALSE); ++ } ++ if (DSP_FAILED(status)) { ++ retVal = false; ++ } else { ++ /* RMM gives word address. Need to convert to byte address */ ++ info->load_addr = rmmAddr.addr * DSPWORDSIZE; ++ info->run_addr = info->load_addr; ++ info->context = (u32)rmmAddr.segid; ++ GT_3trace(DBLL_debugMask, GT_5CLASS, ++ "Remote alloc: %s base = 0x%lx len" ++ "= 0x%lx\n", info->name, info->load_addr / DSPWORDSIZE, ++ info->size / DSPWORDSIZE); ++ } ++ return retVal; ++} ++ ++/* ++ * ======== rmmDealloc ======== ++ */ ++static void rmmDealloc(struct Dynamic_Loader_Allocate *this, ++ struct LDR_SECTION_INFO *info) ++{ ++ struct DBLLAlloc *pAlloc = (struct DBLLAlloc *)this; ++ struct DBLL_LibraryObj *lib; ++ u32 segid; ++ DSP_STATUS status = DSP_SOK; ++ unsigned stype = DLOAD_SECTION_TYPE(info->type); ++ u32 memType; ++ u32 freeSize = 0; ++ ++ memType = (stype == DLOAD_TEXT) ? DBLL_CODE : (stype == DLOAD_BSS) ? ++ DBLL_BSS : DBLL_DATA; ++ DBC_Require(this != NULL); ++ lib = pAlloc->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ /* segid was set by alloc function */ ++ segid = (u32)info->context; ++ if (memType == DBLL_CODE) ++ freeSize = info->size + GEM_L1P_PREFETCH_SIZE; ++ else ++ freeSize = info->size; ++ if (lib != NULL) { ++ status = (lib->pTarget->attrs.free)(lib->pTarget-> ++ attrs.symHandle, segid, info->load_addr / DSPWORDSIZE, ++ freeSize, false); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ GT_2trace(DBLL_debugMask, GT_5CLASS, ++ "Remote dealloc: base = 0x%lx len =" ++ "0x%lx\n", info->load_addr / DSPWORDSIZE, ++ freeSize / DSPWORDSIZE); ++ } ++} ++ ++/* Dynamic_Loader_Initialize */ ++/* ++ * ======== connect ======== ++ */ ++static int connect(struct Dynamic_Loader_Initialize *this) ++{ ++ return true; ++} ++ ++/* ++ * ======== readMem ======== ++ * This function does not need to be implemented. ++ */ ++static int readMem(struct Dynamic_Loader_Initialize *this, void *buf, ++ LDR_ADDR addr, struct LDR_SECTION_INFO *info, ++ unsigned nbytes) ++{ ++ struct DBLLInit *pInit = (struct DBLLInit *)this; ++ struct DBLL_LibraryObj *lib; ++ int bytesRead = 0; ++ ++ DBC_Require(this != NULL); ++ lib = pInit->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ /* Need WMD_BRD_Read function */ ++ return bytesRead; ++} ++ ++/* ++ * ======== writeMem ======== ++ */ ++static int writeMem(struct Dynamic_Loader_Initialize *this, void *buf, ++ LDR_ADDR addr, struct LDR_SECTION_INFO *info, ++ unsigned nBytes) ++{ ++ struct DBLLInit *pInit = (struct DBLLInit *)this; ++ struct DBLL_LibraryObj *lib; ++ struct DBLL_SectInfo sectInfo; ++ u32 memType; ++ bool retVal = true; ++ ++ DBC_Require(this != NULL); ++ lib = pInit->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ ++ memType = (DLOAD_SECTION_TYPE(info->type) == DLOAD_TEXT) ? DBLL_CODE : ++ DBLL_DATA; ++ if (lib != NULL) { ++ retVal = (*lib->pTarget->attrs.write)(lib->pTarget-> ++ attrs.wHandle, addr, buf, nBytes, memType); ++ } ++ if (lib->pTarget->attrs.logWrite) { ++ sectInfo.name = info->name; ++ sectInfo.runAddr = info->run_addr; ++ sectInfo.loadAddr = info->load_addr; ++ sectInfo.size = info->size; ++ sectInfo.type = memType; ++ /* Pass the information about what we've written to ++ * another module */ ++ (*lib->pTarget->attrs.logWrite)(lib->pTarget-> ++ attrs.logWriteHandle, §Info, addr, nBytes); ++ } ++ return retVal; ++} ++ ++/* ++ * ======== fillMem ======== ++ * Fill nBytes of memory at a given address with a given value by ++ * writing from a buffer containing the given value. Write in ++ * sets of MAXEXPR (128) bytes to avoid large stack buffer issues. ++ */ ++static int fillMem(struct Dynamic_Loader_Initialize *this, LDR_ADDR addr, ++ struct LDR_SECTION_INFO *info, unsigned nBytes, ++ unsigned val) ++{ ++ bool retVal = true; ++ char *pBuf; ++ struct DBLL_LibraryObj *lib; ++ struct DBLLInit *pInit = (struct DBLLInit *)this; ++ ++ DBC_Require(this != NULL); ++ lib = pInit->lib; ++ pBuf = NULL; ++ /* Pass the NULL pointer to writeMem to get the start address of Shared ++ memory. This is a trick to just get the start address, there is no ++ writing taking place with this Writemem ++ */ ++ if ((lib->pTarget->attrs.write) != (DBLL_WriteFxn)NoOp) ++ writeMem(this, &pBuf, addr, info, 0); ++ if (pBuf) ++ memset(pBuf, val, nBytes); ++ ++ return retVal; ++} ++ ++/* ++ * ======== execute ======== ++ */ ++static int execute(struct Dynamic_Loader_Initialize *this, LDR_ADDR start) ++{ ++ struct DBLLInit *pInit = (struct DBLLInit *)this; ++ struct DBLL_LibraryObj *lib; ++ bool retVal = true; ++ ++ DBC_Require(this != NULL); ++ lib = pInit->lib; ++ DBC_Require(MEM_IsValidHandle(lib, DBLL_LIBSIGNATURE)); ++ /* Save entry point */ ++ if (lib != NULL) ++ lib->entry = (u32)start; ++ ++ return retVal; ++} ++ ++/* ++ * ======== release ======== ++ */ ++static void release(struct Dynamic_Loader_Initialize *this) ++{ ++} ++ +diff --git a/drivers/dsp/bridge/pmgr/dev.c b/drivers/dsp/bridge/pmgr/dev.c +new file mode 100644 +index 0000000..1c2f7d5 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/dev.c +@@ -0,0 +1,1476 @@ ++/* ++ * dev.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dev.c ======== ++ * Description: ++ * Implementation of 'Bridge Mini-driver device operations. ++ * ++ * Public Functions: ++ * DEV_BrdWriteFxn ++ * DEV_CreateDevice ++ * DEV_Create2 ++ * DEV_Destroy2 ++ * DEV_DestroyDevice ++ * DEV_GetChnlMgr ++ * DEV_GetCmmMgr ++ * DEV_GetCodMgr ++ * DEV_GetDehMgr ++ * DEV_GetDevNode ++ * DEV_GetDSPWordSize ++ * DEV_GetFirst ++ * DEV_GetIntfFxns ++ * DEV_GetIOMgr ++ * DEV_GetNext ++ * DEV_GetNodeManager ++ * DEV_GetSymbol ++ * DEV_GetWMDContext ++ * DEV_Exit ++ * DEV_Init ++ * DEV_InsertProcObject ++ * DEV_IsLocked ++ * DEV_NotifyClient ++ * DEV_RegisterNotify ++ * DEV_ReleaseCodMgr ++ * DEV_RemoveDevice ++ * DEV_RemoveProcObject ++ * DEV_SetChnlMgr ++ * DEV_SetMsgMgr ++ * DEV_SetLockOwner ++ * DEV_StartDevice ++ * ++ * Private Functions: ++ * FxnNotImplemented ++ * InitCodMgr ++ * InsertDevObject ++ * IsValidHandle ++ * RemoveDevObject ++ * StoreInterfaceFxns ++ * ++ *! Revision History: ++ *! ================ ++ *! 03-Jan-2005 hn Support for IVA DEH ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping feature ++ *! 09-Feb-2004 vp Updated to support IVA. ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 29-Nov-2001 jeh Check for DSP_ENOTIMPL status of DEH create function. ++ *! 05-Nov-2001 kc Added support for DEH module. ++ *! 05-Aug-2001 ag Shared memory registration moved to WMD_IO_OnLoaded(). ++ *! 11-Jul-2001 jeh Moved MGR_Create() from DSP_Init() to DEV_StartDevice(). ++ *! 11-Apr-2001 rr: Removed CMM_RegisterGPPSMSeg. ++ *! 02-Apr-2001 rr: CHNL_Create failure is printed out. ++ *! 15-Jan-2001 jeh Removed call to IO_OnLoaded() from DEV_Create2(). ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name update. ++ *! 15-Dec-2000 rr: Dev_Create2 returns error if NODE_CreateMgr fails. ++ *! 05-Dec-2000 jeh Moved IO_OnLoaded() to PROC_Load. Added DEV_SetMsgMgr. ++ *! 05-Dev-2000 ag SM Heap for messaging registered via CMM_RegisterGPPSMSeg(). ++ *! SM heap base and size currently taken from registry. ++ *! 29-Nov-2000 rr: Incorporated code review changes. ++ *! 17-Nov-2000 jeh Added calls to get IO manager (IO_Create), IO_OnLoaded(). ++ *! 06-Oct-2000 rr: DEV_Destroy2 and DEV_Create2 added. ++ *! 02-Oct-2000 rr: DEV_GetNodeManager added. ++ *! 11-Aug-2000 ag: Added DEV_GetCmmMgr(), CMM_Init() & CMM_Exit(). ++ *! Removed <dspbridge/std.h> & <stdwin.h>, added <dspbridge/dbtype.h> ++ *! 10-Aug-2000 rr: DEV_InsertProcObject/RemoveProcObject added. ++ *! DEV_Cleanup calls PROC_Detach if it is a matching process. ++ *! 27-Jul-2000 rr: DEV is in new directoy DEV and produces devlib.lib ++ *! 17-Jul-2000 rr: DRV Object holds the list of Dev Objects. DEV gets ++ *! the List and Next devices through DRV. ++ *! DEV object has a back pointer to DRV Object. ++ *! 06-Jun-2000 jeh Added DEV_GetSymbol(). ++ *! 09-May-2000 rr: dwMemBase has index for multiple windows need. ++ *! 28-Feb-2000 rr: New GT Usage implemented. ++ *! 03-Feb-2000 rr: GT and Module init/exit Changes.(Done up front from ++ *! SERVICES) ++ *! 31-Jan-2000 rr: Comments changed after code review. ++ *! 21-Jan-2000 rr: windows.h, tchar.h, HMODULE removed. FreeLibrary replaced ++ *! with LDR_FreeModule ++ *! 17-Jan-2000 rr: CFG_Get/SetPrivateDword renamed to CFG_Get/SetDevObject. ++ *! StoreInterfaceFxns stores the new fxn WMD_BRD_SETSTATE. ++ *! 20-Nov-1999 ag: Actual uSMLength = total - monitor offset. ++ *! 12-Nov-1999 rr: bIRQ and IRQAttrib taken from the struct CFG_HOSTRES. ++ *! dMemBase is added with offset for monitor taken from ++ *! registry. ++ *! 31-Oct-1999 ag: Added CHNL support. ++ *! 10-Sep-1999 rr: GT Enabled. DEV_Create will Load the Mini Driver and will ++ *! find its fxn table. Right now lot of things are hardcoded ++ *! as the REG is not ready. ++ *! 10-Jun-1996 rr: Created from WSX ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/ldr.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/util.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/cod.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/proc.h> ++#include <dspbridge/dmm.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/mgr.h> ++#include <dspbridge/node.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbreg.h> ++#include <dspbridge/wcd.h> /* WCD version info. */ ++ ++#include <dspbridge/chnl.h> ++#include <dspbridge/io.h> ++#include <dspbridge/msg.h> ++#include <dspbridge/cmm.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++ ++#define SIGNATURE 0x5f564544 /* "DEV_" (in reverse) */ ++#define MAKEVERSION(major, minor) (major * 10 + minor) ++#define WCDVERSION MAKEVERSION(WCD_MAJOR_VERSION, WCD_MINOR_VERSION) ++ ++/* The WMD device object: */ ++struct DEV_OBJECT { ++ /* LST requires "link" to be first field! */ ++ struct LST_ELEM link; /* Link to next DEV_OBJECT. */ ++ u32 devType; /* Device Type */ ++ u32 dwSignature; /* Used for object validation. */ ++ struct CFG_DEVNODE *hDevNode; /* Platform specific device id */ ++ struct WMD_DEV_CONTEXT *hWmdContext; /* WMD Context Handle */ ++ struct WMD_DRV_INTERFACE intfFxns; /* Function interface to WMD. */ ++ struct BRD_OBJECT *lockOwner; /* Client with exclusive access. */ ++ struct COD_MANAGER *hCodMgr; /* Code manager handle. */ ++ struct CHNL_MGR *hChnlMgr; /* Channel manager. */ ++ struct DEH_MGR *hDehMgr; /* DEH manager. */ ++ struct MSG_MGR *hMsgMgr; /* Message manager. */ ++ struct IO_MGR *hIOMgr; /* IO manager (CHNL, MSG) */ ++ struct CMM_OBJECT *hCmmMgr; /* SM memory manager. */ ++ struct DMM_OBJECT *hDmmMgr; /* Dynamic memory manager. */ ++ struct LDR_MODULE *hModule; /* WMD Module handle. */ ++ u32 uWordSize; /* DSP word size: quick access. */ ++ struct DRV_OBJECT *hDrvObject; /* Driver Object */ ++ struct LST_LIST *procList; /* List of Proceeosr attached to ++ * this device */ ++ struct NODE_MGR *hNodeMgr; ++} ; ++ ++/* ----------------------------------- Globals */ ++static u32 cRefs; /* Module reference count */ ++#if GT_TRACE ++static struct GT_Mask debugMask = { NULL, NULL }; /* For debugging */ ++#endif ++ ++/* ----------------------------------- Function Prototypes */ ++static DSP_STATUS FxnNotImplemented(int arg, ...); ++static DSP_STATUS InitCodMgr(struct DEV_OBJECT *pDevObject); ++static bool IsValidHandle(struct DEV_OBJECT *hObj); ++static void StoreInterfaceFxns(struct WMD_DRV_INTERFACE *pDrvFxns, ++ OUT struct WMD_DRV_INTERFACE *pIntfFxns); ++/* ++ * ======== DEV_BrdWriteFxn ======== ++ * Purpose: ++ * Exported function to be used as the COD write function. This function ++ * is passed a handle to a DEV_hObject, then calls the ++ * device's WMD_BRD_Write() function. ++ */ ++u32 DEV_BrdWriteFxn(void *pArb, u32 ulDspAddr, void *pHostBuf, ++ u32 ulNumBytes, u32 nMemSpace) ++{ ++ struct DEV_OBJECT *pDevObject = (struct DEV_OBJECT *)pArb; ++ u32 ulWritten = 0; ++ DSP_STATUS status; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pHostBuf != NULL); /* Required of BrdWrite(). */ ++ GT_5trace(debugMask, GT_ENTER, ++ "Entered DEV_BrdWriteFxn, pArb: 0x%x\n\t\t" ++ "ulDspAddr: 0x%x\n\t\tpHostBuf: 0x%x\n \t\tulNumBytes: 0x%x\n" ++ "\t\tnMemSpace: 0x%x\n", pArb, ulDspAddr, pHostBuf, ++ ulNumBytes, nMemSpace); ++ if (IsValidHandle(pDevObject)) { ++ /* Require of BrdWrite() */ ++ DBC_Assert(pDevObject->hWmdContext != NULL); ++ status = (*pDevObject->intfFxns.pfnBrdWrite)(pDevObject-> ++ hWmdContext, pHostBuf, ulDspAddr, ulNumBytes, ++ nMemSpace); ++ /* Special case of getting the address only */ ++ if (ulNumBytes == 0) ++ ulNumBytes = 1; ++ if (DSP_SUCCEEDED(status)) ++ ulWritten = ulNumBytes; ++ ++ } ++ GT_1trace(debugMask, GT_ENTER, "Exit DEV_BrdWriteFxn ulWritten: 0x%x\n", ++ ulWritten); ++ return ulWritten; ++} ++ ++/* ++ * ======== DEV_CreateDevice ======== ++ * Purpose: ++ * Called by the operating system to load the PM Mini Driver for a ++ * PM board (device). ++ */ ++DSP_STATUS DEV_CreateDevice(OUT struct DEV_OBJECT **phDevObject, ++ IN CONST char *pstrWMDFileName, ++ IN CONST struct CFG_HOSTRES *pHostConfig, ++ IN CONST struct CFG_DSPRES *pDspConfig, ++ struct CFG_DEVNODE *hDevNode) ++{ ++ struct LDR_MODULE *hModule = NULL; ++ struct WMD_DRV_INTERFACE *pDrvFxns = NULL; ++ struct DEV_OBJECT *pDevObject = NULL; ++ struct CHNL_MGRATTRS mgrAttrs; ++ struct IO_ATTRS ioMgrAttrs; ++ u32 uNumWindows; ++ struct DRV_OBJECT *hDrvObject = NULL; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDevObject != NULL); ++ DBC_Require(pstrWMDFileName != NULL); ++ DBC_Require(pHostConfig != NULL); ++ DBC_Require(pDspConfig != NULL); ++ ++ GT_5trace(debugMask, GT_ENTER, ++ "Entered DEV_CreateDevice, phDevObject: 0x%x\n" ++ "\t\tpstrWMDFileName: 0x%x\n\t\tpHostConfig:0x%x\n\t\t" ++ "pDspConfig: 0x%x\n\t\tnhDevNode: 0x%x\n", phDevObject, ++ pstrWMDFileName, pHostConfig, pDspConfig, hDevNode); ++ /* Get the WMD interface functions*/ ++ WMD_DRV_Entry(&pDrvFxns, pstrWMDFileName); ++ if (DSP_FAILED(CFG_GetObject((u32 *) &hDrvObject, REG_DRV_OBJECT))) { ++ /* don't propogate CFG errors from this PROC function */ ++ GT_0trace(debugMask, GT_7CLASS, ++ "Failed to get the DRV Object \n"); ++ status = DSP_EFAIL; ++ } ++ /* Create the device object, and pass a handle to the WMD for ++ * storage. */ ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(pDrvFxns); ++ MEM_AllocObject(pDevObject, struct DEV_OBJECT, SIGNATURE); ++ if (pDevObject) { ++ /* Fill out the rest of the Dev Object structure: */ ++ pDevObject->hDevNode = hDevNode; ++ pDevObject->hModule = hModule; ++ pDevObject->hCodMgr = NULL; ++ pDevObject->hChnlMgr = NULL; ++ pDevObject->hDehMgr = NULL; ++ pDevObject->lockOwner = NULL; ++ pDevObject->uWordSize = pDspConfig->uWordSize; ++ pDevObject->hDrvObject = hDrvObject; ++ pDevObject->devType = DSP_UNIT; ++ /* Store this WMD's interface functions, based on its ++ * version. */ ++ StoreInterfaceFxns(pDrvFxns, &pDevObject->intfFxns); ++ /* Call WMD_DEV_CREATE() to get the WMD's device ++ * context handle. */ ++ status = (pDevObject->intfFxns.pfnDevCreate) ++ (&pDevObject->hWmdContext, pDevObject, ++ pHostConfig, pDspConfig); ++ /* Assert WMD_DEV_Create()'s ensure clause: */ ++ DBC_Assert(DSP_FAILED(status) || (pDevObject-> ++ hWmdContext != NULL)); ++ } else { ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_Create: Out Of Memory"); ++ status = DSP_EMEMORY; ++ } ++ } ++ /* Attempt to create the COD manager for this device: */ ++ if (DSP_SUCCEEDED(status)) ++ status = InitCodMgr(pDevObject); ++ ++ /* Attempt to create the channel manager for this device: */ ++ if (DSP_SUCCEEDED(status)) { ++ mgrAttrs.cChannels = CHNL_MAXCHANNELS; ++ ioMgrAttrs.bIRQ = pHostConfig->bIRQRegisters; ++ ioMgrAttrs.fShared = (pHostConfig->bIRQAttrib & CFG_IRQSHARED); ++ ioMgrAttrs.uWordSize = pDspConfig->uWordSize; ++ mgrAttrs.uWordSize = pDspConfig->uWordSize; ++ uNumWindows = pHostConfig->wNumMemWindows; ++ if (uNumWindows) { ++ /* Assume last memory window is for CHNL */ ++ ioMgrAttrs.dwSMBase = pHostConfig->dwMemBase[1] + ++ pHostConfig->dwOffsetForMonitor; ++ ioMgrAttrs.uSMLength = pHostConfig->dwMemLength[1] - ++ pHostConfig->dwOffsetForMonitor; ++ } else { ++ ioMgrAttrs.dwSMBase = 0; ++ ioMgrAttrs.uSMLength = 0; ++ GT_0trace(debugMask, GT_7CLASS, ++ "**There is no memory reserved for " ++ "shared structures**\n"); ++ } ++ status = CHNL_Create(&pDevObject->hChnlMgr, pDevObject, ++ &mgrAttrs); ++ if (status == DSP_ENOTIMPL) { ++ /* It's OK for a device not to have a channel ++ * manager: */ ++ status = DSP_SOK; ++ } ++ /* Create CMM mgr even if Msg Mgr not impl. */ ++ status = CMM_Create(&pDevObject->hCmmMgr, ++ (struct DEV_OBJECT *)pDevObject, NULL); ++ if (DSP_FAILED(status)) { ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_Create: Failed to Create SM " ++ "Manager\n"); ++ } ++ /* Only create IO manager if we have a channel manager */ ++ if (DSP_SUCCEEDED(status) && pDevObject->hChnlMgr) { ++ status = IO_Create(&pDevObject->hIOMgr, pDevObject, ++ &ioMgrAttrs); ++ } ++ /* Only create DEH manager if we have an IO manager */ ++ if (DSP_SUCCEEDED(status)) { ++ /* Instantiate the DEH module */ ++ status = (*pDevObject->intfFxns.pfnDehCreate) ++ (&pDevObject->hDehMgr, pDevObject); ++ } ++ /* Create DMM mgr . */ ++ status = DMM_Create(&pDevObject->hDmmMgr, ++ (struct DEV_OBJECT *)pDevObject, NULL); ++ if (DSP_FAILED(status)) { ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_Create: Failed to Create DMM " ++ "Manager\n"); ++ } ++ } ++ /* Add the new DEV_Object to the global list: */ ++ if (DSP_SUCCEEDED(status)) { ++ LST_InitElem(&pDevObject->link); ++ status = DRV_InsertDevObject(hDrvObject, pDevObject); ++ } ++ /* Create the Processor List */ ++ if (DSP_SUCCEEDED(status)) { ++ pDevObject->procList = LST_Create(); ++ if (!(pDevObject->procList)) { ++ status = DSP_EFAIL; ++ GT_0trace(debugMask, GT_7CLASS, "DEV_Create: " ++ "Failed to Create Proc List"); ++ } ++ } ++ /* If all went well, return a handle to the dev object; ++ * else, cleanup and return NULL in the OUT parameter. */ ++ if (DSP_SUCCEEDED(status)) { ++ *phDevObject = pDevObject; ++ GT_1trace(debugMask, GT_1CLASS, ++ "DEV_CreateDevice Succeeded \nDevObject " ++ "0x%x\n", pDevObject); ++ } else { ++ if (pDevObject && pDevObject->procList) ++ LST_Delete(pDevObject->procList); ++ ++ if (pDevObject && pDevObject->hCodMgr) ++ COD_Delete(pDevObject->hCodMgr); ++ ++ if (pDevObject && pDevObject->hDmmMgr) ++ DMM_Destroy(pDevObject->hDmmMgr); ++ ++ if (pDevObject) ++ MEM_FreeObject(pDevObject); ++ ++ *phDevObject = NULL; ++ GT_0trace(debugMask, GT_7CLASS, "DEV_CreateDevice Failed\n"); ++ } ++ GT_1trace(debugMask, GT_1CLASS, "Exiting DEV_Create: DevObject 0x%x\n", ++ *phDevObject); ++ DBC_Ensure((DSP_SUCCEEDED(status) && IsValidHandle(*phDevObject)) || ++ (DSP_FAILED(status) && !*phDevObject)); ++ return status; ++} ++ ++/* ++ * ======== DEV_Create2 ======== ++ * Purpose: ++ * After successful loading of the image from WCD_InitComplete2 ++ * (PROC Auto_Start) or PROC_Load this fxn is called. This creates ++ * the Node Manager and updates the DEV Object. ++ */ ++DSP_STATUS DEV_Create2(struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(hDevObject)); ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Entered DEV_Create2, hDevObject: 0x%x\n", hDevObject); ++ /* There can be only one Node Manager per DEV object */ ++ DBC_Assert(!pDevObject->hNodeMgr); ++ status = NODE_CreateMgr(&pDevObject->hNodeMgr, hDevObject); ++ if (DSP_FAILED(status)) { ++ GT_1trace(debugMask, GT_7CLASS, ++ "DEV_Create2: NODE_CreateMgr failed, " ++ "0x%x!\n", status); ++ pDevObject->hNodeMgr = NULL; ++ GT_0trace(debugMask, GT_7CLASS, "DEV_Create2: Failed!!\n"); ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && pDevObject->hNodeMgr != NULL) ++ || (DSP_FAILED(status) && pDevObject->hNodeMgr == NULL)); ++ GT_2trace(debugMask, GT_ENTER, ++ "Exiting DEV_Create2, hNodeMgr: 0x%x, status:" ++ " 0x%x\n", pDevObject->hNodeMgr, status); ++ return status; ++} ++ ++/* ++ * ======== DEV_Destroy2 ======== ++ * Purpose: ++ * Destroys the Node manager for this device. ++ */ ++DSP_STATUS DEV_Destroy2(struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(hDevObject)); ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Entered DEV_Destroy2, hDevObject: 0x%x\n", ++ hDevObject); ++ if (pDevObject->hNodeMgr) { ++ if (DSP_FAILED(NODE_DeleteMgr(pDevObject->hNodeMgr))) ++ status = DSP_EFAIL; ++ else ++ pDevObject->hNodeMgr = NULL; ++ ++ } ++ if (DSP_FAILED(status)) ++ GT_0trace(debugMask, GT_7CLASS, "DEV_Destroy2 failed!!\n"); ++ ++ DBC_Ensure((DSP_SUCCEEDED(status) && pDevObject->hNodeMgr == NULL) || ++ DSP_FAILED(status)); ++ GT_2trace(debugMask, GT_ENTER, ++ "Exiting DEV_Destroy2, hNodeMgr: 0x%x, status" ++ " = 0x%x\n", pDevObject->hNodeMgr, status); ++ return status; ++} ++ ++/* ++ * ======== DEV_DestroyDevice ======== ++ * Purpose: ++ * Destroys the channel manager for this device, if any, calls ++ * WMD_DEV_Destroy(), and then attempts to unload the WMD module. ++ */ ++DSP_STATUS DEV_DestroyDevice(struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(debugMask, GT_ENTER, "Entered DEV_DestroyDevice, hDevObject: " ++ "0x%x\n", hDevObject); ++ if (IsValidHandle(hDevObject)) { ++ if (pDevObject->hCodMgr) ++ COD_Delete(pDevObject->hCodMgr); ++ ++ if (pDevObject->hNodeMgr) ++ NODE_DeleteMgr(pDevObject->hNodeMgr); ++ ++ /* Free the io, channel, and message managers for this board: */ ++ if (pDevObject->hIOMgr) { ++ IO_Destroy(pDevObject->hIOMgr); ++ pDevObject->hIOMgr = NULL; ++ } ++ if (pDevObject->hChnlMgr) { ++ CHNL_Destroy(pDevObject->hChnlMgr); ++ pDevObject->hChnlMgr = NULL; ++ } ++ if (pDevObject->hMsgMgr) ++ MSG_Delete(pDevObject->hMsgMgr); ++ ++ if (pDevObject->hDehMgr) { ++ /* Uninitialize DEH module. */ ++ (*pDevObject->intfFxns.pfnDehDestroy) ++ (pDevObject->hDehMgr); ++ } ++ if (pDevObject->hCmmMgr) ++ CMM_Destroy(pDevObject->hCmmMgr, true); ++ ++ if (pDevObject->hDmmMgr) ++ DMM_Destroy(pDevObject->hDmmMgr); ++ ++ /* Call the driver's WMD_DEV_Destroy() function: */ ++ /* Require of DevDestroy */ ++ DBC_Assert(pDevObject->hWmdContext != NULL); ++ status = (*pDevObject->intfFxns.pfnDevDestroy) ++ (pDevObject->hWmdContext); ++ if (DSP_SUCCEEDED(status)) { ++ if (pDevObject->procList) ++ LST_Delete(pDevObject->procList); ++ ++ /* Remove this DEV_Object from the global list: */ ++ DRV_RemoveDevObject(pDevObject->hDrvObject, pDevObject); ++ /* Free The library * LDR_FreeModule ++ * (pDevObject->hModule);*/ ++ /* Free this dev object: */ ++ MEM_FreeObject(pDevObject); ++ } ++ } else { ++ GT_0trace(debugMask, GT_7CLASS, "DEV_Destroy: Invlaid handle"); ++ status = DSP_EHANDLE; ++ } ++ GT_1trace(debugMask, GT_ENTER, "Exit DEV_destroy: status 0x%x\n", ++ status); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetChnlMgr ======== ++ * Purpose: ++ * Retrieve the handle to the channel manager handle created for this ++ * device. ++ */ ++DSP_STATUS DEV_GetChnlMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct CHNL_MGR **phMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMgr != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetChnlMgr, hDevObject: 0x%x\n\t" ++ "\tphMgr: 0x%x\n", hDevObject, phMgr); ++ if (IsValidHandle(hDevObject)) { ++ *phMgr = pDevObject->hChnlMgr; ++ } else { ++ *phMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetChnlMgr: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetChnlMgr: status 0x%x\t\n hMgr: " ++ "0x%x\n", status, *phMgr); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phMgr != NULL) && ++ (*phMgr == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetCmmMgr ======== ++ * Purpose: ++ * Retrieve the handle to the shared memory manager created for this ++ * device. ++ */ ++DSP_STATUS DEV_GetCmmMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct CMM_OBJECT **phMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMgr != NULL); ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetCmmMgr, hDevObject: 0x%x\n\t" ++ "\tphMgr: 0x%x\n", hDevObject, phMgr); ++ if (IsValidHandle(hDevObject)) { ++ *phMgr = pDevObject->hCmmMgr; ++ } else { ++ *phMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetCmmMgr: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetCmmMgr: status 0x%x\t\nhMgr: " ++ "0x%x\n", status, *phMgr); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phMgr != NULL) && ++ (*phMgr == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetDmmMgr ======== ++ * Purpose: ++ * Retrieve the handle to the dynamic memory manager created for this ++ * device. ++ */ ++DSP_STATUS DEV_GetDmmMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct DMM_OBJECT **phMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMgr != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, "Entered DEV_GetDmmMgr, hDevObject: " ++ "0x%x\n\t\tphMgr: 0x%x\n", hDevObject, phMgr); ++ if (IsValidHandle(hDevObject)) { ++ *phMgr = pDevObject->hDmmMgr; ++ } else { ++ *phMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetDmmMgr: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetDmmMgr: status 0x%x\t\n hMgr: " ++ "0x%x\n", status, *phMgr); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phMgr != NULL) && ++ (*phMgr == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetCodMgr ======== ++ * Purpose: ++ * Retrieve the COD manager create for this device. ++ */ ++DSP_STATUS DEV_GetCodMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct COD_MANAGER **phCodMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phCodMgr != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetCodMgr, hDevObject: 0x%x\n\t\t" ++ "phCodMgr: 0x%x\n", hDevObject, phCodMgr); ++ if (IsValidHandle(hDevObject)) { ++ *phCodMgr = pDevObject->hCodMgr; ++ } else { ++ *phCodMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_1trace(debugMask, GT_7CLASS, ++ "DEV_GetCodMgr, invalid handle: 0x%x\n", ++ hDevObject); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetCodMgr: status 0x%x\t\n hCodMgr:" ++ " 0x%x\n", status, *phCodMgr); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phCodMgr != NULL) && ++ (*phCodMgr == NULL))); ++ return status; ++} ++ ++/* ++ * ========= DEV_GetDehMgr ======== ++ */ ++DSP_STATUS DEV_GetDehMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct DEH_MGR **phDehMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDehMgr != NULL); ++ DBC_Require(MEM_IsValidHandle(hDevObject, SIGNATURE)); ++ if (IsValidHandle(hDevObject)) { ++ *phDehMgr = hDevObject->hDehMgr; ++ } else { ++ *phDehMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetDehMgr: Invalid handle"); ++ } ++ return status; ++} ++ ++/* ++ * ======== DEV_GetDevNode ======== ++ * Purpose: ++ * Retrieve the platform specific device ID for this device. ++ */ ++DSP_STATUS DEV_GetDevNode(struct DEV_OBJECT *hDevObject, ++ OUT struct CFG_DEVNODE **phDevNode) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDevNode != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetDevNode, hDevObject: 0x%x\n\t" ++ "\tphDevNode: 0x%x\n", hDevObject, phDevNode); ++ if (IsValidHandle(hDevObject)) { ++ *phDevNode = pDevObject->hDevNode; ++ } else { ++ *phDevNode = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetDevNode: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetDevNode: status 0x%x\t\nhDevNode:" ++ "0x%x\n", status, *phDevNode); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phDevNode != NULL) && ++ (*phDevNode == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetFirst ======== ++ * Purpose: ++ * Retrieve the first Device Object handle from an internal linked list ++ * DEV_OBJECTs maintained by DEV. ++ */ ++struct DEV_OBJECT *DEV_GetFirst(void) ++{ ++ struct DEV_OBJECT *pDevObject = NULL; ++ ++ pDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ ++ DBC_Ensure((pDevObject == NULL) || IsValidHandle(pDevObject)); ++ ++ return pDevObject; ++} ++ ++/* ++ * ======== DEV_GetIntfFxns ======== ++ * Purpose: ++ * Retrieve the WMD interface function structure for the loaded WMD. ++ * ppIntfFxns != NULL. ++ */ ++DSP_STATUS DEV_GetIntfFxns(struct DEV_OBJECT *hDevObject, ++ OUT struct WMD_DRV_INTERFACE **ppIntfFxns) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(ppIntfFxns != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetIntfFxns, hDevObject: 0x%x\n\t" ++ "\tppIntfFxns: 0x%x\n", hDevObject, ppIntfFxns); ++ if (IsValidHandle(hDevObject)) { ++ *ppIntfFxns = &pDevObject->intfFxns; ++ } else { ++ *ppIntfFxns = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetIntDxns: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, "Exit DEV_GetIntFxns: status 0x%x\t\n" ++ "ppIntFxns: 0x%x\n", status, *ppIntfFxns); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((ppIntfFxns != NULL) && ++ (*ppIntfFxns == NULL))); ++ return status; ++} ++ ++/* ++ * ========= DEV_GetIOMgr ======== ++ */ ++DSP_STATUS DEV_GetIOMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct IO_MGR **phIOMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phIOMgr != NULL); ++ DBC_Require(MEM_IsValidHandle(hDevObject, SIGNATURE)); ++ ++ if (IsValidHandle(hDevObject)) { ++ *phIOMgr = hDevObject->hIOMgr; ++ } else { ++ *phIOMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, "DEV_GetIOMgr: Invalid handle"); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DEV_GetNext ======== ++ * Purpose: ++ * Retrieve the next Device Object handle from an internal linked list ++ * of DEV_OBJECTs maintained by DEV, after having previously called ++ * DEV_GetFirst() and zero or more DEV_GetNext ++ */ ++struct DEV_OBJECT *DEV_GetNext(struct DEV_OBJECT *hDevObject) ++{ ++ struct DEV_OBJECT *pNextDevObject = NULL; ++ ++ if (IsValidHandle(hDevObject)) { ++ pNextDevObject = (struct DEV_OBJECT *) ++ DRV_GetNextDevObject((u32)hDevObject); ++ } ++ DBC_Ensure((pNextDevObject == NULL) || IsValidHandle(pNextDevObject)); ++ return pNextDevObject; ++} ++ ++/* ++ * ========= DEV_GetMsgMgr ======== ++ */ ++void DEV_GetMsgMgr(struct DEV_OBJECT *hDevObject, ++ OUT struct MSG_MGR **phMsgMgr) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMsgMgr != NULL); ++ DBC_Require(MEM_IsValidHandle(hDevObject, SIGNATURE)); ++ ++ *phMsgMgr = hDevObject->hMsgMgr; ++} ++ ++/* ++ * ======== DEV_GetNodeManager ======== ++ * Purpose: ++ * Retrieve the Node Manager Handle ++ */ ++DSP_STATUS DEV_GetNodeManager(struct DEV_OBJECT *hDevObject, ++ OUT struct NODE_MGR **phNodeMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phNodeMgr != NULL); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetNodeManager, hDevObject: 0x%x" ++ "\n\t\tphNodeMgr: 0x%x\n", hDevObject, phNodeMgr); ++ if (IsValidHandle(hDevObject)) { ++ *phNodeMgr = pDevObject->hNodeMgr; ++ } else { ++ *phNodeMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_1trace(debugMask, GT_7CLASS, ++ "DEV_GetNodeManager, invalid handle: 0x" ++ "%x\n", hDevObject); ++ } ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetNodeManager: status 0x%x\t\nhMgr:" ++ " 0x%x\n", status, *phNodeMgr); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phNodeMgr != NULL) && ++ (*phNodeMgr == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetSymbol ======== ++ */ ++DSP_STATUS DEV_GetSymbol(struct DEV_OBJECT *hDevObject, ++ IN CONST char *pstrSym, OUT u32 *pulValue) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct COD_MANAGER *hCodMgr; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pstrSym != NULL && pulValue != NULL); ++ ++ GT_3trace(debugMask, GT_ENTER, ++ "Entered DEV_GetSymbol, hDevObject: 0x%x\n\t\t" ++ "pstrSym: 0x%x\n\t\tpulValue: 0x%x\n", hDevObject, pstrSym, ++ pulValue); ++ if (IsValidHandle(hDevObject)) { ++ status = DEV_GetCodMgr(hDevObject, &hCodMgr); ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(hCodMgr != NULL); ++ status = COD_GetSymValue(hCodMgr, (char *)pstrSym, ++ pulValue); ++ } ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetSymbol: Invalid handle"); ++ } ++ GT_2trace(debugMask, GT_ENTER, "Exit DEV_GetSymbol: status 0x%x\t\n" ++ "hWmdContext: 0x%x\n", status, *pulValue); ++ return status; ++} ++ ++/* ++ * ======== DEV_GetWMDContext ======== ++ * Purpose: ++ * Retrieve the WMD Context handle, as returned by the WMD_Create fxn. ++ */ ++DSP_STATUS DEV_GetWMDContext(struct DEV_OBJECT *hDevObject, ++ OUT struct WMD_DEV_CONTEXT **phWmdContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phWmdContext != NULL); ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_GetWMDContext, hDevObject: 0x%x\n" ++ "\t\tphWmdContext: 0x%x\n", hDevObject, phWmdContext); ++ if (IsValidHandle(hDevObject)) { ++ *phWmdContext = pDevObject->hWmdContext; ++ } else { ++ *phWmdContext = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_GetWMDContext: Invalid handle"); ++ } ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Exit DEV_GetWMDContext: status 0x%x\t\n" ++ "hWmdContext: 0x%x\n", status, *phWmdContext); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phWmdContext != NULL) && ++ (*phWmdContext == NULL))); ++ return status; ++} ++ ++/* ++ * ======== DEV_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ */ ++void DEV_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ if (cRefs == 0) { ++ CMM_Exit(); ++ DMM_Exit(); ++ } ++ ++ GT_1trace(debugMask, GT_5CLASS, "Entered DEV_Exit, ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== DEV_Init ======== ++ * Purpose: ++ * Initialize DEV's private state, keeping a reference count on each call. ++ */ ++bool DEV_Init(void) ++{ ++ bool fCmm, fDmm, fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ /* Set the Trace mask */ ++ DBC_Assert(!debugMask.flags); ++ GT_create(&debugMask, "DV"); /* "DV" for DeVice */ ++ fCmm = CMM_Init(); ++ fDmm = DMM_Init(); ++ ++ fRetval = fCmm && fDmm; ++ ++ if (!fRetval) { ++ if (fCmm) ++ CMM_Exit(); ++ ++ ++ if (fDmm) ++ DMM_Exit(); ++ ++ } ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ ++ GT_1trace(debugMask, GT_5CLASS, "Entered DEV_Init, ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++/* ++ * ======== DEV_NotifyClients ======== ++ * Purpose: ++ * Notify all clients of this device of a change in device status. ++ */ ++DSP_STATUS DEV_NotifyClients(struct DEV_OBJECT *hDevObject, u32 ulStatus) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ DSP_HPROCESSOR hProcObject; ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_NotifyClients, hDevObject: 0x%x\n" ++ "\t\tulStatus: 0x%x\n", hDevObject, ulStatus); ++ for (hProcObject = (DSP_HPROCESSOR)LST_First(pDevObject->procList); ++ hProcObject != NULL; ++ hProcObject = (DSP_HPROCESSOR)LST_Next(pDevObject->procList, ++ (struct LST_ELEM *)hProcObject)) ++ PROC_NotifyClients(hProcObject, (u32) ulStatus); ++ ++ return status; ++} ++ ++/* ++ * ======== DEV_RemoveDevice ======== ++ */ ++DSP_STATUS DEV_RemoveDevice(struct CFG_DEVNODE *hDevNode) ++{ ++ struct DEV_OBJECT *hDevObject; /* handle to device object */ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject; ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Entered DEV_RemoveDevice, hDevNode: 0x%x\n", hDevNode); ++ /* Retrieve the device object handle originaly stored with ++ * the DevNode: */ ++ status = CFG_GetDevObject(hDevNode, (u32 *)&hDevObject); ++ if (DSP_SUCCEEDED(status)) { ++ /* Remove the Processor List */ ++ pDevObject = (struct DEV_OBJECT *)hDevObject; ++ /* Destroy the device object. */ ++ status = DEV_DestroyDevice(hDevObject); ++ if (DSP_SUCCEEDED(status)) { ++ /* Null out the handle stored with the DevNode. */ ++ GT_0trace(debugMask, GT_1CLASS, ++ "DEV_RemoveDevice, success"); ++ } ++ } ++ GT_1trace(debugMask, GT_ENTER, "Exit DEV_RemoveDevice, status: 0x%x\n", ++ status); ++ return status; ++} ++ ++/* ++ * ======== DEV_SetChnlMgr ======== ++ * Purpose: ++ * Set the channel manager for this device. ++ */ ++DSP_STATUS DEV_SetChnlMgr(struct DEV_OBJECT *hDevObject, struct CHNL_MGR *hMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = hDevObject; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_SetChnlMgr, hDevObject: 0x%x\n\t" ++ "\thMgr:0x%x\n", hDevObject, hMgr); ++ if (IsValidHandle(hDevObject)) { ++ pDevObject->hChnlMgr = hMgr; ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(debugMask, GT_7CLASS, ++ "DEV_SetChnlMgr, Invalid handle\n"); ++ } ++ DBC_Ensure(DSP_FAILED(status) || (pDevObject->hChnlMgr == hMgr)); ++ return status; ++} ++ ++/* ++ * ======== DEV_SetMsgMgr ======== ++ * Purpose: ++ * Set the message manager for this device. ++ */ ++void DEV_SetMsgMgr(struct DEV_OBJECT *hDevObject, struct MSG_MGR *hMgr) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(hDevObject)); ++ GT_2trace(debugMask, GT_ENTER, ++ "Entered DEV_SetMsgMgr, hDevObject: 0x%x\n\t\t" ++ "hMgr: 0x%x\n", hDevObject, hMgr); ++ hDevObject->hMsgMgr = hMgr; ++} ++ ++/* ++ * ======== DEV_StartDevice ======== ++ * Purpose: ++ * Initializes the new device with the BRIDGE environment. ++ */ ++DSP_STATUS DEV_StartDevice(struct CFG_DEVNODE *hDevNode) ++{ ++ struct DEV_OBJECT *hDevObject = NULL; /* handle to 'Bridge Device */ ++ struct CFG_HOSTRES hostRes; /* resources struct. */ ++ struct CFG_DSPRES dspRes; /* DSP resources struct */ ++ char szWMDFileName[CFG_MAXSEARCHPATHLEN] = "UMA"; /* wmd filename */ ++ DSP_STATUS status; ++ struct MGR_OBJECT *hMgrObject = NULL; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Entered DEV_StartDevice, hDevObject: 0x%x\n", hDevNode); ++ status = CFG_GetHostResources(hDevNode, &hostRes); ++ if (DSP_SUCCEEDED(status)) { ++ /* Get DSP resources of device from Registry: */ ++ status = CFG_GetDSPResources(hDevNode, &dspRes); ++ if (DSP_FAILED(status)) { ++ GT_1trace(debugMask, GT_7CLASS, ++ "Failed to get WMD DSP resources" ++ " from registry: 0x%x ", status); ++ } ++ } else { ++ GT_1trace(debugMask, GT_7CLASS, ++ "Failed to get WMD Host resources " ++ "from registry: 0x%x ", status); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Given all resources, create a device object. */ ++ status = DEV_CreateDevice(&hDevObject, szWMDFileName, &hostRes, ++ &dspRes, hDevNode); ++ if (DSP_SUCCEEDED(status)) { ++ /* Store away the hDevObject with the DEVNODE */ ++ status = CFG_SetDevObject(hDevNode, (u32)hDevObject); ++ if (DSP_FAILED(status)) { ++ /* Clean up */ ++ GT_1trace(debugMask, GT_7CLASS, ++ "Failed to set DevObject in the " ++ "Registry: 0x%x", status); ++ DEV_DestroyDevice(hDevObject); ++ hDevObject = NULL; ++ } ++ } else { ++ GT_1trace(debugMask, GT_7CLASS, ++ "Failed to Create Device: 0x%x", ++ status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Create the Manager Object */ ++ status = MGR_Create(&hMgrObject, hDevNode); ++ } ++ if (DSP_FAILED(status)) { ++ GT_1trace(debugMask, GT_7CLASS, "Failed to MGR object: 0x%x", ++ status); ++ status = DSP_EFAIL; ++ } ++ if (DSP_FAILED(status)) { ++ if (hDevObject) ++ DEV_DestroyDevice(hDevObject); ++ ++ /* Ensure the device extension is NULL */ ++ CFG_SetDevObject(hDevNode, 0L); ++ } ++ GT_1trace(debugMask, GT_ENTER, "Exiting DEV_StartDevice status 0x%x\n", ++ status); ++ return status; ++} ++ ++/* ++ * ======== FxnNotImplemented ======== ++ * Purpose: ++ * Takes the place of a WMD Null Function. ++ * Parameters: ++ * Multiple, optional. ++ * Returns: ++ * DSP_ENOTIMPL: Always. ++ */ ++static DSP_STATUS FxnNotImplemented(int arg, ...) ++{ ++ DBG_Trace(DBG_LEVEL1, ++ "WARNING: Calling a non-implemented WMD function.\n"); ++ ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== IsValidHandle ======== ++ * Purpose: ++ * Validate the device object handle. ++ * Parameters: ++ * hDevObject: Handle to device object created with ++ * DEV_CreateDevice(). ++ * Returns: ++ * true if handle is valid; false otherwise. ++ * Requires: ++ * Ensures: ++ */ ++static bool IsValidHandle(struct DEV_OBJECT *hObj) ++{ ++ bool retVal; ++ ++ retVal = (hObj != NULL) && (hObj->dwSignature == SIGNATURE); ++ ++ return retVal; ++} ++ ++/* ++ * ======== InitCodMgr ======== ++ * Purpose: ++ * Create a COD manager for this device. ++ * Parameters: ++ * pDevObject: Pointer to device object created with ++ * DEV_CreateDevice() ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EHANDLE: Invalid hDevObject. ++ * Requires: ++ * Should only be called once by DEV_CreateDevice() for a given DevObject. ++ * Ensures: ++ */ ++static DSP_STATUS InitCodMgr(struct DEV_OBJECT *pDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ char *szDummyFile = "dummy"; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(!IsValidHandle(pDevObject) || ++ (pDevObject->hCodMgr == NULL)); ++ GT_1trace(debugMask, GT_ENTER, "Entering InitCodMgr pDevObject: 0x%x", ++ pDevObject); ++ status = COD_Create(&pDevObject->hCodMgr, szDummyFile, NULL); ++ GT_1trace(debugMask, GT_ENTER, "Exiting InitCodMgr status 0x%x\n ", ++ status); ++ return status; ++} ++ ++/* ++ * ======== DEV_InsertProcObject ======== ++ * Purpose: ++ * Insert a ProcObject into the list maintained by DEV. ++ * Parameters: ++ * pProcObject: Ptr to ProcObject to insert. ++ * pDevObject: Ptr to Dev Object where the list is. ++ * pbAlreadyAttached: Ptr to return the bool ++ * Returns: ++ * DSP_SOK: If successful. ++ * Requires: ++ * List Exists ++ * hDevObject is Valid handle ++ * DEV Initialized ++ * pbAlreadyAttached != NULL ++ * hProcObject != 0 ++ * Ensures: ++ * DSP_SOK and List is not Empty. ++ */ ++DSP_STATUS DEV_InsertProcObject(struct DEV_OBJECT *hDevObject, ++ u32 hProcObject, ++ OUT bool *pbAlreadyAttached) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = (struct DEV_OBJECT *)hDevObject; ++ ++ GT_2trace(debugMask, GT_ENTER, ++ "Entering DEV_InsetProcObject pProcObject 0x%x" ++ "pDevObject 0x%x\n", hProcObject, hDevObject); ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(pDevObject)); ++ DBC_Require(hProcObject != 0); ++ DBC_Require(pDevObject->procList != NULL); ++ DBC_Require(pbAlreadyAttached != NULL); ++ if (!LST_IsEmpty(pDevObject->procList)) ++ *pbAlreadyAttached = true; ++ ++ /* Add DevObject to tail. */ ++ LST_PutTail(pDevObject->procList, (struct LST_ELEM *)hProcObject); ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Exiting DEV_InsetProcObject status 0x%x\n", status); ++ DBC_Ensure(DSP_SUCCEEDED(status) && !LST_IsEmpty(pDevObject->procList)); ++ ++ return status; ++} ++ ++/* ++ * ======== DEV_RemoveProcObject ======== ++ * Purpose: ++ * Search for and remove a Proc object from the given list maintained ++ * by the DEV ++ * Parameters: ++ * pProcObject: Ptr to ProcObject to insert. ++ * pDevObject Ptr to Dev Object where the list is. ++ * Returns: ++ * DSP_SOK: If successful. ++ * Requires: ++ * List exists and is not empty ++ * hProcObject != 0 ++ * hDevObject is a valid Dev handle. ++ * Ensures: ++ * Details: ++ * List will be deleted when the DEV is destroyed. ++ */ ++DSP_STATUS DEV_RemoveProcObject(struct DEV_OBJECT *hDevObject, ++ u32 hProcObject) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct LST_ELEM *pCurElem; ++ struct DEV_OBJECT *pDevObject = (struct DEV_OBJECT *)hDevObject; ++ ++ DBC_Require(IsValidHandle(pDevObject)); ++ DBC_Require(hProcObject != 0); ++ DBC_Require(pDevObject->procList != NULL); ++ DBC_Require(!LST_IsEmpty(pDevObject->procList)); ++ ++ GT_1trace(debugMask, GT_ENTER, ++ "Entering DEV_RemoveProcObject hDevObject " ++ "0x%x\n", hDevObject); ++ /* Search list for pDevObject: */ ++ for (pCurElem = LST_First(pDevObject->procList); pCurElem != NULL; ++ pCurElem = LST_Next(pDevObject->procList, pCurElem)) { ++ /* If found, remove it. */ ++ if ((u32)pCurElem == hProcObject) { ++ LST_RemoveElem(pDevObject->procList, pCurElem); ++ status = DSP_SOK; ++ break; ++ } ++ } ++ GT_1trace(debugMask, GT_ENTER, "DEV_RemoveProcObject returning 0x%x\n", ++ status); ++ return status; ++} ++ ++DSP_STATUS DEV_GetDevType(struct DEV_OBJECT *hdevObject, u32 *devType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *pDevObject = (struct DEV_OBJECT *)hdevObject; ++ ++ *devType = pDevObject->devType; ++ ++ return status; ++} ++ ++/* ++ * ======== StoreInterfaceFxns ======== ++ * Purpose: ++ * Copy the WMD's interface functions into the device object, ++ * ensuring that FxnNotImplemented() is set for: ++ * ++ * 1. All WMD function pointers which are NULL; and ++ * 2. All function slots in the struct DEV_OBJECT structure which have no ++ * corresponding slots in the the WMD's interface, because the WMD ++ * is of an *older* version. ++ * Parameters: ++ * pIntfFxns: Interface Fxn Structure of the WCD's Dev Object. ++ * pDrvFxns: Interface Fxns offered by the WMD during DEV_Create(). ++ * Returns: ++ * Requires: ++ * Input pointers are valid. ++ * WMD is *not* written for a newer WCD. ++ * Ensures: ++ * All function pointers in the dev object's Fxn interface are not NULL. ++ */ ++static void StoreInterfaceFxns(struct WMD_DRV_INTERFACE *pDrvFxns, ++ OUT struct WMD_DRV_INTERFACE *pIntfFxns) ++{ ++ u32 dwWMDVersion; ++ ++ /* Local helper macro: */ ++#define StoreFxn(cast, pfn) \ ++ (pIntfFxns->pfn = ((pDrvFxns->pfn != NULL) ? pDrvFxns->pfn : \ ++ (cast)FxnNotImplemented)) ++ ++ DBC_Require(pIntfFxns != NULL); ++ DBC_Require(pDrvFxns != NULL); ++ DBC_Require(MAKEVERSION(pDrvFxns->dwWCDMajorVersion, ++ pDrvFxns->dwWCDMinorVersion) <= WCDVERSION); ++ dwWMDVersion = MAKEVERSION(pDrvFxns->dwWCDMajorVersion, ++ pDrvFxns->dwWCDMinorVersion); ++ pIntfFxns->dwWCDMajorVersion = pDrvFxns->dwWCDMajorVersion; ++ pIntfFxns->dwWCDMinorVersion = pDrvFxns->dwWCDMinorVersion; ++ /* Install functions up to WCD version .80 (first alpha): */ ++ if (dwWMDVersion > 0) { ++ StoreFxn(WMD_DEV_CREATE, pfnDevCreate); ++ StoreFxn(WMD_DEV_DESTROY, pfnDevDestroy); ++ StoreFxn(WMD_DEV_CTRL, pfnDevCntrl); ++ StoreFxn(WMD_BRD_MONITOR, pfnBrdMonitor); ++ StoreFxn(WMD_BRD_START, pfnBrdStart); ++ StoreFxn(WMD_BRD_STOP, pfnBrdStop); ++ StoreFxn(WMD_BRD_STATUS, pfnBrdStatus); ++ StoreFxn(WMD_BRD_READ, pfnBrdRead); ++ StoreFxn(WMD_BRD_WRITE, pfnBrdWrite); ++ StoreFxn(WMD_BRD_SETSTATE, pfnBrdSetState); ++ StoreFxn(WMD_BRD_MEMCOPY, pfnBrdMemCopy); ++ StoreFxn(WMD_BRD_MEMWRITE, pfnBrdMemWrite); ++ StoreFxn(WMD_BRD_MEMMAP, pfnBrdMemMap); ++ StoreFxn(WMD_BRD_MEMUNMAP, pfnBrdMemUnMap); ++ StoreFxn(WMD_CHNL_CREATE, pfnChnlCreate); ++ StoreFxn(WMD_CHNL_DESTROY, pfnChnlDestroy); ++ StoreFxn(WMD_CHNL_OPEN, pfnChnlOpen); ++ StoreFxn(WMD_CHNL_CLOSE, pfnChnlClose); ++ StoreFxn(WMD_CHNL_ADDIOREQ, pfnChnlAddIOReq); ++ StoreFxn(WMD_CHNL_GETIOC, pfnChnlGetIOC); ++ StoreFxn(WMD_CHNL_CANCELIO, pfnChnlCancelIO); ++ StoreFxn(WMD_CHNL_FLUSHIO, pfnChnlFlushIO); ++ StoreFxn(WMD_CHNL_GETINFO, pfnChnlGetInfo); ++ StoreFxn(WMD_CHNL_GETMGRINFO, pfnChnlGetMgrInfo); ++ StoreFxn(WMD_CHNL_IDLE, pfnChnlIdle); ++ StoreFxn(WMD_CHNL_REGISTERNOTIFY, pfnChnlRegisterNotify); ++ StoreFxn(WMD_DEH_CREATE, pfnDehCreate); ++ StoreFxn(WMD_DEH_DESTROY, pfnDehDestroy); ++ StoreFxn(WMD_DEH_NOTIFY, pfnDehNotify); ++ StoreFxn(WMD_DEH_REGISTERNOTIFY, pfnDehRegisterNotify); ++ StoreFxn(WMD_DEH_GETINFO, pfnDehGetInfo); ++ StoreFxn(WMD_IO_CREATE, pfnIOCreate); ++ StoreFxn(WMD_IO_DESTROY, pfnIODestroy); ++ StoreFxn(WMD_IO_ONLOADED, pfnIOOnLoaded); ++ StoreFxn(WMD_IO_GETPROCLOAD, pfnIOGetProcLoad); ++ StoreFxn(WMD_MSG_CREATE, pfnMsgCreate); ++ StoreFxn(WMD_MSG_CREATEQUEUE, pfnMsgCreateQueue); ++ StoreFxn(WMD_MSG_DELETE, pfnMsgDelete); ++ StoreFxn(WMD_MSG_DELETEQUEUE, pfnMsgDeleteQueue); ++ StoreFxn(WMD_MSG_GET, pfnMsgGet); ++ StoreFxn(WMD_MSG_PUT, pfnMsgPut); ++ StoreFxn(WMD_MSG_REGISTERNOTIFY, pfnMsgRegisterNotify); ++ StoreFxn(WMD_MSG_SETQUEUEID, pfnMsgSetQueueId); ++ } ++ /* Add code for any additional functions in newer WMD versions here: */ ++ /* Ensure postcondition: */ ++ DBC_Ensure(pIntfFxns->pfnDevCreate != NULL); ++ DBC_Ensure(pIntfFxns->pfnDevDestroy != NULL); ++ DBC_Ensure(pIntfFxns->pfnDevCntrl != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdMonitor != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdStart != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdStop != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdStatus != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdRead != NULL); ++ DBC_Ensure(pIntfFxns->pfnBrdWrite != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlCreate != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlDestroy != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlOpen != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlClose != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlAddIOReq != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlGetIOC != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlCancelIO != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlFlushIO != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlGetInfo != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlGetMgrInfo != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlIdle != NULL); ++ DBC_Ensure(pIntfFxns->pfnChnlRegisterNotify != NULL); ++ DBC_Ensure(pIntfFxns->pfnDehCreate != NULL); ++ DBC_Ensure(pIntfFxns->pfnDehDestroy != NULL); ++ DBC_Ensure(pIntfFxns->pfnDehNotify != NULL); ++ DBC_Ensure(pIntfFxns->pfnDehRegisterNotify != NULL); ++ DBC_Ensure(pIntfFxns->pfnDehGetInfo != NULL); ++ DBC_Ensure(pIntfFxns->pfnIOCreate != NULL); ++ DBC_Ensure(pIntfFxns->pfnIODestroy != NULL); ++ DBC_Ensure(pIntfFxns->pfnIOOnLoaded != NULL); ++ DBC_Ensure(pIntfFxns->pfnIOGetProcLoad != NULL); ++ DBC_Ensure(pIntfFxns->pfnMsgSetQueueId != NULL); ++ ++#undef StoreFxn ++} ++ +diff --git a/drivers/dsp/bridge/pmgr/dmm.c b/drivers/dsp/bridge/pmgr/dmm.c +new file mode 100644 +index 0000000..803de93 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/dmm.c +@@ -0,0 +1,692 @@ ++/* ++ * dmm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== dmm.c ======== ++ * Purpose: ++ * The Dynamic Memory Manager (DMM) module manages the DSP Virtual address ++ * space that can be directly mapped to any MPU buffer or memory region ++ * ++ * Public Functions: ++ * DMM_CreateTables ++ * DMM_Create ++ * DMM_Destroy ++ * DMM_Exit ++ * DMM_Init ++ * DMM_MapMemory ++ * DMM_Reset ++ * DMM_ReserveMemory ++ * DMM_UnMapMemory ++ * DMM_UnReserveMemory ++ * ++ * Private Functions: ++ * AddRegion ++ * CreateRegion ++ * GetRegion ++ * GetFreeRegion ++ * GetMappedRegion ++ * ++ * Notes: ++ * Region: Generic memory entitiy having a start address and a size ++ * Chunk: Reserved region ++ * ++ * ++ *! Revision History: ++ *! ================ ++ *! 04-Jun-2008 Hari K : Optimized DMM implementation. Removed linked list ++ *! and instead used Table approach. ++ *! 19-Apr-2004 sb: Integrated Alan's code review updates. ++ *! 17-Mar-2004 ap: Fixed GetRegion for size=0 using tighter bound. ++ *! 20-Feb-2004 sb: Created. ++ *! ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/errbase.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/proc.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dmm.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++/* Object signatures */ ++#define DMMSIGNATURE 0x004d4d44 /* "DMM" (in reverse) */ ++ ++#define DMM_ADDR_VIRTUAL(a) \ ++ (((struct MapPage *)(a) - pVirtualMappingTable) * PG_SIZE_4K +\ ++ dynMemMapBeg) ++#define DMM_ADDR_TO_INDEX(a) (((a) - dynMemMapBeg) / PG_SIZE_4K) ++ ++/* DMM Mgr */ ++struct DMM_OBJECT { ++ u32 dwSignature; /* Used for object validation */ ++ /* Dmm Lock is used to serialize access mem manager for ++ * multi-threads. */ ++ struct SYNC_CSOBJECT *hDmmLock; /* Lock to access dmm mgr */ ++}; ++ ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask DMM_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++struct MapPage { ++ u32 RegionSize:15; ++ u32 MappedSize:15; ++ u32 bReserved:1; ++ u32 bMapped:1; ++}; ++ ++/* Create the free list */ ++static struct MapPage *pVirtualMappingTable; ++static u32 iFreeRegion; /* The index of free region */ ++static u32 iFreeSize; ++static u32 *pPhysicalAddrTable; /* Physical address of MPU buffer */ ++static u32 dynMemMapBeg; /* The Beginning of dynamic memory mapping */ ++static u32 TableSize;/* The size of virtual and physical pages tables */ ++ ++/* ----------------------------------- Function Prototypes */ ++static struct MapPage *GetRegion(u32 addr); ++static struct MapPage *GetFreeRegion(u32 aSize); ++static struct MapPage *GetMappedRegion(u32 aAddr); ++#ifdef DSP_DMM_DEBUG ++u32 DMM_MemMapDump(struct DMM_OBJECT *hDmmMgr); ++#endif ++ ++/* ======== DMM_CreateTables ======== ++ * Purpose: ++ * Create table to hold the information of physical address ++ * the buffer pages that is passed by the user, and the table ++ * to hold the information of the virtual memory that is reserved ++ * for DSP. ++ */ ++DSP_STATUS DMM_CreateTables(struct DMM_OBJECT *hDmmMgr, u32 addr, u32 size) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_CreateTables () hDmmMgr %x, addr" ++ " %x, size %x\n", hDmmMgr, addr, size); ++ status = DMM_DeleteTables(pDmmObj); ++ if (DSP_SUCCEEDED(status)) { ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ dynMemMapBeg = addr; ++ TableSize = (size/PG_SIZE_4K) + 1; ++ /* Create the free list */ ++ pVirtualMappingTable = (struct MapPage *) MEM_Calloc ++ (TableSize*sizeof(struct MapPage), MEM_NONPAGED); ++ if (pVirtualMappingTable == NULL) ++ status = DSP_EMEMORY; ++ else { ++ /* This table will be used ++ * to store the virtual to physical ++ * address translations ++ */ ++ pPhysicalAddrTable = (u32 *)MEM_Calloc ++ (TableSize*sizeof(u32), MEM_NONPAGED); ++ GT_1trace(DMM_debugMask, GT_4CLASS, ++ "DMM_CreateTables: Allocate" ++ "memory for pPhysicalAddrTable=%d entries\n", ++ TableSize); ++ if (pPhysicalAddrTable == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(DMM_debugMask, GT_7CLASS, ++ "DMM_CreateTables: Memory allocation for " ++ "pPhysicalAddrTable failed\n"); ++ } else { ++ /* On successful allocation, ++ * all entries are zero ('free') */ ++ iFreeRegion = 0; ++ iFreeSize = TableSize*PG_SIZE_4K; ++ pVirtualMappingTable[0].RegionSize = TableSize; ++ } ++ } ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ } else ++ GT_0trace(DMM_debugMask, GT_7CLASS, ++ "DMM_CreateTables: DMM_DeleteTables" ++ "Failure\n"); ++ ++ GT_1trace(DMM_debugMask, GT_4CLASS, "Leaving DMM_CreateTables status" ++ "0x%x\n", status); ++ return status; ++} ++ ++/* ++ * ======== DMM_Create ======== ++ * Purpose: ++ * Create a dynamic memory manager object. ++ */ ++DSP_STATUS DMM_Create(OUT struct DMM_OBJECT **phDmmMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct DMM_MGRATTRS *pMgrAttrs) ++{ ++ struct DMM_OBJECT *pDmmObject = NULL; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDmmMgr != NULL); ++ ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "DMM_Create: phDmmMgr: 0x%x hDevObject: " ++ "0x%x pMgrAttrs: 0x%x\n", phDmmMgr, hDevObject, pMgrAttrs); ++ *phDmmMgr = NULL; ++ /* create, zero, and tag a cmm mgr object */ ++ MEM_AllocObject(pDmmObject, struct DMM_OBJECT, DMMSIGNATURE); ++ if (pDmmObject != NULL) { ++ status = SYNC_InitializeCS(&pDmmObject->hDmmLock); ++ if (DSP_SUCCEEDED(status)) ++ *phDmmMgr = pDmmObject; ++ else ++ DMM_Destroy(pDmmObject); ++ } else { ++ GT_0trace(DMM_debugMask, GT_7CLASS, ++ "DMM_Create: Object Allocation " ++ "Failure(DMM Object)\n"); ++ status = DSP_EMEMORY; ++ } ++ GT_2trace(DMM_debugMask, GT_4CLASS, ++ "Leaving DMM_Create status %x pDmmObject %x\n", ++ status, pDmmObject); ++ ++ return status; ++} ++ ++/* ++ * ======== DMM_Destroy ======== ++ * Purpose: ++ * Release the communication memory manager resources. ++ */ ++DSP_STATUS DMM_Destroy(struct DMM_OBJECT *hDmmMgr) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_1trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_Destroy () hDmmMgr %x\n", hDmmMgr); ++ DBC_Require(cRefs > 0); ++ if (MEM_IsValidHandle(hDmmMgr, DMMSIGNATURE)) { ++ status = DMM_DeleteTables(pDmmObj); ++ if (DSP_SUCCEEDED(status)) { ++ /* Delete CS & dmm mgr object */ ++ SYNC_DeleteCS(pDmmObj->hDmmLock); ++ MEM_FreeObject(pDmmObj); ++ } else ++ GT_0trace(DMM_debugMask, GT_7CLASS, ++ "DMM_Destroy: DMM_DeleteTables " ++ "Failure\n"); ++ } else ++ status = DSP_EHANDLE; ++ GT_1trace(DMM_debugMask, GT_4CLASS, "Leaving DMM_Destroy status %x\n", ++ status); ++ return status; ++} ++ ++ ++/* ++ * ======== DMM_DeleteTables ======== ++ * Purpose: ++ * Delete DMM Tables. ++ */ ++DSP_STATUS DMM_DeleteTables(struct DMM_OBJECT *hDmmMgr) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_1trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_DeleteTables () hDmmMgr %x\n", hDmmMgr); ++ DBC_Require(cRefs > 0); ++ if (MEM_IsValidHandle(hDmmMgr, DMMSIGNATURE)) { ++ /* Delete all DMM tables */ ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ ++ if (pVirtualMappingTable != NULL) ++ MEM_Free(pVirtualMappingTable); ++ ++ if (pPhysicalAddrTable != NULL) ++ MEM_Free(pPhysicalAddrTable); ++ ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ } else ++ status = DSP_EHANDLE; ++ GT_1trace(DMM_debugMask, GT_4CLASS, ++ "Leaving DMM_DeleteTables status %x\n", status); ++ return status; ++} ++ ++ ++ ++ ++/* ++ * ======== DMM_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ */ ++void DMM_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(DMM_debugMask, GT_ENTER, ++ "exiting DMM_Exit, ref count:0x%x\n", cRefs); ++} ++ ++/* ++ * ======== DMM_GetHandle ======== ++ * Purpose: ++ * Return the dynamic memory manager object for this device. ++ * This is typically called from the client process. ++ */ ++DSP_STATUS DMM_GetHandle(DSP_HPROCESSOR hProcessor, ++ OUT struct DMM_OBJECT **phDmmMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *hDevObject; ++ ++ GT_2trace(DMM_debugMask, GT_ENTER, ++ "DMM_GetHandle: hProcessor %x, phDmmMgr" ++ "%x\n", hProcessor, phDmmMgr); ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDmmMgr != NULL); ++ if (hProcessor != NULL) ++ status = PROC_GetDevObject(hProcessor, &hDevObject); ++ else ++ hDevObject = DEV_GetFirst(); /* default */ ++ ++ if (DSP_SUCCEEDED(status)) ++ status = DEV_GetDmmMgr(hDevObject, phDmmMgr); ++ ++ GT_2trace(DMM_debugMask, GT_4CLASS, "Leaving DMM_GetHandle status %x, " ++ "*phDmmMgr %x\n", status, phDmmMgr ? *phDmmMgr : NULL); ++ return status; ++} ++ ++/* ++ * ======== DMM_Init ======== ++ * Purpose: ++ * Initializes private state of DMM module. ++ */ ++bool DMM_Init(void) ++{ ++ bool fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ /* Set the Trace mask */ ++ /*"DM" for Dymanic Memory Manager */ ++ GT_create(&DMM_debugMask, "DM"); ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ GT_1trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_Init, ref count:0x%x\n", cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ pVirtualMappingTable = NULL ; ++ pPhysicalAddrTable = NULL ; ++ TableSize = 0; ++ ++ return fRetval; ++} ++ ++/* ++ * ======== DMM_MapMemory ======== ++ * Purpose: ++ * Add a mapping block to the reserved chunk. DMM assumes that this block ++ * will be mapped in the DSP/IVA's address space. DMM returns an error if a ++ * mapping overlaps another one. This function stores the info that will be ++ * required later while unmapping the block. ++ */ ++DSP_STATUS DMM_MapMemory(struct DMM_OBJECT *hDmmMgr, u32 addr, u32 size) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ struct MapPage *chunk; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_MapMemory () hDmmMgr %x, " ++ "addr %x, size %x\n", hDmmMgr, addr, size); ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ /* Find the Reserved memory chunk containing the DSP block to ++ * be mapped */ ++ chunk = (struct MapPage *)GetRegion(addr); ++ if (chunk != NULL) { ++ /* Mark the region 'mapped', leave the 'reserved' info as-is */ ++ chunk->bMapped = true; ++ chunk->MappedSize = (size/PG_SIZE_4K); ++ } else ++ status = DSP_ENOTFOUND; ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ GT_2trace(DMM_debugMask, GT_4CLASS, ++ "Leaving DMM_MapMemory status %x, chunk %x\n", ++ status, chunk); ++ return status; ++} ++ ++/* ++ * ======== DMM_ReserveMemory ======== ++ * Purpose: ++ * Reserve a chunk of virtually contiguous DSP/IVA address space. ++ */ ++DSP_STATUS DMM_ReserveMemory(struct DMM_OBJECT *hDmmMgr, u32 size, ++ u32 *pRsvAddr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ struct MapPage *node; ++ u32 rsvAddr = 0; ++ u32 rsvSize = 0; ++ ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_ReserveMemory () hDmmMgr %x, " ++ "size %x, pRsvAddr %x\n", hDmmMgr, size, pRsvAddr); ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ ++ /* Try to get a DSP chunk from the free list */ ++ node = GetFreeRegion(size); ++ if (node != NULL) { ++ /* DSP chunk of given size is available. */ ++ rsvAddr = DMM_ADDR_VIRTUAL(node); ++ /* Calculate the number entries to use */ ++ rsvSize = size/PG_SIZE_4K; ++ if (rsvSize < node->RegionSize) { ++ /* Mark remainder of free region */ ++ node[rsvSize].bMapped = false; ++ node[rsvSize].bReserved = false; ++ node[rsvSize].RegionSize = node->RegionSize - rsvSize; ++ node[rsvSize].MappedSize = 0; ++ } ++ /* GetRegion will return first fit chunk. But we only use what ++ is requested. */ ++ node->bMapped = false; ++ node->bReserved = true; ++ node->RegionSize = rsvSize; ++ node->MappedSize = 0; ++ /* Return the chunk's starting address */ ++ *pRsvAddr = rsvAddr; ++ } else ++ /*dSP chunk of given size is not available */ ++ status = DSP_EMEMORY; ++ ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ GT_3trace(DMM_debugMask, GT_4CLASS, ++ "Leaving ReserveMemory status %x, rsvAddr" ++ " %x, rsvSize %x\n", status, rsvAddr, rsvSize); ++ return status; ++} ++ ++ ++/* ++ * ======== DMM_UnMapMemory ======== ++ * Purpose: ++ * Remove the mapped block from the reserved chunk. ++ */ ++DSP_STATUS DMM_UnMapMemory(struct DMM_OBJECT *hDmmMgr, u32 addr, u32 *pSize) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ struct MapPage *chunk; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_UnMapMemory () hDmmMgr %x, " ++ "addr %x, pSize %x\n", hDmmMgr, addr, pSize); ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ chunk = GetMappedRegion(addr) ; ++ if (chunk == NULL) ++ status = DSP_ENOTFOUND ; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Unmap the region */ ++ *pSize = chunk->MappedSize * PG_SIZE_4K; ++ chunk->bMapped = false; ++ chunk->MappedSize = 0; ++ } ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ GT_3trace(DMM_debugMask, GT_ENTER, ++ "Leaving DMM_UnMapMemory status %x, chunk" ++ " %x, *pSize %x\n", status, chunk, *pSize); ++ ++ return status; ++} ++ ++/* ++ * ======== DMM_UnReserveMemory ======== ++ * Purpose: ++ * Free a chunk of reserved DSP/IVA address space. ++ */ ++DSP_STATUS DMM_UnReserveMemory(struct DMM_OBJECT *hDmmMgr, u32 rsvAddr) ++{ ++ struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr; ++ struct MapPage *chunk; ++ u32 i; ++ DSP_STATUS status = DSP_SOK; ++ u32 chunkSize; ++ ++ GT_2trace(DMM_debugMask, GT_ENTER, ++ "Entered DMM_UnReserveMemory () hDmmMgr " ++ "%x, rsvAddr %x\n", hDmmMgr, rsvAddr); ++ ++ SYNC_EnterCS(pDmmObj->hDmmLock); ++ ++ /* Find the chunk containing the reserved address */ ++ chunk = GetMappedRegion(rsvAddr); ++ if (chunk == NULL) ++ status = DSP_ENOTFOUND; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Free all the mapped pages for this reserved region */ ++ i = 0; ++ while (i < chunk->RegionSize) { ++ if (chunk[i].bMapped) { ++ /* Remove mapping from the page tables. */ ++ chunkSize = chunk[i].MappedSize; ++ /* Clear the mapping flags */ ++ chunk[i].bMapped = false; ++ chunk[i].MappedSize = 0; ++ i += chunkSize; ++ } else ++ i++; ++ } ++ /* Clear the flags (mark the region 'free') */ ++ chunk->bReserved = false; ++ /* NOTE: We do NOT coalesce free regions here. ++ * Free regions are coalesced in GetRegion(), as it traverses ++ *the whole mapping table ++ */ ++ } ++ SYNC_LeaveCS(pDmmObj->hDmmLock); ++ GT_2trace(DMM_debugMask, GT_ENTER, ++ "Leaving DMM_UnReserveMemory status %x" ++ " chunk %x\n", status, chunk); ++ return status; ++} ++ ++ ++/* ++ * ======== GetRegion ======== ++ * Purpose: ++ * Returns a region containing the specified memory region ++ */ ++static struct MapPage *GetRegion(u32 aAddr) ++{ ++ struct MapPage *currRegion = NULL; ++ u32 i = 0; ++ ++ GT_1trace(DMM_debugMask, GT_ENTER, "Entered GetRegion () " ++ " aAddr %x\n", aAddr); ++ ++ if (pVirtualMappingTable != NULL) { ++ /* find page mapped by this address */ ++ i = DMM_ADDR_TO_INDEX(aAddr); ++ if (i < TableSize) ++ currRegion = pVirtualMappingTable + i; ++ } ++ GT_3trace(DMM_debugMask, GT_4CLASS, ++ "Leaving GetRegion currRegion %x, iFreeRegion %d\n," ++ "iFreeSize %d\n", currRegion, iFreeRegion, iFreeSize) ; ++ return currRegion; ++} ++ ++/* ++ * ======== GetFreeRegion ======== ++ * Purpose: ++ * Returns the requested free region ++ */ ++static struct MapPage *GetFreeRegion(u32 aSize) ++{ ++ struct MapPage *currRegion = NULL; ++ u32 i = 0; ++ u32 RegionSize = 0; ++ u32 nextI = 0; ++ GT_1trace(DMM_debugMask, GT_ENTER, "Entered GetFreeRegion () " ++ "aSize 0x%x\n", aSize); ++ ++ if (pVirtualMappingTable == NULL) ++ return currRegion; ++ if (aSize > iFreeSize) { ++ /* Find the largest free region ++ * (coalesce during the traversal) */ ++ while (i < TableSize) { ++ RegionSize = pVirtualMappingTable[i].RegionSize; ++ nextI = i+RegionSize; ++ if (pVirtualMappingTable[i].bReserved == false) { ++ /* Coalesce, if possible */ ++ if (nextI < TableSize && ++ pVirtualMappingTable[nextI].bReserved ++ == false) { ++ pVirtualMappingTable[i].RegionSize += ++ pVirtualMappingTable[nextI].RegionSize; ++ continue; ++ } ++ RegionSize *= PG_SIZE_4K; ++ if (RegionSize > iFreeSize) { ++ iFreeRegion = i; ++ iFreeSize = RegionSize; ++ } ++ } ++ i = nextI; ++ } ++ } ++ if (aSize <= iFreeSize) { ++ currRegion = pVirtualMappingTable + iFreeRegion; ++ iFreeRegion += (aSize / PG_SIZE_4K); ++ iFreeSize -= aSize; ++ } ++ return currRegion; ++} ++ ++/* ++ * ======== GetMappedRegion ======== ++ * Purpose: ++ * Returns the requestedmapped region ++ */ ++static struct MapPage *GetMappedRegion(u32 aAddr) ++{ ++ u32 i = 0; ++ struct MapPage *currRegion = NULL; ++ GT_1trace(DMM_debugMask, GT_ENTER, "Entered GetMappedRegion () " ++ "aAddr 0x%x\n", aAddr); ++ ++ if (pVirtualMappingTable == NULL) ++ return currRegion; ++ ++ i = DMM_ADDR_TO_INDEX(aAddr); ++ if (i < TableSize && (pVirtualMappingTable[i].bMapped || ++ pVirtualMappingTable[i].bReserved)) ++ currRegion = pVirtualMappingTable + i; ++ return currRegion; ++} ++ ++/* ++ * ======== DMM_GetPhysicalAddrTable ======== ++ * Purpose: ++ * Returns the physical table address ++ */ ++u32 *DMM_GetPhysicalAddrTable(void) ++{ ++ GT_1trace(DMM_debugMask, GT_ENTER, "Entered " ++ "DMM_GetPhysicalAddrTable()- pPhysicalAddrTable 0x%x\n", ++ pPhysicalAddrTable); ++ return pPhysicalAddrTable; ++} ++ ++#ifdef DSP_DMM_DEBUG ++u32 DMM_MemMapDump(struct DMM_OBJECT *hDmmMgr) ++{ ++ struct MapPage *curNode = NULL; ++ u32 i; ++ u32 freemem = 0; ++ u32 bigsize = 0; ++ ++ SYNC_EnterCS(hDmmMgr->hDmmLock); ++ ++ if (pVirtualMappingTable != NULL) { ++ for (i = 0; i < TableSize; i += ++ pVirtualMappingTable[i].RegionSize) { ++ curNode = pVirtualMappingTable + i; ++ if (curNode->bReserved == TRUE) { ++ /*printk("RESERVED size = 0x%x, " ++ "Map size = 0x%x\n", ++ (curNode->RegionSize * PG_SIZE_4K), ++ (curNode->bMapped == false) ? 0 : ++ (curNode->MappedSize * PG_SIZE_4K)); ++*/ ++ } else { ++/* printk("UNRESERVED size = 0x%x\n", ++ (curNode->RegionSize * PG_SIZE_4K)); ++*/ ++ freemem += (curNode->RegionSize * PG_SIZE_4K); ++ if (curNode->RegionSize > bigsize) ++ bigsize = curNode->RegionSize; ++ } ++ } ++ } ++ printk(KERN_INFO "Total DSP VA FREE memory = %d Mbytes\n", ++ freemem/(1024*1024)); ++ printk(KERN_INFO "Total DSP VA USED memory= %d Mbytes \n", ++ (((TableSize * PG_SIZE_4K)-freemem))/(1024*1024)); ++ printk(KERN_INFO "DSP VA - Biggest FREE block = %d Mbytes \n\n", ++ (bigsize*PG_SIZE_4K/(1024*1024))); ++ SYNC_LeaveCS(hDmmMgr->hDmmLock); ++ ++ return 0; ++} ++#endif +diff --git a/drivers/dsp/bridge/pmgr/io.c b/drivers/dsp/bridge/pmgr/io.c +new file mode 100644 +index 0000000..cdfe0dc +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/io.c +@@ -0,0 +1,205 @@ ++/* ++ * io.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== io.c ======== ++ * Description: ++ * IO manager interface: Manages IO between CHNL and MSG. ++ * ++ * Public Functions: ++ * IO_Create ++ * IO_Destroy ++ * IO_Exit ++ * IO_Init ++ * IO_OnLoaded ++ * ++ * Notes: ++ * This interface is basically a pass through to the WMD IO functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 04-Apr-2001 rr WSX_STATUS initialized in IO_Create. ++ *! 07-Nov-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- This */ ++#include <ioobj.h> ++#include <dspbridge/iodefs.h> ++#include <dspbridge/io.h> ++ ++/* ----------------------------------- Globals */ ++static u32 cRefs; ++ ++#if GT_TRACE ++static struct GT_Mask IO_DebugMask = { NULL, NULL }; /* WCD IO Mask */ ++#endif ++ ++/* ++ * ======== IO_Create ======== ++ * Purpose: ++ * Create an IO manager object, responsible for managing IO between ++ * CHNL and MSG ++ */ ++DSP_STATUS IO_Create(OUT struct IO_MGR **phIOMgr, struct DEV_OBJECT *hDevObject, ++ IN CONST struct IO_ATTRS *pMgrAttrs) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct IO_MGR *hIOMgr = NULL; ++ struct IO_MGR_ *pIOMgr = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phIOMgr != NULL); ++ DBC_Require(pMgrAttrs != NULL); ++ ++ GT_3trace(IO_DebugMask, GT_ENTER, "Entered IO_Create: phIOMgr: 0x%x\t " ++ "hDevObject: 0x%x\tpMgrAttrs: 0x%x\n", ++ phIOMgr, hDevObject, pMgrAttrs); ++ ++ *phIOMgr = NULL; ++ ++ /* A memory base of 0 implies no memory base: */ ++ if ((pMgrAttrs->dwSMBase != 0) && (pMgrAttrs->uSMLength == 0)) { ++ status = CHNL_E_INVALIDMEMBASE; ++ GT_0trace(IO_DebugMask, GT_7CLASS, ++ "IO_Create:Invalid Mem Base\n"); ++ } ++ ++ if (pMgrAttrs->uWordSize == 0) { ++ status = CHNL_E_INVALIDWORDSIZE; ++ GT_0trace(IO_DebugMask, GT_7CLASS, ++ "IO_Create:Invalid Word size\n"); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ DEV_GetIntfFxns(hDevObject, &pIntfFxns); ++ ++ /* Let WMD channel module finish the create: */ ++ status = (*pIntfFxns->pfnIOCreate)(&hIOMgr, hDevObject, ++ pMgrAttrs); ++ ++ if (DSP_SUCCEEDED(status)) { ++ pIOMgr = (struct IO_MGR_ *) hIOMgr; ++ pIOMgr->pIntfFxns = pIntfFxns; ++ pIOMgr->hDevObject = hDevObject; ++ ++ /* Return the new channel manager handle: */ ++ *phIOMgr = hIOMgr; ++ GT_1trace(IO_DebugMask, GT_1CLASS, ++ "IO_Create: Success hIOMgr: 0x%x\n", ++ hIOMgr); ++ } ++ } ++ ++ GT_2trace(IO_DebugMask, GT_ENTER, ++ "Exiting IO_Create: hIOMgr: 0x%x, status:" ++ " 0x%x\n", hIOMgr, status); ++ ++ return status; ++} ++ ++/* ++ * ======== IO_Destroy ======== ++ * Purpose: ++ * Delete IO manager. ++ */ ++DSP_STATUS IO_Destroy(struct IO_MGR *hIOMgr) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct IO_MGR_ *pIOMgr = (struct IO_MGR_ *)hIOMgr; ++ DSP_STATUS status; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(IO_DebugMask, GT_ENTER, "Entered IO_Destroy: hIOMgr: 0x%x\n", ++ hIOMgr); ++ ++ pIntfFxns = pIOMgr->pIntfFxns; ++ ++ /* Let WMD channel module destroy the IO_MGR: */ ++ status = (*pIntfFxns->pfnIODestroy) (hIOMgr); ++ ++ GT_2trace(IO_DebugMask, GT_ENTER, ++ "Exiting IO_Destroy: pIOMgr: 0x%x, status:" ++ " 0x%x\n", pIOMgr, status); ++ return status; ++} ++ ++/* ++ * ======== IO_Exit ======== ++ * Purpose: ++ * Discontinue usage of the IO module. ++ */ ++void IO_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(IO_DebugMask, GT_5CLASS, ++ "Entered IO_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== IO_Init ======== ++ * Purpose: ++ * Initialize the IO module's private state. ++ */ ++bool IO_Init(void) ++{ ++ bool fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!IO_DebugMask.flags); ++ GT_create(&IO_DebugMask, "IO"); /* "IO" for IO */ ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ ++ GT_1trace(IO_DebugMask, GT_5CLASS, ++ "Entered IO_Init, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} +diff --git a/drivers/dsp/bridge/pmgr/ioobj.h b/drivers/dsp/bridge/pmgr/ioobj.h +new file mode 100644 +index 0000000..f473a63 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/ioobj.h +@@ -0,0 +1,52 @@ ++/* ++ * ioobj.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== ioobj.h ======== ++ * Description: ++ * Structure subcomponents of channel class library IO objects which ++ * are exposed to class driver from mini-driver. ++ * ++ * Public Functions: ++ * None. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 01/16/97 gp: Created from chnlpriv.h ++ */ ++ ++#ifndef IOOBJ_ ++#define IOOBJ_ ++ ++#include <dspbridge/devdefs.h> ++#include <dspbridge/wmd.h> ++ ++/* ++ * This struct is the first field in a IO_MGR struct, as implemented in ++ * a WMD channel class library. Other, implementation specific fields ++ * follow this structure in memory. ++ */ ++struct IO_MGR_ { ++ /* These must be the first fields in a IO_MGR struct: */ ++ u32 dwSignature; /* Used for object validation. */ ++ struct WMD_DEV_CONTEXT *hWmdContext; /* WMD device context. */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD. */ ++ struct DEV_OBJECT *hDevObject; /* Device this board represents. */ ++} ; ++ ++#endif /* IOOBJ_ */ +diff --git a/drivers/dsp/bridge/pmgr/msg.c b/drivers/dsp/bridge/pmgr/msg.c +new file mode 100644 +index 0000000..bbf5174 +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/msg.c +@@ -0,0 +1,173 @@ ++/* ++ * msg.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== msg.c ======== ++ * Description: ++ * DSP/BIOS Bridge MSG Module. ++ * ++ * Public Functions: ++ * MSG_Create ++ * MSG_Delete ++ * MSG_Exit ++ * MSG_Init ++ * ++ *! Revision History: ++ *! ================= ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 15-May-2001 ag Changed SUCCEEDED to DSP_SUCCEEDED. ++ *! 16-Feb-2001 jeh Fixed some comments. ++ *! 15-Dec-2000 rr MSG_Create returns DSP_EFAIL if pfnMsgCreate fails. ++ *! 12-Sep-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- Mini Driver */ ++#include <dspbridge/wmd.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- This */ ++#include <msgobj.h> ++#include <dspbridge/msg.h> ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask MSG_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++static u32 cRefs; /* module reference count */ ++ ++/* ++ * ======== MSG_Create ======== ++ * Purpose: ++ * Create an object to manage message queues. Only one of these objects ++ * can exist per device object. ++ */ ++DSP_STATUS MSG_Create(OUT struct MSG_MGR **phMsgMgr, ++ struct DEV_OBJECT *hDevObject, MSG_ONEXIT msgCallback) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct MSG_MGR_ *pMsgMgr; ++ struct MSG_MGR *hMsgMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phMsgMgr != NULL); ++ DBC_Require(msgCallback != NULL); ++ DBC_Require(hDevObject != NULL); ++ ++ GT_3trace(MSG_debugMask, GT_ENTER, "MSG_Create: phMsgMgr: 0x%x\t" ++ "hDevObject: 0x%x\tmsgCallback: 0x%x\n", ++ phMsgMgr, hDevObject, msgCallback); ++ ++ *phMsgMgr = NULL; ++ ++ DEV_GetIntfFxns(hDevObject, &pIntfFxns); ++ ++ /* Let WMD message module finish the create: */ ++ status = (*pIntfFxns->pfnMsgCreate)(&hMsgMgr, hDevObject, msgCallback); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in WCD message module's fields of the MSG_MGR ++ * structure */ ++ pMsgMgr = (struct MSG_MGR_ *)hMsgMgr; ++ pMsgMgr->pIntfFxns = pIntfFxns; ++ ++ /* Finally, return the new message manager handle: */ ++ *phMsgMgr = hMsgMgr; ++ GT_1trace(MSG_debugMask, GT_1CLASS, ++ "MSG_Create: Success pMsgMgr: 0x%x\n", pMsgMgr); ++ } else { ++ status = DSP_EFAIL; ++ } ++ return status; ++} ++ ++/* ++ * ======== MSG_Delete ======== ++ * Purpose: ++ * Delete a MSG manager allocated in MSG_Create(). ++ */ ++void MSG_Delete(struct MSG_MGR *hMsgMgr) ++{ ++ struct MSG_MGR_ *pMsgMgr = (struct MSG_MGR_ *)hMsgMgr; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pMsgMgr, MSGMGR_SIGNATURE)); ++ ++ GT_1trace(MSG_debugMask, GT_ENTER, "MSG_Delete: hMsgMgr: 0x%x\n", ++ hMsgMgr); ++ ++ pIntfFxns = pMsgMgr->pIntfFxns; ++ ++ /* Let WMD message module destroy the MSG_MGR: */ ++ (*pIntfFxns->pfnMsgDelete)(hMsgMgr); ++ ++ DBC_Ensure(!MEM_IsValidHandle(pMsgMgr, MSGMGR_SIGNATURE)); ++} ++ ++/* ++ * ======== MSG_Exit ======== ++ */ ++void MSG_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ cRefs--; ++ GT_1trace(MSG_debugMask, GT_5CLASS, ++ "Entered MSG_Exit, ref count: 0x%x\n", cRefs); ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== MSG_Init ======== ++ */ ++bool MSG_Init(void) ++{ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!MSG_debugMask.flags); ++ GT_create(&MSG_debugMask, "MG"); /* "MG" for MsG */ ++ } ++ ++ cRefs++; ++ ++ GT_1trace(MSG_debugMask, GT_5CLASS, "MSG_Init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++ ++ return true; ++} ++ +diff --git a/drivers/dsp/bridge/pmgr/msgobj.h b/drivers/dsp/bridge/pmgr/msgobj.h +new file mode 100644 +index 0000000..63d025b +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/msgobj.h +@@ -0,0 +1,52 @@ ++/* ++ * msgobj.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== msgobj.h ======== ++ * Description: ++ * Structure subcomponents of channel class library MSG objects which ++ * are exposed to class driver from mini-driver. ++ * ++ * Public Functions: ++ * None. ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 17-Nov-2000 jeh Created. ++ */ ++ ++#ifndef MSGOBJ_ ++#define MSGOBJ_ ++ ++#include <dspbridge/wmd.h> ++ ++#include <dspbridge/msgdefs.h> ++ ++/* ++ * This struct is the first field in a MSG_MGR struct, as implemented in ++ * a WMD channel class library. Other, implementation specific fields ++ * follow this structure in memory. ++ */ ++struct MSG_MGR_ { ++ /* The first two fields must match those in msgobj.h */ ++ u32 dwSignature; ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD. */ ++}; ++ ++#endif /* MSGOBJ_ */ ++ +diff --git a/drivers/dsp/bridge/pmgr/wcd.c b/drivers/dsp/bridge/pmgr/wcd.c +new file mode 100644 +index 0000000..859043d +--- /dev/null ++++ b/drivers/dsp/bridge/pmgr/wcd.c +@@ -0,0 +1,1647 @@ ++/* ++ * wcd.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== wcd.c ======== ++ * Description: ++ * Common WCD functions, also includes the wrapper ++ * functions called directly by the DeviceIOControl interface. ++ * ++ * Public Functions: ++ * WCD_CallDevIOCtl ++ * WCD_Init ++ * WCD_InitComplete2 ++ * WCD_Exit ++ * <MOD>WRAP_* ++ * ++ *! Revision History: ++ *! ================ ++ *! 29-Apr-2004 hp Call PROC_AutoStart only for DSP device ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping APIs ++ *! 03-Apr-2003 sb Process environment pointer in PROCWRAP_Load ++ *! 24-Feb-2003 swa PMGR Code review comments incorporated. ++ *! 30-Jan-2002 ag CMMWRAP_AllocBuf name changed to CMMWRAP_CallocBuf ++ *! 15-Jan-2002 ag Added actual bufSize param to STRMWRAP_Reclaim[issue]. ++ *! 14-Dec-2001 rr ARGS_NODE_CONNECT maps the pAttr. ++ *! 03-Oct-2001 rr ARGS_NODE_ALLOCMSGBUF/FREEMSGBUF maps the pAttr. ++ *! 10-Sep-2001 ag Added CMD_CMM_GETHANDLE. ++ *! 23-Apr-2001 jeh Pass pStatus to NODE_Terminate. ++ *! 11-Apr-2001 jeh STRMWRAP_Reclaim embedded pointer is mapped and unmapped. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 06-Dec-2000 jeh WRAP_MAP2CALLER pointers in RegisterNotify calls. ++ *! 05-Dec-2000 ag: Removed MAP2CALLER in NODEWRAP_FreeMsgBuf(). ++ *! 22-Nov-2000 kc: Added MGRWRAP_GetPerf_Data(). ++ *! 20-Nov-2000 jeh Added MSG_Init()/MSG_Exit(), IO_Init()/IO_Exit(). ++ *! WRAP pointers to handles for PROC_Attach, NODE_Allocate. ++ *! 27-Oct-2000 jeh Added NODEWRAP_AllocMsgBuf, NODEWRAP_FreeMsgBuf. Removed ++ *! NODEWRAP_GetMessageStream. ++ *! 12-Oct-2000 ag: Added user CMM wrappers. ++ *! 05-Oct-2000 rr: WcdInitComplete2 will fail even if one BRD or PROC ++ *! AutoStart fails. ++ *! 25-Sep-2000 rr: Updated to Version 0.9 ++ *! 13-Sep-2000 jeh Pass ARGS_NODE_CONNECT.pAttrs to NODE_Connect(). ++ *! 11-Aug-2000 rr: Part of node enabled. ++ *! 31-Jul-2000 rr: UTIL_Wrap and MEM_Wrap added to RM. ++ *! 27-Jul-2000 rr: PROCWRAP, NODEWRAP and STRMWRAP implemented. ++ *! STRM and some NODE Wrappers are not implemented. ++ *! 27-Jun-2000 rr: MGRWRAP fxns added.IFDEF to build for PM or DSP/BIOS Bridge ++ *! 08-Feb-2000 rr File name changed to wcd.c ++ *! 03-Feb-2000 rr: Module initialization are done by SERVICES init. GT Class ++ *! changes for module init/exit fxns. ++ *! 24-Jan-2000 rr: Merged with Scott's code. ++ *! 21-Jan-1999 sg: Changed ARGS_CHNL_GETMODE field name from pdwMode to pMode. ++ *! 17-Jan-2000 rr: BRD_GetStatus does WRAP_MAP2CALLER for state. ++ *! 14-Dec-1999 ag: Removed _MAP2CALLER in CHNL_GetMgr(). ++ *! 13-Dec-1999 rr: BRDWRAP_GetSymbol, BRDWRAP_GetTrace uses WRAP_MAP2CALLER ++ *! macros.BRDWRAP_Load maps and unmaps embedded pointers. ++ *! 10-Dec-1999 ag: User CHNL bufs mapped in _AddIOReq & _GetIOCompletion. ++ *! 09-Dec-1999 rr: BRDWRAP_Open and CHNLWRAP_GetMgr does not map ++ *! pointer as there was a change in config.c ++ *! 06-Dec-1999 rr: BRD_Read and Write Maps the buf pointers. ++ *! 03-Dec-1999 rr: CHNLWRAP_GetMgr and BRDWRAP_Open maps hDevNode pointer. ++ *! WCD_InitComplete2 Included for BRD_AutoStart. ++ *! 16-Nov-1999 ag: Map buf to process in CHNLWRAP_AllocBuffer(). ++ *! CHNL_GetMgr() Mapping Fix. ++ *! 10-Nov-1999 ag: Removed unnecessary calls to WRAP_MAP2CALLER. ++ *! 08-Nov-1999 kc: Added MEMRY & enabled BRD_IOCtl for tests. ++ *! 29-Oct-1999 ag: Added CHNL. ++ *! 29-Oct-1999 kc: Added trace statements; added ptr mapping; updated ++ *! use of UTIL module API. ++ *! 29-Oct-1999 rr: Wrapper functions does the Mapping of the Pointers. ++ *! in WinCE all the explicit pointers will be converted ++ *! by the OS during interprocess but not the embedded pointers. ++ *! 16-Oct-1999 kc: Code review cleanup. ++ *! 07-Oct-1999 kc: Added UTILWRAP_TestDll() to run PM test harness. See ++ *! /src/doc/pmtest.doc for more detail. ++ *! 09-Sep-1999 rr: After exactly two years(!). Adopted for WinCE. GT Enabled. ++ *! 09-Sep-1997 gp: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/services.h> ++#include <dspbridge/util.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/chnl.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/drv.h> ++ ++#include <dspbridge/proc.h> ++#include <dspbridge/strm.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/disp.h> ++#include <dspbridge/mgr.h> ++#include <dspbridge/node.h> ++#include <dspbridge/rmm.h> ++ ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/msg.h> ++#include <dspbridge/cmm.h> ++#include <dspbridge/io.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/_dcd.h> ++#include <dspbridge/dbdcd.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/resourcecleanup.h> ++#endif ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define MAX_TRACEBUFLEN 255 ++#define MAX_LOADARGS 16 ++#define MAX_NODES 64 ++#define MAX_STREAMS 16 ++#define MAX_BUFS 64 ++ ++/* Following two macros should ideally have do{}while(0) */ ++ ++#define cp_fm_usr(dest, src, status, elements) \ ++ if (DSP_SUCCEEDED(status)) {\ ++ if (unlikely(src == NULL) || \ ++ unlikely(copy_from_user(dest, src, elements * sizeof(*(dest))))) { \ ++ GT_1trace(WCD_debugMask, GT_7CLASS, \ ++ "copy_from_user failed, src=0x%x\n", src); \ ++ status = DSP_EPOINTER ; \ ++ } \ ++ } ++ ++#define cp_to_usr(dest, src, status, elements) \ ++ if (DSP_SUCCEEDED(status)) {\ ++ if (unlikely(dest == NULL) || \ ++ unlikely(copy_to_user(dest, src, elements * sizeof(*(src))))) { \ ++ GT_1trace(WCD_debugMask, GT_7CLASS, \ ++ "copy_to_user failed, dest=0x%x\n", dest); \ ++ status = DSP_EPOINTER ;\ ++ } \ ++ } ++ ++/* Device IOCtl function pointer */ ++struct WCD_Cmd { ++ u32(*fxn)(union Trapped_Args *args); ++ u32 dwIndex; ++} ; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask WCD_debugMask = { NULL, NULL }; /* Core VxD Mask */ ++#endif ++static u32 WCD_cRefs; ++ ++/* ++ * Function table. ++ * The order of these functions MUST be the same as the order of the command ++ * numbers defined in wcdioctl.h This is how an IOCTL number in user mode ++ * turns into a function call in kernel mode. ++ */ ++static struct WCD_Cmd WCD_cmdTable[] = { ++ /* MGR module */ ++ {MGRWRAP_EnumNode_Info, CMD_MGR_ENUMNODE_INFO_OFFSET}, ++ {MGRWRAP_EnumProc_Info, CMD_MGR_ENUMPROC_INFO_OFFSET}, ++ {MGRWRAP_RegisterObject, CMD_MGR_REGISTEROBJECT_OFFSET}, ++ {MGRWRAP_UnregisterObject, CMD_MGR_UNREGISTEROBJECT_OFFSET}, ++ {MGRWRAP_WaitForBridgeEvents, CMD_MGR_WAIT_OFFSET}, ++#ifndef RES_CLEANUP_DISABLE ++ {MGRWRAP_GetProcessResourcesInfo, CMD_MGR_RESOUCES_OFFSET}, ++#endif ++ /* PROC Module */ ++ {PROCWRAP_Attach, CMD_PROC_ATTACH_OFFSET}, ++ {PROCWRAP_Ctrl, CMD_PROC_CTRL_OFFSET}, ++ {PROCWRAP_Detach, CMD_PROC_DETACH_OFFSET}, ++ {PROCWRAP_EnumNode_Info, CMD_PROC_ENUMNODE_OFFSET}, ++ {PROCWRAP_EnumResources, CMD_PROC_ENUMRESOURCES_OFFSET}, ++ {PROCWRAP_GetState, CMD_PROC_GETSTATE_OFFSET}, ++ {PROCWRAP_GetTrace, CMD_PROC_GETTRACE_OFFSET}, ++ {PROCWRAP_Load, CMD_PROC_LOAD_OFFSET}, ++ {PROCWRAP_RegisterNotify, CMD_PROC_REGISTERNOTIFY_OFFSET}, ++ {PROCWRAP_Start, CMD_PROC_START_OFFSET}, ++ {PROCWRAP_ReserveMemory, CMD_PROC_RSVMEM_OFFSET}, ++ {PROCWRAP_UnReserveMemory, CMD_PROC_UNRSVMEM_OFFSET}, ++ {PROCWRAP_Map, CMD_PROC_MAPMEM_OFFSET}, ++ {PROCWRAP_UnMap, CMD_PROC_UNMAPMEM_OFFSET}, ++ {PROCWRAP_FlushMemory, CMD_PROC_FLUSHMEMORY_OFFSET}, ++ {PROCWRAP_Stop, CMD_PROC_STOP_OFFSET}, ++ {PROCWRAP_InvalidateMemory, CMD_PROC_INVALIDATEMEMORY_OFFSET}, ++ /* NODE Module */ ++ {NODEWRAP_Allocate, CMD_NODE_ALLOCATE_OFFSET}, ++ {NODEWRAP_AllocMsgBuf, CMD_NODE_ALLOCMSGBUF_OFFSET}, ++ {NODEWRAP_ChangePriority, CMD_NODE_CHANGEPRIORITY_OFFSET}, ++ {NODEWRAP_Connect, CMD_NODE_CONNECT_OFFSET}, ++ {NODEWRAP_Create, CMD_NODE_CREATE_OFFSET}, ++ {NODEWRAP_Delete, CMD_NODE_DELETE_OFFSET}, ++ {NODEWRAP_FreeMsgBuf, CMD_NODE_FREEMSGBUF_OFFSET}, ++ {NODEWRAP_GetAttr, CMD_NODE_GETATTR_OFFSET}, ++ {NODEWRAP_GetMessage, CMD_NODE_GETMESSAGE_OFFSET}, ++ {NODEWRAP_Pause, CMD_NODE_PAUSE_OFFSET}, ++ {NODEWRAP_PutMessage, CMD_NODE_PUTMESSAGE_OFFSET}, ++ {NODEWRAP_RegisterNotify, CMD_NODE_REGISTERNOTIFY_OFFSET}, ++ {NODEWRAP_Run, CMD_NODE_RUN_OFFSET}, ++ {NODEWRAP_Terminate, CMD_NODE_TERMINATE_OFFSET}, ++ {NODEWRAP_GetUUIDProps, CMD_NODE_GETUUIDPROPS_OFFSET}, ++ /* STRM wrapper functions */ ++ {STRMWRAP_AllocateBuffer, CMD_STRM_ALLOCATEBUFFER_OFFSET}, ++ {STRMWRAP_Close, CMD_STRM_CLOSE_OFFSET}, ++ {STRMWRAP_FreeBuffer, CMD_STRM_FREEBUFFER_OFFSET}, ++ {STRMWRAP_GetEventHandle, CMD_STRM_GETEVENTHANDLE_OFFSET}, ++ {STRMWRAP_GetInfo, CMD_STRM_GETINFO_OFFSET}, ++ {STRMWRAP_Idle, CMD_STRM_IDLE_OFFSET}, ++ {STRMWRAP_Issue, CMD_STRM_ISSUE_OFFSET}, ++ {STRMWRAP_Open, CMD_STRM_OPEN_OFFSET}, ++ {STRMWRAP_Reclaim, CMD_STRM_RECLAIM_OFFSET}, ++ {STRMWRAP_RegisterNotify, CMD_STRM_REGISTERNOTIFY_OFFSET}, ++ {STRMWRAP_Select, CMD_STRM_SELECT_OFFSET}, ++ /* CMM module */ ++ {CMMWRAP_CallocBuf, CMD_CMM_ALLOCBUF_OFFSET}, ++ {CMMWRAP_FreeBuf, CMD_CMM_FREEBUF_OFFSET}, ++ {CMMWRAP_GetHandle, CMD_CMM_GETHANDLE_OFFSET}, ++ {CMMWRAP_GetInfo, CMD_CMM_GETINFO_OFFSET} ++}; ++ ++/* ++ * ======== WCD_CallDevIOCtl ======== ++ * Purpose: ++ * Call the (wrapper) function for the corresponding WCD IOCTL. ++ */ ++inline DSP_STATUS WCD_CallDevIOCtl(u32 cmd, union Trapped_Args *args, ++ u32 *pResult) ++{ ++ if ((cmd < (sizeof(WCD_cmdTable) / sizeof(struct WCD_Cmd)))) { ++ /* make the fxn call via the cmd table */ ++ *pResult = (*WCD_cmdTable[cmd].fxn) (args); ++ return DSP_SOK; ++ } else { ++ return DSP_EINVALIDARG; ++ } ++} ++ ++/* ++ * ======== WCD_Exit ======== ++ */ ++void WCD_Exit(void) ++{ ++ DBC_Require(WCD_cRefs > 0); ++ WCD_cRefs--; ++ GT_1trace(WCD_debugMask, GT_5CLASS, ++ "Entered WCD_Exit, ref count: 0x%x\n", WCD_cRefs); ++ if (WCD_cRefs == 0) { ++ /* Release all WCD modules initialized in WCD_Init(). */ ++ COD_Exit(); ++ DEV_Exit(); ++ CHNL_Exit(); ++ MSG_Exit(); ++ IO_Exit(); ++ STRM_Exit(); ++ NTFY_Exit(); ++ DISP_Exit(); ++ NODE_Exit(); ++ PROC_Exit(); ++ MGR_Exit(); ++ RMM_exit(); ++ DRV_Exit(); ++ SERVICES_Exit(); ++ } ++ DBC_Ensure(WCD_cRefs >= 0); ++} ++ ++/* ++ * ======== WCD_Init ======== ++ * Purpose: ++ * Module initialization is done by SERVICES Init. ++ */ ++bool WCD_Init(void) ++{ ++ bool fInit = true; ++ bool fDRV, fDEV, fCOD, fSERVICES, fCHNL, fMSG, fIO; ++ bool fMGR, fPROC, fNODE, fDISP, fNTFY, fSTRM, fRMM; ++#ifdef DEBUG ++ /* runtime check of Device IOCtl array. */ ++ u32 i; ++ for (i = 1; i < (sizeof(WCD_cmdTable) / sizeof(struct WCD_Cmd)); i++) ++ DBC_Assert(WCD_cmdTable[i - 1].dwIndex == i); ++ ++#endif ++ if (WCD_cRefs == 0) { ++ /* initialize all SERVICES modules */ ++ fSERVICES = SERVICES_Init(); ++ /* initialize debugging module */ ++ DBC_Assert(!WCD_debugMask.flags); ++ GT_create(&WCD_debugMask, "CD"); /* CD for class driver */ ++ /* initialize class driver and other modules */ ++ fDRV = DRV_Init(); ++ fMGR = MGR_Init(); ++ fPROC = PROC_Init(); ++ fNODE = NODE_Init(); ++ fDISP = DISP_Init(); ++ fNTFY = NTFY_Init(); ++ fSTRM = STRM_Init(); ++ fRMM = RMM_init(); ++ fCHNL = CHNL_Init(); ++ fMSG = MSG_Init(); ++ fIO = IO_Init(); ++ fDEV = DEV_Init(); ++ fCOD = COD_Init(); ++ fInit = fSERVICES && fDRV && fDEV && fCHNL && fCOD && ++ fMSG && fIO; ++ fInit = fInit && fMGR && fPROC && fRMM; ++ if (!fInit) { ++ if (fSERVICES) ++ SERVICES_Exit(); ++ ++ if (fDRV) ++ DRV_Exit(); ++ ++ if (fMGR) ++ MGR_Exit(); ++ ++ if (fSTRM) ++ STRM_Exit(); ++ ++ if (fPROC) ++ PROC_Exit(); ++ ++ if (fNODE) ++ NODE_Exit(); ++ ++ if (fDISP) ++ DISP_Exit(); ++ ++ if (fNTFY) ++ NTFY_Exit(); ++ ++ if (fCHNL) ++ CHNL_Exit(); ++ ++ if (fMSG) ++ MSG_Exit(); ++ ++ if (fIO) ++ IO_Exit(); ++ ++ if (fDEV) ++ DEV_Exit(); ++ ++ if (fCOD) ++ COD_Exit(); ++ ++ if (fRMM) ++ RMM_exit(); ++ ++ } ++ } ++ if (fInit) ++ WCD_cRefs++; ++ ++ GT_1trace(WCD_debugMask, GT_5CLASS, ++ "Entered WCD_Init, ref count: 0x%x\n", WCD_cRefs); ++ return fInit; ++} ++ ++/* ++ * ======== WCD_InitComplete2 ======== ++ * Purpose: ++ * Perform any required WCD, and WMD initialization which ++ * cannot not be performed in WCD_Init() or DEV_StartDevice() due ++ * to the fact that some services are not yet ++ * completely initialized. ++ * Parameters: ++ * Returns: ++ * DSP_SOK: Allow this device to load ++ * DSP_EFAIL: Failure. ++ * Requires: ++ * WCD initialized. ++ * Ensures: ++ */ ++DSP_STATUS WCD_InitComplete2(void) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CFG_DEVNODE *DevNode; ++ struct DEV_OBJECT *hDevObject; ++ u32 devType; ++ ++ DBC_Require(WCD_cRefs > 0); ++ GT_0trace(WCD_debugMask, GT_ENTER, "Entered WCD_InitComplete\n"); ++ /* Walk the list of DevObjects, get each devnode, and attempting to ++ * autostart the board. Note that this requires COF loading, which ++ * requires KFILE. */ ++ for (hDevObject = DEV_GetFirst(); hDevObject != NULL; ++ hDevObject = DEV_GetNext(hDevObject)) { ++ if (DSP_FAILED(DEV_GetDevNode(hDevObject, &DevNode))) ++ continue; ++ ++ if (DSP_FAILED(DEV_GetDevType(hDevObject, &devType))) ++ continue; ++ ++ if ((devType == DSP_UNIT) || (devType == IVA_UNIT)) { ++ if (DSP_FAILED(PROC_AutoStart(DevNode, hDevObject))) { ++ GT_0trace(WCD_debugMask, GT_1CLASS, ++ "WCD_InitComplete2 Failed\n"); ++ status = DSP_EFAIL; ++ /* break; */ ++ } ++ } else ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "Ignoring PROC_AutoStart " ++ "for Device Type = 0x%x \n", devType); ++ } /* End For Loop */ ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "Exiting WCD_InitComplete status 0x%x\n", status); ++ return status; ++} ++ ++/* ++ * ======== MGRWRAP_EnumNode_Info ======== ++ */ ++u32 MGRWRAP_EnumNode_Info(union Trapped_Args *args) ++{ ++ u8 *pNDBProps; ++ u32 uNumNodes; ++ DSP_STATUS status = DSP_SOK; ++ u32 size = args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize; ++ ++ GT_4trace(WCD_debugMask, GT_ENTER, ++ "MGR_EnumNodeInfo: entered args:\n0x%x" ++ " uNode: 0x%x\tpNDBProps: 0x%x\tuNDBPropsSize: " ++ "0x%x\tpuNumNodes\n", args->ARGS_MGR_ENUMNODE_INFO.uNode, ++ args->ARGS_MGR_ENUMNODE_INFO.pNDBProps, ++ args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize, ++ args->ARGS_MGR_ENUMNODE_INFO.puNumNodes); ++ pNDBProps = MEM_Alloc(size, MEM_NONPAGED); ++ if (pNDBProps == NULL) ++ status = DSP_EMEMORY; ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = MGR_EnumNodeInfo(args->ARGS_MGR_ENUMNODE_INFO.uNode, ++ (struct DSP_NDBPROPS *)pNDBProps, ++ size, &uNumNodes); ++ } ++ cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.pNDBProps, pNDBProps, status, ++ size); ++ cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.puNumNodes, &uNumNodes, status, ++ 1); ++ if (pNDBProps) ++ MEM_Free(pNDBProps); ++ ++ return status; ++} ++ ++/* ++ * ======== MGRWRAP_EnumProc_Info ======== ++ */ ++u32 MGRWRAP_EnumProc_Info(union Trapped_Args *args) ++{ ++ u8 *pProcessorInfo; ++ u32 uNumProcs; ++ DSP_STATUS status = DSP_SOK; ++ u32 size = args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize; ++ ++ GT_4trace(WCD_debugMask, GT_ENTER, ++ "MGRWRAP_EnumProc_Info: entered args:\n" ++ "0x%x uProcessor: 0x%x\tpProcessorInfo: 0x%x\t" ++ "uProcessorInfoSize: 0x%x\tpuNumProcs \n", ++ args->ARGS_MGR_ENUMPROC_INFO.uProcessor, ++ args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo, ++ args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize, ++ args->ARGS_MGR_ENUMPROC_INFO.puNumProcs); ++ pProcessorInfo = MEM_Alloc(size, MEM_NONPAGED); ++ if (pProcessorInfo == NULL) ++ status = DSP_EMEMORY; ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = MGR_EnumProcessorInfo(args-> ++ ARGS_MGR_ENUMPROC_INFO.uProcessor, ++ (struct DSP_PROCESSORINFO *)pProcessorInfo, ++ size, &uNumProcs); ++ } ++ cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo, pProcessorInfo, ++ status, size); ++ cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.puNumProcs, &uNumProcs, ++ status, 1); ++ if (pProcessorInfo) ++ MEM_Free(pProcessorInfo); ++ ++ return status; ++} ++ ++#define WRAP_MAP2CALLER(x) x ++/* ++ * ======== MGRWRAP_RegisterObject ======== ++ */ ++u32 MGRWRAP_RegisterObject(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "MGRWRAP_RegisterObject: entered pg2hMsg " ++ "0x%x\n", args->ARGS_MGR_REGISTEROBJECT.pUuid); ++ retVal = DCD_RegisterObject(WRAP_MAP2CALLER ++ (args->ARGS_MGR_REGISTEROBJECT.pUuid), ++ args->ARGS_MGR_REGISTEROBJECT.objType, ++ WRAP_MAP2CALLER(args->ARGS_MGR_REGISTEROBJECT.pszPathName)); ++ return retVal; ++} ++ ++/* ++ * ======== MGRWRAP_UnregisterObject ======== ++ */ ++u32 MGRWRAP_UnregisterObject(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "MGRWRAP_UnregisterObject: entered pg2hMsg" ++ " 0x%x\n", args->ARGS_MGR_UNREGISTEROBJECT.pUuid); ++ retVal = DCD_UnregisterObject(WRAP_MAP2CALLER ++ (args->ARGS_MGR_UNREGISTEROBJECT.pUuid), ++ args->ARGS_MGR_UNREGISTEROBJECT.objType); ++ ++ return retVal; ++} ++ ++/* ++ * ======== MGRWRAP_WaitForBridgeEvents ======== ++ */ ++u32 MGRWRAP_WaitForBridgeEvents(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_NOTIFICATION *aNotifications[MAX_EVENTS]; ++ struct DSP_NOTIFICATION notifications[MAX_EVENTS]; ++ u32 uIndex, i; ++ u32 uCount = args->ARGS_MGR_WAIT.uCount; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "MGRWRAP_WaitForBridgeEvents: entered\n"); ++ ++ if (uCount > MAX_EVENTS) ++ status = DSP_EINVALIDARG; ++ ++ /* get the array of pointers to user structures */ ++ cp_fm_usr(aNotifications, args->ARGS_MGR_WAIT.aNotifications, ++ status, uCount); ++ /* get the events */ ++ for (i = 0; i < uCount; i++) { ++ cp_fm_usr(¬ifications[i], aNotifications[i], status, 1); ++ if (DSP_SUCCEEDED(status)) { ++ /* set the array of pointers to kernel structures*/ ++ aNotifications[i] = ¬ifications[i]; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = MGR_WaitForBridgeEvents(aNotifications, uCount, ++ &uIndex, args->ARGS_MGR_WAIT.uTimeout); ++ } ++ cp_to_usr(args->ARGS_MGR_WAIT.puIndex, &uIndex, status, 1); ++ return status; ++} ++ ++ ++#ifndef RES_CLEANUP_DISABLE ++/* ++ * ======== MGRWRAP_GetProcessResourceInfo ======== ++ */ ++u32 MGRWRAP_GetProcessResourcesInfo(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 uSize = 0; ++ u8 *pBuf = MEM_Alloc(8092, MEM_NONPAGED); ++ status = DRV_ProcDisplayResInfo(pBuf, &uSize); ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "MGRWRAP_GetProcessResourcesInfo:uSize=%d :\n", uSize); ++ cp_to_usr(args->ARGS_PROC_GETTRACE.pBuf, pBuf, status, uSize); ++ GT_0trace(WCD_debugMask, GT_ENTER, "\n***********" ++ "123MGRWRAP_GetProcessResourcesInfo:**************\n"); ++ GT_0trace(WCD_debugMask, GT_ENTER, "\n***********" ++ "456MGRWRAP_GetProcessResourcesInfo:**************\n"); ++ cp_to_usr(args->ARGS_PROC_GETTRACE.pSize, &uSize, status, 1); ++ MEM_Free(pBuf); ++ return status; ++} ++#endif ++ ++ ++/* ++ * ======== PROCWRAP_Attach ======== ++ */ ++u32 PROCWRAP_Attach(union Trapped_Args *args) ++{ ++ DSP_HPROCESSOR processor; ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_PROCESSORATTRIN attrIn, *pAttrIn = NULL; ++ ++ GT_3trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_Attach: entered args:\n" "0x%x" ++ " uProcessor: 0x%x\tpAttrIn: 0x%x\tphProcessor \n", ++ args->ARGS_PROC_ATTACH.uProcessor, ++ args->ARGS_PROC_ATTACH.pAttrIn, ++ args->ARGS_PROC_ATTACH.phProcessor); ++ /* Optional argument */ ++ if (args->ARGS_PROC_ATTACH.pAttrIn) { ++ cp_fm_usr(&attrIn, args->ARGS_PROC_ATTACH.pAttrIn, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ pAttrIn = &attrIn; ++ ++ } ++ status = PROC_Attach(args->ARGS_PROC_ATTACH.uProcessor, pAttrIn, ++ &processor); ++ cp_to_usr(args->ARGS_PROC_ATTACH.phProcessor, &processor, status, 1); ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Ctrl ======== ++ */ ++u32 PROCWRAP_Ctrl(union Trapped_Args *args) ++{ ++ u32 cbDataSize, __user *pSize = (u32 __user *) ++ args->ARGS_PROC_CTRL.pArgs; ++ u8 *pArgs = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ GT_3trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_Ctrl: entered args:\n 0x%x" ++ " uProcessor: 0x%x\tdwCmd: 0x%x\tpArgs \n", ++ args->ARGS_PROC_CTRL.hProcessor, ++ args->ARGS_PROC_CTRL.dwCmd, ++ args->ARGS_PROC_CTRL.pArgs); ++ if (pSize) { ++ if (get_user(cbDataSize, pSize)) ++ status = DSP_EFAIL; ++ ++ cbDataSize += sizeof(u32); ++ if (DSP_SUCCEEDED(status)) { ++ pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED); ++ if (pArgs == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ cp_fm_usr(pArgs, args->ARGS_PROC_CTRL.pArgs, status, ++ cbDataSize); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_Ctrl(args->ARGS_PROC_CTRL.hProcessor, ++ args->ARGS_PROC_CTRL.dwCmd, ++ (struct DSP_CBDATA *)pArgs); ++ } ++ ++ /* cp_to_usr(args->ARGS_PROC_CTRL.pArgs, pArgs, status, 1);*/ ++ if (pArgs) ++ MEM_Free(pArgs); ++ ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Detach ======== ++ */ ++u32 PROCWRAP_Detach(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_1trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_Detach: entered args\n0x%x " ++ "hProceesor \n", args->ARGS_PROC_DETACH.hProcessor); ++ retVal = PROC_Detach(args->ARGS_PROC_DETACH.hProcessor); ++ ++ return retVal; ++} ++ ++/* ++ * ======== PROCWRAP_EnumNode_Info ======== ++ */ ++u32 PROCWRAP_EnumNode_Info(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ DSP_HNODE aNodeTab[MAX_NODES]; ++ u32 uNumNodes; ++ u32 uAllocated; ++ ++ GT_5trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_EnumNode_Info:entered args:\n0x" ++ "%xhProcessor:0x%x\taNodeTab:0x%x\tuNodeTabSize:" ++ "%0x%x\tpuNumNodes%\n0x%x puAllocated: \n", ++ args->ARGS_PROC_ENUMNODE_INFO.hProcessor, ++ args->ARGS_PROC_ENUMNODE_INFO.aNodeTab, ++ args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize, ++ args->ARGS_PROC_ENUMNODE_INFO.puNumNodes, ++ args->ARGS_PROC_ENUMNODE_INFO.puAllocated); ++ DBC_Require(args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize <= MAX_NODES); ++ status = PROC_EnumNodes(args->ARGS_PROC_ENUMNODE_INFO.hProcessor, ++ aNodeTab, ++ args->ARGS_PROC_ENUMNODE_INFO.uNodeTabSize, ++ &uNumNodes, &uAllocated); ++ cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.aNodeTab, aNodeTab, status, ++ uNumNodes); ++ cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.puNumNodes, &uNumNodes, ++ status, 1); ++ cp_to_usr(args->ARGS_PROC_ENUMNODE_INFO.puAllocated, &uAllocated, ++ status, 1); ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_FlushMemory ======== ++ */ ++u32 PROCWRAP_FlushMemory(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_FlushMemory: entered\n"); ++ ++ status = PROC_FlushMemory(args->ARGS_PROC_FLUSHMEMORY.hProcessor, ++ args->ARGS_PROC_FLUSHMEMORY.pMpuAddr, ++ args->ARGS_PROC_FLUSHMEMORY.ulSize, ++ args->ARGS_PROC_FLUSHMEMORY.ulFlags); ++ return status; ++} ++ ++ ++/* ++ * ======== PROCWRAP_InvalidateMemory ======== ++ */ ++u32 PROCWRAP_InvalidateMemory(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_InvalidateMemory:entered\n"); ++ ++ status = PROC_InvalidateMemory( ++ args->ARGS_PROC_INVALIDATEMEMORY.hProcessor, ++ args->ARGS_PROC_INVALIDATEMEMORY.pMpuAddr, ++ args->ARGS_PROC_INVALIDATEMEMORY.ulSize); ++ return status; ++} ++ ++ ++/* ++ * ======== PROCWRAP_EnumResources ======== ++ */ ++u32 PROCWRAP_EnumResources(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_4trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_EnumResources: entered args:\n" ++ "0x%x hProcessor: 0x%x\tuResourceMask: 0x%x\tpResourceInfo" ++ " 0x%x\tuResourceInfoSixe \n", ++ args->ARGS_PROC_ENUMRESOURCES.hProcessor, ++ args->ARGS_PROC_ENUMRESOURCES.uResourceType, ++ args->ARGS_PROC_ENUMRESOURCES.pResourceInfo, ++ args->ARGS_PROC_ENUMRESOURCES.uResourceInfoSize); ++ retVal = PROC_GetResourceInfo(args->ARGS_PROC_ENUMRESOURCES.hProcessor, ++ args->ARGS_PROC_ENUMRESOURCES.uResourceType, ++ WRAP_MAP2CALLER(args->ARGS_PROC_ENUMRESOURCES. ++ pResourceInfo), args->ARGS_PROC_ENUMRESOURCES. ++ uResourceInfoSize); ++ ++ return retVal; ++} ++ ++/* ++ * ======== PROCWRAP_GetState ======== ++ */ ++u32 PROCWRAP_GetState(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ struct DSP_PROCESSORSTATE procStatus; ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_GetState: entered\n"); ++ status = PROC_GetState(args->ARGS_PROC_GETSTATE.hProcessor, &procStatus, ++ args->ARGS_PROC_GETSTATE.uStateInfoSize); ++ cp_to_usr(args->ARGS_PROC_GETSTATE.pProcStatus, &procStatus, status, 1); ++ return status; ++ ++} ++ ++/* ++ * ======== PROCWRAP_GetTrace ======== ++ */ ++u32 PROCWRAP_GetTrace(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ u8 *pBuf; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_GetTrace: entered\n"); ++ ++ DBC_Require(args->ARGS_PROC_GETTRACE.uMaxSize <= MAX_TRACEBUFLEN); ++ ++ pBuf = MEM_Calloc(args->ARGS_PROC_GETTRACE.uMaxSize, MEM_NONPAGED); ++ if (pBuf != NULL) { ++ status = PROC_GetTrace(args->ARGS_PROC_GETTRACE.hProcessor, ++ pBuf, args->ARGS_PROC_GETTRACE.uMaxSize); ++ } else { ++ status = DSP_EMEMORY; ++ } ++ cp_to_usr(args->ARGS_PROC_GETTRACE.pBuf, pBuf, status, ++ args->ARGS_PROC_GETTRACE.uMaxSize); ++ if (pBuf) ++ MEM_Free(pBuf); ++ ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Load ======== ++ */ ++u32 PROCWRAP_Load(union Trapped_Args *args) ++{ ++ s32 i, len; ++ DSP_STATUS status = DSP_SOK; ++ char *temp; ++ s32 argc = args->ARGS_PROC_LOAD.iArgc; ++ u8 **argv, **envp = NULL; ++ ++ ++ DBC_Require(argc > 0); ++ DBC_Require(argc <= MAX_LOADARGS); ++ ++ argv = MEM_Alloc(argc * sizeof(u8 *), MEM_NONPAGED); ++ if (argv == NULL) ++ status = DSP_EMEMORY; ++ ++ cp_fm_usr(argv, args->ARGS_PROC_LOAD.aArgv, status, argc); ++ for (i = 0; DSP_SUCCEEDED(status) && (i < argc); i++) { ++ if (argv[i] != NULL) { ++ /* User space pointer to argument */ ++ temp = (char *) argv[i]; ++ len = strlen_user((char *)temp); ++ /* Kernel space pointer to argument */ ++ argv[i] = MEM_Alloc(len, MEM_NONPAGED); ++ if (argv[i] == NULL) { ++ status = DSP_EMEMORY; ++ break; ++ } ++ cp_fm_usr(argv[i], temp, status, len); ++ } ++ } ++ /* TODO: validate this */ ++ if (args->ARGS_PROC_LOAD.aEnvp != NULL) { ++ /* number of elements in the envp array including NULL */ ++ len = 0; ++ do { ++ len++; ++ get_user(temp, args->ARGS_PROC_LOAD.aEnvp); ++ } while (temp); ++ envp = MEM_Alloc(len * sizeof(u8 *), MEM_NONPAGED); ++ if (envp == NULL) ++ status = DSP_EMEMORY; ++ ++ cp_fm_usr(envp, args->ARGS_PROC_LOAD.aEnvp, status, len); ++ for (i = 0; DSP_SUCCEEDED(status) && (envp[i] != NULL); i++) { ++ /* User space pointer to argument */ ++ temp = (char *)envp[i]; ++ len = strlen_user((char *)temp); ++ /* Kernel space pointer to argument */ ++ envp[i] = MEM_Alloc(len, MEM_NONPAGED); ++ if (envp[i] == NULL) { ++ status = DSP_EMEMORY; ++ break; ++ } ++ cp_fm_usr(envp[i], temp, status, len); ++ } ++ } ++ GT_5trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_Load, hProcessor: 0x%x\n\tiArgc:" ++ "0x%x\n\taArgv: 0x%x\n\taArgv[0]: %s\n\taEnvp: 0x%0x\n", ++ args->ARGS_PROC_LOAD.hProcessor, ++ args->ARGS_PROC_LOAD.iArgc, args->ARGS_PROC_LOAD.aArgv, ++ argv[0], args->ARGS_PROC_LOAD.aEnvp); ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_Load(args->ARGS_PROC_LOAD.hProcessor, ++ args->ARGS_PROC_LOAD.iArgc, ++ (CONST char **)argv, (CONST char **)envp); ++ } ++ if (envp != NULL) { ++ i = 0; ++ while (envp[i] != NULL) ++ MEM_Free(envp[i++]); ++ ++ MEM_Free(envp); ++ } ++ if (argv != NULL) { ++ for (i = 0; i < argc; i++) { ++ if (argv[i] != NULL) ++ MEM_Free(argv[i]); ++ ++ } ++ MEM_Free(argv); ++ } ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Map ======== ++ */ ++u32 PROCWRAP_Map(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ void *pMapAddr; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_Map: entered\n"); ++ status = PROC_Map(args->ARGS_PROC_MAPMEM.hProcessor, ++ args->ARGS_PROC_MAPMEM.pMpuAddr, ++ args->ARGS_PROC_MAPMEM.ulSize, ++ args->ARGS_PROC_MAPMEM.pReqAddr, &pMapAddr, ++ args->ARGS_PROC_MAPMEM.ulMapAttr); ++ if (DSP_SUCCEEDED(status)) { ++ if (put_user(pMapAddr, args->ARGS_PROC_MAPMEM.ppMapAddr)) ++ status = DSP_EINVALIDARG; ++ ++ } ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_RegisterNotify ======== ++ */ ++u32 PROCWRAP_RegisterNotify(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ struct DSP_NOTIFICATION notification; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_RegisterNotify: entered\n"); ++ ++ /* Initialize the notification data structure */ ++ notification.psName = NULL; ++ notification.handle = NULL; ++ ++ status = PROC_RegisterNotify(args->ARGS_PROC_REGISTER_NOTIFY.hProcessor, ++ args->ARGS_PROC_REGISTER_NOTIFY.uEventMask, ++ args->ARGS_PROC_REGISTER_NOTIFY.uNotifyType, ++ ¬ification); ++ cp_to_usr(args->ARGS_PROC_REGISTER_NOTIFY.hNotification, ¬ification, ++ status, 1); ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_ReserveMemory ======== ++ */ ++u32 PROCWRAP_ReserveMemory(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ void *pRsvAddr; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_ReserveMemory: entered\n"); ++ status = PROC_ReserveMemory(args->ARGS_PROC_RSVMEM.hProcessor, ++ args->ARGS_PROC_RSVMEM.ulSize, &pRsvAddr); ++ if (put_user(pRsvAddr, args->ARGS_PROC_RSVMEM.ppRsvAddr)) ++ status = DSP_EINVALIDARG; ++ ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Start ======== ++ */ ++u32 PROCWRAP_Start(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_Start: entered\n"); ++ retVal = PROC_Start(args->ARGS_PROC_START.hProcessor); ++ return retVal; ++} ++ ++/* ++ * ======== PROCWRAP_UnMap ======== ++ */ ++u32 PROCWRAP_UnMap(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_UnMap: entered\n"); ++ status = PROC_UnMap(args->ARGS_PROC_UNMAPMEM.hProcessor, ++ args->ARGS_PROC_UNMAPMEM.pMapAddr); ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_UnReserveMemory ======== ++ */ ++u32 PROCWRAP_UnReserveMemory(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "PROCWRAP_UnReserveMemory: entered\n"); ++ status = PROC_UnReserveMemory(args->ARGS_PROC_UNRSVMEM.hProcessor, ++ args->ARGS_PROC_UNRSVMEM.pRsvAddr); ++ return status; ++} ++ ++/* ++ * ======== PROCWRAP_Stop ======== ++ */ ++u32 PROCWRAP_Stop(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "PROCWRAP_Stop: entered\n"); ++ retVal = PROC_Stop(args->ARGS_PROC_STOP.hProcessor); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_Allocate ======== ++ */ ++u32 NODEWRAP_Allocate(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_UUID nodeId; ++ u32 cbDataSize; ++ u32 __user *pSize = (u32 __user *)args->ARGS_NODE_ALLOCATE.pArgs; ++ u8 *pArgs = NULL; ++ struct DSP_NODEATTRIN attrIn, *pAttrIn = NULL; ++ struct NODE_OBJECT *hNode; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Allocate: entered\n"); ++ ++ /* Optional argument */ ++ if (pSize) { ++ if (get_user(cbDataSize, pSize)) ++ status = DSP_EFAIL; ++ ++ cbDataSize += sizeof(u32); ++ if (DSP_SUCCEEDED(status)) { ++ pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED); ++ if (pArgs == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ cp_fm_usr(pArgs, args->ARGS_NODE_ALLOCATE.pArgs, status, ++ cbDataSize); ++ } ++ cp_fm_usr(&nodeId, args->ARGS_NODE_ALLOCATE.pNodeID, status, 1); ++ /* Optional argument */ ++ if (args->ARGS_NODE_ALLOCATE.pAttrIn) { ++ cp_fm_usr(&attrIn, args->ARGS_NODE_ALLOCATE.pAttrIn, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ pAttrIn = &attrIn; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = NODE_Allocate(args->ARGS_NODE_ALLOCATE.hProcessor, ++ &nodeId, (struct DSP_CBDATA *)pArgs, ++ pAttrIn, &hNode); ++ } ++ cp_to_usr(args->ARGS_NODE_ALLOCATE.phNode, &hNode, status, 1); ++ if (pArgs) ++ MEM_Free(pArgs); ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_AllocMsgBuf ======== ++ */ ++u32 NODEWRAP_AllocMsgBuf(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_BUFFERATTR *pAttr = NULL; ++ struct DSP_BUFFERATTR attr; ++ u8 *pBuffer = NULL; ++ ++ if (args->ARGS_NODE_ALLOCMSGBUF.pAttr) { /* Optional argument */ ++ cp_fm_usr(&attr, args->ARGS_NODE_ALLOCMSGBUF.pAttr, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ pAttr = &attr; ++ ++ } ++ /* IN OUT argument */ ++ cp_fm_usr(&pBuffer, args->ARGS_NODE_ALLOCMSGBUF.pBuffer, status, 1); ++ if (DSP_SUCCEEDED(status)) { ++ status = NODE_AllocMsgBuf(args->ARGS_NODE_ALLOCMSGBUF.hNode, ++ args->ARGS_NODE_ALLOCMSGBUF.uSize, ++ pAttr, &pBuffer); ++ } ++ cp_to_usr(args->ARGS_NODE_ALLOCMSGBUF.pBuffer, &pBuffer, status, 1) ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_ChangePriority ======== ++ */ ++u32 NODEWRAP_ChangePriority(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "NODEWRAP_ChangePriority: entered\n"); ++ retVal = NODE_ChangePriority(args->ARGS_NODE_CHANGEPRIORITY.hNode, ++ args->ARGS_NODE_CHANGEPRIORITY.iPriority); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_Connect ======== ++ */ ++u32 NODEWRAP_Connect(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_STRMATTR attrs; ++ struct DSP_STRMATTR *pAttrs = NULL; ++ u32 cbDataSize; ++ u32 __user *pSize = (u32 __user *)args->ARGS_NODE_CONNECT.pConnParam; ++ u8 *pArgs = NULL; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Connect: entered\n"); ++ ++ /* Optional argument */ ++ if (pSize) { ++ if (get_user(cbDataSize, pSize)) ++ status = DSP_EFAIL; ++ ++ cbDataSize += sizeof(u32); ++ if (DSP_SUCCEEDED(status)) { ++ pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED); ++ if (pArgs == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ cp_fm_usr(pArgs, args->ARGS_NODE_CONNECT.pConnParam, status, ++ cbDataSize); ++ } ++ if (args->ARGS_NODE_CONNECT.pAttrs) { /* Optional argument */ ++ cp_fm_usr(&attrs, args->ARGS_NODE_CONNECT.pAttrs, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ pAttrs = &attrs; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = NODE_Connect(args->ARGS_NODE_CONNECT.hNode, ++ args->ARGS_NODE_CONNECT.uStream, ++ args->ARGS_NODE_CONNECT.hOtherNode, ++ args->ARGS_NODE_CONNECT.uOtherStream, ++ pAttrs, (struct DSP_CBDATA *)pArgs); ++ } ++ if (pArgs) ++ MEM_Free(pArgs); ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_Create ======== ++ */ ++u32 NODEWRAP_Create(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Create: entered\n"); ++ retVal = NODE_Create(args->ARGS_NODE_CREATE.hNode); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_Delete ======== ++ */ ++u32 NODEWRAP_Delete(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Delete: entered\n"); ++ retVal = NODE_Delete(args->ARGS_NODE_DELETE.hNode); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_FreeMsgBuf ======== ++ */ ++u32 NODEWRAP_FreeMsgBuf(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_BUFFERATTR *pAttr = NULL; ++ struct DSP_BUFFERATTR attr; ++ if (args->ARGS_NODE_FREEMSGBUF.pAttr) { /* Optional argument */ ++ cp_fm_usr(&attr, args->ARGS_NODE_FREEMSGBUF.pAttr, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ pAttr = &attr; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = NODE_FreeMsgBuf(args->ARGS_NODE_FREEMSGBUF.hNode, ++ args->ARGS_NODE_FREEMSGBUF.pBuffer, ++ pAttr); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_GetAttr ======== ++ */ ++u32 NODEWRAP_GetAttr(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_NODEATTR attr; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_GetAttr: entered\n"); ++ ++ status = NODE_GetAttr(args->ARGS_NODE_GETATTR.hNode, &attr, ++ args->ARGS_NODE_GETATTR.uAttrSize); ++ cp_to_usr(args->ARGS_NODE_GETATTR.pAttr, &attr, status, 1); ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_GetMessage ======== ++ */ ++u32 NODEWRAP_GetMessage(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ struct DSP_MSG msg; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_GetMessage: entered\n"); ++ ++ status = NODE_GetMessage(args->ARGS_NODE_GETMESSAGE.hNode, &msg, ++ args->ARGS_NODE_GETMESSAGE.uTimeout); ++ ++ cp_to_usr(args->ARGS_NODE_GETMESSAGE.pMessage, &msg, status, 1); ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_Pause ======== ++ */ ++u32 NODEWRAP_Pause(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Pause: entered\n"); ++ retVal = NODE_Pause(args->ARGS_NODE_PAUSE.hNode); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_PutMessage ======== ++ */ ++u32 NODEWRAP_PutMessage(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_MSG msg; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_PutMessage: entered\n"); ++ ++ cp_fm_usr(&msg, args->ARGS_NODE_PUTMESSAGE.pMessage, status, 1); ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = NODE_PutMessage(args->ARGS_NODE_PUTMESSAGE.hNode, &msg, ++ args->ARGS_NODE_PUTMESSAGE.uTimeout); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_RegisterNotify ======== ++ */ ++u32 NODEWRAP_RegisterNotify(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_NOTIFICATION notification; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "NODEWRAP_RegisterNotify: entered\n"); ++ ++ /* Initialize the notification data structure */ ++ notification.psName = NULL; ++ notification.handle = NULL; ++ ++ status = NODE_RegisterNotify(args->ARGS_NODE_REGISTERNOTIFY.hNode, ++ args->ARGS_NODE_REGISTERNOTIFY.uEventMask, ++ args->ARGS_NODE_REGISTERNOTIFY.uNotifyType, ++ ¬ification); ++ cp_to_usr(args->ARGS_NODE_REGISTERNOTIFY.hNotification, ¬ification, ++ status, 1); ++ return status; ++} ++ ++/* ++ * ======== NODEWRAP_Run ======== ++ */ ++u32 NODEWRAP_Run(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Run: entered\n"); ++ retVal = NODE_Run(args->ARGS_NODE_RUN.hNode); ++ ++ return retVal; ++} ++ ++/* ++ * ======== NODEWRAP_Terminate ======== ++ */ ++u32 NODEWRAP_Terminate(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ DSP_STATUS tempstatus; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Terminate: entered\n"); ++ ++ status = NODE_Terminate(args->ARGS_NODE_TERMINATE.hNode, &tempstatus); ++ ++ cp_to_usr(args->ARGS_NODE_TERMINATE.pStatus, &tempstatus, status, 1); ++ ++ return status; ++} ++ ++ ++/* ++ * ======== NODEWRAP_GetUUIDProps ======== ++ */ ++u32 NODEWRAP_GetUUIDProps(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_UUID nodeId; ++ struct DSP_NDBPROPS *pnodeProps = NULL; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "NODEWRAP_GetUUIDPropste: entered\n"); ++ ++ ++ cp_fm_usr(&nodeId, args->ARGS_NODE_GETUUIDPROPS.pNodeID, status, 1); ++ pnodeProps = MEM_Alloc(sizeof(struct DSP_NDBPROPS), MEM_NONPAGED); ++ if (pnodeProps != NULL) { ++ status = NODE_GetUUIDProps(args-> ++ ARGS_NODE_GETUUIDPROPS.hProcessor, ++ &nodeId, pnodeProps); ++ cp_to_usr(args->ARGS_NODE_GETUUIDPROPS.pNodeProps, pnodeProps, ++ status, 1); ++ } else ++ status = DSP_EMEMORY; ++ if (pnodeProps) ++ MEM_Free(pnodeProps); ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_AllocateBuffer ======== ++ */ ++u32 STRMWRAP_AllocateBuffer(union Trapped_Args *args) ++{ ++ DSP_STATUS status; ++ u8 **apBuffer = NULL; ++ u32 uNumBufs = args->ARGS_STRM_ALLOCATEBUFFER.uNumBufs; ++ ++ DBC_Require(uNumBufs <= MAX_BUFS); ++ ++ apBuffer = MEM_Alloc((uNumBufs * sizeof(u8 *)), MEM_NONPAGED); ++ ++ status = STRM_AllocateBuffer(args->ARGS_STRM_ALLOCATEBUFFER.hStream, ++ args->ARGS_STRM_ALLOCATEBUFFER.uSize, ++ apBuffer, uNumBufs); ++ cp_to_usr(args->ARGS_STRM_ALLOCATEBUFFER.apBuffer, apBuffer, status, ++ uNumBufs); ++ if (apBuffer) ++ MEM_Free(apBuffer); ++ ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_Close ======== ++ */ ++u32 STRMWRAP_Close(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ retVal = STRM_Close(args->ARGS_STRM_CLOSE.hStream); ++ ++ return retVal; ++} ++ ++/* ++ * ======== STRMWRAP_FreeBuffer ======== ++ */ ++u32 STRMWRAP_FreeBuffer(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u8 **apBuffer = NULL; ++ u32 uNumBufs = args->ARGS_STRM_FREEBUFFER.uNumBufs; ++ ++ DBC_Require(uNumBufs <= MAX_BUFS); ++ ++ apBuffer = MEM_Alloc((uNumBufs * sizeof(u8 *)), MEM_NONPAGED); ++ ++ cp_fm_usr(apBuffer, args->ARGS_STRM_FREEBUFFER.apBuffer, status, ++ uNumBufs); ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = STRM_FreeBuffer(args->ARGS_STRM_FREEBUFFER.hStream, ++ apBuffer, uNumBufs); ++ } ++ cp_to_usr(args->ARGS_STRM_FREEBUFFER.apBuffer, apBuffer, status, ++ uNumBufs); ++ if (apBuffer) ++ MEM_Free(apBuffer); ++ ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_GetEventHandle ======== ++ */ ++u32 STRMWRAP_GetEventHandle(union Trapped_Args *args) ++{ ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== STRMWRAP_GetInfo ======== ++ */ ++u32 STRMWRAP_GetInfo(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_INFO strmInfo; ++ struct DSP_STREAMINFO user; ++ struct DSP_STREAMINFO *temp; ++ ++ cp_fm_usr(&strmInfo, args->ARGS_STRM_GETINFO.pStreamInfo, status, 1); ++ temp = strmInfo.pUser; ++ ++ strmInfo.pUser = &user; ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = STRM_GetInfo(args->ARGS_STRM_GETINFO.hStream, ++ &strmInfo, args->ARGS_STRM_GETINFO.uStreamInfoSize); ++ } ++ cp_to_usr(temp, strmInfo.pUser, status, 1); ++ strmInfo.pUser = temp; ++ cp_to_usr(args->ARGS_STRM_GETINFO.pStreamInfo, &strmInfo, status, 1); ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_Idle ======== ++ */ ++u32 STRMWRAP_Idle(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ retVal = STRM_Idle(args->ARGS_STRM_IDLE.hStream, ++ args->ARGS_STRM_IDLE.bFlush); ++ ++ return retVal; ++} ++ ++/* ++ * ======== STRMWRAP_Issue ======== ++ */ ++u32 STRMWRAP_Issue(union Trapped_Args *args) ++{ ++ u32 retVal; ++ ++ retVal = STRM_Issue(args->ARGS_STRM_ISSUE.hStream, ++ args->ARGS_STRM_ISSUE.pBuffer, ++ args->ARGS_STRM_ISSUE.dwBytes, ++ args->ARGS_STRM_ISSUE.dwBufSize, ++ args->ARGS_STRM_ISSUE.dwArg); ++ ++ /* This is a user space pointer */ ++ return retVal; ++} ++ ++/* ++ * ======== STRMWRAP_Open ======== ++ */ ++u32 STRMWRAP_Open(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_ATTR attr; ++ struct STRM_OBJECT *pStrm; ++ struct DSP_STREAMATTRIN strmAttrIn; ++ ++ cp_fm_usr(&attr, args->ARGS_STRM_OPEN.pAttrIn, status, 1); ++ ++ if (attr.pStreamAttrIn != NULL) { /* Optional argument */ ++ cp_fm_usr(&strmAttrIn, attr.pStreamAttrIn, status, 1); ++ if (DSP_SUCCEEDED(status)) ++ attr.pStreamAttrIn = &strmAttrIn; ++ ++ } ++ status = STRM_Open(args->ARGS_STRM_OPEN.hNode, ++ args->ARGS_STRM_OPEN.uDirection, ++ args->ARGS_STRM_OPEN.uIndex, &attr, &pStrm); ++ cp_to_usr(args->ARGS_STRM_OPEN.phStream, &pStrm, status, 1); ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_Reclaim ======== ++ */ ++u32 STRMWRAP_Reclaim(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u8 *pBufPtr; ++ u32 ulBytes; ++ u32 dwArg; ++ u32 ulBufSize; ++ ++ status = STRM_Reclaim(args->ARGS_STRM_RECLAIM.hStream, &pBufPtr, ++ &ulBytes, &ulBufSize, &dwArg); ++ cp_to_usr(args->ARGS_STRM_RECLAIM.pBufPtr, &pBufPtr, status, 1); ++ cp_to_usr(args->ARGS_STRM_RECLAIM.pBytes, &ulBytes, status, 1); ++ cp_to_usr(args->ARGS_STRM_RECLAIM.pdwArg, &dwArg, status, 1); ++ ++ if (args->ARGS_STRM_RECLAIM.pBufSize != NULL) { ++ cp_to_usr(args->ARGS_STRM_RECLAIM.pBufSize, &ulBufSize, ++ status, 1); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_RegisterNotify ======== ++ */ ++u32 STRMWRAP_RegisterNotify(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_NOTIFICATION notification; ++ ++ GT_0trace(WCD_debugMask, GT_ENTER, ++ "NODEWRAP_RegisterNotify: entered\n"); ++ ++ /* Initialize the notification data structure */ ++ notification.psName = NULL; ++ notification.handle = NULL; ++ ++ status = STRM_RegisterNotify(args->ARGS_STRM_REGISTERNOTIFY.hStream, ++ args->ARGS_STRM_REGISTERNOTIFY.uEventMask, ++ args->ARGS_STRM_REGISTERNOTIFY.uNotifyType, ++ ¬ification); ++ cp_to_usr(args->ARGS_STRM_REGISTERNOTIFY.hNotification, ¬ification, ++ status, 1); ++ ++ return status; ++} ++ ++/* ++ * ======== STRMWRAP_Select ======== ++ */ ++u32 STRMWRAP_Select(union Trapped_Args *args) ++{ ++ u32 mask; ++ struct STRM_OBJECT *aStrmTab[MAX_STREAMS]; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(args->ARGS_STRM_SELECT.nStreams <= MAX_STREAMS); ++ ++ cp_fm_usr(aStrmTab, args->ARGS_STRM_SELECT.aStreamTab, status, ++ args->ARGS_STRM_SELECT.nStreams); ++ if (DSP_SUCCEEDED(status)) { ++ status = STRM_Select(aStrmTab, args->ARGS_STRM_SELECT.nStreams, ++ &mask, args->ARGS_STRM_SELECT.uTimeout); ++ } ++ cp_to_usr(args->ARGS_STRM_SELECT.pMask, &mask, status, 1); ++ return status; ++} ++ ++/* CMM */ ++ ++/* ++ * ======== CMMWRAP_CallocBuf ======== ++ */ ++u32 CMMWRAP_CallocBuf(union Trapped_Args *args) ++{ ++ /* This operation is done in kernel */ ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== CMMWRAP_FreeBuf ======== ++ */ ++u32 CMMWRAP_FreeBuf(union Trapped_Args *args) ++{ ++ /* This operation is done in kernel */ ++ return DSP_ENOTIMPL; ++} ++ ++/* ++ * ======== CMMWRAP_GetHandle ======== ++ */ ++u32 CMMWRAP_GetHandle(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_OBJECT *hCmmMgr; ++ ++ status = CMM_GetHandle(args->ARGS_CMM_GETHANDLE.hProcessor, &hCmmMgr); ++ ++ cp_to_usr(args->ARGS_CMM_GETHANDLE.phCmmMgr, &hCmmMgr, status, 1); ++ ++ return status; ++} ++ ++/* ++ * ======== CMMWRAP_GetInfo ======== ++ */ ++u32 CMMWRAP_GetInfo(union Trapped_Args *args) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_INFO cmmInfo; ++ ++ status = CMM_GetInfo(args->ARGS_CMM_GETINFO.hCmmMgr, &cmmInfo); ++ ++ cp_to_usr(args->ARGS_CMM_GETINFO.pCmmInfo, &cmmInfo, status, 1); ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/rmgr/dbdcd.c b/drivers/dsp/bridge/rmgr/dbdcd.c +new file mode 100644 +index 0000000..c5ec8f9 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/dbdcd.c +@@ -0,0 +1,1573 @@ ++/* ++ * dbdcd.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbdcd.c ======== ++ * Description: ++ * This file contains the implementation of the DSP/BIOS Bridge ++ * Configuration Database (DCD). ++ * ++ * Notes: ++ * The fxn DCD_GetObjects can apply a callback fxn to each DCD object ++ * that is located in a specified COFF file. At the moment, ++ * DCD_AutoRegister, DCD_AutoUnregister, and NLDR module all use ++ * DCD_GetObjects. ++ * ++ *! Revision History ++ *! ================ ++ *! 03-Dec-2003 map Changed DCD_OBJTYPE to DSP_DCDOBJTYPE ++ *! 17-Dec-2002 map Modified DCD_GetDepLibs, DCD_GetNumDepLibs, GetDepLibInfo ++ *! to include phase information ++ *! 02-Dec-2002 map Modified DCD_GetLibraryName for phases in different ++ *! libraries ++ *! 26-Feb-2003 kc Updated DCD_AutoUnregister and DCD_GetObjects to simplify ++ *! DCD implementation. ++ *! 17-Jul-2002 jeh Call COD_Open() instead of COD_OpenBase(), call COD_Close() ++ *! 11-Jul-2002 jeh Added DCD_GetDepLibs(), DCD_GetNumDepLibs(). ++ *! 18-Feb-2003 vp Code review updates ++ *! 18-Oct-2002 vp Ported to Linux platform ++ *! 15-Mar-2002 jeh Read dynamic loading memory requirements into node object ++ *! data. Added DCD_GetLibraryName(). ++ *! 13-Feb-2002 jeh Get system stack size in GetAttrsFromBuf(). ++ *! 01-Aug-2001 ag: Added check for PROC "extended" attributes used for ++ *! DSP-MMU setup. These are private attributes. ++ *! 18-Apr-2001 jeh Use COD_OpenBase instead of COD_LoadBase. ++ *! 03-Apr-2001 sg: Changed error names to DSP_EDCD* format. ++ *! 11-Jan-2001 jeh Changes to DCD_GetObjectDef to match node.cdb, proc.cdb. ++ *! 12-Dec-2000 kc: Added DCD_AutoUnregister. MSGNODE, DAISNODE added in ++ *! GetAttrsFromBuf ++ *! 22-Nov-2000 kc: Replaced sprintf() calls with strncat. ++ *! 09-Nov-2000 kc: Optimized DCD module. ++ *! 30-Oct-2000 kc: Added DCD_AutoRegister function; changed local var. names. ++ *! 29-Sep-2000 kc: Added code review changes (src/reviews/dcd_reviews.txt). ++ *! 06-Sep-2000 jeh Get message segid, message notification type. Added Atoi() ++ *! to replace atoi(), until cdb generation can output in ++ *! decimal format. ++ *! 26-Jul-2000 kc: Created. ++ *! ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/reg.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/cod.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/uuidutil.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dbdcd.h> ++ ++/* ----------------------------------- Global defines. */ ++#define SIGNATURE 0x5f444344 /* "DCD_" (in reverse). */ ++ ++#define IsValidHandle(h) (((h) != NULL) && (h->dwSignature == SIGNATURE)) ++ ++#define MAX_INT2CHAR_LENGTH 16 /* Maximum int2char len of 32 bit int. */ ++ ++/* Name of section containing dependent libraries */ ++#define DEPLIBSECT ".dspbridge_deplibs" ++ ++/* DCD specific structures. */ ++struct DCD_MANAGER { ++ u32 dwSignature; /* Used for object validation. */ ++ struct COD_MANAGER *hCodMgr; /* Handle to COD manager object. */ ++}; ++ ++/* Global reference variables. */ ++static u32 cRefs; ++static u32 cEnumRefs; ++ ++extern struct GT_Mask curTrace; ++ ++/* helper function prototypes. */ ++static s32 Atoi(char *pszBuf); ++ ++static DSP_STATUS GetAttrsFromBuf(char *pszBuf, u32 ulBufSize, ++ enum DSP_DCDOBJTYPE objType, ++ struct DCD_GENERICOBJ *pGenObj); ++ ++static void CompressBuf(char *pszBuf, u32 ulBufSize, s32 cCharSize); ++ ++static char DspChar2GppChar(char *pWord, s32 cDspCharSize); ++ ++static DSP_STATUS GetDepLibInfo(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ IN OUT u16 *pNumLibs, ++ OPTIONAL OUT u16 *pNumPersLibs, ++ OPTIONAL OUT struct DSP_UUID *pDepLibUuids, ++ OPTIONAL OUT bool *pPersistentDepLibs, ++ IN enum NLDR_PHASE phase); ++ ++/* ++ * ======== DCD_AutoRegister ======== ++ * Purpose: ++ * Parses the supplied image and resigsters with DCD. ++ */ ++ ++DSP_STATUS DCD_AutoRegister(IN struct DCD_MANAGER *hDcdMgr, ++ IN char *pszCoffPath) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_AutoRegister: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ if (IsValidHandle(hDcdMgr)) { ++ status = DCD_GetObjects(hDcdMgr, pszCoffPath, ++ (DCD_REGISTERFXN)DCD_RegisterObject, ++ (void *)pszCoffPath); ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_AutoRegister: invalid DCD manager handle.\n"); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_AutoUnregister ======== ++ * Purpose: ++ * Parses the supplied DSP image and unresiters from DCD. ++ */ ++DSP_STATUS DCD_AutoUnregister(IN struct DCD_MANAGER *hDcdMgr, ++ IN char *pszCoffPath) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_AutoUnregister: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ if (IsValidHandle(hDcdMgr)) { ++ status = DCD_GetObjects(hDcdMgr, pszCoffPath, ++ (DCD_REGISTERFXN)DCD_RegisterObject, ++ NULL); ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_AutoUnregister: invalid DCD manager" ++ " handle.\n"); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_CreateManager ======== ++ * Purpose: ++ * Creates DCD manager. ++ */ ++DSP_STATUS DCD_CreateManager(IN char *pszZlDllName, ++ OUT struct DCD_MANAGER **phDcdMgr) ++{ ++ struct COD_MANAGER *hCodMgr; /* COD manager handle */ ++ struct DCD_MANAGER *pDcdMgr = NULL; /* DCD Manager pointer */ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs >= 0); ++ DBC_Require(phDcdMgr); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_CreateManager: phDcdMgr 0x%x\n", ++ phDcdMgr); ++ ++ status = COD_Create(&hCodMgr, pszZlDllName, NULL); ++ if (DSP_SUCCEEDED(status)) { ++ ++ /* Create a DCD object. */ ++ MEM_AllocObject(pDcdMgr, struct DCD_MANAGER, SIGNATURE); ++ if (pDcdMgr != NULL) { ++ ++ /* Fill out the object. */ ++ pDcdMgr->hCodMgr = hCodMgr; ++ ++ /* Return handle to this DCD interface. */ ++ *phDcdMgr = pDcdMgr; ++ ++ GT_2trace(curTrace, GT_5CLASS, ++ "DCD_CreateManager: pDcdMgr 0x%x, " ++ " hCodMgr 0x%x", pDcdMgr, hCodMgr); ++ } else { ++ status = DSP_EMEMORY; ++ ++ /* ++ * If allocation of DcdManager object failed, delete the ++ * COD manager. ++ */ ++ COD_Delete(hCodMgr); ++ ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_CreateManager: MEM_AllocObject failed\n"); ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_CreateManager: COD_Create failed\n"); ++ } ++ ++ DBC_Ensure((DSP_SUCCEEDED(status)) || ((hCodMgr == NULL) && ++ (status == DSP_EFAIL)) || ((pDcdMgr == NULL) && ++ (status == DSP_EMEMORY))); ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_DestroyManager ======== ++ * Purpose: ++ * Frees DCD Manager object. ++ */ ++DSP_STATUS DCD_DestroyManager(IN struct DCD_MANAGER *hDcdMgr) ++{ ++ struct DCD_MANAGER *pDcdMgr = hDcdMgr; ++ DSP_STATUS status = DSP_EHANDLE; ++ ++ DBC_Require(cRefs >= 0); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_DestroyManager: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ if (IsValidHandle(hDcdMgr)) { ++ ++ /* Delete the COD manager. */ ++ COD_Delete(pDcdMgr->hCodMgr); ++ ++ /* Deallocate a DCD manager object. */ ++ MEM_FreeObject(pDcdMgr); ++ ++ status = DSP_SOK; ++ } else { ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_DestroyManager: invalid DCD manager handle.\n"); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_EnumerateObject ======== ++ * Purpose: ++ * Enumerates objects in the DCD. ++ */ ++DSP_STATUS DCD_EnumerateObject(IN s32 cIndex, IN enum DSP_DCDOBJTYPE objType, ++ OUT struct DSP_UUID *pUuid) ++{ ++ DSP_STATUS status = DSP_SOK; ++ char szRegKey[REG_MAXREGPATHLENGTH]; ++ char szValue[REG_MAXREGPATHLENGTH]; ++ char szData[REG_MAXREGPATHLENGTH]; ++ u32 dwValueSize; ++ u32 dwDataSize; ++ struct DSP_UUID dspUuid; ++ char szObjType[MAX_INT2CHAR_LENGTH]; /* str. rep. of objType. */ ++ u32 dwKeyLen = 0; ++ ++ DBC_Require(cRefs >= 0); ++ DBC_Require(cIndex >= 0); ++ DBC_Require(pUuid != NULL); ++ ++ GT_3trace(curTrace, GT_ENTER, ++ "DCD_EnumerateObject: cIndex %d, objType %d, " ++ " pUuid 0x%x\n", cIndex, objType, pUuid); ++ ++ if ((cIndex != 0) && (cEnumRefs == 0)) { ++ /* ++ * If an enumeration is being performed on an index greater ++ * than zero, then the current cEnumRefs must have been ++ * incremented to greater than zero. ++ */ ++ status = DSP_ECHANGEDURINGENUM; ++ } else { ++ /* Enumerate a specific key in the registry by index. */ ++ dwValueSize = REG_MAXREGPATHLENGTH; ++ dwDataSize = REG_MAXREGPATHLENGTH; ++ ++ /* ++ * Pre-determine final key length. It's length of DCD_REGKEY + ++ * "_\0" + length of szObjType string + terminating NULL. ++ */ ++ dwKeyLen = strlen(DCD_REGKEY) + 1 + sizeof(szObjType) + 1; ++ DBC_Assert(dwKeyLen < REG_MAXREGPATHLENGTH); ++ ++ /* Create proper REG key; concatenate DCD_REGKEY with ++ * objType. */ ++ strncpy(szRegKey, DCD_REGKEY, strlen(DCD_REGKEY) + 1); ++ if ((strlen(szRegKey) + strlen("_\0")) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, "_\0", 2); ++ } else { ++ status = DSP_EFAIL; ++ } ++ ++ /* This snprintf is guaranteed not to exceed max size of an ++ * integer. */ ++ status = snprintf(szObjType, MAX_INT2CHAR_LENGTH, "%d", ++ objType); ++ ++ if (status == -1) { ++ status = DSP_EFAIL; ++ } else { ++ status = DSP_SOK; ++ if ((strlen(szRegKey) + strlen(szObjType)) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szObjType, ++ strlen(szObjType) + 1); ++ } else { ++ status = DSP_EFAIL; ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = REG_EnumValue(NULL, cIndex, szRegKey, szValue, ++ &dwValueSize, szData, ++ &dwDataSize); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Create UUID value using string retrieved from ++ * registry. */ ++ UUID_UuidFromString(szValue, &dspUuid); ++ ++ *pUuid = dspUuid; ++ ++ /* Increment cEnumRefs to update reference count. */ ++ cEnumRefs++; ++ ++ status = DSP_SOK; ++ } else if (status == REG_E_NOMOREITEMS) { ++ /* At the end of enumeration. Reset cEnumRefs. */ ++ cEnumRefs = 0; ++ ++ status = DSP_SENUMCOMPLETE; ++ } else { ++ status = DSP_EFAIL; ++ GT_1trace(curTrace, GT_6CLASS, ++ "DCD_EnumerateObject: REG_EnumValue" ++ " failed, status = 0x%x\n", status); ++ } ++ } ++ ++ DBC_Ensure(pUuid || (status == DSP_EFAIL)); ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_Exit ======== ++ * Purpose: ++ * Discontinue usage of the DCD module. ++ */ ++void DCD_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(curTrace, GT_5CLASS, "DCD_Exit: cRefs 0x%x\n", cRefs); ++ ++ cRefs--; ++ if (cRefs == 0) { ++ REG_Exit(); ++ COD_Exit(); ++ MEM_Exit(); ++ } ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== DCD_GetDepLibs ======== ++ */ ++DSP_STATUS DCD_GetDepLibs(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ u16 numLibs, OUT struct DSP_UUID *pDepLibUuids, ++ OUT bool *pPersistentDepLibs, IN enum NLDR_PHASE phase) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(hDcdMgr)); ++ DBC_Require(pUuid != NULL); ++ DBC_Require(pDepLibUuids != NULL); ++ DBC_Require(pPersistentDepLibs != NULL); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_GetDepLibs: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ status = GetDepLibInfo(hDcdMgr, pUuid, &numLibs, NULL, pDepLibUuids, ++ pPersistentDepLibs, phase); ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_GetNumDepLibs ======== ++ */ ++DSP_STATUS DCD_GetNumDepLibs(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, OUT u16 *pNumLibs, ++ OUT u16 *pNumPersLibs, IN enum NLDR_PHASE phase) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(IsValidHandle(hDcdMgr)); ++ DBC_Require(pNumLibs != NULL); ++ DBC_Require(pNumPersLibs != NULL); ++ DBC_Require(pUuid != NULL); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_GetNumDepLibs: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ status = GetDepLibInfo(hDcdMgr, pUuid, pNumLibs, pNumPersLibs, ++ NULL, NULL, phase); ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_GetObjectDef ======== ++ * Purpose: ++ * Retrieves the properties of a node or processor based on the UUID and ++ * object type. ++ */ ++DSP_STATUS DCD_GetObjectDef(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pObjUuid, ++ IN enum DSP_DCDOBJTYPE objType, ++ OUT struct DCD_GENERICOBJ *pObjDef) ++{ ++ struct DCD_MANAGER *pDcdMgr = hDcdMgr; /* pointer to DCD manager */ ++ struct COD_LIBRARYOBJ *lib = NULL; ++ DSP_STATUS status = DSP_SOK; ++ u32 ulAddr = 0; /* Used by COD_GetSection */ ++ u32 ulLen = 0; /* Used by COD_GetSection */ ++ u32 dwBufSize; /* Used by REG functions */ ++ char szRegKey[REG_MAXREGPATHLENGTH]; ++ char *szUuid; /*[MAXUUIDLEN];*/ ++ char szRegData[REG_MAXREGPATHLENGTH]; ++ char szSectName[MAXUUIDLEN + 2]; /* ".[UUID]\0" */ ++ char *pszCoffBuf; ++ u32 dwKeyLen; /* Len of REG key. */ ++ char szObjType[MAX_INT2CHAR_LENGTH]; /* str. rep. of objType. */ ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pObjDef != NULL); ++ DBC_Require(pObjUuid != NULL); ++ ++ GT_4trace(curTrace, GT_ENTER, ++ "DCD_GetObjectDef: hDcdMgr 0x%x, " "objUuid" ++ " 0x%x, objType 0x%x, pObjDef 0x%x\n", hDcdMgr, pObjUuid, ++ objType, pObjDef); ++ szUuid = (char *)MEM_Calloc(MAXUUIDLEN, MEM_PAGED); ++ if (!szUuid) ++ return status = DSP_EMEMORY; ++ ++ if (!IsValidHandle(hDcdMgr)) { ++ status = DSP_EHANDLE; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef: invalid " ++ "DCD manager handle.\n"); ++ goto func_end; ++ } ++ /* Pre-determine final key length. It's length of DCD_REGKEY + ++ * "_\0" + length of szObjType string + terminating NULL */ ++ dwKeyLen = strlen(DCD_REGKEY) + 1 + sizeof(szObjType) + 1; ++ DBC_Assert(dwKeyLen < REG_MAXREGPATHLENGTH); ++ /* Create proper REG key; concatenate DCD_REGKEY with objType. */ ++ strncpy(szRegKey, DCD_REGKEY, strlen(DCD_REGKEY) + 1); ++ ++ if ((strlen(szRegKey) + strlen("_\0")) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, "_\0", 2); ++ else ++ status = DSP_EFAIL; ++ ++ status = snprintf(szObjType, MAX_INT2CHAR_LENGTH, "%d", objType); ++ if (status == -1) { ++ status = DSP_EFAIL; ++ } else { ++ status = DSP_SOK; ++ ++ if ((strlen(szRegKey) + strlen(szObjType)) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szObjType, strlen(szObjType) + 1); ++ } else { ++ status = DSP_EFAIL; ++ } ++ /* Create UUID value to set in registry. */ ++ UUID_UuidToString(pObjUuid, szUuid, MAXUUIDLEN); ++ ++ if ((strlen(szRegKey) + MAXUUIDLEN) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, szUuid, MAXUUIDLEN); ++ else ++ status = DSP_EFAIL; ++ ++ /* Retrieve paths from the registry based on struct DSP_UUID */ ++ dwBufSize = REG_MAXREGPATHLENGTH; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = REG_GetValue(NULL, szRegKey, szRegKey, (u8 *)szRegData, ++ &dwBufSize); ++ } ++ if (DSP_FAILED(status)) { ++ status = DSP_EUUID; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef: " ++ "REG_GetValue() failed\n"); ++ goto func_end; ++ } ++ /* Open COFF file. */ ++ status = COD_Open(pDcdMgr->hCodMgr, szRegData, COD_NOLOAD, &lib); ++ if (DSP_FAILED(status)) { ++ status = DSP_EDCDLOADBASE; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef: " ++ "COD_OpenBase() failed\n"); ++ goto func_end; ++ } ++ /* Ensure szUuid + 1 is not greater than sizeof szSectName. */ ++ DBC_Assert((strlen(szUuid) + 1) < sizeof(szSectName)); ++ /* Create section name based on node UUID. A period is ++ * pre-pended to the UUID string to form the section name. ++ * I.e. ".24BC8D90_BB45_11d4_B756_006008BDB66F" */ ++ strncpy(szSectName, ".", 2); ++ strncat(szSectName, szUuid, strlen(szUuid)); ++ /* Get section information. */ ++ status = COD_GetSection(lib, szSectName, &ulAddr, &ulLen); ++ if (DSP_FAILED(status)) { ++ status = DSP_EDCDGETSECT; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef:" ++ " COD_GetSection() failed\n"); ++ goto func_end; ++ } ++ /* Allocate zeroed buffer. */ ++ pszCoffBuf = MEM_Calloc(ulLen + 4, MEM_PAGED); ++#ifdef _DB_TIOMAP ++ if (strstr(szRegData, "iva") == NULL) { ++ /* Locate section by objectID and read its content. */ ++ status = COD_ReadSection(lib, szSectName, pszCoffBuf, ulLen); ++ } else { ++ status = COD_ReadSection(lib, szSectName, pszCoffBuf, ulLen); ++ GT_0trace(curTrace, GT_4CLASS, ++ "Skipped Byte swap for IVA !!\n"); ++ } ++#else ++ status = COD_ReadSection(lib, szSectName, pszCoffBuf, ulLen); ++#endif ++ if (DSP_SUCCEEDED(status)) { ++ /* Compres DSP buffer to conform to PC format. */ ++ if (strstr(szRegData, "iva") == NULL) { ++ CompressBuf(pszCoffBuf, ulLen, DSPWORDSIZE); ++ } else { ++ CompressBuf(pszCoffBuf, ulLen, 1); ++ GT_0trace(curTrace, GT_4CLASS, "Compressing IVA " ++ "COFF buffer by 1 for IVA !!\n"); ++ } ++ /* Parse the content of the COFF buffer. */ ++ status = GetAttrsFromBuf(pszCoffBuf, ulLen, objType, pObjDef); ++ if (DSP_FAILED(status)) { ++ status = DSP_EDCDPARSESECT; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef: " ++ "GetAttrsFromBuf() failed\n"); ++ } ++ } else { ++ status = DSP_EDCDREADSECT; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjectDef: " ++ "COD_ReadSection() failed\n"); ++ } ++ /* Free the previously allocated dynamic buffer. */ ++ MEM_Free(pszCoffBuf); ++func_end: ++ if (lib) ++ COD_Close(lib); ++ ++ if (szUuid) ++ MEM_Free(szUuid); ++ return status; ++} ++ ++/* ++ * ======== DCD_GetObjects ======== ++ */ ++DSP_STATUS DCD_GetObjects(IN struct DCD_MANAGER *hDcdMgr, IN char *pszCoffPath, ++ DCD_REGISTERFXN registerFxn, void *handle) ++{ ++ struct DCD_MANAGER *pDcdMgr = hDcdMgr; /* pointer to DCD manager */ ++ DSP_STATUS status = DSP_SOK; ++ char *pszCoffBuf; ++ char *pszCur; ++ struct COD_LIBRARYOBJ *lib = NULL; ++ u32 ulAddr = 0; /* Used by COD_GetSection */ ++ u32 ulLen = 0; /* Used by COD_GetSection */ ++ char seps[] = ":, "; ++ char *pToken = NULL; ++ struct DSP_UUID dspUuid; ++ s32 cObjectType; ++ ++ DBC_Require(cRefs > 0); ++ GT_1trace(curTrace, GT_ENTER, ++ "DCD_GetObjects: hDcdMgr 0x%x\n", hDcdMgr); ++ if (!IsValidHandle(hDcdMgr)) { ++ status = DSP_EHANDLE; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_GetObjects: invalid DCD manager handle.\n"); ++ goto func_end; ++ } ++ /* Open DSP coff file, don't load symbols. */ ++ status = COD_Open(pDcdMgr->hCodMgr, pszCoffPath, COD_NOLOAD, &lib); ++ if (DSP_FAILED(status)) { ++ status = DSP_EDCDLOADBASE; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_AutoRegister: COD_Open() failed\n"); ++ goto func_cont; ++ } ++ /* Get DCD_RESIGER_SECTION section information. */ ++ status = COD_GetSection(lib, DCD_REGISTER_SECTION, &ulAddr, &ulLen); ++ if (DSP_FAILED(status) || !(ulLen > 0)) { ++ status = DSP_EDCDNOAUTOREGISTER; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_GetObjects: COD_GetSection() " ++ "- no auto register section\n"); ++ goto func_cont; ++ } ++ /* Allocate zeroed buffer. */ ++ pszCoffBuf = MEM_Calloc(ulLen + 4, MEM_PAGED); ++#ifdef _DB_TIOMAP ++ if (strstr(pszCoffPath, "iva") == NULL) { ++ /* Locate section by objectID and read its content. */ ++ status = COD_ReadSection(lib, DCD_REGISTER_SECTION, ++ pszCoffBuf, ulLen); ++ } else { ++ GT_0trace(curTrace, GT_4CLASS, "Skipped Byte swap for IVA!!\n"); ++ status = COD_ReadSection(lib, DCD_REGISTER_SECTION, ++ pszCoffBuf, ulLen); ++ } ++#else ++ status = COD_ReadSection(lib, DCD_REGISTER_SECTION, pszCoffBuf, ulLen); ++#endif ++ if (DSP_SUCCEEDED(status)) { ++ /* Compress DSP buffer to conform to PC format. */ ++ GT_0trace(curTrace, GT_4CLASS, ++ "Successfully read section !!\n"); ++ if (strstr(pszCoffPath, "iva") == NULL) { ++ CompressBuf(pszCoffBuf, ulLen, DSPWORDSIZE); ++ } else { ++ CompressBuf(pszCoffBuf, ulLen, 1); ++ GT_0trace(curTrace, GT_4CLASS, "Compress COFF buffer " ++ "with 1 word for IVA !!\n"); ++ } ++ /* Read from buffer and register object in buffer. */ ++ pszCur = pszCoffBuf; ++ while ((pToken = strsep(&pszCur, seps)) && *pToken != '\0') { ++ /* Retrieve UUID string. */ ++ UUID_UuidFromString(pToken, &dspUuid); ++ /* Retrieve object type */ ++ pToken = strsep(&pszCur, seps); ++ /* Retrieve object type */ ++ cObjectType = Atoi(pToken); ++ /* ++ * Apply registerFxn to the found DCD object. ++ * Possible actions include: ++ * ++ * 1) Register found DCD object. ++ * 2) Unregister found DCD object (when handle == NULL) ++ * 3) Add overlay node. ++ */ ++ GT_1trace(curTrace, GT_4CLASS, "Registering objtype " ++ "%d \n", cObjectType); ++ status = registerFxn(&dspUuid, cObjectType, handle); ++ if (DSP_SUCCEEDED(status)) { ++ GT_1trace(curTrace, GT_5CLASS, ++ "DCD_GetObjects: status 0x%x\n", ++ status); ++ } else { ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_GetObjects: " ++ "registration() failed\n"); ++ /* if error occurs, break from while loop. */ ++ break; ++ } ++ } ++ } else { ++ status = DSP_EDCDREADSECT; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_GetObjects: " ++ "COD_ReadSection() failed\n"); ++ } ++ /* Free the previously allocated dynamic buffer. */ ++ MEM_Free(pszCoffBuf); ++func_cont: ++ if (lib) ++ COD_Close(lib); ++ ++func_end: ++ return status; ++} ++ ++/* ++ * ======== DCD_GetLibraryName ======== ++ * Purpose: ++ * Retrieves the library name for the given UUID. ++ * ++ */ ++DSP_STATUS DCD_GetLibraryName(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ IN OUT char *pstrLibName, IN OUT u32 *pdwSize, ++ enum NLDR_PHASE phase, OUT bool *fPhaseSplit) ++{ ++ char szRegKey[REG_MAXREGPATHLENGTH]; ++ char szUuid[MAXUUIDLEN]; ++ u32 dwKeyLen; /* Len of REG key. */ ++ char szObjType[MAX_INT2CHAR_LENGTH]; /* str. rep. of objType. */ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(pUuid != NULL); ++ DBC_Require(pstrLibName != NULL); ++ DBC_Require(pdwSize != NULL); ++ DBC_Require(IsValidHandle(hDcdMgr)); ++ ++ GT_4trace(curTrace, GT_ENTER, ++ "DCD_GetLibraryName: hDcdMgr 0x%x, pUuid 0x%x, " ++ " pstrLibName 0x%x, pdwSize 0x%x\n", hDcdMgr, pUuid, ++ pstrLibName, pdwSize); ++ /* ++ * Pre-determine final key length. It's length of DCD_REGKEY + ++ * "_\0" + length of szObjType string + terminating NULL. ++ */ ++ dwKeyLen = strlen(DCD_REGKEY) + 1 + sizeof(szObjType) + 1; ++ DBC_Assert(dwKeyLen < REG_MAXREGPATHLENGTH); ++ /* Create proper REG key; concatenate DCD_REGKEY with objType. */ ++ strncpy(szRegKey, DCD_REGKEY, strlen(DCD_REGKEY) + 1); ++ if ((strlen(szRegKey) + strlen("_\0")) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, "_\0", 2); ++ else ++ status = DSP_EFAIL; ++ ++ switch (phase) { ++ case NLDR_CREATE: ++ /* create phase type */ ++ sprintf(szObjType, "%d", DSP_DCDCREATELIBTYPE); ++ break; ++ case NLDR_EXECUTE: ++ /* execute phase type */ ++ sprintf(szObjType, "%d", DSP_DCDEXECUTELIBTYPE); ++ break; ++ case NLDR_DELETE: ++ /* delete phase type */ ++ sprintf(szObjType, "%d", DSP_DCDDELETELIBTYPE); ++ break; ++ case NLDR_NOPHASE: ++ /* known to be a dependent library */ ++ sprintf(szObjType, "%d", DSP_DCDLIBRARYTYPE); ++ break; ++ default: ++ status = -1; ++ DBC_Assert(false); ++ } ++ if (status == -1) { ++ status = DSP_EFAIL; ++ } else { ++ status = DSP_SOK; ++ if ((strlen(szRegKey) + strlen(szObjType)) ++ < REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szObjType, strlen(szObjType) + 1); ++ } else { ++ status = DSP_EFAIL; ++ } ++ /* Create UUID value to find match in registry. */ ++ UUID_UuidToString(pUuid, szUuid, MAXUUIDLEN); ++ if ((strlen(szRegKey) + MAXUUIDLEN) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szUuid, MAXUUIDLEN); ++ } else { ++ status = DSP_EFAIL; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Retrieve path from the registry based on DSP_UUID */ ++ status = REG_GetValue(NULL, szRegKey, szRegKey, ++ (u8 *)pstrLibName, pdwSize); ++ } ++ /* If can't find, phases might be registered as generic LIBRARYTYPE */ ++ if (DSP_FAILED(status) && phase != NLDR_NOPHASE) { ++ if (fPhaseSplit) ++ *fPhaseSplit = false; ++ ++ strncpy(szRegKey, DCD_REGKEY, strlen(DCD_REGKEY) + 1); ++ if ((strlen(szRegKey) + strlen("_\0")) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, "_\0", 2); ++ } else { ++ status = DSP_EFAIL; ++ } ++ sprintf(szObjType, "%d", DSP_DCDLIBRARYTYPE); ++ if ((strlen(szRegKey) + strlen(szObjType)) ++ < REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szObjType, strlen(szObjType) + 1); ++ } else { ++ status = DSP_EFAIL; ++ } ++ UUID_UuidToString(pUuid, szUuid, MAXUUIDLEN); ++ if ((strlen(szRegKey) + MAXUUIDLEN) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, szUuid, MAXUUIDLEN); ++ else ++ status = DSP_EFAIL; ++ ++ status = REG_GetValue(NULL, szRegKey, szRegKey, ++ (u8 *)pstrLibName, pdwSize); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_Init ======== ++ * Purpose: ++ * Initialize the DCD module. ++ */ ++bool DCD_Init(void) ++{ ++ bool fInitMEM; ++ bool fInitREG; ++ bool fInitCOD; ++ bool fInit = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_Init: (on enter) cRefs = 0x%x\n", ++ cRefs); ++ ++ if (cRefs == 0) { ++ ++ /* Initialize required modules. */ ++ fInitMEM = MEM_Init(); ++ fInitCOD = COD_Init(); ++ fInitREG = REG_Init(); ++ if (!fInitMEM || !fInitCOD || !fInitREG) { ++ fInit = false; ++ GT_0trace(curTrace, GT_6CLASS, "DCD_Init failed\n"); ++ /* Exit initialized modules. */ ++ if (fInitMEM) ++ MEM_Exit(); ++ ++ if (fInitCOD) ++ COD_Exit(); ++ ++ if (fInitREG) ++ REG_Exit(); ++ ++ } ++ } ++ ++ if (fInit) ++ cRefs++; ++ ++ ++ GT_1trace(curTrace, GT_5CLASS, "DCD_Init: (on exit) cRefs = 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fInit && (cRefs > 0)) || (!fInit && (cRefs == 0))); ++ ++ return fInit; ++} ++ ++/* ++ * ======== DCD_RegisterObject ======== ++ * Purpose: ++ * Registers a node or a processor with the DCD. ++ * If pszPathName == NULL, unregister the specified DCD object. ++ */ ++DSP_STATUS DCD_RegisterObject(IN struct DSP_UUID *pUuid, ++ IN enum DSP_DCDOBJTYPE objType, ++ IN char *pszPathName) ++{ ++ DSP_STATUS status = DSP_SOK; ++ char szRegKey[REG_MAXREGPATHLENGTH]; ++ char szUuid[MAXUUIDLEN + 1]; ++ u32 dwPathSize = 0; ++ u32 dwKeyLen; /* Len of REG key. */ ++ char szObjType[MAX_INT2CHAR_LENGTH]; /* str. rep. of objType. */ ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pUuid != NULL); ++ DBC_Require((objType == DSP_DCDNODETYPE) || ++ (objType == DSP_DCDPROCESSORTYPE) || ++ (objType == DSP_DCDLIBRARYTYPE) || ++ (objType == DSP_DCDCREATELIBTYPE) || ++ (objType == DSP_DCDEXECUTELIBTYPE) || ++ (objType == DSP_DCDDELETELIBTYPE)); ++ ++ GT_3trace(curTrace, GT_ENTER, "DCD_RegisterObject: object UUID 0x%x, " ++ "objType %d, szPathName %s\n", pUuid, objType, pszPathName); ++ /* ++ * Pre-determine final key length. It's length of DCD_REGKEY + ++ * "_\0" + length of szObjType string + terminating NULL. ++ */ ++ dwKeyLen = strlen(DCD_REGKEY) + 1 + sizeof(szObjType) + 1; ++ DBC_Assert(dwKeyLen < REG_MAXREGPATHLENGTH); ++ /* Create proper REG key; concatenate DCD_REGKEY with objType. */ ++ strncpy(szRegKey, DCD_REGKEY, strlen(DCD_REGKEY) + 1); ++ if ((strlen(szRegKey) + strlen("_\0")) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, "_\0", 2); ++ else ++ status = DSP_EFAIL; ++ ++ status = snprintf(szObjType, MAX_INT2CHAR_LENGTH, "%d", objType); ++ if (status == -1) { ++ status = DSP_EFAIL; ++ } else { ++ status = DSP_SOK; ++ if ((strlen(szRegKey) + strlen(szObjType)) < ++ REG_MAXREGPATHLENGTH) { ++ strncat(szRegKey, szObjType, strlen(szObjType) + 1); ++ } else { ++ status = DSP_EFAIL; ++ } ++ /* Create UUID value to set in registry. */ ++ UUID_UuidToString(pUuid, szUuid, MAXUUIDLEN); ++ if ((strlen(szRegKey) + MAXUUIDLEN) < REG_MAXREGPATHLENGTH) ++ strncat(szRegKey, szUuid, MAXUUIDLEN); ++ else ++ status = DSP_EFAIL; ++ ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* ++ * If pszPathName != NULL, perform registration, otherwise, ++ * perform unregistration. ++ */ ++ if (pszPathName) { ++ /* Add new reg value (UUID+objType) with COFF path ++ * info. */ ++ dwPathSize = strlen(pszPathName) + 1; ++ status = REG_SetValue(NULL, szRegKey, szRegKey, REG_SZ, ++ (u8 *)pszPathName, dwPathSize); ++ GT_3trace(curTrace, GT_6CLASS, ++ "REG_SetValue REG_SZ=%d, " ++ "(u8 *)pszPathName=%s, dwPathSize=%d\n", ++ REG_SZ, pszPathName, dwPathSize); ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_RegisterObject: REG_SetValue failed!\n"); ++ } ++ } else { ++ /* Deregister an existing object. */ ++ status = REG_DeleteValue(NULL, szRegKey, szRegKey); ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_6CLASS, ++ "DCD_UnregisterObject: " ++ "REG_DeleteValue failed!\n"); ++ } ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* ++ * Because the node database has been updated through a ++ * successful object registration/de-registration operation, ++ * we need to reset the object enumeration counter to allow ++ * current enumerations to reflect this update in the node ++ * database. ++ */ ++ ++ cEnumRefs = 0; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DCD_UnregisterObject ======== ++ * Call DCD_Register object with pszPathName set to NULL to ++ * perform actual object de-registration. ++ */ ++DSP_STATUS DCD_UnregisterObject(IN struct DSP_UUID *pUuid, ++ IN enum DSP_DCDOBJTYPE objType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pUuid != NULL); ++ DBC_Require((objType == DSP_DCDNODETYPE) || ++ (objType == DSP_DCDPROCESSORTYPE) || ++ (objType == DSP_DCDLIBRARYTYPE) || ++ (objType == DSP_DCDCREATELIBTYPE) || ++ (objType == DSP_DCDEXECUTELIBTYPE) || ++ (objType == DSP_DCDDELETELIBTYPE)); ++ ++ GT_2trace(curTrace, GT_ENTER, ++ "DCD_UnregisterObject: object UUID 0x%x, " ++ "objType %d\n", pUuid, objType); ++ ++ /* ++ * When DCD_RegisterObject is called with NULL as pathname, ++ * it indicates an unregister object operation. ++ */ ++ status = DCD_RegisterObject(pUuid, objType, NULL); ++ ++ return status; ++} ++ ++/* ++ ********************************************************************** ++ * DCD Helper Functions ++ ********************************************************************** ++ */ ++ ++/* ++ * ======== Atoi ======== ++ * Purpose: ++ * This function converts strings in decimal or hex format to integers. ++ */ ++static s32 Atoi(char *pszBuf) ++{ ++ s32 result = 0; ++ char *pch = pszBuf; ++ char c; ++ char first; ++ s32 base = 10; ++ s32 len; ++ ++ while (isspace(*pch)) ++ pch++; ++ ++ first = *pch; ++ if (first == '-' || first == '+') { ++ pch++; ++ } else { ++ /* Determine if base 10 or base 16 */ ++ len = strlen(pch); ++ if (len > 1) { ++ c = pch[1]; ++ if ((*pch == '0' && (c == 'x' || c == 'X'))) { ++ base = 16; ++ pch += 2; ++ } ++ c = pch[len - 1]; ++ if (c == 'h' || c == 'H') ++ base = 16; ++ ++ } ++ } ++ ++ while (isdigit(c = *pch) || ((base == 16) && isxdigit(c))) { ++ result *= base; ++ if ('A' <= c && c <= 'F') { ++ c = c - 'A' + 10; ++ } else { ++ if ('a' <= c && c <= 'f') ++ c = c - 'a' + 10; ++ else ++ c -= '0'; ++ ++ } ++ result += c; ++ ++pch; ++ } ++ ++ return result; ++} ++ ++/* ++ * ======== GetAttrsFromBuf ======== ++ * Purpose: ++ * Parse the content of a buffer filled with DSP-side data and ++ * retrieve an object's attributes from it. IMPORTANT: Assume the ++ * buffer has been converted from DSP format to GPP format. ++ */ ++static DSP_STATUS GetAttrsFromBuf(char *pszBuf, u32 ulBufSize, ++ enum DSP_DCDOBJTYPE objType, ++ struct DCD_GENERICOBJ *pGenObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ char seps[] = ", "; ++ char *pszCur; ++ char *token; ++ s32 cLen = 0; ++ u32 i = 0; ++#ifdef _DB_TIOMAP ++ s32 iEntry; ++#endif ++ ++ DBC_Require(pszBuf != NULL); ++ DBC_Require(ulBufSize != 0); ++ DBC_Require((objType == DSP_DCDNODETYPE) ++ || (objType == DSP_DCDPROCESSORTYPE)); ++ DBC_Require(pGenObj != NULL); ++ ++ ++ switch (objType) { ++ case DSP_DCDNODETYPE: ++ /* ++ * Parse COFF sect buffer to retrieve individual tokens used ++ * to fill in object attrs. ++ */ ++ pszCur = pszBuf; ++ token = strsep(&pszCur, seps); ++ ++ /* u32 cbStruct */ ++ pGenObj->objData.nodeObj.ndbProps.cbStruct = ++ (u32) Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* DSP_UUID uiNodeID */ ++ UUID_UuidFromString(token, ++ &pGenObj->objData.nodeObj.ndbProps.uiNodeID); ++ token = strsep(&pszCur, seps); ++ ++ /* acName */ ++ DBC_Require(token); ++ cLen = strlen(token); ++ if (cLen > DSP_MAXNAMELEN - 1) ++ cLen = DSP_MAXNAMELEN - 1; ++ ++ strncpy(pGenObj->objData.nodeObj.ndbProps.acName, ++ token, cLen); ++ pGenObj->objData.nodeObj.ndbProps.acName[cLen] = '\0'; ++ token = strsep(&pszCur, seps); ++ /* u32 uNodeType */ ++ pGenObj->objData.nodeObj.ndbProps.uNodeType = Atoi(token); ++ token = strsep(&pszCur, seps); ++ /* u32 bCacheOnGPP */ ++ pGenObj->objData.nodeObj.ndbProps.bCacheOnGPP = Atoi(token); ++ token = strsep(&pszCur, seps); ++ /* DSP_RESOURCEREQMTS dspResourceReqmts */ ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts.cbStruct = ++ (u32) Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uStaticDataSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uGlobalDataSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uProgramMemSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uWCExecutionTime = Atoi(token); ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uWCPeriod = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uWCDeadline = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uAvgExectionTime = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.nodeObj.ndbProps.dspResourceReqmts. ++ uMinimumPeriod = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* s32 iPriority */ ++ pGenObj->objData.nodeObj.ndbProps.iPriority = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uStackSize */ ++ pGenObj->objData.nodeObj.ndbProps.uStackSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uSysStackSize */ ++ pGenObj->objData.nodeObj.ndbProps.uSysStackSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uStackSeg */ ++ pGenObj->objData.nodeObj.ndbProps.uStackSeg = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uMessageDepth */ ++ pGenObj->objData.nodeObj.ndbProps.uMessageDepth = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uNumInputStreams */ ++ pGenObj->objData.nodeObj.ndbProps.uNumInputStreams = ++ Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uNumOutputStreams */ ++ pGenObj->objData.nodeObj.ndbProps.uNumOutputStreams = ++ Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* u32 uTimeout */ ++ pGenObj->objData.nodeObj.ndbProps.uTimeout = ++ Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* char * pstrCreatePhaseFxn */ ++ DBC_Require(token); ++ cLen = strlen(token); ++ pGenObj->objData.nodeObj.pstrCreatePhaseFxn = ++ MEM_Calloc(cLen + 1, MEM_PAGED); ++ strncpy(pGenObj->objData.nodeObj.pstrCreatePhaseFxn, ++ token, cLen); ++ pGenObj->objData.nodeObj.pstrCreatePhaseFxn[cLen] = '\0'; ++ token = strsep(&pszCur, seps); ++ ++ /* char * pstrExecutePhaseFxn */ ++ DBC_Require(token); ++ cLen = strlen(token); ++ pGenObj->objData.nodeObj.pstrExecutePhaseFxn = ++ MEM_Calloc(cLen + 1, MEM_PAGED); ++ strncpy(pGenObj->objData.nodeObj.pstrExecutePhaseFxn, ++ token, cLen); ++ pGenObj->objData.nodeObj.pstrExecutePhaseFxn[cLen] = '\0'; ++ token = strsep(&pszCur, seps); ++ ++ /* char * pstrDeletePhaseFxn */ ++ DBC_Require(token); ++ cLen = strlen(token); ++ pGenObj->objData.nodeObj.pstrDeletePhaseFxn = ++ MEM_Calloc(cLen + 1, MEM_PAGED); ++ strncpy(pGenObj->objData.nodeObj.pstrDeletePhaseFxn, ++ token, cLen); ++ pGenObj->objData.nodeObj.pstrDeletePhaseFxn[cLen] = '\0'; ++ token = strsep(&pszCur, seps); ++ ++ /* Segment id for message buffers */ ++ pGenObj->objData.nodeObj.uMsgSegid = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* Message notification type */ ++ pGenObj->objData.nodeObj.uMsgNotifyType = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ /* char * pstrIAlgName */ ++ if (token) { ++ cLen = strlen(token); ++ pGenObj->objData.nodeObj.pstrIAlgName = ++ MEM_Calloc(cLen + 1, MEM_PAGED); ++ strncpy(pGenObj->objData.nodeObj.pstrIAlgName, ++ token, cLen); ++ pGenObj->objData.nodeObj.pstrIAlgName[cLen] = '\0'; ++ token = strsep(&pszCur, seps); ++ } ++ ++ /* Load type (static, dynamic, or overlay) */ ++ if (token) { ++ pGenObj->objData.nodeObj.usLoadType = Atoi(token); ++ token = strsep(&pszCur, seps); ++ } ++ ++ /* Dynamic load data requirements */ ++ if (token) { ++ pGenObj->objData.nodeObj.ulDataMemSegMask = Atoi(token); ++ token = strsep(&pszCur, seps); ++ } ++ ++ /* Dynamic load code requirements */ ++ if (token) { ++ pGenObj->objData.nodeObj.ulCodeMemSegMask = Atoi(token); ++ token = strsep(&pszCur, seps); ++ } ++ ++ /* Extract node profiles into node properties */ ++ if (token) { ++ ++ pGenObj->objData.nodeObj.ndbProps.uCountProfiles = ++ Atoi(token); ++ for (i = 0; i < pGenObj->objData.nodeObj.ndbProps. ++ uCountProfiles; i++) { ++ token = strsep(&pszCur, seps); ++ if (token) { ++ /* Heap Size for the node */ ++ pGenObj->objData.nodeObj.ndbProps. ++ aProfiles[i].ulHeapSize = ++ Atoi(token); ++ } ++ } ++ } ++ token = strsep(&pszCur, seps); ++ if (token) { ++ pGenObj->objData.nodeObj.ndbProps.uStackSegName = ++ (u32)(token); ++ } ++ ++ break; ++ ++ case DSP_DCDPROCESSORTYPE: ++ /* ++ * Parse COFF sect buffer to retrieve individual tokens used ++ * to fill in object attrs. ++ */ ++ pszCur = pszBuf; ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.cbStruct = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.uProcessorFamily = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.uProcessorType = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.uClockRate = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.ulInternalMemSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.ulExternalMemSize = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.uProcessorID = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.tyRunningRTOS = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.nNodeMinPriority = Atoi(token); ++ token = strsep(&pszCur, seps); ++ ++ pGenObj->objData.procObj.nNodeMaxPriority = Atoi(token); ++ ++#ifdef _DB_TIOMAP ++ /* Proc object may contain additional(extended) attributes. */ ++ /* attr must match proc.hxx */ ++ for (iEntry = 0; iEntry < 7; iEntry++) { ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.extProcObj.tyTlb[iEntry].ulGppPhys = ++ Atoi(token); ++ ++ token = strsep(&pszCur, seps); ++ pGenObj->objData.extProcObj.tyTlb[iEntry].ulDspVirt = ++ Atoi(token); ++ } ++#endif ++ ++ break; ++ ++ default: ++ status = DSP_EFAIL; ++ break; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== CompressBuffer ======== ++ * Purpose: ++ * Compress the DSP buffer, if necessary, to conform to PC format. ++ */ ++static void CompressBuf(char *pszBuf, u32 ulBufSize, s32 cCharSize) ++{ ++ char *p; ++ char ch; ++ char *q; ++ ++ p = pszBuf; ++ if (p == NULL) ++ return; ++ ++ for (q = pszBuf; q < (pszBuf + ulBufSize);) { ++ ++ ch = DspChar2GppChar(q, cCharSize); ++ if (ch == '\\') { ++ q += cCharSize; ++ ch = DspChar2GppChar(q, cCharSize); ++ switch (ch) { ++ case 't': ++ *p = '\t'; ++ break; ++ ++ case 'n': ++ *p = '\n'; ++ break; ++ ++ case 'r': ++ *p = '\r'; ++ break; ++ ++ case '0': ++ *p = '\0'; ++ break; ++ ++ default: ++ *p = ch; ++ break; ++ } ++ } else { ++ *p = ch; ++ } ++ p++; ++ q += cCharSize; ++ } ++ ++ /* NULL out remainder of buffer. */ ++ while (p < q) ++ *p++ = '\0'; ++ ++} ++ ++/* ++ * ======== DspChar2GppChar ======== ++ * Purpose: ++ * Convert DSP char to host GPP char in a portable manner ++ */ ++static char DspChar2GppChar(char *pWord, s32 cDspCharSize) ++{ ++ char ch = '\0'; ++ char *chSrc; ++ s32 i; ++ ++ for (chSrc = pWord, i = cDspCharSize; i > 0; i--) ++ ch |= *chSrc++; ++ ++ return ch; ++} ++ ++/* ++ * ======== GetDepLibInfo ======== ++ */ ++static DSP_STATUS GetDepLibInfo(IN struct DCD_MANAGER *hDcdMgr, ++ IN struct DSP_UUID *pUuid, ++ IN OUT u16 *pNumLibs, ++ OPTIONAL OUT u16 *pNumPersLibs, ++ OPTIONAL OUT struct DSP_UUID *pDepLibUuids, ++ OPTIONAL OUT bool *pPersistentDepLibs, ++ enum NLDR_PHASE phase) ++{ ++ struct DCD_MANAGER *pDcdMgr = hDcdMgr; /* pointer to DCD manager */ ++ char *pszCoffBuf = NULL; ++ char *pszCur; ++ char *pszFileName = NULL; ++ struct COD_LIBRARYOBJ *lib = NULL; ++ u32 ulAddr = 0; /* Used by COD_GetSection */ ++ u32 ulLen = 0; /* Used by COD_GetSection */ ++ u32 dwDataSize = COD_MAXPATHLENGTH; ++ char seps[] = ", "; ++ char *pToken = NULL; ++ bool fGetUuids = (pDepLibUuids != NULL); ++ u16 nDepLibs = 0; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ DBC_Require(IsValidHandle(hDcdMgr)); ++ DBC_Require(pNumLibs != NULL); ++ DBC_Require(pUuid != NULL); ++ ++ GT_1trace(curTrace, GT_ENTER, "DCD_GetNumDepLibs: hDcdMgr 0x%x\n", ++ hDcdMgr); ++ ++ /* Initialize to 0 dependent libraries, if only counting number of ++ * dependent libraries */ ++ if (!fGetUuids) { ++ *pNumLibs = 0; ++ *pNumPersLibs = 0; ++ } ++ ++ /* Allocate a buffer for file name */ ++ pszFileName = MEM_Calloc(dwDataSize, MEM_PAGED); ++ if (pszFileName == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Get the name of the library */ ++ status = DCD_GetLibraryName(hDcdMgr, pUuid, pszFileName, ++ &dwDataSize, phase, NULL); ++ } ++ /* Open the library */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_Open(pDcdMgr->hCodMgr, pszFileName, ++ COD_NOLOAD, &lib); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get dependent library section information. */ ++ status = COD_GetSection(lib, DEPLIBSECT, &ulAddr, &ulLen); ++ ++ if (DSP_FAILED(status)) { ++ /* Ok, no dependent libraries */ ++ ulLen = 0; ++ status = DSP_SNODEPENDENTLIBS; ++ } ++ } ++ ++ if (DSP_FAILED(status) || !(ulLen > 0)) ++ goto func_cont; ++ ++ /* Allocate zeroed buffer. */ ++ pszCoffBuf = MEM_Calloc(ulLen, MEM_PAGED); ++ if (pszCoffBuf == NULL) ++ status = DSP_EMEMORY; ++ ++ /* Read section contents. */ ++ status = COD_ReadSection(lib, DEPLIBSECT, pszCoffBuf, ulLen); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* Compress and format DSP buffer to conform to PC format. */ ++ CompressBuf(pszCoffBuf, ulLen, DSPWORDSIZE); ++ /* Read from buffer */ ++ pszCur = pszCoffBuf; ++ while ((pToken = strsep(&pszCur, seps)) && *pToken != '\0') { ++ if (fGetUuids) { ++ if (nDepLibs >= *pNumLibs) { ++ /* Gone beyond the limit */ ++ break; ++ } else { ++ /* Retrieve UUID string. */ ++ UUID_UuidFromString(pToken, ++ &(pDepLibUuids[nDepLibs])); ++ /* Is this library persistent? */ ++ pToken = strsep(&pszCur, seps); ++ pPersistentDepLibs[nDepLibs] = Atoi(pToken); ++ nDepLibs++; ++ } ++ } else { ++ /* Advanc to next token */ ++ pToken = strsep(&pszCur, seps); ++ if (Atoi(pToken)) ++ (*pNumPersLibs)++; ++ ++ /* Just counting number of dependent libraries */ ++ (*pNumLibs)++; ++ } ++ } ++func_cont: ++ if (lib) ++ COD_Close(lib); ++ ++ /* Free previously allocated dynamic buffers. */ ++ if (pszFileName) ++ MEM_Free(pszFileName); ++ ++ if (pszCoffBuf) ++ MEM_Free(pszCoffBuf); ++ ++ return status; ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/disp.c b/drivers/dsp/bridge/rmgr/disp.c +new file mode 100644 +index 0000000..3fbbf01 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/disp.c +@@ -0,0 +1,916 @@ ++/* ++ * disp.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== disp.c ======== ++ * ++ * Description: ++ * Node Dispatcher interface. Communicates with Resource Manager Server ++ * (RMS) on DSP. Access to RMS is synchronized in NODE. ++ * ++ * Public Functions: ++ * DISP_Create ++ * DISP_Delete ++ * DISP_Exit ++ * DISP_Init ++ * DISP_NodeChangePriority ++ * DISP_NodeCreate ++ * DISP_NodeDelete ++ * DISP_NodePause ++ * DISP_NodeRun ++ * ++ *! Revision History: ++ *! ================= ++ *! 18-Feb-2003 vp Code review updates ++ *! 18-Oct-2002 vp Ported to Linux platform ++ *! 16-May-2002 jeh Added DISP_DoCinit(). ++ *! 24-Apr-2002 jeh Added DISP_MemWrite(). ++ *! 13-Feb-2002 jeh Pass system stack size to RMS. ++ *! 16-Jan-2002 ag Added bufsize param to _ChnlAddIOReq() fxn ++ *! 10-May-2001 jeh Code Review cleanup. ++ *! 26-Sep-2000 jeh Fixed status values in SendMessage(). ++ *! 19-Jun-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/gt.h> ++#include <dspbridge/dbc.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/dev.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/csl.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmd.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/chnldefs.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/nodedefs.h> ++#include <dspbridge/nodepriv.h> ++#include <dspbridge/rms_sh.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/disp.h> ++ ++#define DISP_SIGNATURE 0x50534944 /* "PSID" */ ++ ++/* Size of a reply from RMS */ ++#define REPLYSIZE (3 * sizeof(RMS_WORD)) ++ ++/* Reserved channel offsets for communication with RMS */ ++#define CHNLTORMSOFFSET 0 ++#define CHNLFROMRMSOFFSET 1 ++ ++#define CHNLIOREQS 1 ++ ++#define SwapWord(x) (((u32)(x) >> 16) | ((u32)(x) << 16)) ++ ++/* ++ * ======== DISP_OBJECT ======== ++ */ ++struct DISP_OBJECT { ++ u32 dwSignature; /* Used for object validation */ ++ struct DEV_OBJECT *hDevObject; /* Device for this processor */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ struct CHNL_MGR *hChnlMgr; /* Channel manager */ ++ struct CHNL_OBJECT *hChnlToDsp; /* Channel for commands to RMS */ ++ struct CHNL_OBJECT *hChnlFromDsp; /* Channel for replies from RMS */ ++ u8 *pBuf; /* Buffer for commands, replies */ ++ u32 ulBufsize; /* pBuf size in bytes */ ++ u32 ulBufsizeRMS; /* pBuf size in RMS words */ ++ u32 uCharSize; /* Size of DSP character */ ++ u32 uWordSize; /* Size of DSP word */ ++ u32 uDataMauSize; /* Size of DSP Data MAU */ ++}; ++ ++static u32 cRefs; ++ ++/* Debug msgs: */ ++#if GT_TRACE ++static struct GT_Mask DISP_DebugMask = { NULL, NULL }; ++#endif ++ ++static void DeleteDisp(struct DISP_OBJECT *hDisp); ++static DSP_STATUS FillStreamDef(RMS_WORD *pdwBuf, u32 *ptotal, u32 offset, ++ struct NODE_STRMDEF strmDef, u32 max, ++ u32 uCharsInRMSWord); ++static DSP_STATUS SendMessage(struct DISP_OBJECT *hDisp, u32 dwTimeout, ++ u32 ulBytes, OUT u32 *pdwArg); ++ ++/* ++ * ======== DISP_Create ======== ++ * Create a NODE Dispatcher object. ++ */ ++DSP_STATUS DISP_Create(OUT struct DISP_OBJECT **phDispObject, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct DISP_ATTRS *pDispAttrs) ++{ ++ struct DISP_OBJECT *pDisp; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ u32 ulChnlId; ++ struct CHNL_ATTRS chnlAttrs; ++ DSP_STATUS status = DSP_SOK; ++ u32 devType; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDispObject != NULL); ++ DBC_Require(pDispAttrs != NULL); ++ DBC_Require(hDevObject != NULL); ++ ++ GT_3trace(DISP_DebugMask, GT_ENTER, "DISP_Create: phDispObject: 0x%x\t" ++ "hDevObject: 0x%x\tpDispAttrs: 0x%x\n", phDispObject, ++ hDevObject, pDispAttrs); ++ ++ *phDispObject = NULL; ++ ++ /* Allocate Node Dispatcher object */ ++ MEM_AllocObject(pDisp, struct DISP_OBJECT, DISP_SIGNATURE); ++ if (pDisp == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: MEM_AllocObject() failed!\n"); ++ } else { ++ pDisp->hDevObject = hDevObject; ++ } ++ ++ /* Get Channel manager and WMD function interface */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetChnlMgr(hDevObject, &(pDisp->hChnlMgr)); ++ if (DSP_SUCCEEDED(status)) { ++ (void) DEV_GetIntfFxns(hDevObject, &pIntfFxns); ++ pDisp->pIntfFxns = pIntfFxns; ++ } else { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: Failed to get " ++ "channel manager! status = 0x%x\n", status); ++ } ++ } ++ ++ /* check device type and decide if streams or messag'ing is used for ++ * RMS/EDS */ ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ status = DEV_GetDevType(hDevObject, &devType); ++ GT_1trace(DISP_DebugMask, GT_6CLASS, "DISP_Create: Creating DISP for " ++ "device = 0x%x\n", devType); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ if (devType != DSP_UNIT) { ++ GT_0trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: Unkown device " ++ "type in Device object !! \n"); ++ status = DSP_EFAIL; ++ goto func_cont; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pDisp->uCharSize = DSPWORDSIZE; ++ pDisp->uWordSize = DSPWORDSIZE; ++ pDisp->uDataMauSize = DSPWORDSIZE; ++ /* Open channels for communicating with the RMS */ ++ chnlAttrs.uIOReqs = CHNLIOREQS; ++ chnlAttrs.hEvent = NULL; ++ ulChnlId = pDispAttrs->ulChnlOffset + CHNLTORMSOFFSET; ++ status = (*pIntfFxns->pfnChnlOpen)(&(pDisp->hChnlToDsp), ++ pDisp->hChnlMgr, CHNL_MODETODSP, ulChnlId, &chnlAttrs); ++ if (DSP_FAILED(status)) { ++ GT_2trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: Channel to RMS " ++ "open failed, chnl id = %d, status = 0x%x\n", ++ ulChnlId, status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ ulChnlId = pDispAttrs->ulChnlOffset + CHNLFROMRMSOFFSET; ++ status = (*pIntfFxns->pfnChnlOpen)(&(pDisp->hChnlFromDsp), ++ pDisp->hChnlMgr, CHNL_MODEFROMDSP, ulChnlId, ++ &chnlAttrs); ++ if (DSP_FAILED(status)) { ++ GT_2trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: Channel from RMS " ++ "open failed, chnl id = %d, status = 0x%x\n", ++ ulChnlId, status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Allocate buffer for commands, replies */ ++ pDisp->ulBufsize = pDispAttrs->ulChnlBufSize; ++ pDisp->ulBufsizeRMS = RMS_COMMANDBUFSIZE; ++ pDisp->pBuf = MEM_Calloc(pDisp->ulBufsize, MEM_PAGED); ++ if (pDisp->pBuf == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Create: Failed " ++ "to allocate channel buffer!\n"); ++ } ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) ++ *phDispObject = pDisp; ++ else ++ DeleteDisp(pDisp); ++ ++ DBC_Ensure(((DSP_FAILED(status)) && ((*phDispObject == NULL))) || ++ ((DSP_SUCCEEDED(status)) && ++ (MEM_IsValidHandle((*phDispObject), DISP_SIGNATURE)))); ++ return status; ++} ++ ++/* ++ * ======== DISP_Delete ======== ++ * Delete the NODE Dispatcher. ++ */ ++void DISP_Delete(struct DISP_OBJECT *hDisp) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++ ++ GT_1trace(DISP_DebugMask, GT_ENTER, ++ "DISP_Delete: hDisp: 0x%x\n", hDisp); ++ ++ DeleteDisp(hDisp); ++ ++ DBC_Ensure(!MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++} ++ ++/* ++ * ======== DISP_Exit ======== ++ * Discontinue usage of DISP module. ++ */ ++void DISP_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(DISP_DebugMask, GT_5CLASS, ++ "Entered DISP_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== DISP_Init ======== ++ * Initialize the DISP module. ++ */ ++bool DISP_Init(void) ++{ ++ bool fRetVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!DISP_DebugMask.flags); ++ GT_create(&DISP_DebugMask, "DI"); /* "DI" for DIspatcher */ ++ } ++ ++ if (fRetVal) ++ cRefs++; ++ ++ GT_1trace(DISP_DebugMask, GT_5CLASS, ++ "DISP_Init(), ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure((fRetVal && (cRefs > 0)) || (!fRetVal && (cRefs >= 0))); ++ return fRetVal; ++} ++ ++/* ++ * ======== DISP_NodeChangePriority ======== ++ * Change the priority of a node currently running on the target. ++ */ ++DSP_STATUS DISP_NodeChangePriority(struct DISP_OBJECT *hDisp, ++ struct NODE_OBJECT *hNode, ++ u32 ulRMSFxn, NODE_ENV nodeEnv, ++ s32 nPriority) ++{ ++ u32 dwArg; ++ struct RMS_Command *pCommand; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++ DBC_Require(hNode != NULL); ++ ++ GT_5trace(DISP_DebugMask, GT_ENTER, "DISP_NodeChangePriority: hDisp: " ++ "0x%x\thNode: 0x%x\tulRMSFxn: 0x%x\tnodeEnv: 0x%x\tnPriority\n", ++ hDisp, hNode, ulRMSFxn, nodeEnv, nPriority); ++ ++ /* Send message to RMS to change priority */ ++ pCommand = (struct RMS_Command *)(hDisp->pBuf); ++ pCommand->fxn = (RMS_WORD)(ulRMSFxn); ++ pCommand->arg1 = (RMS_WORD)nodeEnv; ++ pCommand->arg2 = nPriority; ++ status = SendMessage(hDisp, NODE_GetTimeout(hNode), ++ sizeof(struct RMS_Command), &dwArg); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeChangePriority failed! " ++ "status = 0x%x\n", status); ++ } ++ return status; ++} ++ ++/* ++ * ======== DISP_NodeCreate ======== ++ * Create a node on the DSP by remotely calling the node's create function. ++ */ ++DSP_STATUS DISP_NodeCreate(struct DISP_OBJECT *hDisp, struct NODE_OBJECT *hNode, ++ u32 ulRMSFxn, u32 ulCreateFxn, ++ IN CONST struct NODE_CREATEARGS *pArgs, ++ OUT NODE_ENV *pNodeEnv) ++{ ++ struct NODE_MSGARGS msgArgs; ++ struct NODE_TASKARGS taskArgs; ++ struct RMS_Command *pCommand; ++ struct RMS_MsgArgs *pMsgArgs; ++ struct RMS_MoreTaskArgs *pMoreTaskArgs; ++ enum NODE_TYPE nodeType; ++ u32 dwLength; ++ RMS_WORD *pdwBuf = NULL; ++ u32 ulBytes; ++ u32 i; ++ u32 total; ++ u32 uCharsInRMSWord; ++ s32 taskArgsOffset; ++ s32 sioInDefOffset; ++ s32 sioOutDefOffset; ++ s32 sioDefsOffset; ++ s32 argsOffset = -1; ++ s32 offset; ++ struct NODE_STRMDEF strmDef; ++ u32 max; ++ DSP_STATUS status = DSP_SOK; ++ struct DSP_NODEINFO nodeInfo; ++ u32 devType; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++ DBC_Require(hNode != NULL); ++ DBC_Require(NODE_GetType(hNode) != NODE_DEVICE); ++ DBC_Require(pNodeEnv != NULL); ++ ++ GT_6trace(DISP_DebugMask, GT_ENTER, ++ "DISP_NodeCreate: hDisp: 0x%x\thNode:" ++ " 0x%x\tulRMSFxn: 0x%x\tulCreateFxn: 0x%x\tpArgs: 0x%x\tpNodeEnv:" ++ " 0x%x\n", hDisp, hNode, ulRMSFxn, ulCreateFxn, pArgs, pNodeEnv); ++ ++ status = DEV_GetDevType(hDisp->hDevObject, &devType); ++ ++ GT_1trace(DISP_DebugMask, GT_6CLASS, "DISP_Create: Creating DISP " ++ "for device = 0x%x\n", devType); ++ ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ if (devType != DSP_UNIT) { ++ GT_1trace(DISP_DebugMask, GT_7CLASS, ++ "DISP_NodeCreate unknown device " ++ "type = 0x%x\n", devType); ++ goto func_end; ++ } ++ DBC_Require(pArgs != NULL); ++ nodeType = NODE_GetType(hNode); ++ msgArgs = pArgs->asa.msgArgs; ++ max = hDisp->ulBufsizeRMS; /*Max # of RMS words that can be sent */ ++ DBC_Assert(max == RMS_COMMANDBUFSIZE); ++ uCharsInRMSWord = sizeof(RMS_WORD) / hDisp->uCharSize; ++ /* Number of RMS words needed to hold arg data */ ++ dwLength = (msgArgs.uArgLength + uCharsInRMSWord - 1) / uCharsInRMSWord; ++ /* Make sure msg args and command fit in buffer */ ++ total = sizeof(struct RMS_Command) / sizeof(RMS_WORD) + ++ sizeof(struct RMS_MsgArgs) ++ / sizeof(RMS_WORD) - 1 + dwLength; ++ if (total >= max) { ++ status = DSP_EFAIL; ++ GT_2trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeCreate: Message args too" ++ " large for buffer! Message args size = %d, max = %d\n", ++ total, max); ++ } ++ /* ++ * Fill in buffer to send to RMS. ++ * The buffer will have the following format: ++ * ++ * RMS command: ++ * Address of RMS_CreateNode() ++ * Address of node's create function ++ * dummy argument ++ * node type ++ * ++ * Message Args: ++ * max number of messages ++ * segid for message buffer allocation ++ * notification type to use when message is received ++ * length of message arg data ++ * message args data ++ * ++ * Task Args (if task or socket node): ++ * priority ++ * stack size ++ * system stack size ++ * stack segment ++ * misc ++ * number of input streams ++ * pSTRMInDef[] - offsets of STRM definitions for input streams ++ * number of output streams ++ * pSTRMOutDef[] - offsets of STRM definitions for output ++ * streams ++ * STRMInDef[] - array of STRM definitions for input streams ++ * STRMOutDef[] - array of STRM definitions for output streams ++ * ++ * Socket Args (if DAIS socket node): ++ * ++ */ ++ if (DSP_SUCCEEDED(status)) { ++ total = 0; /* Total number of words in buffer so far */ ++ pdwBuf = (RMS_WORD *)hDisp->pBuf; ++ pCommand = (struct RMS_Command *)pdwBuf; ++ pCommand->fxn = (RMS_WORD)(ulRMSFxn); ++ pCommand->arg1 = (RMS_WORD)(ulCreateFxn); ++ if (NODE_GetLoadType(hNode) == NLDR_DYNAMICLOAD) { ++ /* Flush ICACHE on Load */ ++ pCommand->arg2 = 1; /* dummy argument */ ++ } else { ++ /* Do not flush ICACHE */ ++ pCommand->arg2 = 0; /* dummy argument */ ++ } ++ pCommand->data = NODE_GetType(hNode); ++ /* ++ * argsOffset is the offset of the data field in struct ++ * RMS_Command structure. We need this to calculate stream ++ * definition offsets. ++ */ ++ argsOffset = 3; ++ total += sizeof(struct RMS_Command) / sizeof(RMS_WORD); ++ /* Message args */ ++ pMsgArgs = (struct RMS_MsgArgs *) (pdwBuf + total); ++ pMsgArgs->maxMessages = msgArgs.uMaxMessages; ++ pMsgArgs->segid = msgArgs.uSegid; ++ pMsgArgs->notifyType = msgArgs.uNotifyType; ++ pMsgArgs->argLength = msgArgs.uArgLength; ++ total += sizeof(struct RMS_MsgArgs) / sizeof(RMS_WORD) - 1; ++ memcpy(pdwBuf + total, msgArgs.pData, msgArgs.uArgLength); ++ total += dwLength; ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* If node is a task node, copy task create arguments into buffer */ ++ if (nodeType == NODE_TASK || nodeType == NODE_DAISSOCKET) { ++ taskArgs = pArgs->asa.taskArgs; ++ taskArgsOffset = total; ++ total += sizeof(struct RMS_MoreTaskArgs) / sizeof(RMS_WORD) + ++ 1 + taskArgs.uNumInputs + taskArgs.uNumOutputs; ++ /* Copy task arguments */ ++ if (total < max) { ++ total = taskArgsOffset; ++ pMoreTaskArgs = (struct RMS_MoreTaskArgs *)(pdwBuf + ++ total); ++ /* ++ * Get some important info about the node. Note that we ++ * don't just reach into the hNode struct because ++ * that would break the node object's abstraction. ++ */ ++ GetNodeInfo(hNode, &nodeInfo); ++ GT_2trace(DISP_DebugMask, GT_ENTER, ++ "uExecutionPriority %x, nPriority %x\n", ++ nodeInfo.uExecutionPriority, ++ taskArgs.nPriority); ++ pMoreTaskArgs->priority = nodeInfo.uExecutionPriority; ++ pMoreTaskArgs->stackSize = taskArgs.uStackSize; ++ pMoreTaskArgs->sysstackSize = taskArgs.uSysStackSize; ++ pMoreTaskArgs->stackSeg = taskArgs.uStackSeg; ++ pMoreTaskArgs->heapAddr = taskArgs.uDSPHeapAddr; ++ pMoreTaskArgs->heapSize = taskArgs.uHeapSize; ++ pMoreTaskArgs->misc = taskArgs.ulDaisArg; ++ pMoreTaskArgs->numInputStreams = taskArgs.uNumInputs; ++ total += ++ sizeof(struct RMS_MoreTaskArgs) / sizeof(RMS_WORD); ++ GT_2trace(DISP_DebugMask, GT_7CLASS, ++ "DISP::::uDSPHeapAddr %x, " ++ "uHeapSize %x\n", taskArgs.uDSPHeapAddr, ++ taskArgs.uHeapSize); ++ /* Keep track of pSIOInDef[] and pSIOOutDef[] ++ * positions in the buffer, since this needs to be ++ * filled in later. */ ++ sioInDefOffset = total; ++ total += taskArgs.uNumInputs; ++ pdwBuf[total++] = taskArgs.uNumOutputs; ++ sioOutDefOffset = total; ++ total += taskArgs.uNumOutputs; ++ sioDefsOffset = total; ++ /* Fill SIO defs and offsets */ ++ offset = sioDefsOffset; ++ for (i = 0; i < taskArgs.uNumInputs; i++) { ++ if (DSP_FAILED(status)) ++ break; ++ ++ pdwBuf[sioInDefOffset + i] = ++ (offset - argsOffset) ++ * (sizeof(RMS_WORD) / DSPWORDSIZE); ++ strmDef = taskArgs.strmInDef[i]; ++ status = FillStreamDef(pdwBuf, &total, offset, ++ strmDef, max, uCharsInRMSWord); ++ offset = total; ++ } ++ for (i = 0; (i < taskArgs.uNumOutputs) && ++ (DSP_SUCCEEDED(status)); i++) { ++ pdwBuf[sioOutDefOffset + i] = ++ (offset - argsOffset) ++ * (sizeof(RMS_WORD) / DSPWORDSIZE); ++ strmDef = taskArgs.strmOutDef[i]; ++ status = FillStreamDef(pdwBuf, &total, offset, ++ strmDef, max, uCharsInRMSWord); ++ offset = total; ++ } ++ if (DSP_FAILED(status)) { ++ GT_2trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeCreate: Message" ++ " args to large for buffer! Message args" ++ " size = %d, max = %d\n", total, max); ++ } ++ } else { ++ /* Args won't fit */ ++ status = DSP_EFAIL; ++ GT_2trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeCreate: Message args " ++ " too large for buffer! Message args size = %d" ++ ", max = %d\n", total, max); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ ulBytes = total * sizeof(RMS_WORD); ++ DBC_Assert(ulBytes < (RMS_COMMANDBUFSIZE * sizeof(RMS_WORD))); ++ status = SendMessage(hDisp, NODE_GetTimeout(hNode), ++ ulBytes, pNodeEnv); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeCreate failed! " ++ "status = 0x%x\n", status); ++ } else { ++ /* ++ * Message successfully received from RMS. ++ * Return the status of the Node's create function ++ * on the DSP-side ++ */ ++ status = (((RMS_WORD *)(hDisp->pBuf))[0]); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeCreate, " ++ "DSP-side Node Create failed: 0x%x\n", ++ status); ++ } ++ ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== DISP_NodeDelete ======== ++ * purpose: ++ * Delete a node on the DSP by remotely calling the node's delete function. ++ * ++ */ ++DSP_STATUS DISP_NodeDelete(struct DISP_OBJECT *hDisp, struct NODE_OBJECT *hNode, ++ u32 ulRMSFxn, u32 ulDeleteFxn, NODE_ENV nodeEnv) ++{ ++ u32 dwArg; ++ struct RMS_Command *pCommand; ++ DSP_STATUS status = DSP_SOK; ++ u32 devType; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++ DBC_Require(hNode != NULL); ++ ++ GT_5trace(DISP_DebugMask, GT_ENTER, ++ "DISP_NodeDelete: hDisp: 0x%xthNode: " ++ "0x%x\tulRMSFxn: 0x%x\tulDeleteFxn: 0x%x\tnodeEnv: 0x%x\n", ++ hDisp, hNode, ulRMSFxn, ulDeleteFxn, nodeEnv); ++ ++ status = DEV_GetDevType(hDisp->hDevObject, &devType); ++ ++ if (DSP_SUCCEEDED(status)) { ++ ++ if (devType == DSP_UNIT) { ++ ++ /* ++ * Fill in buffer to send to RMS ++ */ ++ pCommand = (struct RMS_Command *)hDisp->pBuf; ++ pCommand->fxn = (RMS_WORD)(ulRMSFxn); ++ pCommand->arg1 = (RMS_WORD)nodeEnv; ++ pCommand->arg2 = (RMS_WORD)(ulDeleteFxn); ++ pCommand->data = NODE_GetType(hNode); ++ ++ status = SendMessage(hDisp, NODE_GetTimeout(hNode), ++ sizeof(struct RMS_Command), &dwArg); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeDelete failed!" ++ "status = 0x%x\n", status); ++ } else { ++ /* ++ * Message successfully received from RMS. ++ * Return the status of the Node's delete ++ * function on the DSP-side ++ */ ++ status = (((RMS_WORD *)(hDisp->pBuf))[0]); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeDelete, " ++ "DSP-side Node Delete failed: 0x%x\n", ++ status); ++ } ++ } ++ ++ ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== DISP_NodeRun ======== ++ * purpose: ++ * Start execution of a node's execute phase, or resume execution of a node ++ * that has been suspended (via DISP_NodePause()) on the DSP. ++ */ ++DSP_STATUS DISP_NodeRun(struct DISP_OBJECT *hDisp, struct NODE_OBJECT *hNode, ++ u32 ulRMSFxn, u32 ulExecuteFxn, NODE_ENV nodeEnv) ++{ ++ u32 dwArg; ++ struct RMS_Command *pCommand; ++ DSP_STATUS status = DSP_SOK; ++ u32 devType; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hDisp, DISP_SIGNATURE)); ++ DBC_Require(hNode != NULL); ++ ++ GT_5trace(DISP_DebugMask, GT_ENTER, "DISP_NodeRun: hDisp: 0x%xthNode: \ ++ 0x%x\tulRMSFxn: 0x%x\tulExecuteFxn: 0x%x\tnodeEnv: 0x%x\n", \ ++ hDisp, hNode, ulRMSFxn, ulExecuteFxn, nodeEnv); ++ ++ status = DEV_GetDevType(hDisp->hDevObject, &devType); ++ ++ if (DSP_SUCCEEDED(status)) { ++ ++ if (devType == DSP_UNIT) { ++ ++ /* ++ * Fill in buffer to send to RMS. ++ */ ++ pCommand = (struct RMS_Command *) hDisp->pBuf; ++ pCommand->fxn = (RMS_WORD) (ulRMSFxn); ++ pCommand->arg1 = (RMS_WORD) nodeEnv; ++ pCommand->arg2 = (RMS_WORD) (ulExecuteFxn); ++ pCommand->data = NODE_GetType(hNode); ++ ++ status = SendMessage(hDisp, NODE_GetTimeout(hNode), ++ sizeof(struct RMS_Command), &dwArg); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeRun failed!" ++ "status = 0x%x\n", status); ++ } else { ++ /* ++ * Message successfully received from RMS. ++ * Return the status of the Node's execute ++ * function on the DSP-side ++ */ ++ status = (((RMS_WORD *)(hDisp->pBuf))[0]); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_NodeRun, DSP-side Node " ++ "Execute failed: 0x%x\n", ++ status); ++ } ++ } ++ ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DeleteDisp ======== ++ * purpose: ++ * Frees the resources allocated for the dispatcher. ++ */ ++static void DeleteDisp(struct DISP_OBJECT *hDisp) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ ++ if (MEM_IsValidHandle(hDisp, DISP_SIGNATURE)) { ++ pIntfFxns = hDisp->pIntfFxns; ++ ++ /* Free Node Dispatcher resources */ ++ if (hDisp->hChnlFromDsp) { ++ /* Channel close can fail only if the channel handle ++ * is invalid. */ ++ status = (*pIntfFxns->pfnChnlClose) ++ (hDisp->hChnlFromDsp); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Delete: Failed to " ++ "close channel from RMS: 0x%x\n", ++ status); ++ } ++ } ++ if (hDisp->hChnlToDsp) { ++ status = (*pIntfFxns->pfnChnlClose)(hDisp->hChnlToDsp); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "DISP_Delete: Failed to " ++ "close channel to RMS: 0x%x\n", ++ status); ++ } ++ } ++ if (hDisp->pBuf) ++ MEM_Free(hDisp->pBuf); ++ ++ MEM_FreeObject(hDisp); ++ } ++} ++ ++/* ++ * ======== FillStreamDef ======== ++ * purpose: ++ * Fills stream definitions. ++ */ ++static DSP_STATUS FillStreamDef(RMS_WORD *pdwBuf, u32 *ptotal, u32 offset, ++ struct NODE_STRMDEF strmDef, u32 max, ++ u32 uCharsInRMSWord) ++{ ++ struct RMS_StrmDef *pStrmDef; ++ u32 total = *ptotal; ++ u32 uNameLen; ++ u32 dwLength; ++ DSP_STATUS status = DSP_SOK; ++ ++ if (total + sizeof(struct RMS_StrmDef) / sizeof(RMS_WORD) >= max) { ++ status = DSP_EFAIL; ++ } else { ++ pStrmDef = (struct RMS_StrmDef *)(pdwBuf + total); ++ pStrmDef->bufsize = strmDef.uBufsize; ++ pStrmDef->nbufs = strmDef.uNumBufs; ++ pStrmDef->segid = strmDef.uSegid; ++ pStrmDef->align = strmDef.uAlignment; ++ pStrmDef->timeout = strmDef.uTimeout; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* ++ * Since we haven't added the device name yet, subtract ++ * 1 from total. ++ */ ++ total += sizeof(struct RMS_StrmDef) / sizeof(RMS_WORD) - 1; ++ DBC_Require(strmDef.szDevice); ++ dwLength = strlen(strmDef.szDevice) + 1; ++ ++ /* Number of RMS_WORDS needed to hold device name */ ++ uNameLen = (dwLength + uCharsInRMSWord - 1) / uCharsInRMSWord; ++ ++ if (total + uNameLen >= max) { ++ status = DSP_EFAIL; ++ } else { ++ /* ++ * Zero out last word, since the device name may not ++ * extend to completely fill this word. ++ */ ++ pdwBuf[total + uNameLen - 1] = 0; ++ /** TODO USE SERVICES **/ ++ memcpy(pdwBuf + total, strmDef.szDevice, dwLength); ++ total += uNameLen; ++ *ptotal = total; ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== SendMessage ====== ++ * Send command message to RMS, get reply from RMS. ++ */ ++static DSP_STATUS SendMessage(struct DISP_OBJECT *hDisp, u32 dwTimeout, ++ u32 ulBytes, u32 *pdwArg) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct CHNL_OBJECT *hChnl; ++ u32 dwArg = 0; ++ u8 *pBuf; ++ struct CHNL_IOC chnlIOC; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(pdwArg != NULL); ++ ++ *pdwArg = (u32) NULL; ++ pIntfFxns = hDisp->pIntfFxns; ++ hChnl = hDisp->hChnlToDsp; ++ pBuf = hDisp->pBuf; ++ ++ /* Send the command */ ++ status = (*pIntfFxns->pfnChnlAddIOReq) (hChnl, pBuf, ulBytes, 0, ++ 0L, dwArg); ++ ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage: Channel AddIOReq to" ++ " RMS failed! Status = 0x%x\n", status); ++ goto func_cont; ++ } ++ status = (*pIntfFxns->pfnChnlGetIOC) (hChnl, dwTimeout, &chnlIOC); ++ if (DSP_SUCCEEDED(status)) { ++ if (!CHNL_IsIOComplete(chnlIOC)) { ++ if (CHNL_IsTimedOut(chnlIOC)) { ++ status = DSP_ETIMEOUT; ++ } else { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage failed! " ++ "Channel IOC status = 0x%x\n", ++ chnlIOC.status); ++ status = DSP_EFAIL; ++ } ++ } ++ } else { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage: Channel GetIOC to" ++ " RMS failed! Status = 0x%x\n", status); ++ } ++func_cont: ++ /* Get the reply */ ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ hChnl = hDisp->hChnlFromDsp; ++ ulBytes = REPLYSIZE; ++ status = (*pIntfFxns->pfnChnlAddIOReq)(hChnl, pBuf, ulBytes, ++ 0, 0L, dwArg); ++ if (DSP_FAILED(status)) { ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage: Channel AddIOReq " ++ "from RMS failed! Status = 0x%x\n", status); ++ goto func_end; ++ } ++ status = (*pIntfFxns->pfnChnlGetIOC) (hChnl, dwTimeout, &chnlIOC); ++ if (DSP_SUCCEEDED(status)) { ++ if (CHNL_IsTimedOut(chnlIOC)) { ++ status = DSP_ETIMEOUT; ++ } else if (chnlIOC.cBytes < ulBytes) { ++ /* Did not get all of the reply from the RMS */ ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage: Did not get all" ++ "of reply from RMS! Bytes received: %d\n", ++ chnlIOC.cBytes); ++ status = DSP_EFAIL; ++ } else { ++ if (CHNL_IsIOComplete(chnlIOC)) { ++ DBC_Assert(chnlIOC.pBuf == pBuf); ++ status = (*((RMS_WORD *)chnlIOC.pBuf)); ++ *pdwArg = (((RMS_WORD *)(chnlIOC.pBuf))[1]); ++ } else { ++ status = DSP_EFAIL; ++ } ++ } ++ } else { ++ /* GetIOC failed */ ++ GT_1trace(DISP_DebugMask, GT_6CLASS, ++ "SendMessage: Failed to get " ++ "reply from RMS! Status = 0x%x\n", status); ++ } ++func_end: ++ return status; ++} +diff --git a/drivers/dsp/bridge/rmgr/drv.c b/drivers/dsp/bridge/rmgr/drv.c +new file mode 100644 +index 0000000..256ce12 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/drv.c +@@ -0,0 +1,1893 @@ ++/* ++ * drv.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== drv.c ======== ++ * Description: ++ * DSP/BIOS Bridge resource allocation module. ++ * ++ * Public Functions: ++ * DRV_Create ++ * DRV_Destroy ++ * DRV_Exit ++ * DRV_GetDevObject ++ * DRV_GetDevExtension ++ * DRV_GetFirstDevObject ++ * DRV_GetNextDevObject ++ * DRV_GetNextDevExtension ++ * DRV_Init ++ * DRV_InsertDevObject ++ * DRV_RemoveDevObject ++ * DRV_RequestResources ++ * DRV_ReleaseResources ++ * ++ *! Revision History ++ *! ======== ======== ++ *! 19-Apr-2004 sb: Replaced OS specific APIs with MEM_AllocPhysMem and ++ MEM_FreePhysMem. Fixed warnings. Cosmetic updates. ++ *! 12-Apr-2004 hp: IVA clean up during bridge-uninstall ++ *! 05-Jan-2004 vp: Updated for 24xx platform ++ *! 21-Mar-2003 sb: Get SHM size from registry ++ *! 10-Feb-2003 vp: Code review updates ++ *! 18-Oct-2002 vp: Ported to Linux platform ++ *! 30-Oct-2000 kc: Modified usage of REG_SetValue. ++ *! 06-Sep-2000 jeh Read channel info into struct CFG_HOSTRES in ++ *! RequestISAResources() ++ *! 21-Sep-2000 rr: numwindows is calculated instead of default value in ++ *! RequestISAResources. ++ *! 07-Aug-2000 rr: static list of dev objects removed. ++ *! 27-Jul-2000 rr: RequestResources split into two(Request and Release) ++ *! Device extension created to hold the DevNodeString. ++ *! 17-Jul-2000 rr: Driver Object holds the list of Device Objects. ++ *! Added DRV_Create, DRV_Destroy, DRV_GetDevObject, ++ *! DRV_GetFirst/NextDevObject, DRV_Insert/RemoveDevObject. ++ *! 09-May-2000 rr: PCI Support is not L301 specific.Use of MEM_Calloc ++ *! instead of MEM_Alloc. ++ *! 28-Mar-2000 rr: PCI Support added. L301 Specific. TBD. ++ *! 03-Feb-2000 rr: GT and Module Init/exit Changes. Merged with kc. ++ *! 19-Jan-2000 rr: DBC_Ensure in RequestPCMCIA moved within PCCARD ifdef ++ *! 29-Dec-1999 rr: PCCard support for any slot.Bus type stored in the ++ *! struct CFG_HOSTRES Structure. ++ *! 17-Dec-1999 rr: if PCCARD_Init fails we return DSP_EFAIL. ++ *! DBC_Ensure checks for sucess and pDevice != NULL ++ *! 11-Dec-1999 ag: #define "Isa" renamed to "IsaBus". ++ *! 09-Dec-1999 rr: windows.h included to remove warnings. ++ *! 02-Dec-1999 rr: struct GT_Mask is with in if DEBUG. Request resources checks ++ *! status while making call to Reg functions. ++ *! 23-Nov-1999 rr: windows.h included ++ *! 19-Nov-1999 rr: DRV_RELEASE bug while setting the registry to zero. ++ *! fixed. ++ *! 12-Nov-1999 rr: RequestResources() reads values from the registry. ++ *! Hardcoded bIRQRegister define removed. ++ *! 05-Nov-1999 rr: Added hardcoded device interrupt. ++ *! 25-Oct-1999 rr: Resource structure removed. Now it uses the Host ++ *! Resource structure directly. ++ *! 15-Oct-1999 rr: Resource Structure modified. See drv.h ++ *! dwBusType taken from the registry.Hard coded ++ *! registry entries removed. ++ *! 05-Oct-1999 rr: Calling DEV_StartDevice moved to wcdce.c. DRV_Register ++ *! MiniDriver has been renamed to DRV_RequestResources. ++ *! DRV_UnRegisterMiniDriver fxn removed. ++ *! 24-Sep-1999 rr: Significant changes to the RegisterMiniDriver fxns. ++ *! Now it is simpler. IT stores the dev node in the ++ *! registry, assign resources and calls the DEV_Start. ++ *! 10-Sep-1999 rr: Register Minidriver modified. ++ *! - Resource structure follows the NT model ++ *! 08-Aug-1999 rr: Adopted for WinCE. Exports Fxns removed. Hull Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/reg.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/drv.h> ++#include <dspbridge/dev.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/node.h> ++#include <dspbridge/proc.h> ++#include <dspbridge/strm.h> ++#include <dspbridge/nodepriv.h> ++#include <dspbridge/wmdchnl.h> ++#include <dspbridge/resourcecleanup.h> ++#endif ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define SIGNATURE 0x5f52474d /* "DRV_" (in reverse) */ ++ ++struct DRV_OBJECT { ++ u32 dwSignature; ++ struct LST_LIST *devList; ++ struct LST_LIST *devNodeString; ++#ifndef RES_CLEANUP_DISABLE ++ struct PROCESS_CONTEXT *procCtxtList; ++#endif ++}; ++ ++/* ++ * This is the Device Extension. Named with the Prefix ++ * DRV_ since it is living in this module ++ */ ++struct DRV_EXT { ++ struct LST_ELEM link; ++ char szString[MAXREGPATHLENGTH]; ++}; ++ ++/* ----------------------------------- Globals */ ++static s32 cRefs; ++ ++#if GT_TRACE ++extern struct GT_Mask curTrace; ++#endif ++ ++/* ----------------------------------- Function Prototypes */ ++static DSP_STATUS RequestBridgeResources(u32 dwContext, s32 fRequest); ++static DSP_STATUS RequestBridgeResourcesDSP(u32 dwContext, s32 fRequest); ++ ++#ifndef RES_CLEANUP_DISABLE ++/* GPP PROCESS CLEANUP CODE */ ++ ++static DSP_STATUS PrintProcessInformation(void); ++static DSP_STATUS DRV_ProcFreeNodeRes(HANDLE hPCtxt); ++static DSP_STATUS DRV_ProcFreeSTRMRes(HANDLE hPCtxt); ++extern enum NODE_STATE NODE_GetState(HANDLE hNode); ++ ++/* Get the process context list from driver object */ ++ ++/* Set the Process ID */ ++DSP_STATUS DRV_ProcSetPID(HANDLE hPCtxt, s32 hProcess) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Assert(hPCtxt != NULL); ++ ++ pCtxt->pid = hProcess; ++ return status; ++} ++ ++ ++/* Getting the head of the process context list */ ++DSP_STATUS DRV_GetProcCtxtList(struct PROCESS_CONTEXT **pPctxt, ++ struct DRV_OBJECT *hDrvObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject; ++ ++ DBC_Assert(hDrvObject != NULL); ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_GetProcCtxtList: 2 *pPctxt:%x, pDrvObject" ++ ":%x", *pPctxt, pDrvObject); ++ *pPctxt = pDrvObject->procCtxtList; ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_GetProcCtxtList: 3 *pPctxt:%x, pDrvObject" ++ ":%x", *pPctxt, pDrvObject); ++ return status; ++} ++ ++ ++ ++/* Get a particular process context based on process handle (phProcess) */ ++DSP_STATUS DRV_GetProcContext(u32 phProcess, ++ struct DRV_OBJECT *hDrvObject, ++ HANDLE hPCtxt, DSP_HNODE hNode, ++ u32 pMapAddr) ++{ ++ struct PROCESS_CONTEXT **pCtxt = (struct PROCESS_CONTEXT **)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct PROCESS_CONTEXT *pCtxtList = NULL; ++ struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject; ++ struct NODE_RES_OBJECT *pTempNode2 = NULL; ++ struct NODE_RES_OBJECT *pTempNode = NULL; ++ struct DMM_RES_OBJECT *pTempDMM2 = NULL; ++ struct DMM_RES_OBJECT *pTempDMM = NULL; ++ s32 pCtxtFound = 0; ++ ++ DBC_Assert(pDrvObject != NULL); ++ pCtxtList = pDrvObject->procCtxtList; ++ GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 2"); ++ while ((pCtxtList != NULL) && (pCtxtList->pid != phProcess)) { ++ pCtxtList = pCtxtList->next; ++ GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 3"); ++ } ++ if (pCtxtList == NULL) { ++ if (hNode != NULL) { ++ pCtxtList = pDrvObject->procCtxtList; ++ while ((pCtxtList != NULL) && (pCtxtFound == 0)) { ++ pTempNode = pCtxtList->pNodeList; ++ while ((pTempNode != NULL) && ++ (pTempNode->hNode != hNode)) { ++ pTempNode2 = pTempNode; ++ pTempNode = pTempNode->next; ++ } ++ if (pTempNode != NULL) { ++ pCtxtFound = 1; ++ status = DSP_SOK; ++ } else { ++ pCtxtList = pCtxtList->next; ++ } ++ } ++ } else if ((pMapAddr != 0) && (pCtxtFound == 0)) { ++ pCtxtList = pDrvObject->procCtxtList; ++ while ((pCtxtList != NULL) && (pCtxtFound == 0)) { ++ pTempDMM = pCtxtList->pDMMList; ++ while ((pTempDMM != NULL) && ++ (pTempDMM->ulDSPAddr != pMapAddr)) { ++ pTempDMM2 = pTempDMM; ++ pTempDMM = pTempDMM->next; ++ } ++ if (pTempDMM != NULL) { ++ pCtxtFound = 1; ++ status = DSP_SOK; ++ } else { ++ pCtxtList = pCtxtList->next; ++ } ++ } ++ if (pCtxtList == NULL) ++ status = DSP_ENOTFOUND; ++ ++ } ++ } else{ ++ status = DSP_SOK; ++ } ++ GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 4"); ++ *pCtxt = pCtxtList; ++ return status; ++} ++ ++ ++/* Add a new process context to process context list */ ++DSP_STATUS DRV_InsertProcContext(struct DRV_OBJECT *hDrVObject, HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT **pCtxt = (struct PROCESS_CONTEXT **)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct PROCESS_CONTEXT *pCtxtList = NULL; ++ struct DRV_OBJECT *hDRVObject; ++ ++ GT_0trace(curTrace, GT_ENTER, "\n In DRV_InsertProcContext\n"); ++ status = CFG_GetObject((u32 *)&hDRVObject, REG_DRV_OBJECT); ++ DBC_Assert(hDRVObject != NULL); ++ *pCtxt = MEM_Calloc(1 * sizeof(struct PROCESS_CONTEXT), MEM_PAGED); ++ GT_0trace(curTrace, GT_ENTER, ++ "\n In DRV_InsertProcContext Calling " ++ "DRV_GetProcCtxtList\n"); ++ DRV_GetProcCtxtList(&pCtxtList, hDRVObject); ++ GT_0trace(curTrace, GT_ENTER, ++ "\n In DRV_InsertProcContext After Calling " ++ "DRV_GetProcCtxtList\n"); ++ if (pCtxtList != NULL) { ++ GT_0trace(curTrace, GT_ENTER, ++ "\n In DRV_InsertProcContext and pCtxt is " ++ "not Null\n"); ++ while (pCtxtList->next != NULL) ++ pCtxtList = pCtxtList->next; ++ ++ pCtxtList->next = *pCtxt; ++ } else { ++ GT_0trace(curTrace, GT_ENTER, ++ "\n In DRV_InsertProcContext and " ++ "pCtxt is Null\n"); ++ hDRVObject->procCtxtList = *pCtxt; ++ } ++ return status; ++} ++ ++/* Delete a process context from process resource context list */ ++DSP_STATUS DRV_RemoveProcContext(struct DRV_OBJECT *hDRVObject, ++ HANDLE hPCtxt, HANDLE hProcess) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROCESS_CONTEXT *pCtxt2 = NULL; ++ struct PROCESS_CONTEXT *pTmp = NULL; ++ struct PROCESS_CONTEXT *pCtxtList = NULL; ++ ++ DBC_Assert(hDRVObject != NULL); ++ DRV_GetProcContext((u32)hProcess, hDRVObject, &pCtxt2, NULL, 0); ++ ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 12"); ++ DRV_GetProcCtxtList(&pCtxtList, hDRVObject); ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 13"); ++ pTmp = pCtxtList; ++ while ((pCtxtList != NULL) && (pCtxtList != pCtxt2)) { ++ pTmp = pCtxtList; ++ pCtxtList = pCtxtList->next; ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_RemoveProcContext: 2"); ++ } ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 3"); ++ if (hDRVObject->procCtxtList == pCtxt2) ++ hDRVObject->procCtxtList = pCtxt2->next; ++ ++ if (pCtxtList == NULL) ++ return DSP_ENOTFOUND; ++ else if (pTmp->next != NULL) ++ pTmp->next = pTmp->next->next; ++ ++ MEM_Free(pCtxt2); ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 7"); ++ ++ return status; ++} ++ ++/* Update the state of process context */ ++DSP_STATUS DRV_ProcUpdatestate(HANDLE hPCtxt, enum GPP_PROC_RES_STATE status) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status1 = DSP_SOK; ++ if (pCtxt != NULL) { ++ pCtxt->resState = status; ++ } else { ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_ProcUpdatestate: Failed to update " ++ "process state"); ++ } ++ return status1; ++} ++ ++/* Allocate and add a node resource element ++* This function is called from .Node_Allocate. */ ++DSP_STATUS DRV_InsertNodeResElement(HANDLE hNode, HANDLE hNodeRes, ++ HANDLE hPCtxt) ++{ ++ struct NODE_RES_OBJECT **pNodeRes = (struct NODE_RES_OBJECT **)hNodeRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_RES_OBJECT *pTempNodeRes = NULL; ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 1"); ++ *pNodeRes = (struct NODE_RES_OBJECT *)MEM_Calloc ++ (1 * sizeof(struct NODE_RES_OBJECT), MEM_PAGED); ++ DBC_Assert(hPCtxt != NULL); ++ if ((*pNodeRes == NULL) || (hPCtxt == NULL)) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 12"); ++ status = DSP_EHANDLE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ (*pNodeRes)->hNode = hNode; ++ if (pCtxt->pNodeList != NULL) { ++ pTempNodeRes = pCtxt->pNodeList; ++ while (pTempNodeRes->next != NULL) ++ pTempNodeRes = pTempNodeRes->next; ++ ++ pTempNodeRes->next = *pNodeRes; ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_InsertNodeResElement: 2"); ++ } else { ++ pCtxt->pNodeList = *pNodeRes; ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_InsertNodeResElement: 3"); ++ } ++ } ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 4"); ++ return status; ++} ++ ++/* Release all Node resources and its context ++* This is called from .Node_Delete. */ ++DSP_STATUS DRV_RemoveNodeResElement(HANDLE hNodeRes, HANDLE hPCtxt) ++{ ++ struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_RES_OBJECT *pTempNode2 = pCtxt->pNodeList; ++ struct NODE_RES_OBJECT *pTempNode = pCtxt->pNodeList; ++ ++ DBC_Assert(hPCtxt != NULL); ++ GT_0trace(curTrace, GT_ENTER, "\nDRV_RemoveNodeResElement: 1\n"); ++ while ((pTempNode != NULL) && (pTempNode != pNodeRes)) { ++ pTempNode2 = pTempNode; ++ pTempNode = pTempNode->next; ++ } ++ if (pCtxt->pNodeList == pNodeRes) ++ pCtxt->pNodeList = pNodeRes->next; ++ ++ if (pTempNode == NULL) ++ return DSP_ENOTFOUND; ++ else if (pTempNode2->next != NULL) ++ pTempNode2->next = pTempNode2->next->next; ++ ++ MEM_Free(pTempNode); ++ return status; ++} ++ ++/* Actual Node De-Allocation */ ++static DSP_STATUS DRV_ProcFreeNodeRes(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_RES_OBJECT *pNodeList = NULL; ++ struct NODE_RES_OBJECT *pNodeRes = NULL; ++ u32 nState; ++ ++ DBC_Assert(hPCtxt != NULL); ++ pNodeList = pCtxt->pNodeList; ++ while (pNodeList != NULL) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_ProcFreeNodeRes: 1"); ++ pNodeRes = pNodeList; ++ pNodeList = pNodeList->next; ++ if (pNodeRes->nodeAllocated) { ++ nState = NODE_GetState(pNodeRes->hNode) ; ++ GT_1trace(curTrace, GT_5CLASS, ++ "DRV_ProcFreeNodeRes: Node state %x\n", nState); ++ if (nState <= NODE_DELETING) { ++ if ((nState == NODE_RUNNING) || ++ (nState == NODE_PAUSED) || ++ (nState == NODE_TERMINATING)) { ++ GT_1trace(curTrace, GT_5CLASS, ++ "Calling Node_Terminate for Node:" ++ " 0x%x\n", pNodeRes->hNode); ++ status = NODE_Terminate ++ (pNodeRes->hNode, &status); ++ GT_1trace(curTrace, GT_5CLASS, ++ "Calling Node_Delete for Node:" ++ " 0x%x\n", pNodeRes->hNode); ++ status = NODE_Delete(pNodeRes->hNode); ++ GT_1trace(curTrace, GT_5CLASS, ++ "the status after the NodeDelete %x\n", ++ status); ++ } else if ((nState == NODE_ALLOCATED) ++ || (nState == NODE_CREATED)) ++ status = NODE_Delete(pNodeRes->hNode); ++ } ++ } ++ pNodeRes->nodeAllocated = 0; ++ } ++ return status; ++} ++ ++/* Allocate the DMM resource element ++* This is called from Proc_Map. after the actual resource is allocated */ ++DSP_STATUS DRV_InsertDMMResElement(HANDLE hDMMRes, HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ struct DMM_RES_OBJECT **pDMMRes = (struct DMM_RES_OBJECT **)hDMMRes; ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_RES_OBJECT *pTempDMMRes = NULL; ++ ++ *pDMMRes = (struct DMM_RES_OBJECT *) ++ MEM_Calloc(1 * sizeof(struct DMM_RES_OBJECT), MEM_PAGED); ++ DBC_Assert(hPCtxt != NULL); ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertDMMResElement: 1"); ++ if ((*pDMMRes == NULL) || (hPCtxt == NULL)) { ++ GT_0trace(curTrace, GT_5CLASS, "DRV_InsertDMMResElement: 2"); ++ status = DSP_EHANDLE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ if (pCtxt->pDMMList != NULL) { ++ GT_0trace(curTrace, GT_5CLASS, ++ "DRV_InsertDMMResElement: 3"); ++ pTempDMMRes = pCtxt->pDMMList; ++ while (pTempDMMRes->next != NULL) ++ pTempDMMRes = pTempDMMRes->next; ++ ++ pTempDMMRes->next = *pDMMRes; ++ } else { ++ pCtxt->pDMMList = *pDMMRes; ++ GT_0trace(curTrace, GT_5CLASS, ++ "DRV_InsertDMMResElement: 4"); ++ } ++ } ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertDMMResElement: 5"); ++ return status; ++} ++ ++ ++ ++/* Release DMM resource element context ++* This is called from Proc_UnMap. after the actual resource is freed */ ++DSP_STATUS DRV_RemoveDMMResElement(HANDLE hDMMRes, HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ struct DMM_RES_OBJECT *pDMMRes = (struct DMM_RES_OBJECT *)hDMMRes; ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_RES_OBJECT *pTempDMMRes2 = NULL; ++ struct DMM_RES_OBJECT *pTempDMMRes = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ pTempDMMRes2 = pCtxt->pDMMList; ++ pTempDMMRes = pCtxt->pDMMList; ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 1"); ++ while ((pTempDMMRes != NULL) && (pTempDMMRes != pDMMRes)) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 2"); ++ pTempDMMRes2 = pTempDMMRes; ++ pTempDMMRes = pTempDMMRes->next; ++ } ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 3"); ++ if (pCtxt->pDMMList == pTempDMMRes) ++ pCtxt->pDMMList = pTempDMMRes->next; ++ ++ if (pTempDMMRes == NULL) ++ return DSP_ENOTFOUND; ++ else if (pTempDMMRes2->next != NULL) ++ pTempDMMRes2->next = pTempDMMRes2->next->next; ++ ++ MEM_Free(pDMMRes); ++ GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 4"); ++ return status; ++} ++ ++/* Update DMM resource status */ ++DSP_STATUS DRV_UpdateDMMResElement(HANDLE hDMMRes, u32 pMpuAddr, u32 ulSize, ++ u32 pReqAddr, u32 pMapAddr, ++ HANDLE hProcessor) ++{ ++ struct DMM_RES_OBJECT *pDMMRes = (struct DMM_RES_OBJECT *)hDMMRes; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Assert(hDMMRes != NULL); ++ pDMMRes->ulMpuAddr = pMpuAddr; ++ pDMMRes->ulDSPAddr = pMapAddr; ++ pDMMRes->ulDSPResAddr = pReqAddr; ++ pDMMRes->dmmSize = ulSize; ++ pDMMRes->hProcessor = hProcessor; ++ pDMMRes->dmmAllocated = 1; ++ ++ return status; ++} ++ ++/* Actual DMM De-Allocation */ ++DSP_STATUS DRV_ProcFreeDMMRes(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_RES_OBJECT *pDMMList = pCtxt->pDMMList; ++ struct DMM_RES_OBJECT *pDMMRes = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ GT_0trace(curTrace, GT_ENTER, "\nDRV_ProcFreeDMMRes: 1\n"); ++ while (pDMMList != NULL) { ++ pDMMRes = pDMMList; ++ pDMMList = pDMMList->next; ++ if (pDMMRes->dmmAllocated) { ++ status = PROC_UnMap(pDMMRes->hProcessor, ++ (void *)pDMMRes->ulDSPResAddr); ++ status = PROC_UnReserveMemory(pDMMRes->hProcessor, ++ (void *)pDMMRes->ulDSPResAddr); ++ pDMMRes->dmmAllocated = 0; ++ } ++ } ++ return status; ++} ++ ++ ++/* Release all DMM resources and its context ++* This is called from .bridge_release. */ ++DSP_STATUS DRV_RemoveAllDMMResElements(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_RES_OBJECT *pTempDMMRes2 = NULL; ++ struct DMM_RES_OBJECT *pTempDMMRes = NULL; ++ ++ DBC_Assert(pCtxt != NULL); ++ DRV_ProcFreeDMMRes(pCtxt); ++ pTempDMMRes = pCtxt->pDMMList; ++ while (pTempDMMRes != NULL) { ++ pTempDMMRes2 = pTempDMMRes; ++ pTempDMMRes = pTempDMMRes->next; ++ MEM_Free(pTempDMMRes2); ++ } ++ pCtxt->pDMMList = NULL; ++ return status; ++} ++ ++DSP_STATUS DRV_GetDMMResElement(u32 pMapAddr, HANDLE hDMMRes, HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ struct DMM_RES_OBJECT **pDMMRes = (struct DMM_RES_OBJECT **)hDMMRes; ++ DSP_STATUS status = DSP_SOK; ++ struct DMM_RES_OBJECT *pTempDMM2 = NULL; ++ struct DMM_RES_OBJECT *pTempDMM = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ pTempDMM = pCtxt->pDMMList; ++ while ((pTempDMM != NULL) && (pTempDMM->ulDSPAddr != pMapAddr)) { ++ GT_3trace(curTrace, GT_ENTER, ++ "DRV_GetDMMResElement: 2 pTempDMM:%x " ++ "pTempDMM->ulDSPAddr:%x pMapAddr:%x\n", pTempDMM, ++ pTempDMM->ulDSPAddr, pMapAddr); ++ pTempDMM2 = pTempDMM; ++ pTempDMM = pTempDMM->next; ++ } ++ if (pTempDMM != NULL) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetDMMResElement: 3"); ++ *pDMMRes = pTempDMM; ++ } else { ++ status = DSP_ENOTFOUND; ++ } GT_0trace(curTrace, GT_ENTER, "DRV_GetDMMResElement: 4"); ++ return status; ++} ++ ++/* Update Node allocation status */ ++void DRV_ProcNodeUpdateStatus(HANDLE hNodeRes, s32 status) ++{ ++ struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes; ++ DBC_Assert(hNodeRes != NULL); ++ pNodeRes->nodeAllocated = status; ++} ++ ++/* Update Node Heap status */ ++void DRV_ProcNodeUpdateHeapStatus(HANDLE hNodeRes, s32 status) ++{ ++ struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes; ++ DBC_Assert(hNodeRes != NULL); ++ pNodeRes->heapAllocated = status; ++} ++ ++/* Release all Node resources and its context ++* This is called from .bridge_release. ++*/ ++DSP_STATUS DRV_RemoveAllNodeResElements(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_RES_OBJECT *pTempNode2 = NULL; ++ struct NODE_RES_OBJECT *pTempNode = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ DRV_ProcFreeNodeRes(pCtxt); ++ pTempNode = pCtxt->pNodeList; ++ while (pTempNode != NULL) { ++ pTempNode2 = pTempNode; ++ pTempNode = pTempNode->next; ++ MEM_Free(pTempNode2); ++ } ++ pCtxt->pNodeList = NULL; ++ return status; ++} ++ ++/* Getting the node resource element */ ++ ++DSP_STATUS DRV_GetNodeResElement(HANDLE hNode, HANDLE hNodeRes, HANDLE hPCtxt) ++{ ++ struct NODE_RES_OBJECT **nodeRes = (struct NODE_RES_OBJECT **)hNodeRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_RES_OBJECT *pTempNode2 = NULL; ++ struct NODE_RES_OBJECT *pTempNode = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ pTempNode = pCtxt->pNodeList; ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetNodeResElement: 1"); ++ while ((pTempNode != NULL) && (pTempNode->hNode != hNode)) { ++ pTempNode2 = pTempNode; ++ pTempNode = pTempNode->next; ++ } ++ if (pTempNode != NULL) ++ *nodeRes = pTempNode; ++ else ++ status = DSP_ENOTFOUND; ++ ++ return status; ++} ++ ++ ++ ++/* Allocate the STRM resource element ++* This is called after the actual resource is allocated ++*/ ++DSP_STATUS DRV_ProcInsertSTRMResElement(HANDLE hStreamHandle, HANDLE hSTRMRes, ++ HANDLE hPCtxt) ++{ ++ struct STRM_RES_OBJECT **pSTRMRes = (struct STRM_RES_OBJECT **)hSTRMRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_RES_OBJECT *pTempSTRMRes = NULL; ++ DBC_Assert(hPCtxt != NULL); ++ ++ *pSTRMRes = (struct STRM_RES_OBJECT *) ++ MEM_Calloc(1 * sizeof(struct STRM_RES_OBJECT), MEM_PAGED); ++ if ((*pSTRMRes == NULL) || (hPCtxt == NULL)) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_InsertSTRMResElement: 2"); ++ status = DSP_EHANDLE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ (*pSTRMRes)->hStream = hStreamHandle; ++ if (pCtxt->pSTRMList != NULL) { ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_InsertiSTRMResElement: 3"); ++ pTempSTRMRes = pCtxt->pSTRMList; ++ while (pTempSTRMRes->next != NULL) ++ pTempSTRMRes = pTempSTRMRes->next; ++ ++ pTempSTRMRes->next = *pSTRMRes; ++ } else { ++ pCtxt->pSTRMList = *pSTRMRes; ++ GT_0trace(curTrace, GT_ENTER, ++ "DRV_InsertSTRMResElement: 4"); ++ } ++ } ++ return status; ++} ++ ++ ++ ++/* Release Stream resource element context ++* This function called after the actual resource is freed ++*/ ++DSP_STATUS DRV_ProcRemoveSTRMResElement(HANDLE hSTRMRes, HANDLE hPCtxt) ++{ ++ struct STRM_RES_OBJECT *pSTRMRes = (struct STRM_RES_OBJECT *)hSTRMRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_RES_OBJECT *pTempSTRMRes2 = pCtxt->pSTRMList; ++ struct STRM_RES_OBJECT *pTempSTRMRes = pCtxt->pSTRMList; ++ ++ DBC_Assert(hPCtxt != NULL); ++ while ((pTempSTRMRes != NULL) && (pTempSTRMRes != pSTRMRes)) { ++ pTempSTRMRes2 = pTempSTRMRes; ++ pTempSTRMRes = pTempSTRMRes->next; ++ } ++ if (pCtxt->pSTRMList == pTempSTRMRes) ++ pCtxt->pSTRMList = pTempSTRMRes->next; ++ ++ if (pTempSTRMRes == NULL) ++ status = DSP_ENOTFOUND; ++ else if (pTempSTRMRes2->next != NULL) ++ pTempSTRMRes2->next = pTempSTRMRes2->next->next; ++ ++ MEM_Free(pSTRMRes); ++ return status; ++} ++ ++ ++/* Actual Stream De-Allocation */ ++static DSP_STATUS DRV_ProcFreeSTRMRes(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ u8 **apBuffer = NULL; ++ struct STRM_RES_OBJECT *pSTRMList = NULL; ++ struct STRM_RES_OBJECT *pSTRMRes = NULL; ++ u8 *pBufPtr; ++ u32 ulBytes; ++ u32 dwArg; ++ s32 ulBufSize; ++ ++ ++ DBC_Assert(hPCtxt != NULL); ++ pSTRMList = pCtxt->pSTRMList; ++ while (pSTRMList != NULL) { ++ pSTRMRes = pSTRMList; ++ pSTRMList = pSTRMList->next; ++ if (pSTRMRes->uNumBufs != 0) { ++ apBuffer = MEM_Alloc((pSTRMRes->uNumBufs * ++ sizeof(u8 *)), MEM_NONPAGED); ++ status = STRM_FreeBuffer(pSTRMRes->hStream, apBuffer, ++ pSTRMRes->uNumBufs); ++ MEM_Free(apBuffer); ++ } ++ status = STRM_Close(pSTRMRes->hStream); ++ if (DSP_FAILED(status)) { ++ if (status == DSP_EPENDING) { ++ status = STRM_Reclaim(pSTRMRes->hStream, ++ &pBufPtr, &ulBytes, ++ (u32 *)&ulBufSize, &dwArg); ++ if (DSP_SUCCEEDED(status)) ++ status = STRM_Close(pSTRMRes->hStream); ++ ++ } ++ } ++ } ++ return status1; ++} ++ ++/* Release all Stream resources and its context ++* This is called from .bridge_release. ++*/ ++DSP_STATUS DRV_RemoveAllSTRMResElements(HANDLE hPCtxt) ++{ ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_RES_OBJECT *pTempSTRMRes2 = NULL; ++ struct STRM_RES_OBJECT *pTempSTRMRes = NULL; ++ ++ DBC_Assert(hPCtxt != NULL); ++ DRV_ProcFreeSTRMRes(pCtxt); ++ pTempSTRMRes = pCtxt->pSTRMList; ++ while (pTempSTRMRes != NULL) { ++ pTempSTRMRes2 = pTempSTRMRes; ++ pTempSTRMRes = pTempSTRMRes->next; ++ MEM_Free(pTempSTRMRes2); ++ } ++ pCtxt->pSTRMList = NULL; ++ return status; ++} ++ ++ ++/* Getting the stream resource element */ ++DSP_STATUS DRV_GetSTRMResElement(HANDLE hStrm, HANDLE hSTRMRes, HANDLE hPCtxt) ++{ ++ struct STRM_RES_OBJECT **STRMRes = (struct STRM_RES_OBJECT **)hSTRMRes; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_RES_OBJECT *pTempSTRM2 = NULL; ++ struct STRM_RES_OBJECT *pTempSTRM = pCtxt->pSTRMList; ++ ++ DBC_Assert(hPCtxt != NULL); ++ while ((pTempSTRM != NULL) && (pTempSTRM->hStream != hStrm)) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 2"); ++ pTempSTRM2 = pTempSTRM; ++ pTempSTRM = pTempSTRM->next; ++ } ++ if (pTempSTRM != NULL) { ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 3"); ++ *STRMRes = pTempSTRM; ++ } else { ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 4"); ++ status = DSP_ENOTFOUND; ++ } ++ GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 5"); ++ return status; ++} ++ ++/* Updating the stream resource element */ ++DSP_STATUS DRV_ProcUpdateSTRMRes(u32 uNumBufs, HANDLE hSTRMRes, HANDLE hPCtxt) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct STRM_RES_OBJECT **STRMRes = (struct STRM_RES_OBJECT **)hSTRMRes; ++ ++ DBC_Assert(hPCtxt != NULL); ++ (*STRMRes)->uNumBufs = uNumBufs; ++ return status; ++} ++ ++/* Displaying the resources allocated by a process */ ++DSP_STATUS DRV_ProcDisplayResInfo(u8 *pBuf1, u32 *pSize) ++{ ++ struct PROCESS_CONTEXT *pCtxt = NULL; ++ struct NODE_RES_OBJECT *pNodeRes = NULL; ++ struct DMM_RES_OBJECT *pDMMRes = NULL; ++ struct STRM_RES_OBJECT *pSTRMRes = NULL; ++ struct DSPHEAP_RES_OBJECT *pDSPHEAPRes = NULL; ++ u32 tempCount = 1; ++ HANDLE hDrvObject = NULL; ++ void *pBuf = pBuf1; ++ u8 pTempBuf[250]; ++ u32 tempStrLen = 0, tempStrLen2 = 0; ++ DSP_STATUS status = DSP_SOK; ++ ++ CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ DRV_GetProcCtxtList(&pCtxt, (struct DRV_OBJECT *)hDrvObject); ++ GT_0trace(curTrace, GT_ENTER, "*********************" ++ "DRV_ProcDisplayResourceInfo:*\n"); ++ while (pCtxt != NULL) { ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "-------------------------------------" ++ "-----------------------------------\n"); ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ if (pCtxt->resState == PROC_RES_ALLOCATED) { ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "GPP Process Resource State: " ++ "pCtxt->resState = PROC_RES_ALLOCATED, " ++ " Process ID: %d\n", pCtxt->pid); ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ } else { ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "GPP Resource State: pCtxt->resState" ++ " = PROC_RES_DEALLOCATED, Process ID:%d\n", ++ pCtxt->pid); ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ } ++ pNodeRes = pCtxt->pNodeList; ++ tempCount = 1; ++ while (pNodeRes != NULL) { ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_ProcDisplayResourceInfo: #:%d " ++ "pCtxt->pNodeList->hNode:%x\n", ++ tempCount, pNodeRes->hNode); ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "Node Resource Information: Node #" ++ " %d Node Handle hNode:0X%x\n", ++ tempCount, (u32)pNodeRes->hNode); ++ pNodeRes = pNodeRes->next; ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ tempCount++; ++ } ++ tempCount = 1; ++ pDSPHEAPRes = pCtxt->pDSPHEAPList; ++ while (pDSPHEAPRes != NULL) { ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_ProcDisplayResourceInfo: #:%d " ++ "pCtxt->pDSPHEAPRList->ulMpuAddr:%x\n", ++ tempCount, pDSPHEAPRes->ulMpuAddr); ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "DSP Heap Resource Info: HEAP # %d" ++ " Mapped GPP Address: 0x%x, size: 0x%x\n", ++ tempCount, (u32)pDSPHEAPRes->ulMpuAddr, ++ (u32)pDSPHEAPRes->heapSize); ++ pDSPHEAPRes = pDSPHEAPRes->next; ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ tempCount++; ++ } ++ tempCount = 1; ++ pDMMRes = pCtxt->pDMMList; ++ while (pDMMRes != NULL) { ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_ProcDisplayResourceInfo: #:%d " ++ " pCtxt->pDMMList->ulMpuAddr:%x\n", ++ tempCount, ++ pDMMRes->ulMpuAddr); ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "DMM Resource Info: DMM # %d Mapped" ++ " GPP Address: 0x%x, size: 0x%x\n", ++ tempCount, (u32)pDMMRes->ulMpuAddr, ++ (u32)pDMMRes->dmmSize); ++ pDMMRes = pDMMRes->next; ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ tempCount++; ++ } ++ tempCount = 1; ++ pSTRMRes = pCtxt->pSTRMList; ++ while (pSTRMRes != NULL) { ++ GT_2trace(curTrace, GT_ENTER, ++ "DRV_ProcDisplayResourceInfo: #:%d " ++ "pCtxt->pSTRMList->hStream:%x\n", tempCount, ++ pSTRMRes->hStream); ++ tempStrLen2 = sprintf((char *)pTempBuf, ++ "Stream Resource info: STRM # %d " ++ "Stream Handle: 0x%x \n", ++ tempCount, (u32)pSTRMRes->hStream); ++ pSTRMRes = pSTRMRes->next; ++ tempStrLen2 += 2; ++ memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2); ++ tempStrLen += tempStrLen2; ++ tempCount++; ++ } ++ pCtxt = pCtxt->next; ++ } ++ *pSize = tempStrLen; ++ status = PrintProcessInformation(); ++ GT_0trace(curTrace, GT_ENTER, "*********************" ++ "DRV_ProcDisplayResourceInfo:**\n"); ++ return status; ++} ++ ++/* ++ * ======== PrintProcessInformation ======== ++ * Purpose: ++ * This function prints the Process's information stored in ++ * the process context list. Some of the information that ++ * it displays is Process's state, Node, Stream, DMM, and ++ * Heap information. ++ */ ++static DSP_STATUS PrintProcessInformation(void) ++{ ++ struct DRV_OBJECT *hDrvObject = NULL; ++ struct PROCESS_CONTEXT *pCtxtList = NULL; ++ struct NODE_RES_OBJECT *pNodeRes = NULL; ++ struct DMM_RES_OBJECT *pDMMRes = NULL; ++ struct STRM_RES_OBJECT *pSTRMRes = NULL; ++ struct DSPHEAP_RES_OBJECT *pDSPHEAPRes = NULL; ++ DSP_STATUS status = DSP_SOK; ++ u32 tempCount; ++ u32 procID; ++ ++ /* Get the Process context list */ ++ CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ DRV_GetProcCtxtList(&pCtxtList, hDrvObject); ++ GT_0trace(curTrace, GT_4CLASS, "\n### Debug information" ++ " for DSP bridge ##\n"); ++ GT_0trace(curTrace, GT_4CLASS, " \n ###The processes" ++ " information is as follows ### \n") ; ++ GT_0trace(curTrace, GT_4CLASS, " =====================" ++ "============ \n"); ++ /* Go through the entries in the Process context list */ ++ while (pCtxtList != NULL) { ++ GT_1trace(curTrace, GT_4CLASS, "\nThe process" ++ " id is %d\n", pCtxtList->pid); ++ GT_0trace(curTrace, GT_4CLASS, " -------------------" ++ "---------\n"); ++ if (pCtxtList->resState == PROC_RES_ALLOCATED) { ++ GT_0trace(curTrace, GT_4CLASS, " \nThe Process" ++ " is in Allocated state\n"); ++ } else { ++ GT_0trace(curTrace, GT_4CLASS, "\nThe Process" ++ " is in DeAllocated state\n"); ++ } ++ GT_1trace(curTrace, GT_4CLASS, "\nThe hProcessor" ++ " handle is: 0X%x\n", ++ (u32)pCtxtList->hProcessor); ++ if (pCtxtList->hProcessor != NULL) { ++ PROC_GetProcessorId(pCtxtList->hProcessor, &procID); ++ if (procID == DSP_UNIT) { ++ GT_0trace(curTrace, GT_4CLASS, ++ "\nProcess connected to" ++ " DSP Processor\n"); ++ } else if (procID == IVA_UNIT) { ++ GT_0trace(curTrace, GT_4CLASS, ++ "\nProcess connected to" ++ " IVA Processor\n"); ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ "\n***ERROR:Invalid Processor Id***\n"); ++ } ++ } ++ pNodeRes = pCtxtList->pNodeList; ++ tempCount = 1; ++ while (pNodeRes != NULL) { ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n***The Nodes allocated by" ++ " this Process are***\n"); ++ GT_2trace(curTrace, GT_4CLASS, ++ "Node # %d Node Handle hNode:0x%x\n", ++ tempCount, (u32)pNodeRes->hNode); ++ pNodeRes = pNodeRes->next; ++ tempCount++; ++ } ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n ***There are no Nodes" ++ " allocated by this Process***\n"); ++ tempCount = 1; ++ pDSPHEAPRes = pCtxtList->pDSPHEAPList; ++ while (pDSPHEAPRes != NULL) { ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n***The Heaps allocated by" ++ " this Process are***\n"); ++ GT_3trace(curTrace, GT_4CLASS, ++ "DSP Heap Resource Info: HEAP # %d " ++ "Mapped GPP Address:0x%x, Size: 0x%lx\n", ++ tempCount, (u32)pDSPHEAPRes->ulMpuAddr, ++ pDSPHEAPRes->heapSize); ++ pDSPHEAPRes = pDSPHEAPRes->next; ++ tempCount++; ++ } ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n ***There are no Heaps allocated" ++ " by this Process***\n"); ++ tempCount = 1; ++ pDMMRes = pCtxtList->pDMMList; ++ while (pDMMRes != NULL) { ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n ***The DMM resources allocated by" ++ " this Process are***\n"); ++ GT_3trace(curTrace, GT_4CLASS, ++ "DMM Resource Info: DMM # %d " ++ "Mapped GPP Address:0X%lx, Size: 0X%lx\n", ++ tempCount, pDMMRes->ulMpuAddr, ++ pDMMRes->dmmSize); ++ pDMMRes = pDMMRes->next; ++ tempCount++; ++ } ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n ***There are no DMM resources" ++ " allocated by this Process***\n"); ++ tempCount = 1; ++ pSTRMRes = pCtxtList->pSTRMList; ++ while (pSTRMRes != NULL) { ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n***The Stream resources allocated by" ++ " this Process are***\n"); ++ GT_2trace(curTrace, GT_4CLASS, ++ "Stream Resource info: STRM # %d" ++ "Stream Handle:0X%x\n", tempCount, ++ (u32)pSTRMRes->hStream); ++ pSTRMRes = pSTRMRes->next; ++ tempCount++; ++ } ++ if (tempCount == 1) ++ GT_0trace(curTrace, GT_4CLASS, ++ "\n ***There are no Stream resources" ++ "allocated by this Process***\n"); ++ pCtxtList = pCtxtList->next; ++ } ++ return status; ++} ++ ++/* GPP PROCESS CLEANUP CODE END */ ++#endif ++ ++/* ++ * ======== = DRV_Create ======== = ++ * Purpose: ++ * DRV Object gets created only once during Driver Loading. ++ */ ++DSP_STATUS DRV_Create(OUT struct DRV_OBJECT **phDRVObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDRVObject = NULL; ++ ++ DBC_Require(phDRVObject != NULL); ++ DBC_Require(cRefs > 0); ++ GT_1trace(curTrace, GT_ENTER, "Entering DRV_Create" ++ " phDRVObject 0x%x\n", phDRVObject); ++ MEM_AllocObject(pDRVObject, struct DRV_OBJECT, SIGNATURE); ++ if (pDRVObject) { ++ /* Create and Initialize List of device objects */ ++ pDRVObject->devList = LST_Create(); ++ if (pDRVObject->devList) { ++ /* Create and Initialize List of device Extension */ ++ pDRVObject->devNodeString = LST_Create(); ++ if (!(pDRVObject->devNodeString)) { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to Create DRV_EXT list "); ++ MEM_FreeObject(pDRVObject); ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to Create Dev List "); ++ MEM_FreeObject(pDRVObject); ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to Allocate Memory for DRV Obj"); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Store the DRV Object in the Registry */ ++ if (DSP_SUCCEEDED ++ (CFG_SetObject((u32) pDRVObject, REG_DRV_OBJECT))) { ++ GT_1trace(curTrace, GT_1CLASS, ++ "DRV Obj Created pDrvObject 0x%x\n ", ++ pDRVObject); ++ *phDRVObject = pDRVObject; ++ } else { ++ /* Free the DRV Object */ ++ status = DSP_EFAIL; ++ MEM_Free(pDRVObject); ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to update the Registry with " ++ "DRV Object "); ++ } ++ } ++ GT_2trace(curTrace, GT_ENTER, ++ "Exiting DRV_Create: phDRVObject: 0x%x\tstatus:" ++ "0x%x\n", phDRVObject, status); ++ DBC_Ensure(DSP_FAILED(status) || ++ MEM_IsValidHandle(pDRVObject, SIGNATURE)); ++ return status; ++} ++ ++/* ++ * ======== DRV_Exit ======== ++ * Purpose: ++ * Discontinue usage of the DRV module. ++ */ ++void DRV_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ GT_0trace(curTrace, GT_5CLASS, "Entering DRV_Exit \n"); ++ ++ cRefs--; ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== = DRV_Destroy ======== = ++ * purpose: ++ * Invoked during bridge de-initialization ++ */ ++DSP_STATUS DRV_Destroy(struct DRV_OBJECT *hDRVObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE)); ++ ++ GT_1trace(curTrace, GT_ENTER, "Entering DRV_Destroy" ++ " hDRVObject 0x%x\n", hDRVObject); ++ /* ++ * Delete the List if it exists.Should not come here ++ * as the DRV_RemoveDevObject and the Last DRV_RequestResources ++ * removes the list if the lists are empty. ++ */ ++ if (pDRVObject->devList) { ++ /* Could assert if the list is not empty */ ++ LST_Delete(pDRVObject->devList); ++ } ++ if (pDRVObject->devNodeString) { ++ /* Could assert if the list is not empty */ ++ LST_Delete(pDRVObject->devNodeString); ++ } ++ MEM_FreeObject(pDRVObject); ++ /* Update the DRV Object in Registry to be 0 */ ++ (void)CFG_SetObject(0, REG_DRV_OBJECT); ++ GT_2trace(curTrace, GT_ENTER, ++ "Exiting DRV_Destroy: hDRVObject: 0x%x\tstatus:" ++ "0x%x\n", hDRVObject, status); ++ DBC_Ensure(!MEM_IsValidHandle(pDRVObject, SIGNATURE)); ++ return status; ++} ++ ++/* ++ * ======== DRV_GetDevObject ======== ++ * Purpose: ++ * Given a index, returns a handle to DevObject from the list. ++ */ ++DSP_STATUS DRV_GetDevObject(u32 uIndex, struct DRV_OBJECT *hDrvObject, ++ struct DEV_OBJECT **phDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++#if GT_TRACE /* pDrvObject is used only for Assertions and debug messages.*/ ++ struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject; ++#endif ++ struct DEV_OBJECT *pDevObject; ++ u32 i; ++ DBC_Require(MEM_IsValidHandle(pDrvObject, SIGNATURE)); ++ DBC_Require(phDevObject != NULL); ++ DBC_Require(uIndex >= 0); ++ DBC_Require(cRefs > 0); ++ DBC_Assert(!(LST_IsEmpty(pDrvObject->devList))); ++ GT_3trace(curTrace, GT_ENTER, ++ "Entered DRV_GetDevObject, args:\n\tuIndex: " ++ "0x%x\n\thDrvObject: 0x%x\n\tphDevObject: 0x%x\n", ++ uIndex, hDrvObject, phDevObject); ++ pDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ for (i = 0; i < uIndex; i++) { ++ pDevObject = ++ (struct DEV_OBJECT *)DRV_GetNextDevObject((u32)pDevObject); ++ } ++ if (pDevObject) { ++ *phDevObject = (struct DEV_OBJECT *) pDevObject; ++ status = DSP_SOK; ++ } else { ++ *phDevObject = NULL; ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, ++ "DRV: Could not get the DevObject\n"); ++ } ++ GT_2trace(curTrace, GT_ENTER, ++ "Exiting Drv_GetDevObject\n\tstatus: 0x%x\n\t" ++ "hDevObject: 0x%x\n", status, *phDevObject); ++ return status; ++} ++ ++/* ++ * ======== DRV_GetFirstDevObject ======== ++ * Purpose: ++ * Retrieve the first Device Object handle from an internal linked list of ++ * of DEV_OBJECTs maintained by DRV. ++ */ ++u32 DRV_GetFirstDevObject(void) ++{ ++ u32 dwDevObject = 0; ++ struct DRV_OBJECT *pDrvObject; ++ ++ if (DSP_SUCCEEDED ++ (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) { ++ if ((pDrvObject->devList != NULL) && ++ !LST_IsEmpty(pDrvObject->devList)) ++ dwDevObject = (u32) LST_First(pDrvObject->devList); ++ } ++ ++ return dwDevObject; ++} ++ ++/* ++ * ======== DRV_GetFirstDevNodeString ======== ++ * Purpose: ++ * Retrieve the first Device Extension from an internal linked list of ++ * of Pointer to DevNode Strings maintained by DRV. ++ */ ++u32 DRV_GetFirstDevExtension(void) ++{ ++ u32 dwDevExtension = 0; ++ struct DRV_OBJECT *pDrvObject; ++ ++ if (DSP_SUCCEEDED ++ (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) { ++ ++ if ((pDrvObject->devNodeString != NULL) && ++ !LST_IsEmpty(pDrvObject->devNodeString)) { ++ dwDevExtension = (u32)LST_First(pDrvObject-> ++ devNodeString); ++ } ++ } ++ ++ return dwDevExtension; ++} ++ ++/* ++ * ======== DRV_GetNextDevObject ======== ++ * Purpose: ++ * Retrieve the next Device Object handle from an internal linked list of ++ * of DEV_OBJECTs maintained by DRV, after having previously called ++ * DRV_GetFirstDevObject() and zero or more DRV_GetNext. ++ */ ++u32 DRV_GetNextDevObject(u32 hDevObject) ++{ ++ u32 dwNextDevObject = 0; ++ struct DRV_OBJECT *pDrvObject; ++ ++ DBC_Require(hDevObject != 0); ++ ++ if (DSP_SUCCEEDED ++ (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) { ++ ++ if ((pDrvObject->devList != NULL) && ++ !LST_IsEmpty(pDrvObject->devList)) { ++ dwNextDevObject = (u32)LST_Next(pDrvObject->devList, ++ (struct LST_ELEM *)hDevObject); ++ } ++ } ++ return dwNextDevObject; ++} ++ ++/* ++ * ======== DRV_GetNextDevExtension ======== ++ * Purpose: ++ * Retrieve the next Device Extension from an internal linked list of ++ * of pointer to DevNodeString maintained by DRV, after having previously ++ * called DRV_GetFirstDevExtension() and zero or more ++ * DRV_GetNextDevExtension(). ++ */ ++u32 DRV_GetNextDevExtension(u32 hDevExtension) ++{ ++ u32 dwDevExtension = 0; ++ struct DRV_OBJECT *pDrvObject; ++ ++ DBC_Require(hDevExtension != 0); ++ ++ if (DSP_SUCCEEDED(CFG_GetObject((u32 *)&pDrvObject, ++ REG_DRV_OBJECT))) { ++ if ((pDrvObject->devNodeString != NULL) && ++ !LST_IsEmpty(pDrvObject->devNodeString)) { ++ dwDevExtension = (u32)LST_Next(pDrvObject-> ++ devNodeString, ++ (struct LST_ELEM *)hDevExtension); ++ } ++ } ++ ++ return dwDevExtension; ++} ++ ++/* ++ * ======== DRV_Init ======== ++ * Purpose: ++ * Initialize DRV module private state. ++ */ ++DSP_STATUS DRV_Init(void) ++{ ++ s32 fRetval = 1; /* function return value */ ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (fRetval) ++ cRefs++; ++ ++ GT_1trace(curTrace, GT_5CLASS, "Entering DRV_Entry crefs 0x%x \n", ++ cRefs); ++ ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++/* ++ * ======== DRV_InsertDevObject ======== ++ * Purpose: ++ * Insert a DevObject into the list of Manager object. ++ */ ++DSP_STATUS DRV_InsertDevObject(struct DRV_OBJECT *hDRVObject, ++ struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hDevObject != NULL); ++ DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE)); ++ DBC_Assert(pDRVObject->devList); ++ ++ GT_2trace(curTrace, GT_ENTER, ++ "Entering DRV_InsertProcObject hDRVObject " ++ "0x%x\n, hDevObject 0x%x\n", hDRVObject, hDevObject); ++ ++ LST_PutTail(pDRVObject->devList, (struct LST_ELEM *)hDevObject); ++ ++ GT_1trace(curTrace, GT_ENTER, ++ "Exiting InsertDevObject status 0x%x\n", status); ++ ++ DBC_Ensure(DSP_SUCCEEDED(status) && !LST_IsEmpty(pDRVObject->devList)); ++ ++ return status; ++} ++ ++/* ++ * ======== DRV_RemoveDevObject ======== ++ * Purpose: ++ * Search for and remove a DeviceObject from the given list of DRV ++ * objects. ++ */ ++DSP_STATUS DRV_RemoveDevObject(struct DRV_OBJECT *hDRVObject, ++ struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject; ++ struct LST_ELEM *pCurElem; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE)); ++ DBC_Require(hDevObject != NULL); ++ ++ DBC_Require(pDRVObject->devList != NULL); ++ DBC_Require(!LST_IsEmpty(pDRVObject->devList)); ++ ++ GT_2trace(curTrace, GT_ENTER, ++ "Entering DRV_RemoveDevObject hDevObject " ++ "0x%x\n, hDRVObject 0x%x\n", hDevObject, hDRVObject); ++ /* Search list for pProcObject: */ ++ for (pCurElem = LST_First(pDRVObject->devList); pCurElem != NULL; ++ pCurElem = LST_Next(pDRVObject->devList, pCurElem)) { ++ /* If found, remove it. */ ++ if ((struct DEV_OBJECT *) pCurElem == hDevObject) { ++ LST_RemoveElem(pDRVObject->devList, pCurElem); ++ status = DSP_SOK; ++ break; ++ } ++ } ++ /* Remove list if empty. */ ++ if (LST_IsEmpty(pDRVObject->devList)) { ++ LST_Delete(pDRVObject->devList); ++ pDRVObject->devList = NULL; ++ } ++ DBC_Ensure((pDRVObject->devList == NULL) || ++ !LST_IsEmpty(pDRVObject->devList)); ++ GT_1trace(curTrace, GT_ENTER, ++ "DRV_RemoveDevObject returning 0x%x\n", status); ++ return status; ++} ++ ++/* ++ * ======== DRV_RequestResources ======== ++ * Purpose: ++ * Requests resources from the OS. ++ */ ++DSP_STATUS DRV_RequestResources(u32 dwContext, u32 *pDevNodeString) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDRVObject; ++ struct DRV_EXT *pszdevNode; ++ ++ DBC_Require(dwContext != 0); ++ DBC_Require(pDevNodeString != NULL); ++ GT_0trace(curTrace, GT_ENTER, "Entering DRV_RequestResources\n"); ++ /* ++ * Allocate memory to hold the string. This will live untill ++ * it is freed in the Release resources. Update the driver object ++ * list. ++ */ ++ if (DSP_SUCCEEDED(CFG_GetObject((u32 *)&pDRVObject, ++ REG_DRV_OBJECT))) { ++ pszdevNode = MEM_Calloc(sizeof(struct DRV_EXT), MEM_NONPAGED); ++ if (pszdevNode) { ++ LST_InitElem(&pszdevNode->link); ++ strncpy((char *) pszdevNode->szString, ++ (char *)dwContext, MAXREGPATHLENGTH); ++ /* Update the Driver Object List */ ++ *pDevNodeString = (u32)pszdevNode->szString; ++ LST_PutTail(pDRVObject->devNodeString, ++ (struct LST_ELEM *)pszdevNode); ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to Allocate Memory devNodeString "); ++ status = DSP_EFAIL; ++ *pDevNodeString = 0; ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to get Driver Object from Registry"); ++ *pDevNodeString = 0; ++ } ++ ++ if (!(strcmp((char *) dwContext, "TIOMAP1510"))) { ++ GT_0trace(curTrace, GT_1CLASS, ++ " Allocating resources for UMA \n"); ++ status = RequestBridgeResourcesDSP(dwContext, DRV_ASSIGN); ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(curTrace, GT_7CLASS, "Unknown Device "); ++ } ++ ++ if (DSP_FAILED(status)) { ++ GT_0trace(curTrace, GT_7CLASS, ++ "Failed to reserve bridge resources "); ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && pDevNodeString != NULL && ++ !LST_IsEmpty(pDRVObject->devNodeString)) || ++ (DSP_FAILED(status) && *pDevNodeString == 0)); ++ ++ return status; ++} ++ ++/* ++ * ======== DRV_ReleaseResources ======== ++ * Purpose: ++ * Releases resources from the OS. ++ */ ++DSP_STATUS DRV_ReleaseResources(u32 dwContext, struct DRV_OBJECT *hDrvObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDrvObject; ++ struct DRV_EXT *pszdevNode; ++ ++ GT_0trace(curTrace, GT_ENTER, "Entering DRV_Release Resources\n"); ++ ++ if (!(strcmp((char *)((struct DRV_EXT *)dwContext)->szString, ++ "TIOMAP1510"))) { ++ GT_0trace(curTrace, GT_1CLASS, ++ " Releasing DSP-Bridge resources \n"); ++ status = RequestBridgeResources(dwContext, DRV_RELEASE); ++ } else { ++ GT_0trace(curTrace, GT_1CLASS, " Unknown device\n"); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(curTrace, GT_1CLASS, ++ "Failed to relese bridge resources\n"); ++ } ++ ++ /* ++ * Irrespective of the status go ahead and clean it ++ * The following will over write the status. ++ */ ++ for (pszdevNode = (struct DRV_EXT *)DRV_GetFirstDevExtension(); ++ pszdevNode != NULL; pszdevNode = (struct DRV_EXT *) ++ DRV_GetNextDevExtension((u32)pszdevNode)) { ++ if ((u32)pszdevNode == dwContext) { ++ /* Found it */ ++ /* Delete from the Driver object list */ ++ LST_RemoveElem(pDRVObject->devNodeString, ++ (struct LST_ELEM *)pszdevNode); ++ MEM_Free((void *) pszdevNode); ++ break; ++ } ++ /* Delete the List if it is empty */ ++ if (LST_IsEmpty(pDRVObject->devNodeString)) { ++ LST_Delete(pDRVObject->devNodeString); ++ pDRVObject->devNodeString = NULL; ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== RequestBridgeResources ======== ++ * Purpose: ++ * Reserves shared memory for bridge. ++ */ ++static DSP_STATUS RequestBridgeResources(u32 dwContext, s32 bRequest) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CFG_HOSTRES *pResources; ++ u32 dwBuffSize; ++ ++ struct DRV_EXT *driverExt; ++ u32 shm_size; ++ ++ DBC_Require(dwContext != 0); ++ ++ GT_0trace(curTrace, GT_ENTER, "->RequestBridgeResources \n"); ++ ++ if (!bRequest) { ++ driverExt = (struct DRV_EXT *)dwContext; ++ /* Releasing resources by deleting the registry key */ ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED); ++ if (DSP_FAILED(REG_GetValue(NULL, (char *)driverExt->szString, ++ CURRENTCONFIG, (u8 *)pResources, &dwBuffSize))) { ++ status = CFG_E_RESOURCENOTAVAIL; ++ GT_0trace(curTrace, GT_1CLASS, ++ "REG_GetValue Failed \n"); ++ } else { ++ GT_0trace(curTrace, GT_1CLASS, ++ "REG_GetValue Succeeded \n"); ++ } ++ ++ if (pResources != NULL) { ++ dwBuffSize = sizeof(shm_size); ++ status = REG_GetValue(NULL, CURRENTCONFIG, SHMSIZE, ++ (u8 *)&shm_size, &dwBuffSize); ++ if (DSP_SUCCEEDED(status)) { ++ if ((pResources->dwMemBase[1]) && ++ (pResources->dwMemPhys[1])) { ++ MEM_FreePhysMem((void *)pResources-> ++ dwMemBase[1], pResources->dwMemPhys[1], ++ shm_size); ++ } ++ } else { ++ GT_1trace(curTrace, GT_7CLASS, ++ "Error getting SHM size from registry: " ++ "%x. Not calling MEM_FreePhysMem\n", ++ status); ++ } ++ pResources->dwMemBase[1] = 0; ++ pResources->dwMemPhys[1] = 0; ++ ++ if (pResources->dwPrmBase) ++ iounmap((void *)pResources->dwPrmBase); ++ if (pResources->dwCmBase) ++ iounmap((void *)pResources->dwCmBase); ++ if (pResources->dwMboxBase) ++ iounmap((void *)pResources->dwMboxBase); ++ if (pResources->dwMemBase[0]) ++ iounmap((void *)pResources->dwMemBase[0]); ++ if (pResources->dwMemBase[2]) ++ iounmap((void *)pResources->dwMemBase[2]); ++ if (pResources->dwMemBase[3]) ++ iounmap((void *)pResources->dwMemBase[3]); ++ if (pResources->dwMemBase[4]) ++ iounmap((void *)pResources->dwMemBase[4]); ++ if (pResources->dwWdTimerDspBase) ++ iounmap((void *)pResources->dwWdTimerDspBase); ++ if (pResources->dwDmmuBase) ++ iounmap((void *)pResources->dwDmmuBase); ++ if (pResources->dwPerBase) ++ iounmap((void *)pResources->dwPerBase); ++ if (pResources->dwPerPmBase) ++ iounmap((void *)pResources->dwPerPmBase); ++ if (pResources->dwCorePmBase) ++ iounmap((void *)pResources->dwCorePmBase); ++ if (pResources->dwSysCtrlBase) { ++ iounmap((void *)pResources->dwSysCtrlBase); ++ /* don't set pResources->dwSysCtrlBase to null ++ * as it is used in BOARD_Stop */ ++ } ++ pResources->dwPrmBase = (u32) NULL; ++ pResources->dwCmBase = (u32) NULL; ++ pResources->dwMboxBase = (u32) NULL; ++ pResources->dwMemBase[0] = (u32) NULL; ++ pResources->dwMemBase[2] = (u32) NULL; ++ pResources->dwMemBase[3] = (u32) NULL; ++ pResources->dwMemBase[4] = (u32) NULL; ++ pResources->dwWdTimerDspBase = (u32) NULL; ++ pResources->dwDmmuBase = (u32) NULL; ++ ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ status = REG_SetValue(NULL, (char *)driverExt->szString, ++ CURRENTCONFIG, REG_BINARY, (u8 *)pResources, ++ (u32)dwBuffSize); ++ /* Set all the other entries to NULL */ ++ MEM_Free(pResources); ++ } ++ GT_0trace(curTrace, GT_ENTER, " <- RequestBridgeResources \n"); ++ return status; ++ } ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED); ++ if (pResources != NULL) { ++ /* wNumMemWindows must not be more than CFG_MAXMEMREGISTERS */ ++ pResources->wNumMemWindows = 2; ++ /* First window is for DSP internal memory */ ++ ++ pResources->dwPrmBase = (u32)ioremap(OMAP_IVA2_PRM_BASE, ++ OMAP_IVA2_PRM_SIZE); ++ pResources->dwCmBase = (u32)ioremap(OMAP_IVA2_CM_BASE, ++ OMAP_IVA2_CM_SIZE); ++ pResources->dwMboxBase = (u32)ioremap(OMAP_MBOX_BASE, ++ OMAP_MBOX_SIZE); ++ pResources->dwSysCtrlBase = (u32)ioremap(OMAP_SYSC_BASE, ++ OMAP_SYSC_SIZE); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[0] 0x%x\n", ++ pResources->dwMemBase[0]); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[3] 0x%x\n", ++ pResources->dwMemBase[3]); ++ GT_1trace(curTrace, GT_2CLASS, "dwPrmBase 0x%x\n", ++ pResources->dwPrmBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwCmBase 0x%x\n", ++ pResources->dwCmBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwWdTimerDspBase 0x%x\n", ++ pResources->dwWdTimerDspBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwMboxBase 0x%x\n", ++ pResources->dwMboxBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwDmmuBase 0x%x\n", ++ pResources->dwDmmuBase); ++ ++ /* for 24xx base port is not mapping the mamory for DSP ++ * internal memory TODO Do a ioremap here */ ++ /* Second window is for DSP external memory shared with MPU */ ++ if (DSP_SUCCEEDED(status)) { ++ /* for Linux, these are hard-coded values */ ++ pResources->dwBusType = 0; ++ pResources->bIRQRegisters = 0; ++ pResources->bIRQAttrib = 0; ++ pResources->dwOffsetForMonitor = 0; ++ pResources->dwChnlOffset = 0; ++ /* CHNL_MAXCHANNELS */ ++ pResources->dwNumChnls = CHNL_MAXCHANNELS; ++ pResources->dwChnlBufSize = 0x400; ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ status = REG_SetValue(NULL, (char *) dwContext, ++ CURRENTCONFIG, REG_BINARY, ++ (u8 *)pResources, ++ sizeof(struct CFG_HOSTRES)); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(curTrace, GT_1CLASS, ++ " Successfully set the registry " ++ "value for CURRENTCONFIG\n"); ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ " Failed to set the registry " ++ "value for CURRENTCONFIG\n"); ++ } ++ } ++ MEM_Free(pResources); ++ } ++ /* End Mem alloc */ ++ return status; ++} ++ ++/* ++ * ======== RequestBridgeResourcesDSP ======== ++ * Purpose: ++ * Reserves shared memory for bridge. ++ */ ++static DSP_STATUS RequestBridgeResourcesDSP(u32 dwContext, s32 bRequest) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CFG_HOSTRES *pResources; ++ u32 dwBuffSize; ++ u32 dmaAddr; ++ u32 shm_size; ++ ++ DBC_Require(dwContext != 0); ++ ++ GT_0trace(curTrace, GT_ENTER, "->RequestBridgeResourcesDSP \n"); ++ ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ ++ pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED); ++ ++ if (pResources != NULL) { ++ if (DSP_FAILED(CFG_GetHostResources((struct CFG_DEVNODE *) ++ dwContext, pResources))) { ++ /* Call CFG_GetHostResources to get reserve resouces */ ++ status = RequestBridgeResources(dwContext, bRequest); ++ if (DSP_SUCCEEDED(status)) { ++ status = CFG_GetHostResources ++ ((struct CFG_DEVNODE *) dwContext, ++ pResources); ++ } ++ } ++ /* wNumMemWindows must not be more than CFG_MAXMEMREGISTERS */ ++ pResources->wNumMemWindows = 4; ++ ++ pResources->dwMemBase[0] = 0; ++ pResources->dwMemBase[2] = (u32)ioremap(OMAP_DSP_MEM1_BASE, ++ OMAP_DSP_MEM1_SIZE); ++ pResources->dwMemBase[3] = (u32)ioremap(OMAP_DSP_MEM2_BASE, ++ OMAP_DSP_MEM2_SIZE); ++ pResources->dwMemBase[4] = (u32)ioremap(OMAP_DSP_MEM3_BASE, ++ OMAP_DSP_MEM3_SIZE); ++ pResources->dwPerBase = (u32)ioremap(OMAP_PER_CM_BASE, ++ OMAP_PER_CM_SIZE); ++ pResources->dwPerPmBase = (u32)ioremap(OMAP_PER_PRM_BASE, ++ OMAP_PER_PRM_SIZE); ++ pResources->dwCorePmBase = (u32)ioremap(OMAP_CORE_PRM_BASE, ++ OMAP_CORE_PRM_SIZE); ++ pResources->dwDmmuBase = (u32)ioremap(OMAP_DMMU_BASE, ++ OMAP_DMMU_SIZE); ++ pResources->dwWdTimerDspBase = 0; ++ ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[0] 0x%x\n", ++ pResources->dwMemBase[0]); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[1] 0x%x\n", ++ pResources->dwMemBase[1]); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[2] 0x%x\n", ++ pResources->dwMemBase[2]); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[3] 0x%x\n", ++ pResources->dwMemBase[3]); ++ GT_1trace(curTrace, GT_2CLASS, "dwMemBase[4] 0x%x\n", ++ pResources->dwMemBase[4]); ++ GT_1trace(curTrace, GT_2CLASS, "dwPrmBase 0x%x\n", ++ pResources->dwPrmBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwCmBase 0x%x\n", ++ pResources->dwCmBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwWdTimerDspBase 0x%x\n", ++ pResources->dwWdTimerDspBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwMboxBase 0x%x\n", ++ pResources->dwMboxBase); ++ GT_1trace(curTrace, GT_2CLASS, "dwDmmuBase 0x%x\n", ++ pResources->dwDmmuBase); ++ dwBuffSize = sizeof(shm_size); ++ status = REG_GetValue(NULL, CURRENTCONFIG, SHMSIZE, ++ (u8 *)&shm_size, &dwBuffSize); ++ if (DSP_SUCCEEDED(status)) { ++ /* Allocate Physically contiguous, ++ * non-cacheable memory */ ++ pResources->dwMemBase[1] = ++ (u32)MEM_AllocPhysMem(shm_size, 0x100000, ++ &dmaAddr); ++ if (pResources->dwMemBase[1] == 0) { ++ status = DSP_EMEMORY; ++ GT_0trace(curTrace, GT_7CLASS, ++ "SHM reservation Failed\n"); ++ } else { ++ pResources->dwMemLength[1] = shm_size; ++ pResources->dwMemPhys[1] = dmaAddr; ++ ++ GT_3trace(curTrace, GT_1CLASS, ++ "Bridge SHM address 0x%x dmaAddr" ++ " %x size %x\n", ++ pResources->dwMemBase[1], ++ dmaAddr, shm_size); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* for Linux, these are hard-coded values */ ++ pResources->dwBusType = 0; ++ pResources->bIRQRegisters = 0; ++ pResources->bIRQAttrib = 0; ++ pResources->dwOffsetForMonitor = 0; ++ pResources->dwChnlOffset = 0; ++ /* CHNL_MAXCHANNELS */ ++ pResources->dwNumChnls = CHNL_MAXCHANNELS; ++ pResources->dwChnlBufSize = 0x400; ++ dwBuffSize = sizeof(struct CFG_HOSTRES); ++ status = REG_SetValue(NULL, (char *)dwContext, ++ CURRENTCONFIG, REG_BINARY, ++ (u8 *)pResources, ++ sizeof(struct CFG_HOSTRES)); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(curTrace, GT_1CLASS, ++ " Successfully set the registry" ++ " value for CURRENTCONFIG\n"); ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ " Failed to set the registry value" ++ " for CURRENTCONFIG\n"); ++ } ++ } ++ MEM_Free(pResources); ++ } ++ /* End Mem alloc */ ++ return status; ++} +diff --git a/drivers/dsp/bridge/rmgr/drv_interface.c b/drivers/dsp/bridge/rmgr/drv_interface.c +new file mode 100644 +index 0000000..4aa7de6 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/drv_interface.c +@@ -0,0 +1,777 @@ ++/* ++ * drv_interface.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== linux_driver.c ======== ++ * Description: ++ * DSP/BIOS Bridge driver interface. ++ * ++ * Public Functions: ++ * driver_init ++ * driver_exit ++ * driver_open ++ * driver_release ++ * driver_ioctl ++ * driver_mmap ++ * ++ *! Revision History ++ *! ================ ++ *! 21-Apr-2004 map Deprecated use of MODULE_PARM for kernel versions ++ *! greater than 2.5, use module_param. ++ *! 08-Mar-2004 sb Added the dsp_debug argument, which keeps the DSP in self ++ *! loop after image load and waits in a loop for DSP to start ++ *! 16-Feb-2004 vp Deprecated the usage of MOD_INC_USE_COUNT and ++ *! MOD_DEC_USE_COUNT ++ *! for kernel versions greater than 2.5 ++ *! 20-May-2003 vp Added unregister functions for the DPM. ++ *! 24-Mar-2003 sb Pass pid instead of driverContext to DSP_Close ++ *! 24-Mar-2003 vp Added Power Management support. ++ *! 21-Mar-2003 sb Configure SHM size using insmod argument shm_size ++ *! 10-Feb-2003 vp Updated based on code review comments ++ *! 18-Oct-2002 sb Created initial version ++ */ ++ ++/* ----------------------------------- Host OS */ ++ ++#include <dspbridge/host_os.h> ++#include <linux/platform_device.h> ++#include <linux/pm.h> ++ ++#ifdef MODULE ++#include <linux/module.h> ++#endif ++ ++#include <linux/device.h> ++#include <linux/init.h> ++#include <linux/moduleparam.h> ++#include <linux/cdev.h> ++ ++#include <mach/board-3430sdp.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/gt.h> ++#include <dspbridge/dbc.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/services.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/reg.h> ++#include <dspbridge/csl.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/wcdioctl.h> ++#include <dspbridge/_dcd.h> ++#include <dspbridge/dspdrv.h> ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/pwr.h> ++ ++/* ----------------------------------- This */ ++#include <drv_interface.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/cfg.h> ++#include <dspbridge/resourcecleanup.h> ++#include <dspbridge/chnl.h> ++#include <dspbridge/proc.h> ++#include <dspbridge/cfg.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/drvdefs.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/dbreg.h> ++#endif ++ ++#ifdef CONFIG_BRIDGE_DVFS ++#include <mach/omap-pm.h> ++#include <mach-omap2/omap3-opp.h> ++#endif ++ ++#define BRIDGE_NAME "C6410" ++/* ----------------------------------- Globals */ ++#define DRIVER_NAME "DspBridge" ++#define DRIVER_MAJOR 0 /* Linux assigns our Major device number */ ++#define DRIVER_MINOR 0 /* Linux assigns our Major device number */ ++s32 dsp_debug; ++ ++struct platform_device *omap_dspbridge_dev; ++ ++struct bridge_dev { ++ struct cdev cdev; ++}; ++ ++static struct bridge_dev *bridge_device; ++ ++static struct class *bridge_class; ++ ++static u32 driverContext; ++#ifdef CONFIG_BRIDGE_DEBUG ++static char *GT_str; ++#endif /* CONFIG_BRIDGE_DEBUG */ ++static s32 driver_major = DRIVER_MAJOR; ++static s32 driver_minor = DRIVER_MINOR; ++static char *base_img; ++char *iva_img; ++static char *num_procs = "C55=1"; ++static s32 shm_size = 0x400000; /* 4 MB */ ++static u32 phys_mempool_base; ++static u32 phys_mempool_size; ++static int tc_wordswapon; /* Default value is always false */ ++ ++#ifdef CONFIG_PM ++struct omap34xx_bridge_suspend_data { ++ int suspended; ++ wait_queue_head_t suspend_wq; ++}; ++ ++static struct omap34xx_bridge_suspend_data bridge_suspend_data; ++ ++static int omap34xxbridge_suspend_lockout( ++ struct omap34xx_bridge_suspend_data *s, struct file *f) ++{ ++ if ((s)->suspended) { ++ if ((f)->f_flags & O_NONBLOCK) ++ return DSP_EDPMSUSPEND; ++ wait_event_interruptible((s)->suspend_wq, (s)->suspended == 0); ++ } ++ return 0; ++} ++ ++#endif ++ ++#ifdef DEBUG ++module_param(GT_str, charp, 0); ++MODULE_PARM_DESC(GT_str, "GT string, default = NULL"); ++ ++module_param(dsp_debug, int, 0); ++MODULE_PARM_DESC(dsp_debug, "Wait after loading DSP image. default = false"); ++#endif ++ ++module_param(driver_major, int, 0); /* Driver's major number */ ++MODULE_PARM_DESC(driver_major, "Major device number, default = 0 (auto)"); ++ ++module_param(driver_minor, int, 0); /* Driver's major number */ ++MODULE_PARM_DESC(driver_minor, "Minor device number, default = 0 (auto)"); ++ ++module_param(base_img, charp, 0); ++MODULE_PARM_DESC(base_img, "DSP base image, default = NULL"); ++ ++module_param(shm_size, int, 0); ++MODULE_PARM_DESC(shm_size, "SHM size, default = 4 MB, minimum = 64 KB"); ++ ++module_param(phys_mempool_base, uint, 0); ++MODULE_PARM_DESC(phys_mempool_base, ++ "Physical memory pool base passed to driver"); ++ ++module_param(phys_mempool_size, uint, 0); ++MODULE_PARM_DESC(phys_mempool_size, ++ "Physical memory pool size passed to driver"); ++module_param(tc_wordswapon, int, 0); ++MODULE_PARM_DESC(tc_wordswapon, "TC Word Swap Option. default = 0"); ++ ++MODULE_AUTHOR("Texas Instruments"); ++MODULE_LICENSE("GPL"); ++ ++static char *driver_name = DRIVER_NAME; ++ ++#ifdef CONFIG_BRIDGE_DEBUG ++static struct GT_Mask driverTrace; ++#endif /* CONFIG_BRIDGE_DEBUG */ ++ ++static struct file_operations bridge_fops = { ++ .open = bridge_open, ++ .release = bridge_release, ++ .ioctl = bridge_ioctl, ++ .mmap = bridge_mmap, ++}; ++ ++#ifdef CONFIG_PM ++static u32 timeOut = 1000; ++#ifdef CONFIG_BRIDGE_DVFS ++static struct clk *clk_handle; ++s32 dsp_max_opps = VDD1_OPP3; ++#endif ++ ++/* Maximum Opps that can be requested by IVA*/ ++/*vdd1 rate table*/ ++#ifdef CONFIG_BRIDGE_DVFS ++const struct omap_opp vdd1_rate_table_bridge[] = { ++ {0, 0, 0}, ++ /*OPP1*/ ++ {S125M, VDD1_OPP1, 0}, ++ /*OPP2*/ ++ {S250M, VDD1_OPP2, 0}, ++ /*OPP3*/ ++ {S500M, VDD1_OPP3, 0}, ++ /*OPP4*/ ++ {S550M, VDD1_OPP4, 0}, ++ /*OPP5*/ ++ {S600M, VDD1_OPP5, 0}, ++}; ++#endif ++#endif ++ ++struct dspbridge_platform_data *omap_dspbridge_pdata; ++ ++u32 vdd1_dsp_freq[6][4] = { ++ {0, 0, 0, 0}, ++ /*OPP1*/ ++ {0, 90000, 0, 86000}, ++ /*OPP2*/ ++ {0, 180000, 80000, 170000}, ++ /*OPP3*/ ++ {0, 360000, 160000, 340000}, ++ /*OPP4*/ ++ {0, 396000, 325000, 376000}, ++ /*OPP5*/ ++ {0, 430000, 355000, 430000}, ++}; ++ ++#ifdef CONFIG_BRIDGE_DVFS ++static int dspbridge_post_scale(struct notifier_block *op, unsigned long level, ++ void *ptr) ++{ ++ PWR_PM_PostScale(PRCM_VDD1, level); ++ return 0; ++} ++ ++static struct notifier_block iva_clk_notifier = { ++ .notifier_call = dspbridge_post_scale, ++ NULL, ++}; ++#endif ++ ++static int __devinit omap34xx_bridge_probe(struct platform_device *pdev) ++{ ++ int status; ++ u32 initStatus; ++ u32 temp; ++ dev_t dev = 0 ; ++ int result; ++#ifdef CONFIG_BRIDGE_DVFS ++ int i = 0; ++#endif ++ struct dspbridge_platform_data *pdata = pdev->dev.platform_data; ++ ++ omap_dspbridge_dev = pdev; ++ ++ /* use 2.6 device model */ ++ if (driver_major) { ++ dev = MKDEV(driver_major, driver_minor); ++ result = register_chrdev_region(dev, 1, driver_name); ++ } else { ++ result = alloc_chrdev_region(&dev, driver_minor, 1, ++ driver_name); ++ driver_major = MAJOR(dev); ++ } ++ ++ if (result < 0) { ++ GT_1trace(driverTrace, GT_7CLASS, "bridge_init: " ++ "Can't get Major %d \n", driver_major); ++ return result; ++ } ++ ++ bridge_device = kmalloc(sizeof(struct bridge_dev), GFP_KERNEL); ++ if (!bridge_device) { ++ result = -ENOMEM; ++ unregister_chrdev_region(dev, 1); ++ return result; ++ } ++ memset(bridge_device, 0, sizeof(struct bridge_dev)); ++ cdev_init(&bridge_device->cdev, &bridge_fops); ++ bridge_device->cdev.owner = THIS_MODULE; ++ bridge_device->cdev.ops = &bridge_fops; ++ ++ status = cdev_add(&bridge_device->cdev, dev, 1); ++ ++ if (status) { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "Failed to add the bridge device \n"); ++ return status; ++ } ++ ++ /* udev support */ ++ bridge_class = class_create(THIS_MODULE, "ti_bridge"); ++ ++ if (IS_ERR(bridge_class)) ++ GT_0trace(driverTrace, GT_7CLASS, ++ "Error creating bridge class \n"); ++ ++ device_create(bridge_class, NULL, MKDEV(driver_major, driver_minor), ++ NULL, "DspBridge"); ++ ++ GT_init(); ++ GT_create(&driverTrace, "LD"); ++ ++#ifdef DEBUG ++ if (GT_str) ++ GT_set(GT_str); ++#elif defined(DDSP_DEBUG_PRODUCT) && GT_TRACE ++ GT_set("**=67"); ++#endif ++ ++ GT_0trace(driverTrace, GT_ENTER, "-> driver_init\n"); ++ ++#ifdef CONFIG_PM ++ /* Initialize the wait queue */ ++ if (!status) { ++ bridge_suspend_data.suspended = 0; ++ init_waitqueue_head(&bridge_suspend_data.suspend_wq); ++ } ++#endif ++ ++ SERVICES_Init(); ++ ++ /* Autostart flag. This should be set to true if the DSP image should ++ * be loaded and run during bridge module initialization */ ++ ++ if (base_img) { ++ temp = true; ++ REG_SetValue(NULL, NULL, AUTOSTART, REG_DWORD, (u8 *)&temp, ++ sizeof(temp)); ++ REG_SetValue(NULL, NULL, DEFEXEC, REG_SZ, (u8 *)base_img, ++ strlen(base_img) + 1); ++ } else { ++ temp = false; ++ REG_SetValue(NULL, NULL, AUTOSTART, REG_DWORD, (u8 *)&temp, ++ sizeof(temp)); ++ REG_SetValue(NULL, NULL, DEFEXEC, REG_SZ, (u8 *) "\0", (u32)2); ++ } ++ REG_SetValue(NULL, NULL, NUMPROCS, REG_SZ, (u8 *) num_procs, ++ strlen(num_procs) + 1); ++ ++ if (shm_size >= 0x10000) { /* 64 KB */ ++ initStatus = REG_SetValue(NULL, NULL, SHMSIZE, REG_DWORD, ++ (u8 *)&shm_size, sizeof(shm_size)); ++ } else { ++ initStatus = DSP_EINVALIDARG; ++ status = -1; ++ GT_0trace(driverTrace, GT_7CLASS, ++ "SHM size must be at least 64 KB\n"); ++ } ++ GT_1trace(driverTrace, GT_7CLASS, ++ "requested shm_size = 0x%x\n", shm_size); ++ ++ if (pdata->phys_mempool_base && pdata->phys_mempool_size) { ++ phys_mempool_base = pdata->phys_mempool_base; ++ phys_mempool_size = pdata->phys_mempool_size; ++ } ++ ++ if (phys_mempool_base > 0x0) { ++ initStatus = REG_SetValue(NULL, NULL, PHYSMEMPOOLBASE, ++ REG_DWORD, (u8 *)&phys_mempool_base, ++ sizeof(phys_mempool_base)); ++ } ++ GT_1trace(driverTrace, GT_7CLASS, "phys_mempool_base = 0x%x \n", ++ phys_mempool_base); ++ ++ if (phys_mempool_size > 0x0) { ++ initStatus = REG_SetValue(NULL, NULL, PHYSMEMPOOLSIZE, ++ REG_DWORD, (u8 *)&phys_mempool_size, ++ sizeof(phys_mempool_size)); ++ } ++ GT_1trace(driverTrace, GT_7CLASS, "phys_mempool_size = 0x%x\n", ++ phys_mempool_base); ++ if ((phys_mempool_base > 0x0) && (phys_mempool_size > 0x0)) ++ MEM_ExtPhysPoolInit(phys_mempool_base, phys_mempool_size); ++ if (tc_wordswapon) { ++ GT_0trace(driverTrace, GT_7CLASS, "TC Word Swap is enabled\n"); ++ REG_SetValue(NULL, NULL, TCWORDSWAP, REG_DWORD, ++ (u8 *)&tc_wordswapon, sizeof(tc_wordswapon)); ++ } else { ++ GT_0trace(driverTrace, GT_7CLASS, "TC Word Swap is disabled\n"); ++ REG_SetValue(NULL, NULL, TCWORDSWAP, ++ REG_DWORD, (u8 *)&tc_wordswapon, ++ sizeof(tc_wordswapon)); ++ } ++ if (DSP_SUCCEEDED(initStatus)) { ++#ifdef CONFIG_BRIDGE_DVFS ++ for (i = 0; i < 6; i++) ++ pdata->mpu_speed[i] = vdd1_rate_table_bridge[i].rate; ++ ++ clk_handle = clk_get(NULL, "iva2_ck"); ++ if (!clk_handle) { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_get failed to get iva2_ck \n"); ++ } else { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_get PASS to get iva2_ck \n"); ++ } ++ if (!clk_notifier_register(clk_handle, &iva_clk_notifier)) { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_notifier_register PASS for iva2_ck \n"); ++ } else { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_notifier_register FAIL for iva2_ck \n"); ++ } ++#endif ++ driverContext = DSP_Init(&initStatus); ++ if (DSP_FAILED(initStatus)) { ++ status = -1; ++ GT_0trace(driverTrace, GT_7CLASS, ++ "DSP/BIOS Bridge initialization Failed\n"); ++ } else { ++ GT_0trace(driverTrace, GT_5CLASS, ++ "DSP/BIOS Bridge driver loaded\n"); ++ } ++ } ++ ++ DBC_Assert(status == 0); ++ DBC_Assert(DSP_SUCCEEDED(initStatus)); ++ GT_0trace(driverTrace, GT_ENTER, " <- driver_init\n"); ++ return status; ++} ++ ++static int __devexit omap34xx_bridge_remove(struct platform_device *pdev) ++{ ++ dev_t devno; ++ bool ret; ++ DSP_STATUS dsp_status = DSP_SOK; ++ HANDLE hDrvObject = NULL; ++ struct PROCESS_CONTEXT *pTmp = NULL; ++ struct PROCESS_CONTEXT *pCtxtclosed = NULL; ++ struct PROCESS_CONTEXT *pCtxttraverse = NULL; ++ ++ GT_0trace(driverTrace, GT_ENTER, "-> driver_exit\n"); ++ ++ dsp_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ DRV_GetProcCtxtList(&pCtxtclosed, (struct DRV_OBJECT *)hDrvObject); ++ while (pCtxtclosed != NULL) { ++ DRV_RemoveAllResources(pCtxtclosed); ++ if (pCtxtclosed->hProcessor != NULL) { ++ DRV_GetProcCtxtList(&pCtxttraverse, ++ (struct DRV_OBJECT *)hDrvObject); ++ if (pCtxttraverse->next == NULL) { ++ PROC_Detach(pCtxtclosed->hProcessor); ++ goto func_cont; ++ } ++ if ((pCtxtclosed->pid == pCtxttraverse->pid) && ++ (pCtxttraverse->next != NULL)) { ++ pCtxttraverse = pCtxttraverse->next; ++ } ++ while ((pCtxttraverse != NULL) && ++ (pCtxtclosed->hProcessor ++ != pCtxttraverse->hProcessor)) { ++ pCtxttraverse = pCtxttraverse->next; ++ if ((pCtxttraverse != NULL) && ++ (pCtxtclosed->pid == pCtxttraverse->pid)) { ++ pCtxttraverse = pCtxttraverse->next; ++ } ++ } ++ if (pCtxttraverse == NULL) ++ PROC_Detach(pCtxtclosed->hProcessor); ++ } ++func_cont: ++ pTmp = pCtxtclosed->next; ++ DRV_RemoveProcContext((struct DRV_OBJECT *)hDrvObject, ++ pCtxtclosed, (void *)pCtxtclosed->pid); ++ pCtxtclosed = pTmp; ++ } ++ ++ /* unregister the clock notifier */ ++#ifdef CONFIG_BRIDGE_DVFS ++ if (!clk_notifier_unregister(clk_handle, &iva_clk_notifier)) { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_notifier_unregister PASS for iva2_ck \n"); ++ } else { ++ GT_0trace(driverTrace, GT_7CLASS, ++ "clk_notifier_unregister PASS for iva2_ck \n"); ++ } ++ ++ clk_put(clk_handle); ++ clk_handle = NULL; ++#endif /* #ifdef CONFIG_BRIDGE_DVFS */ ++ ++ if (driverContext) { ++ ret = DSP_Deinit(driverContext); ++ driverContext = 0; ++ ++ DBC_Assert(ret == true); ++ } ++ SERVICES_Exit(); ++ GT_exit(); ++ ++ devno = MKDEV(driver_major, driver_minor); ++ if (bridge_device) { ++ cdev_del(&bridge_device->cdev); ++ kfree(bridge_device); ++ } ++ unregister_chrdev_region(devno, 1); ++ if (bridge_class) { ++ /* remove the device from sysfs */ ++ device_destroy(bridge_class, MKDEV(driver_major, driver_minor)); ++ class_destroy(bridge_class); ++ ++ } ++ return 0; ++} ++ ++ ++#ifdef CONFIG_PM ++static int bridge_suspend(struct platform_device *pdev, pm_message_t state) ++{ ++ u32 status; ++ u32 command = PWR_EMERGENCYDEEPSLEEP; ++ ++ status = PWR_SleepDSP(command, timeOut); ++ if (DSP_FAILED(status)) ++ return -1; ++ ++ bridge_suspend_data.suspended = 1; ++ return 0; ++} ++ ++static int bridge_resume(struct platform_device *pdev) ++{ ++ u32 status; ++ ++ status = PWR_WakeDSP(timeOut); ++ if (DSP_FAILED(status)) ++ return -1; ++ ++ bridge_suspend_data.suspended = 0; ++ wake_up(&bridge_suspend_data.suspend_wq); ++ return 0; ++} ++#else ++#define bridge_suspend NULL ++#define bridge_resume NULL ++#endif ++ ++static struct platform_driver bridge_driver = { ++ .driver = { ++ .name = BRIDGE_NAME, ++ }, ++ .probe = omap34xx_bridge_probe, ++ .remove = __devexit_p(omap34xx_bridge_remove), ++ .suspend = bridge_suspend, ++ .resume = bridge_resume, ++}; ++ ++static int __init bridge_init(void) ++{ ++ return platform_driver_register(&bridge_driver); ++} ++ ++static void __exit bridge_exit(void) ++{ ++ platform_driver_unregister(&bridge_driver); ++} ++ ++/* This function is called when an application opens handle to the ++ * bridge driver. */ ++ ++static int bridge_open(struct inode *ip, struct file *filp) ++{ ++ int status = 0; ++#ifndef RES_CLEANUP_DISABLE ++ u32 hProcess; ++ DSP_STATUS dsp_status = DSP_SOK; ++ HANDLE hDrvObject = NULL; ++ struct PROCESS_CONTEXT *pPctxt = NULL; ++ struct PROCESS_CONTEXT *next_node = NULL; ++ struct PROCESS_CONTEXT *pCtxtclosed = NULL; ++ struct PROCESS_CONTEXT *pCtxttraverse = NULL; ++ struct task_struct *tsk = NULL; ++ GT_0trace(driverTrace, GT_ENTER, "-> driver_open\n"); ++ dsp_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ ++ /* Checking weather task structure for all process existing ++ * in the process context list If not removing those processes*/ ++ if (DSP_FAILED(dsp_status)) ++ goto func_cont; ++ ++ DRV_GetProcCtxtList(&pCtxtclosed, (struct DRV_OBJECT *)hDrvObject); ++ while (pCtxtclosed != NULL) { ++ tsk = find_task_by_vpid(pCtxtclosed->pid); ++ next_node = pCtxtclosed->next; ++ ++ if ((tsk == NULL) || (tsk->exit_state == EXIT_ZOMBIE)) { ++ ++ GT_1trace(driverTrace, GT_5CLASS, ++ "***Task structure not existing for " ++ "process***%d\n", pCtxtclosed->pid); ++ DRV_RemoveAllResources(pCtxtclosed); ++ if (pCtxtclosed->hProcessor != NULL) { ++ DRV_GetProcCtxtList(&pCtxttraverse, ++ (struct DRV_OBJECT *)hDrvObject); ++ if (pCtxttraverse->next == NULL) { ++ PROC_Detach(pCtxtclosed->hProcessor); ++ } else { ++ if ((pCtxtclosed->pid == ++ pCtxttraverse->pid) && ++ (pCtxttraverse->next != NULL)) { ++ pCtxttraverse = ++ pCtxttraverse->next; ++ } ++ while ((pCtxttraverse != NULL) && ++ (pCtxtclosed->hProcessor ++ != pCtxttraverse->hProcessor)) { ++ pCtxttraverse = ++ pCtxttraverse->next; ++ if ((pCtxttraverse != NULL) && ++ (pCtxtclosed->pid == ++ pCtxttraverse->pid)) { ++ pCtxttraverse = ++ pCtxttraverse->next; ++ } ++ } ++ if (pCtxttraverse == NULL) { ++ PROC_Detach ++ (pCtxtclosed->hProcessor); ++ } ++ } ++ } ++ DRV_RemoveProcContext((struct DRV_OBJECT *)hDrvObject, ++ pCtxtclosed, ++ (void *)pCtxtclosed->pid); ++ } ++ pCtxtclosed = next_node; ++ } ++func_cont: ++ dsp_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(dsp_status)) ++ dsp_status = DRV_InsertProcContext( ++ (struct DRV_OBJECT *)hDrvObject, &pPctxt); ++ ++ if (pPctxt != NULL) { ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ DRV_ProcUpdatestate(pPctxt, PROC_RES_ALLOCATED); ++ DRV_ProcSetPID(pPctxt, hProcess); ++ } ++#endif ++ ++ GT_0trace(driverTrace, GT_ENTER, " <- driver_open\n"); ++ return status; ++} ++ ++/* This function is called when an application closes handle to the bridge ++ * driver. */ ++static int bridge_release(struct inode *ip, struct file *filp) ++{ ++ int status; ++ u32 pid; ++ ++ GT_0trace(driverTrace, GT_ENTER, "-> driver_release\n"); ++ ++ /* Return PID instead of process handle */ ++ pid = current->pid; ++ ++ status = DSP_Close(pid); ++ ++ ++ (status == true) ? (status = 0) : (status = -1); ++ ++ GT_0trace(driverTrace, GT_ENTER, " <- driver_release\n"); ++ ++ return status; ++} ++ ++/* This function provides IO interface to the bridge driver. */ ++static int bridge_ioctl(struct inode *ip, struct file *filp, unsigned int code, ++ unsigned long args) ++{ ++ int status; ++ u32 retval = DSP_SOK; ++ union Trapped_Args pBufIn; ++ ++ DBC_Require(filp != NULL); ++#ifdef CONFIG_PM ++ status = omap34xxbridge_suspend_lockout(&bridge_suspend_data, filp); ++ if (status != 0) ++ return status; ++#endif ++ ++ GT_0trace(driverTrace, GT_ENTER, " -> driver_ioctl\n"); ++ ++ /* Deduct one for the CMD_BASE. */ ++ code = (code - 1); ++ ++ status = copy_from_user(&pBufIn, (union Trapped_Args *)args, ++ sizeof(union Trapped_Args)); ++ ++ if (status >= 0) { ++ status = WCD_CallDevIOCtl(code, &pBufIn, &retval); ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = retval; ++ } else { ++ GT_1trace(driverTrace, GT_7CLASS, ++ "IOCTL Failed, code : 0x%x\n", code); ++ status = -1; ++ } ++ ++ } ++ ++ GT_0trace(driverTrace, GT_ENTER, " <- driver_ioctl\n"); ++ ++ return status; ++} ++ ++/* This function maps kernel space memory to user space memory. */ ++static int bridge_mmap(struct file *filp, struct vm_area_struct *vma) ++{ ++#if GT_TRACE ++ u32 offset = vma->vm_pgoff << PAGE_SHIFT; ++#endif ++ u32 status; ++ ++ DBC_Assert(vma->vm_start < vma->vm_end); ++ ++ vma->vm_flags |= VM_RESERVED | VM_IO; ++ vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); ++ ++ GT_6trace(driverTrace, GT_3CLASS, ++ "vm filp %p offset %lx start %lx end %lx" ++ " page_prot %lx flags %lx\n", filp, offset, vma->vm_start, ++ vma->vm_end, vma->vm_page_prot, vma->vm_flags); ++ ++ status = remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff, ++ vma->vm_end - vma->vm_start, vma->vm_page_prot); ++ if (status != 0) ++ status = -EAGAIN; ++ ++ return status; ++} ++ ++#ifndef RES_CLEANUP_DISABLE ++/* To remove all process resources before removing the process from the ++ * process context list*/ ++DSP_STATUS DRV_RemoveAllResources(HANDLE hPCtxt) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt; ++ if (pCtxt != NULL) { ++ DRV_RemoveAllSTRMResElements(pCtxt); ++ DRV_RemoveAllNodeResElements(pCtxt); ++ DRV_RemoveAllDMMResElements(pCtxt); ++ DRV_ProcUpdatestate(pCtxt, PROC_RES_FREED); ++ } ++ return status; ++} ++#endif ++ ++/* Bridge driver initialization and de-initialization functions */ ++module_init(bridge_init); ++module_exit(bridge_exit); ++ +diff --git a/drivers/dsp/bridge/rmgr/drv_interface.h b/drivers/dsp/bridge/rmgr/drv_interface.h +new file mode 100644 +index 0000000..f5b068e +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/drv_interface.h +@@ -0,0 +1,40 @@ ++/* ++ * drv_interface.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== drv_interface.h ======== ++ * ++ *! Revision History ++ *! ================ ++ *! 24-Mar-2003 vp Added hooks for Power Management Test ++ *! 18-Feb-2003 vp Code review updates ++ *! 18-Oct-2002 sb Created initial version ++ ++ */ ++ ++#ifndef _DRV_INTERFACE_H_ ++#define _DRV_INTERFACE_H_ ++ ++/* Prototypes for all functions in this bridge */ ++static int __init bridge_init(void); /* Initialize bridge */ ++static void __exit bridge_exit(void); /* Opposite of initialize */ ++static int bridge_open(struct inode *, struct file *); /* Open */ ++static int bridge_release(struct inode *, struct file *); /* Release */ ++static int bridge_ioctl(struct inode *, struct file *, unsigned int, ++ unsigned long); ++static int bridge_mmap(struct file *filp, struct vm_area_struct *vma); ++#endif /* ifndef _DRV_INTERFACE_H_ */ +diff --git a/drivers/dsp/bridge/rmgr/dspdrv.c b/drivers/dsp/bridge/rmgr/dspdrv.c +new file mode 100644 +index 0000000..a7a74fc +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/dspdrv.c +@@ -0,0 +1,276 @@ ++/* ++ * dspdrv.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dspdrv.c ======== ++ * Description: ++ * Interface to allocate and free bridge resources. ++ * ++ *! Revision History ++ *! ================ ++ *! 12-Apr-2004 hp: Compile IVA only for 24xx. ++ *! 09-Feb-2004 vp: Updated to support IVA. ++ *! 10-Feb-2003 vp: Code review updates. ++ *! 18-oct-2002 vp: Ported to the Linux platform. ++ *! 03-Mar-2002 rr: DSP_Deinit bug fixed (gets the Mgrhandle from registry ++ *! before calling MGR_Destroy. ++ *! 11-Jul-2001 jeh Moved MGR_Create() from DSP_Init() to DEV_StartDevice(). ++ *! 02-Apr-2001 rr: WCD_InitComplete2 return value is not checked thus ++ *! sllowing the class driver to load irrespective of ++ *! the image load. ++ *! 30-Oct-2000 kc: Made changes w.r.t. usage of REG_SetValue. ++ *! 05-Oct-2000 rr: WCD_InitComplete2 return value checked for RM. ++ *! Failure in WCD_InitComplete2 will cause the ++ *! DSP_Init to fail. ++ *! 12-Aug-2000 kc: Changed REG_EnumValue to REG_EnumKey. ++ *! 07-Aug-2000 rr: MGR_Create does the job of loading the DCD Dll. ++ *! 26-Jul-2000 rr: Driver Object holds the DevNodeStrings for each ++ *! DevObjects. Static variables removed. Returns ++ *! the Driver Object in DSP_Init. ++ *! 17-Jul-2000 rr: Driver Object is created in DSP_Init and that holds ++ *! the list of Device objects. ++ *! 07-Jul-2000 rr: RM implementaion started. ++ *! 24-May-2000 ag: Cleaned up debug msgs. ++ *! 02-May-2000 rr: DSP_Open returns GetCallerProcess as dwOpenContext. ++ *! 03-Feb-2000 rr: GT Changes. ++ *! 28-Jan-2000 rr: Code Cleaned up.Type void changed to void. ++ *! DSP_Deinit checks return values.dwCode in ++ *! DSP_IO_CONTROL is decoded(not hard coded) ++ *! 27-Jan-2000 rr: REG_EnumValue Used .EnumerateKey fxn removed. ++ *! 13-Jan-2000 rr: CFG_GetPrivateDword renamed to CFG_GetDevObject. ++ *! 29-Dec-1999 rr: Code Cleaned up ++ *! 09-Dec-1999 rr: EnumerateKey changed for retail build. ++ *! 06-Dec-1999 rr: ArrayofInstalledNode, index and ArrayofInstalledDev ++ *! is Global.DevObject stores this pointer as hDevNode. ++ *! 02-Dec-1999 rr: DBG_SetGT and RetailMSG conditionally included. ++ *! Comments changed.Deinit handled.Code cleaned up. ++ *! DSP_IOControl, Close, Deinit returns bool values. ++ *! Calls WCD_InitComplete2 for Board AutoStart. ++ *! 29-Nov-1999 rr: DSP_IOControl returns the result through pBufOut. ++ *! Global Arrays keeps track of installed devices. ++ *! 19-Nov-1999 rr: DSP_Init handles multiple drivers. ++ *! 12-Nov-1999 rr: GetDriverKey and EnumerateKey functions added. ++ *! for multiple mini driver support.PCCARD flag ++ *! checking to include PCMCIA related stuff. ++ *! 25-Oct-1999 rr: GT_Init is called within the Process Attach. ++ *! return value initalized to S_OK upfront in the ++ *! Process Attach. ++ *! 15-Oct-1999 rr: DSP_DeInit handles the return values ++ *! 05-Oct-1999 rr: All the PCMCIA related functions are now in PCCARD.c ++ *! DRV_Request Resources is used instead of the ++ *! RegisterMiniDriver as it sounds close to what we are doing. ++ *! 24-Sep-1999 rr: DRV_RegisterMiniDriver is being called from here. Only ++ *! neccessaryPCMCIA fxns are here. Soon they will move out ++ *! either to a seperate file for bus specific inits. ++ *! 10-Sep-1999 rr: GT Enabled. Considerably changed the driver structure as ++ *! - This is the Class driver. After successfully initialized ++ *! the Class driver will attempt to load the Mini driver. ++ *! - Need to seperate the PCMCIA stuff based on bus type. ++ *! - Changed the name of the file to wcdce.c ++ *! - Made the Media Handle as Global again ++ *! ++ *! 19-Aug-1999 rr: Removed the Global hbhMediaHandle. Included the MemTest. ++ *! Modified the DSP_Init, now three windows are opened. ++ *! Split the driver into PDD so that hardware dependent ++ *! functions will reside in PDD. ++ *! 16-Jul-1999 ag Adapted from rkw's CAC Bullet card driver. ++ *! ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/reg.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/drv.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/_dcd.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/mgr.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dspdrv.h> ++ ++/* ----------------------------------- Globals */ ++struct GT_Mask curTrace; ++ ++/* ++ * ======== DSP_Init ======== ++ * Allocates bridge resources. Loads a base image onto DSP, if specified. ++ */ ++u32 DSP_Init(OUT u32 *initStatus) ++{ ++ char devNode[MAXREGPATHLENGTH] = "TIOMAP1510"; ++ DSP_STATUS status = DSP_EFAIL; ++ struct DRV_OBJECT *drvObject = NULL; ++ u32 index = 0; ++ u32 deviceNode; ++ u32 deviceNodeString; ++ ++ GT_create(&curTrace, "DD"); ++ ++ GT_0trace(curTrace, GT_ENTER, "Entering DSP_Init \r\n"); ++ ++ if (DSP_FAILED(WCD_Init())) { ++ GT_0trace(curTrace, GT_7CLASS, "DSP_Init Failed \n"); ++ goto func_cont; ++ } /* End WCD_Exit */ ++ if (DSP_FAILED(DRV_Create(&drvObject))) { ++ GT_0trace(curTrace, GT_7CLASS, "DSP_Init:DRV_Create Failed \n"); ++ WCD_Exit(); ++ goto func_cont; ++ } /* End DRV_Create */ ++ GT_0trace(curTrace, GT_5CLASS, "DSP_Init:DRV Created \r\n"); ++ ++ /* Request Resources */ ++ if (DSP_SUCCEEDED(DRV_RequestResources((u32)&devNode, ++ &deviceNodeString))) { ++ /* Attempt to Start the Device */ ++ if (DSP_SUCCEEDED(DEV_StartDevice( ++ (struct CFG_DEVNODE *)deviceNodeString))) { ++ /* Retreive the DevObject from the Registry */ ++ GT_2trace(curTrace, GT_1CLASS, ++ "DSP_Init Succeeded for Device1:" ++ "%d: value: %x\n", index, deviceNodeString); ++ status = DSP_SOK; ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ "DSP_Init:DEV_StartDevice Failed\n"); ++ (void)DRV_ReleaseResources ++ ((u32) deviceNodeString, drvObject); ++ status = DSP_EFAIL; ++ } ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, ++ "DSP_Init:DRV_RequestResources Failed \r\n"); ++ status = DSP_EFAIL; ++ } /* DRV_RequestResources */ ++ index++; ++ ++ /* Unwind whatever was loaded */ ++ if (DSP_FAILED(status)) { ++ /* irrespective of the status of DEV_RemoveDevice we conitinue ++ * unloading. Get the Driver Object iterate through and remove. ++ * Reset the status to E_FAIL to avoid going through ++ * WCD_InitComplete2. */ ++ status = DSP_EFAIL; ++ for (deviceNode = DRV_GetFirstDevExtension(); deviceNode != 0; ++ deviceNode = DRV_GetNextDevExtension(deviceNode)) { ++ (void)DEV_RemoveDevice ++ ((struct CFG_DEVNODE *)deviceNode); ++ (void)DRV_ReleaseResources((u32)deviceNode, ++ drvObject); ++ } ++ /* Remove the Driver Object */ ++ (void)DRV_Destroy(drvObject); ++ drvObject = NULL; ++ WCD_Exit(); ++ GT_0trace(curTrace, GT_7CLASS, ++ "DSP_Init:Logical device Failed to Load\n"); ++ } /* Unwinding the loaded drivers */ ++func_cont: ++ /* Attempt to Start the Board */ ++ if (DSP_SUCCEEDED(status)) { ++ /* BRD_AutoStart could fail if the dsp execuetable is not the ++ * correct one. We should not propagate that error ++ * into the device loader. */ ++ (void)WCD_InitComplete2(); ++ GT_0trace(curTrace, GT_1CLASS, "DSP_Init Succeeded\n"); ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, "DSP_Init Failed\n"); ++ } /* End WCD_InitComplete2 */ ++ DBC_Ensure((DSP_SUCCEEDED(status) && drvObject != NULL) || ++ (DSP_FAILED(status) && drvObject == NULL)); ++ *initStatus = status; ++ /* Return the Driver Object */ ++ return (u32)drvObject; ++} ++ ++/* ++ * ======== DSP_Deinit ======== ++ * Frees the resources allocated for bridge. ++ */ ++bool DSP_Deinit(u32 deviceContext) ++{ ++ bool retVal = true; ++ u32 deviceNode; ++ struct MGR_OBJECT *mgrObject = NULL; ++ ++ GT_0trace(curTrace, GT_ENTER, "Entering DSP_Deinit \r\n"); ++ ++ while ((deviceNode = DRV_GetFirstDevExtension()) != 0) { ++ (void)DEV_RemoveDevice((struct CFG_DEVNODE *)deviceNode); ++ ++ (void)DRV_ReleaseResources((u32)deviceNode, ++ (struct DRV_OBJECT *)deviceContext); ++ } ++ ++ (void) DRV_Destroy((struct DRV_OBJECT *) deviceContext); ++ ++ /* Get the Manager Object from Registry ++ * MGR Destroy will unload the DCD dll */ ++ if (DSP_SUCCEEDED(CFG_GetObject((u32 *)&mgrObject, REG_MGR_OBJECT))) ++ (void)MGR_Destroy(mgrObject); ++ ++ WCD_Exit(); ++ ++ return retVal; ++} ++ ++/* ++ * ======== DSP_Close ======== ++ * The Calling Process handle is passed to DEV_CleanupProcesState ++ * for cleaning up of any resources used by the application ++ */ ++bool DSP_Close(u32 dwOpenContext) ++{ ++ bool retVal = false; ++ ++ DBC_Require(dwOpenContext != 0); ++ ++ GT_0trace(curTrace, GT_ENTER, "Entering DSP_Close\n"); ++ ++#ifdef RES_CLEANUP_DISABLE ++ ++ if (DSP_SUCCEEDED(DEV_CleanupProcessState((HANDLE) dwOpenContext))) { ++ GT_0trace(curTrace, GT_1CLASS, "DSP_Close Succeeded \r\n"); ++ retVal = true; ++ } else { ++ GT_0trace(curTrace, GT_7CLASS, "DSP_Close failed \r\n"); ++ } ++#endif ++ ++ return retVal; ++} +diff --git a/drivers/dsp/bridge/rmgr/mgr.c b/drivers/dsp/bridge/rmgr/mgr.c +new file mode 100644 +index 0000000..943cf93 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/mgr.c +@@ -0,0 +1,491 @@ ++/* ++ * mgr.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mgr.c ======== ++ * Description: ++ * Implementation of Manager interface to the device object at the ++ * driver level. This queries the NDB data base and retrieves the ++ * data about Node and Processor. ++ * ++ * ++ *! Revision History: ++ *! ================ ++ *! 12-Feb-2003 vp: Code review updates. ++ *! 18-Oct-2002 vp: Ported to Linux platform ++ *! 01-Aug-2001 ag: Added extended info for DSP-MMU setup support. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 22-Nov-2000 kc: Added MGR_GetPerfData. ++ *! 03-Nov-2000 rr: Updated after code review. ++ *! 25-Sep-2000 rr: Updated to Version 0.9 ++ *! 10-Aug-2000 rr: dwSignature is not specifically inserted in MGR Obj ++ *! as it is taken care by MEM_AllocObject. stdwin.h added ++ *! for retail build to succeed. ++ *! 07-Aug-2000 rr: MGR_Create does the job of Loading DCD Dll. ++ *! 26-Jul-2000 rr: MGR_Destroy releases the hNDBDll. ++ *! 20-Jun-2000 rr: Created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbdcd.h> ++#include <dspbridge/dbreg.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/mgr.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define ZLDLLNAME "" ++#define SIGNATURE 0x5f52474d /* "MGR_" (in reverse) */ ++ ++struct MGR_OBJECT { ++ u32 dwSignature; ++ struct DCD_MANAGER *hDcdMgr; /* Proc/Node data manager */ ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask MGR_DebugMask = { NULL, NULL }; ++#endif ++ ++static u32 cRefs; ++ ++/* ++ * ========= MGR_Create ========= ++ * Purpose: ++ * MGR Object gets created only once during driver Loading. ++ */ ++DSP_STATUS MGR_Create(OUT struct MGR_OBJECT **phMgrObject, ++ struct CFG_DEVNODE *hDevNode) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct MGR_OBJECT *pMgrObject = NULL; ++ ++ DBC_Require(phMgrObject != NULL); ++ DBC_Require(cRefs > 0); ++ GT_1trace(MGR_DebugMask, GT_ENTER, ++ "Entering MGR_Create phMgrObject 0x%x\n ", ++ phMgrObject); ++ MEM_AllocObject(pMgrObject, struct MGR_OBJECT, SIGNATURE); ++ if (pMgrObject) { ++ if (DSP_SUCCEEDED(DCD_CreateManager(ZLDLLNAME, ++ &pMgrObject->hDcdMgr))) { ++ /* If succeeded store the handle in the MGR Object */ ++ if (DSP_SUCCEEDED(CFG_SetObject((u32)pMgrObject, ++ REG_MGR_OBJECT))) { ++ *phMgrObject = pMgrObject; ++ GT_0trace(MGR_DebugMask, GT_1CLASS, ++ "MGR_Create:MGR Created\r\n"); ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "MGR_Create:CFG_SetObject " ++ "Failed\r\n"); ++ DCD_DestroyManager(pMgrObject->hDcdMgr); ++ MEM_FreeObject(pMgrObject); ++ } ++ } else { ++ /* failed to Create DCD Manager */ ++ status = DSP_EFAIL; ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "MGR_Create:DCD_ManagerCreate Failed\r\n"); ++ MEM_FreeObject(pMgrObject); ++ } ++ } else { ++ status = DSP_EMEMORY; ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "MGR_Create DSP_FAILED to allocate memory \n"); ++ } ++ GT_2trace(MGR_DebugMask, GT_ENTER, ++ "Exiting MGR_Create: phMgrObject: 0x%x\t" ++ "status: 0x%x\n", phMgrObject, status); ++ DBC_Ensure(DSP_FAILED(status) || ++ MEM_IsValidHandle(pMgrObject, SIGNATURE)); ++ return status; ++} ++ ++/* ++ * ========= MGR_Destroy ========= ++ * This function is invoked during bridge driver unloading.Frees MGR object. ++ */ ++DSP_STATUS MGR_Destroy(struct MGR_OBJECT *hMgrObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct MGR_OBJECT *pMgrObject = (struct MGR_OBJECT *)hMgrObject; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hMgrObject, SIGNATURE)); ++ ++ GT_1trace(MGR_DebugMask, GT_ENTER, ++ "Entering MGR_Destroy hMgrObject 0x%x\n", hMgrObject); ++ /* Free resources */ ++ if (hMgrObject->hDcdMgr) ++ DCD_DestroyManager(hMgrObject->hDcdMgr); ++ ++ MEM_FreeObject(pMgrObject); ++ /* Update the Registry with NULL for MGR Object */ ++ (void)CFG_SetObject(0, REG_MGR_OBJECT); ++ ++ GT_2trace(MGR_DebugMask, GT_ENTER, ++ "Exiting MGR_Destroy: hMgrObject: 0x%x\t" ++ "status: 0x%x\n", hMgrObject, status); ++ ++ DBC_Ensure(DSP_FAILED(status) || ++ !MEM_IsValidHandle(hMgrObject, SIGNATURE)); ++ ++ return status; ++} ++ ++/* ++ * ======== MGR_EnumNodeInfo ======== ++ * Enumerate and get configuration information about nodes configured ++ * in the node database. ++ */ ++DSP_STATUS MGR_EnumNodeInfo(u32 uNode, OUT struct DSP_NDBPROPS *pNDBProps, ++ u32 uNDBPropsSize, OUT u32 *puNumNodes) ++{ ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ struct DSP_UUID Uuid, uTempUuid; ++ u32 uTempIndex = 0; ++ u32 uNodeIndex = 0; ++ struct DCD_GENERICOBJ GenObj; ++ struct MGR_OBJECT *pMgrObject = NULL; ++ ++ DBC_Require(pNDBProps != NULL); ++ DBC_Require(puNumNodes != NULL); ++ DBC_Require(uNDBPropsSize >= sizeof(struct DSP_NDBPROPS)); ++ DBC_Require(cRefs > 0); ++ ++ GT_4trace(MGR_DebugMask, GT_ENTER, "Entered Manager_EnumNodeInfo, " ++ "args:\n\t uNode: 0x%x\n\tpNDBProps: 0x%x\n\tuNDBPropsSize:" ++ "0x%x\tpuNumNodes: 0x%x\n", uNode, pNDBProps, ++ uNDBPropsSize, puNumNodes); ++ *puNumNodes = 0; ++ /* Get The Manager Object from the Registry */ ++ if (DSP_FAILED(CFG_GetObject((u32 *)&pMgrObject, ++ REG_MGR_OBJECT))) { ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumNodeInfo:Failed To Get" ++ " MGR Object from Registry\r\n"); ++ goto func_cont; ++ } ++ DBC_Assert(MEM_IsValidHandle(pMgrObject, SIGNATURE)); ++ /* Forever loop till we hit failed or no more items in the ++ * Enumeration. We will exit the loop other than DSP_SOK; */ ++ while (status == DSP_SOK) { ++ status = DCD_EnumerateObject(uTempIndex++, DSP_DCDNODETYPE, ++ &uTempUuid); ++ if (status == DSP_SOK) { ++ uNodeIndex++; ++ if (uNode == (uNodeIndex - 1)) ++ Uuid = uTempUuid; ++ ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ if (uNode > (uNodeIndex - 1)) { ++ status = DSP_EINVALIDARG; ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumNodeInfo: uNode" ++ " is Invalid \r\n"); ++ } else { ++ status1 = DCD_GetObjectDef(pMgrObject->hDcdMgr, ++ (struct DSP_UUID *)&Uuid, ++ DSP_DCDNODETYPE, &GenObj); ++ if (DSP_SUCCEEDED(status1)) { ++ /* Get the Obj def */ ++ *pNDBProps = GenObj.objData.nodeObj.ndbProps; ++ *puNumNodes = uNodeIndex; ++ status = DSP_SOK; ++ } else { ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumNodeInfo: " ++ "Failed to Get Node Info \r\n"); ++ status = DSP_EFAIL; ++ } ++ } ++ } else { ++ /* This could be changed during enum, EFAIL ... */ ++ GT_0trace(MGR_DebugMask, GT_7CLASS, "Manager_EnumNodeInfo: " ++ "Enumeration failure\r\n"); ++ status = DSP_EFAIL; ++ } ++func_cont: ++ GT_4trace(MGR_DebugMask, GT_ENTER, ++ "Exiting Manager_EnumNodeInfo, args:\n\t" ++ "uNode: 0x%x\n\tpNDBProps: 0x%x\n\tuNDBPropsSize:" ++ " 0x%x\tuNumNodes: 0x%x\n", uNode, pNDBProps, ++ uNDBPropsSize, *puNumNodes); ++ DBC_Ensure((DSP_SUCCEEDED(status) && *puNumNodes > 0) || ++ (DSP_FAILED(status) && *puNumNodes == 0)); ++ ++ return status; ++} ++ ++/* ++ * ======== MGR_EnumProcessorInfo ======== ++ * Enumerate and get configuration information about available ++ * DSP processors. ++ */ ++DSP_STATUS MGR_EnumProcessorInfo(u32 uProcessor, ++ OUT struct DSP_PROCESSORINFO *pProcessorInfo, ++ u32 uProcessorInfoSize, OUT u32 *puNumProcs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ DSP_STATUS status2 = DSP_SOK; ++ struct DSP_UUID uTempUuid; ++ u32 uTempIndex = 0; ++ u32 uProcIndex = 0; ++ struct DCD_GENERICOBJ GenObj; ++ struct MGR_OBJECT *pMgrObject = NULL; ++ struct MGR_PROCESSOREXTINFO *pExtInfo; ++ struct DEV_OBJECT *hDevObject; ++ struct DRV_OBJECT *hDrvObject; ++ s32 devType; ++ struct CFG_DEVNODE *devNode; ++ struct CFG_DSPRES chipResources; ++ bool procDetect = false; ++ ++ DBC_Require(pProcessorInfo != NULL); ++ DBC_Require(puNumProcs != NULL); ++ DBC_Require(uProcessorInfoSize >= sizeof(struct DSP_PROCESSORINFO)); ++ DBC_Require(cRefs > 0); ++ ++ GT_4trace(MGR_DebugMask, GT_ENTER, ++ "Entered Manager_EnumProcessorInfo, " ++ "args:\n\tuProcessor: 0x%x\n\tpProcessorInfo: 0x%x\n\t" ++ "uProcessorInfoSize: 0x%x\tpuNumProcs: 0x%x\n", uProcessor, ++ pProcessorInfo, uProcessorInfoSize, puNumProcs); ++ *puNumProcs = 0; ++ status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(status)) { ++ status = DRV_GetDevObject(uProcessor, hDrvObject, &hDevObject); ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetDevType(hDevObject, (u32 *) &devType); ++ status = DEV_GetDevNode(hDevObject, &devNode); ++ if (devType == DSP_UNIT) { ++ status = CFG_GetDSPResources(devNode, ++ &chipResources); ++ } else { ++ status = DSP_EFAIL; ++ GT_1trace(MGR_DebugMask, GT_7CLASS, ++ "Unsupported dev type gotten" ++ "from device object %d\n", devType); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pProcessorInfo->uProcessorType = ++ chipResources.uChipType; ++ } ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Get The Manager Object from the Registry */ ++ if (DSP_FAILED(CFG_GetObject((u32 *)&pMgrObject, ++ REG_MGR_OBJECT))) { ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumProcessorInfo: " ++ "Failed To Get MGR Object from Registry\r\n"); ++ goto func_end; ++ } ++ DBC_Assert(MEM_IsValidHandle(pMgrObject, SIGNATURE)); ++ /* Forever loop till we hit no more items in the ++ * Enumeration. We will exit the loop other than DSP_SOK; */ ++ while (status1 == DSP_SOK) { ++ status1 = DCD_EnumerateObject(uTempIndex++, ++ DSP_DCDPROCESSORTYPE, ++ &uTempUuid); ++ if (status1 != DSP_SOK) ++ break; ++ ++ uProcIndex++; ++ /* Get the Object properties to find the Device/Processor ++ * Type */ ++ if (procDetect != false) ++ continue; ++ ++ status2 = DCD_GetObjectDef(pMgrObject->hDcdMgr, ++ (struct DSP_UUID *)&uTempUuid, ++ DSP_DCDPROCESSORTYPE, ++ &GenObj); ++ if (DSP_SUCCEEDED(status2)) { ++ /* Get the Obj def */ ++ if (uProcessorInfoSize < ++ sizeof(struct MGR_PROCESSOREXTINFO)) { ++ *pProcessorInfo = GenObj.objData.procObj; ++ } else { ++ /* extended info */ ++ pExtInfo = (struct MGR_PROCESSOREXTINFO *) ++ pProcessorInfo; ++ *pExtInfo = GenObj.objData.extProcObj; ++ } ++ GT_1trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumProcessorInfo: Got" ++ " Proctype from DCD %x \r\n", ++ pProcessorInfo->uProcessorType); ++ /* See if we got the needed processor */ ++ if (devType == DSP_UNIT) { ++ if (pProcessorInfo->uProcessorType == ++ DSPPROCTYPE_C64) ++ procDetect = true; ++ } else if (devType == IVA_UNIT) { ++ if (pProcessorInfo->uProcessorType == ++ IVAPROCTYPE_ARM7) ++ procDetect = true; ++ } ++ /* User applciatiuons aonly check for chip type, so ++ * this clumsy overwrite */ ++ pProcessorInfo->uProcessorType = ++ chipResources.uChipType; ++ } else { ++ GT_1trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumProcessorInfo: " ++ "Failed to Get DCD Processor Info %x \r\n", ++ status2); ++ status = DSP_EFAIL; ++ } ++ } ++ *puNumProcs = uProcIndex; ++ if (procDetect == false) { ++ GT_0trace(MGR_DebugMask, GT_7CLASS, ++ "Manager_EnumProcessorInfo: Failed" ++ " to get Proc info from DCD , so use CFG registry\n"); ++ pProcessorInfo->uProcessorType = chipResources.uChipType; ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== MGR_Exit ======== ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ */ ++void MGR_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ cRefs--; ++ if (cRefs == 0) ++ DCD_Exit(); ++ ++ GT_1trace(MGR_DebugMask, GT_5CLASS, ++ "Entered MGR_Exit, ref count: 0x%x\n", cRefs); ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== MGR_GetDCDHandle ======== ++ * Retrieves the MGR handle. Accessor Function. ++ */ ++DSP_STATUS MGR_GetDCDHandle(struct MGR_OBJECT *hMGRHandle, ++ OUT u32 *phDCDHandle) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct MGR_OBJECT *pMgrObject = (struct MGR_OBJECT *)hMGRHandle; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDCDHandle != NULL); ++ ++ *phDCDHandle = (u32)NULL; ++ if (MEM_IsValidHandle(pMgrObject, SIGNATURE)) { ++ *phDCDHandle = (u32) pMgrObject->hDcdMgr; ++ status = DSP_SOK; ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && *phDCDHandle != (u32)NULL) || ++ (DSP_FAILED(status) && *phDCDHandle == (u32)NULL)); ++ ++ return status; ++} ++ ++/* ++ * ======== MGR_Init ======== ++ * Initialize MGR's private state, keeping a reference count on each call. ++ */ ++bool MGR_Init(void) ++{ ++ bool fRetval = true; ++ bool fInitDCD = false; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ ++ /* Set the Trace mask */ ++ DBC_Assert(!MGR_DebugMask.flags); ++ ++ GT_create(&MGR_DebugMask, "MG"); /* "MG" for Manager */ ++ fInitDCD = DCD_Init(); /* DCD Module */ ++ ++ if (!fInitDCD) { ++ fRetval = false; ++ GT_0trace(MGR_DebugMask, GT_6CLASS, ++ "MGR_Init failed\n"); ++ } ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ ++ GT_1trace(MGR_DebugMask, GT_5CLASS, ++ "Entered MGR_Init, ref count: 0x%x\n", cRefs); ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++/* ++ * ======== MGR_WaitForBridgeEvents ======== ++ * Block on any Bridge event(s) ++ */ ++DSP_STATUS MGR_WaitForBridgeEvents(struct DSP_NOTIFICATION **aNotifications, ++ u32 uCount, OUT u32 *puIndex, u32 uTimeout) ++{ ++ DSP_STATUS status; ++ struct SYNC_OBJECT *hSyncEvents[MAX_EVENTS]; ++ u32 i; ++ ++ DBC_Require(uCount < MAX_EVENTS); ++ ++ for (i = 0; i < uCount; i++) ++ hSyncEvents[i] = aNotifications[i]->handle; ++ ++ status = SYNC_WaitOnMultipleEvents(hSyncEvents, uCount, uTimeout, ++ puIndex); ++ ++ return status; ++ ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/nldr.c b/drivers/dsp/bridge/rmgr/nldr.c +new file mode 100644 +index 0000000..f3c429c +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/nldr.c +@@ -0,0 +1,1967 @@ ++/* ++ * nldr.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== nldr.c ======== ++ * Description: ++ * DSP/BIOS Bridge dynamic + overlay Node loader. ++ * ++ * Public Functions: ++ * NLDR_Allocate ++ * NLDR_Create ++ * NLDR_Delete ++ * NLDR_Exit ++ * NLDR_Free ++ * NLDR_GetFxnAddr ++ * NLDR_Init ++ * NLDR_Load ++ * NLDR_Unload ++ * ++ * Notes: ++ * ++ *! Revision History ++ *! ================ ++ *! 07-Apr-2003 map Removed references to dead DLDR module ++ *! 23-Jan-2003 map Updated RemoteAlloc to support memory granularity ++ *! 20-Jan-2003 map Updated to maintain persistent dependent libraries ++ *! 15-Jan-2003 map Adapted for use with multiple dynamic phase libraries ++ *! 19-Dec-2002 map Fixed overlay bug in AddOvlySect for overlay ++ *! sections > 1024 bytes. ++ *! 13-Dec-2002 map Fixed NLDR_GetFxnAddr bug by searching dependent ++ *! libs for symbols ++ *! 27-Sep-2002 map Added RemoteFree to convert size to words for ++ *! correct deallocation ++ *! 16-Sep-2002 map Code Review Cleanup(from dldr.c) ++ *! 29-Aug-2002 map Adjusted for ARM-side overlay copy ++ *! 05-Aug-2002 jeh Created. ++ */ ++ ++#include <dspbridge/host_os.h> ++ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++#ifdef DEBUG ++#include <dspbridge/dbg.h> ++#endif ++ ++/* OS adaptation layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* Platform manager */ ++#include <dspbridge/cod.h> ++#include <dspbridge/dev.h> ++ ++/* Resource manager */ ++#include <dspbridge/dbll.h> ++#include <dspbridge/dbdcd.h> ++#include <dspbridge/rmm.h> ++#include <dspbridge/uuidutil.h> ++ ++#include <dspbridge/nldr.h> ++ ++#define NLDR_SIGNATURE 0x52444c4e /* "RDLN" */ ++#define NLDR_NODESIGNATURE 0x4e444c4e /* "NDLN" */ ++ ++/* Name of section containing dynamic load mem */ ++#define DYNMEMSECT ".dspbridge_mem" ++ ++/* Name of section containing dependent library information */ ++#define DEPLIBSECT ".dspbridge_deplibs" ++ ++/* Max depth of recursion for loading node's dependent libraries */ ++#define MAXDEPTH 5 ++ ++/* Max number of persistent libraries kept by a node */ ++#define MAXLIBS 5 ++ ++/* ++ * Defines for extracting packed dynamic load memory requirements from two ++ * masks. ++ * These defines must match node.cdb and dynm.cdb ++ * Format of data/code mask is: ++ * uuuuuuuu|fueeeeee|fudddddd|fucccccc| ++ * where ++ * u = unused ++ * cccccc = prefered/required dynamic mem segid for create phase data/code ++ * dddddd = prefered/required dynamic mem segid for delete phase data/code ++ * eeeeee = prefered/req. dynamic mem segid for execute phase data/code ++ * f = flag indicating if memory is preferred or required: ++ * f = 1 if required, f = 0 if preferred. ++ * ++ * The 6 bits of the segid are interpreted as follows: ++ * ++ * If the 6th bit (bit 5) is not set, then this specifies a memory segment ++ * between 0 and 31 (a maximum of 32 dynamic loading memory segments). ++ * If the 6th bit (bit 5) is set, segid has the following interpretation: ++ * segid = 32 - Any internal memory segment can be used. ++ * segid = 33 - Any external memory segment can be used. ++ * segid = 63 - Any memory segment can be used (in this case the ++ * required/preferred flag is irrelevant). ++ * ++ */ ++/* Maximum allowed dynamic loading memory segments */ ++#define MAXMEMSEGS 32 ++ ++#define MAXSEGID 3 /* Largest possible (real) segid */ ++#define MEMINTERNALID 32 /* Segid meaning use internal mem */ ++#define MEMEXTERNALID 33 /* Segid meaning use external mem */ ++#define NULLID 63 /* Segid meaning no memory req/pref */ ++#define FLAGBIT 7 /* 7th bit is pref./req. flag */ ++#define SEGMASK 0x3f /* Bits 0 - 5 */ ++ ++#define CREATEBIT 0 /* Create segid starts at bit 0 */ ++#define DELETEBIT 8 /* Delete segid starts at bit 8 */ ++#define EXECUTEBIT 16 /* Execute segid starts at bit 16 */ ++ ++/* ++ * Masks that define memory type. Must match defines in dynm.cdb. ++ */ ++#define DYNM_CODE 0x2 ++#define DYNM_DATA 0x4 ++#define DYNM_CODEDATA (DYNM_CODE | DYNM_DATA) ++#define DYNM_INTERNAL 0x8 ++#define DYNM_EXTERNAL 0x10 ++ ++/* ++ * Defines for packing memory requirement/preference flags for code and ++ * data of each of the node's phases into one mask. ++ * The bit is set if the segid is required for loading code/data of the ++ * given phase. The bit is not set, if the segid is preferred only. ++ * ++ * These defines are also used as indeces into a segid array for the node. ++ * eg node's segid[CREATEDATAFLAGBIT] is the memory segment id that the ++ * create phase data is required or preferred to be loaded into. ++ */ ++#define CREATEDATAFLAGBIT 0 ++#define CREATECODEFLAGBIT 1 ++#define EXECUTEDATAFLAGBIT 2 ++#define EXECUTECODEFLAGBIT 3 ++#define DELETEDATAFLAGBIT 4 ++#define DELETECODEFLAGBIT 5 ++#define MAXFLAGS 6 ++ ++#define IsInternal(hNldr, segid) (((segid) <= MAXSEGID && \ ++ hNldr->segTable[(segid)] & DYNM_INTERNAL) || \ ++ (segid) == MEMINTERNALID) ++ ++#define IsExternal(hNldr, segid) (((segid) <= MAXSEGID && \ ++ hNldr->segTable[(segid)] & DYNM_EXTERNAL) || \ ++ (segid) == MEMEXTERNALID) ++ ++#define SWAPLONG(x) ((((x) << 24) & 0xFF000000) | (((x) << 8) & 0xFF0000L) | \ ++ (((x) >> 8) & 0xFF00L) | (((x) >> 24) & 0xFF)) ++ ++#define SWAPWORD(x) ((((x) << 8) & 0xFF00) | (((x) >> 8) & 0xFF)) ++ ++ /* ++ * These names may be embedded in overlay sections to identify which ++ * node phase the section should be overlayed. ++ */ ++#define PCREATE "create" ++#define PDELETE "delete" ++#define PEXECUTE "execute" ++ ++#define IsEqualUUID(uuid1, uuid2) (\ ++ ((uuid1).ulData1 == (uuid2).ulData1) && \ ++ ((uuid1).usData2 == (uuid2).usData2) && \ ++ ((uuid1).usData3 == (uuid2).usData3) && \ ++ ((uuid1).ucData4 == (uuid2).ucData4) && \ ++ ((uuid1).ucData5 == (uuid2).ucData5) && \ ++ (strncmp((void *)(uuid1).ucData6, (void *)(uuid2).ucData6, 6)) == 0) ++ ++ /* ++ * ======== MemInfo ======== ++ * Format of dynamic loading memory segment info in coff file. ++ * Must match dynm.h55. ++ */ ++struct MemInfo { ++ u32 segid; /* Dynamic loading memory segment number */ ++ u32 base; ++ u32 len; ++ u32 type; /* Mask of DYNM_CODE, DYNM_INTERNAL, etc. */ ++}; ++ ++/* ++ * ======== LibNode ======== ++ * For maintaining a tree of library dependencies. ++ */ ++struct LibNode { ++ struct DBLL_LibraryObj *lib; /* The library */ ++ u16 nDepLibs; /* Number of dependent libraries */ ++ struct LibNode *pDepLibs; /* Dependent libraries of lib */ ++}; ++ ++/* ++ * ======== OvlySect ======== ++ * Information needed to overlay a section. ++ */ ++struct OvlySect { ++ struct OvlySect *pNextSect; ++ u32 loadAddr; /* Load address of section */ ++ u32 runAddr; /* Run address of section */ ++ u32 size; /* Size of section */ ++ u16 page; /* DBL_CODE, DBL_DATA */ ++}; ++ ++/* ++ * ======== OvlyNode ======== ++ * For maintaining a list of overlay nodes, with sections that need to be ++ * overlayed for each of the nodes phases. ++ */ ++struct OvlyNode { ++ struct DSP_UUID uuid; ++ char *pNodeName; ++ struct OvlySect *pCreateSects; ++ struct OvlySect *pDeleteSects; ++ struct OvlySect *pExecuteSects; ++ struct OvlySect *pOtherSects; ++ u16 nCreateSects; ++ u16 nDeleteSects; ++ u16 nExecuteSects; ++ u16 nOtherSects; ++ u16 createRef; ++ u16 deleteRef; ++ u16 executeRef; ++ u16 otherRef; ++}; ++ ++/* ++ * ======== NLDR_OBJECT ======== ++ * Overlay loader object. ++ */ ++struct NLDR_OBJECT { ++ u32 dwSignature; /* For object validation */ ++ struct DEV_OBJECT *hDevObject; /* Device object */ ++ struct DCD_MANAGER *hDcdMgr; /* Proc/Node data manager */ ++ struct DBLL_TarObj *dbll; /* The DBL loader */ ++ struct DBLL_LibraryObj *baseLib; /* Base image library */ ++ struct RMM_TargetObj *rmm; /* Remote memory manager for DSP */ ++ struct DBLL_Fxns dbllFxns; /* Loader function table */ ++ struct DBLL_Attrs dbllAttrs; /* attrs to pass to loader functions */ ++ NLDR_OVLYFXN ovlyFxn; /* "write" for overlay nodes */ ++ NLDR_WRITEFXN writeFxn; /* "write" for dynamic nodes */ ++ struct OvlyNode *ovlyTable; /* Table of overlay nodes */ ++ u16 nOvlyNodes; /* Number of overlay nodes in base */ ++ u16 nNode; /* Index for tracking overlay nodes */ ++ u16 nSegs; /* Number of dynamic load mem segs */ ++ u32 *segTable; /* memtypes of dynamic memory segs ++ * indexed by segid ++ */ ++ u16 usDSPMauSize; /* Size of DSP MAU */ ++ u16 usDSPWordSize; /* Size of DSP word */ ++}; ++ ++/* ++ * ======== NLDR_NODEOBJECT ======== ++ * Dynamic node object. This object is created when a node is allocated. ++ */ ++struct NLDR_NODEOBJECT { ++ u32 dwSignature; /* For object validation */ ++ struct NLDR_OBJECT *pNldr; /* Dynamic loader handle */ ++ void *pPrivRef; /* Handle to pass to DBL_WriteFxn */ ++ struct DSP_UUID uuid; /* Node's UUID */ ++ bool fDynamic; /* Dynamically loaded node? */ ++ bool fOverlay; /* Overlay node? */ ++ bool *pfPhaseSplit; /* Multiple phase libraries? */ ++ struct LibNode root; /* Library containing node phase */ ++ struct LibNode createLib; /* Library containing create phase lib */ ++ struct LibNode executeLib; /* Library containing execute phase lib */ ++ struct LibNode deleteLib; /* Library containing delete phase lib */ ++ struct LibNode persLib[MAXLIBS]; /* libs remain loaded until Delete */ ++ s32 nPersLib; /* Number of persistent libraries */ ++ /* Path in lib dependency tree */ ++ struct DBLL_LibraryObj *libPath[MAXDEPTH + 1]; ++ enum NLDR_PHASE phase; /* Node phase currently being loaded */ ++ ++ /* ++ * Dynamic loading memory segments for data and code of each phase. ++ */ ++ u16 segId[MAXFLAGS]; ++ ++ /* ++ * Mask indicating whether each mem segment specified in segId[] ++ * is preferred or required. ++ * For example if (codeDataFlagMask & (1 << EXECUTEDATAFLAGBIT)) != 0, ++ * then it is required to load execute phase data into the memory ++ * specified by segId[EXECUTEDATAFLAGBIT]. ++ */ ++ u32 codeDataFlagMask; ++}; ++ ++/* Dynamic loader function table */ ++static struct DBLL_Fxns dbllFxns = { ++ (DBLL_CloseFxn) DBLL_close, ++ (DBLL_CreateFxn) DBLL_create, ++ (DBLL_DeleteFxn) DBLL_delete, ++ (DBLL_ExitFxn) DBLL_exit, ++ (DBLL_GetAttrsFxn) DBLL_getAttrs, ++ (DBLL_GetAddrFxn) DBLL_getAddr, ++ (DBLL_GetCAddrFxn) DBLL_getCAddr, ++ (DBLL_GetSectFxn) DBLL_getSect, ++ (DBLL_InitFxn) DBLL_init, ++ (DBLL_LoadFxn) DBLL_load, ++ (DBLL_LoadSectFxn) DBLL_loadSect, ++ (DBLL_OpenFxn) DBLL_open, ++ (DBLL_ReadSectFxn) DBLL_readSect, ++ (DBLL_SetAttrsFxn) DBLL_setAttrs, ++ (DBLL_UnloadFxn) DBLL_unload, ++ (DBLL_UnloadSectFxn) DBLL_unloadSect, ++}; ++ ++static struct GT_Mask NLDR_debugMask = { NULL, NULL }; /* GT trace variable */ ++static u32 cRefs; /* module reference count */ ++ ++static DSP_STATUS AddOvlyInfo(void *handle, struct DBLL_SectInfo *sectInfo, ++ u32 addr, u32 nBytes); ++static DSP_STATUS AddOvlyNode(struct DSP_UUID *pUuid, ++ enum DSP_DCDOBJTYPE objType, ++ IN void *handle); ++static DSP_STATUS AddOvlySect(struct NLDR_OBJECT *hNldr, ++ struct OvlySect **pList, ++ struct DBLL_SectInfo *pSectInfo, bool *pExists, ++ u32 addr, u32 nBytes); ++static s32 fakeOvlyWrite(void *handle, u32 dspAddr, void *buf, u32 nBytes, ++ s32 mtype); ++static void FreeSects(struct NLDR_OBJECT *hNldr, struct OvlySect *pPhaseSects, ++ u16 nAlloc); ++static bool GetSymbolValue(void *handle, void *pArg, void *rmmHandle, ++ char *symName, struct DBLL_Symbol **sym); ++static DSP_STATUS LoadLib(struct NLDR_NODEOBJECT *hNldrNode, ++ struct LibNode *root, struct DSP_UUID uuid, ++ bool rootPersistent, struct DBLL_LibraryObj **libPath, ++ enum NLDR_PHASE phase, u16 depth); ++static DSP_STATUS LoadOvly(struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++static DSP_STATUS RemoteAlloc(void **pRef, u16 memType, u32 size, ++ u32 align, u32 *dspAddr, ++ OPTIONAL s32 segmentId, OPTIONAL s32 req, ++ bool reserve); ++static DSP_STATUS RemoteFree(void **pRef, u16 space, u32 dspAddr, ++ u32 size, bool reserve); ++ ++static void UnloadLib(struct NLDR_NODEOBJECT *hNldrNode, struct LibNode *root); ++static void UnloadOvly(struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase); ++static bool findInPersistentLibArray(struct NLDR_NODEOBJECT *hNldrNode, ++ struct DBLL_LibraryObj *lib); ++static u32 findLcm(u32 a, u32 b); ++static u32 findGcf(u32 a, u32 b); ++ ++/* ++ * ======== NLDR_Allocate ======== ++ */ ++DSP_STATUS NLDR_Allocate(struct NLDR_OBJECT *hNldr, void *pPrivRef, ++ IN CONST struct DCD_NODEPROPS *pNodeProps, ++ OUT struct NLDR_NODEOBJECT **phNldrNode, ++ IN bool *pfPhaseSplit) ++{ ++ struct NLDR_NODEOBJECT *pNldrNode = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pNodeProps != NULL); ++ DBC_Require(phNldrNode != NULL); ++ DBC_Require(MEM_IsValidHandle(hNldr, NLDR_SIGNATURE)); ++ ++ GT_5trace(NLDR_debugMask, GT_ENTER, "NLDR_Allocate(0x%x, 0x%x, 0x%x, " ++ "0x%x, 0x%x)\n", hNldr, pPrivRef, pNodeProps, phNldrNode, ++ pfPhaseSplit); ++ ++ /* Initialize handle in case of failure */ ++ *phNldrNode = NULL; ++ /* Allocate node object */ ++ MEM_AllocObject(pNldrNode, struct NLDR_NODEOBJECT, NLDR_NODESIGNATURE); ++ ++ if (pNldrNode == NULL) { ++ GT_0trace(NLDR_debugMask, GT_6CLASS, "NLDR_Allocate: " ++ "Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ pNldrNode->pfPhaseSplit = pfPhaseSplit; ++ pNldrNode->nPersLib = 0; ++ pNldrNode->pNldr = hNldr; ++ pNldrNode->pPrivRef = pPrivRef; ++ /* Save node's UUID. */ ++ pNldrNode->uuid = pNodeProps->ndbProps.uiNodeID; ++ /* ++ * Determine if node is a dynamically loaded node from ++ * ndbProps. ++ */ ++ if (pNodeProps->usLoadType == NLDR_DYNAMICLOAD) { ++ /* Dynamic node */ ++ pNldrNode->fDynamic = true; ++ /* ++ * Extract memory requirements from ndbProps masks ++ */ ++ /* Create phase */ ++ pNldrNode->segId[CREATEDATAFLAGBIT] = (u16) ++ (pNodeProps->ulDataMemSegMask >> CREATEBIT) & ++ SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulDataMemSegMask >> ++ (CREATEBIT + FLAGBIT)) & 1) << ++ CREATEDATAFLAGBIT; ++ pNldrNode->segId[CREATECODEFLAGBIT] = (u16) ++ (pNodeProps->ulCodeMemSegMask >> ++ CREATEBIT) & SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulCodeMemSegMask >> ++ (CREATEBIT + FLAGBIT)) & 1) << ++ CREATECODEFLAGBIT; ++ /* Execute phase */ ++ pNldrNode->segId[EXECUTEDATAFLAGBIT] = (u16) ++ (pNodeProps->ulDataMemSegMask >> ++ EXECUTEBIT) & SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulDataMemSegMask >> ++ (EXECUTEBIT + FLAGBIT)) & 1) << ++ EXECUTEDATAFLAGBIT; ++ pNldrNode->segId[EXECUTECODEFLAGBIT] = (u16) ++ (pNodeProps->ulCodeMemSegMask >> ++ EXECUTEBIT) & SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulCodeMemSegMask >> ++ (EXECUTEBIT + FLAGBIT)) & 1) << ++ EXECUTECODEFLAGBIT; ++ /* Delete phase */ ++ pNldrNode->segId[DELETEDATAFLAGBIT] = (u16) ++ (pNodeProps->ulDataMemSegMask >> DELETEBIT) & ++ SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulDataMemSegMask >> ++ (DELETEBIT + FLAGBIT)) & 1) << ++ DELETEDATAFLAGBIT; ++ pNldrNode->segId[DELETECODEFLAGBIT] = (u16) ++ (pNodeProps->ulCodeMemSegMask >> ++ DELETEBIT) & SEGMASK; ++ pNldrNode->codeDataFlagMask |= ++ ((pNodeProps->ulCodeMemSegMask >> ++ (DELETEBIT + FLAGBIT)) & 1) << ++ DELETECODEFLAGBIT; ++ } else { ++ /* Non-dynamically loaded nodes are part of the ++ * base image */ ++ pNldrNode->root.lib = hNldr->baseLib; ++ /* Check for overlay node */ ++ if (pNodeProps->usLoadType == NLDR_OVLYLOAD) ++ pNldrNode->fOverlay = true; ++ ++ } ++ *phNldrNode = (struct NLDR_NODEOBJECT *) pNldrNode; ++ } ++ /* Cleanup on failure */ ++ if (DSP_FAILED(status) && pNldrNode) ++ NLDR_Free((struct NLDR_NODEOBJECT *) pNldrNode); ++ ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle(((struct NLDR_NODEOBJECT *)(*phNldrNode)), ++ NLDR_NODESIGNATURE)) || (DSP_FAILED(status) && ++ *phNldrNode == NULL)); ++ return status; ++} ++ ++/* ++ * ======== NLDR_Create ======== ++ */ ++DSP_STATUS NLDR_Create(OUT struct NLDR_OBJECT **phNldr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct NLDR_ATTRS *pAttrs) ++{ ++ struct COD_MANAGER *hCodMgr; /* COD manager */ ++ char *pszCoffBuf = NULL; ++ char szZLFile[COD_MAXPATHLENGTH]; ++ struct NLDR_OBJECT *pNldr = NULL; ++ struct DBLL_Attrs saveAttrs; ++ struct DBLL_Attrs newAttrs; ++ DBLL_Flags flags; ++ u32 ulEntry; ++ u16 nSegs = 0; ++ struct MemInfo *pMemInfo; ++ u32 ulLen = 0; ++ u32 ulAddr; ++ struct RMM_Segment *rmmSegs = NULL; ++ u16 i; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(phNldr != NULL); ++ DBC_Require(hDevObject != NULL); ++ DBC_Require(pAttrs != NULL); ++ DBC_Require(pAttrs->pfnOvly != NULL); ++ DBC_Require(pAttrs->pfnWrite != NULL); ++ GT_3trace(NLDR_debugMask, GT_ENTER, "NLDR_Create(0x%x, 0x%x, 0x%x)\n", ++ phNldr, hDevObject, pAttrs); ++ /* Allocate dynamic loader object */ ++ MEM_AllocObject(pNldr, struct NLDR_OBJECT, NLDR_SIGNATURE); ++ if (pNldr) { ++ pNldr->hDevObject = hDevObject; ++ /* warning, lazy status checking alert! */ ++ status = DEV_GetCodMgr(hDevObject, &hCodMgr); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ status = COD_GetLoader(hCodMgr, &pNldr->dbll); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ status = COD_GetBaseLib(hCodMgr, &pNldr->baseLib); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ status = COD_GetBaseName(hCodMgr, szZLFile, COD_MAXPATHLENGTH); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ status = DSP_SOK; ++ /* end lazy status checking */ ++ pNldr->usDSPMauSize = pAttrs->usDSPMauSize; ++ pNldr->usDSPWordSize = pAttrs->usDSPWordSize; ++ pNldr->dbllFxns = dbllFxns; ++ if (!(pNldr->dbllFxns.initFxn())) ++ status = DSP_EMEMORY; ++ ++ } else { ++ GT_0trace(NLDR_debugMask, GT_6CLASS, "NLDR_Create: " ++ "Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } ++ /* Create the DCD Manager */ ++ if (DSP_SUCCEEDED(status)) ++ status = DCD_CreateManager(NULL, &pNldr->hDcdMgr); ++ ++ /* Get dynamic loading memory sections from base lib */ ++ if (DSP_SUCCEEDED(status)) { ++ status = pNldr->dbllFxns.getSectFxn(pNldr->baseLib, DYNMEMSECT, ++ &ulAddr, &ulLen); ++ if (DSP_SUCCEEDED(status)) { ++ pszCoffBuf = MEM_Calloc(ulLen * pNldr->usDSPMauSize, ++ MEM_PAGED); ++ if (!pszCoffBuf) { ++ GT_0trace(NLDR_debugMask, GT_6CLASS, ++ "NLDR_Create: Memory " ++ "allocation failed\n"); ++ status = DSP_EMEMORY; ++ } ++ } else { ++ /* Ok to not have dynamic loading memory */ ++ status = DSP_SOK; ++ ulLen = 0; ++ GT_1trace(NLDR_debugMask, GT_6CLASS, ++ "NLDR_Create: DBLL_getSect " ++ "failed (no dynamic loading mem segments): " ++ "0x%lx\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status) && ulLen > 0) { ++ /* Read section containing dynamic load mem segments */ ++ status = pNldr->dbllFxns.readSectFxn(pNldr->baseLib, DYNMEMSECT, ++ pszCoffBuf, ulLen); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NLDR_debugMask, GT_6CLASS, ++ "NLDR_Create: DBLL_read Section" ++ "failed: 0x%lx\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status) && ulLen > 0) { ++ /* Parse memory segment data */ ++ nSegs = (u16)(*((u32 *)pszCoffBuf)); ++ if (nSegs > MAXMEMSEGS) { ++ GT_1trace(NLDR_debugMask, GT_6CLASS, ++ "NLDR_Create: Invalid number of " ++ "dynamic load mem segments: 0x%lx\n", nSegs); ++ status = DSP_ECORRUPTFILE; ++ } ++ } ++ /* Parse dynamic load memory segments */ ++ if (DSP_SUCCEEDED(status) && nSegs > 0) { ++ rmmSegs = MEM_Calloc(sizeof(struct RMM_Segment) * nSegs, ++ MEM_PAGED); ++ pNldr->segTable = MEM_Calloc(sizeof(u32) * nSegs, MEM_PAGED); ++ if (rmmSegs == NULL || pNldr->segTable == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ pNldr->nSegs = nSegs; ++ pMemInfo = (struct MemInfo *)(pszCoffBuf + ++ sizeof(u32)); ++ for (i = 0; i < nSegs; i++) { ++ rmmSegs[i].base = (pMemInfo + i)->base; ++ rmmSegs[i].length = (pMemInfo + i)->len; ++ rmmSegs[i].space = 0; ++ pNldr->segTable[i] = (pMemInfo + i)->type; ++#ifdef DEBUG ++ DBG_Trace(DBG_LEVEL7, ++ "** (proc) DLL MEMSEGMENT: %d, Base: 0x%x, " ++ "Length: 0x%x\n", i, rmmSegs[i].base, ++ rmmSegs[i].length); ++#endif ++ } ++ } ++ } ++ /* Create Remote memory manager */ ++ if (DSP_SUCCEEDED(status)) ++ status = RMM_create(&pNldr->rmm, rmmSegs, nSegs); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* set the alloc, free, write functions for loader */ ++ pNldr->dbllFxns.getAttrsFxn(pNldr->dbll, &saveAttrs); ++ newAttrs = saveAttrs; ++ newAttrs.alloc = (DBLL_AllocFxn) RemoteAlloc; ++ newAttrs.free = (DBLL_FreeFxn) RemoteFree; ++ newAttrs.symLookup = (DBLL_SymLookup) GetSymbolValue; ++ newAttrs.symHandle = pNldr; ++ newAttrs.write = (DBLL_WriteFxn) pAttrs->pfnWrite; ++ pNldr->ovlyFxn = pAttrs->pfnOvly; ++ pNldr->writeFxn = pAttrs->pfnWrite; ++ pNldr->dbllAttrs = newAttrs; ++ } ++ if (rmmSegs) ++ MEM_Free(rmmSegs); ++ ++ if (pszCoffBuf) ++ MEM_Free(pszCoffBuf); ++ ++ /* Get overlay nodes */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetBaseName(hCodMgr, szZLFile, COD_MAXPATHLENGTH); ++ /* lazy check */ ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ /* First count number of overlay nodes */ ++ status = DCD_GetObjects(pNldr->hDcdMgr, szZLFile, AddOvlyNode, ++ (void *) pNldr); ++ /* Now build table of overlay nodes */ ++ if (DSP_SUCCEEDED(status) && pNldr->nOvlyNodes > 0) { ++ /* Allocate table for overlay nodes */ ++ pNldr->ovlyTable = ++ MEM_Calloc(sizeof(struct OvlyNode) * pNldr->nOvlyNodes, ++ MEM_PAGED); ++ /* Put overlay nodes in the table */ ++ pNldr->nNode = 0; ++ status = DCD_GetObjects(pNldr->hDcdMgr, szZLFile, ++ AddOvlyNode, ++ (void *) pNldr); ++ } ++ } ++ /* Do a fake reload of the base image to get overlay section info */ ++ if (DSP_SUCCEEDED(status) && pNldr->nOvlyNodes > 0) { ++ saveAttrs.write = fakeOvlyWrite; ++ saveAttrs.logWrite = AddOvlyInfo; ++ saveAttrs.logWriteHandle = pNldr; ++ flags = DBLL_CODE | DBLL_DATA | DBLL_SYMB; ++ status = pNldr->dbllFxns.loadFxn(pNldr->baseLib, flags, ++ &saveAttrs, &ulEntry); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ *phNldr = (struct NLDR_OBJECT *) pNldr; ++ } else { ++ if (pNldr) ++ NLDR_Delete((struct NLDR_OBJECT *) pNldr); ++ ++ *phNldr = NULL; ++ } ++ /* FIXME:Temp. Fix. Must be removed */ ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle(((struct NLDR_OBJECT *)*phNldr), ++ NLDR_SIGNATURE)) ++ || (DSP_FAILED(status) && (*phNldr == NULL))); ++ return status; ++} ++ ++/* ++ * ======== NLDR_Delete ======== ++ */ ++void NLDR_Delete(struct NLDR_OBJECT *hNldr) ++{ ++ struct OvlySect *pSect; ++ struct OvlySect *pNext; ++ u16 i; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNldr, NLDR_SIGNATURE)); ++ GT_1trace(NLDR_debugMask, GT_ENTER, "NLDR_Delete(0x%x)\n", hNldr); ++ hNldr->dbllFxns.exitFxn(); ++ if (hNldr->rmm) ++ RMM_delete(hNldr->rmm); ++ ++ if (hNldr->segTable) ++ MEM_Free(hNldr->segTable); ++ ++ if (hNldr->hDcdMgr) ++ DCD_DestroyManager(hNldr->hDcdMgr); ++ ++ /* Free overlay node information */ ++ if (hNldr->ovlyTable) { ++ for (i = 0; i < hNldr->nOvlyNodes; i++) { ++ pSect = hNldr->ovlyTable[i].pCreateSects; ++ while (pSect) { ++ pNext = pSect->pNextSect; ++ MEM_Free(pSect); ++ pSect = pNext; ++ } ++ pSect = hNldr->ovlyTable[i].pDeleteSects; ++ while (pSect) { ++ pNext = pSect->pNextSect; ++ MEM_Free(pSect); ++ pSect = pNext; ++ } ++ pSect = hNldr->ovlyTable[i].pExecuteSects; ++ while (pSect) { ++ pNext = pSect->pNextSect; ++ MEM_Free(pSect); ++ pSect = pNext; ++ } ++ pSect = hNldr->ovlyTable[i].pOtherSects; ++ while (pSect) { ++ pNext = pSect->pNextSect; ++ MEM_Free(pSect); ++ pSect = pNext; ++ } ++ } ++ MEM_Free(hNldr->ovlyTable); ++ } ++ MEM_FreeObject(hNldr); ++ DBC_Ensure(!MEM_IsValidHandle(hNldr, NLDR_SIGNATURE)); ++} ++ ++/* ++ * ======== NLDR_Exit ======== ++ * Discontinue usage of NLDR module. ++ */ ++void NLDR_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(NLDR_debugMask, GT_5CLASS, ++ "Entered NLDR_Exit, ref count: 0x%x\n", cRefs); ++ ++ if (cRefs == 0) { ++ RMM_exit(); ++ NLDR_debugMask.flags = NULL; ++ } ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== NLDR_Free ======== ++ */ ++void NLDR_Free(struct NLDR_NODEOBJECT *hNldrNode) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNldrNode, NLDR_NODESIGNATURE)); ++ ++ GT_1trace(NLDR_debugMask, GT_ENTER, "NLDR_Free(0x%x)\n", hNldrNode); ++ ++ MEM_FreeObject(hNldrNode); ++} ++ ++/* ++ * ======== NLDR_GetFxnAddr ======== ++ */ ++DSP_STATUS NLDR_GetFxnAddr(struct NLDR_NODEOBJECT *hNldrNode, char *pstrFxn, ++ u32 *pulAddr) ++{ ++ struct DBLL_Symbol *pSym; ++ struct NLDR_OBJECT *hNldr; ++ DSP_STATUS status = DSP_SOK; ++ bool status1 = false; ++ s32 i = 0; ++ struct LibNode root = { NULL, 0, NULL }; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNldrNode, NLDR_NODESIGNATURE)); ++ DBC_Require(pulAddr != NULL); ++ DBC_Require(pstrFxn != NULL); ++ GT_3trace(NLDR_debugMask, GT_ENTER, "NLDR_GetFxnAddr(0x%x, %s, 0x%x)\n", ++ hNldrNode, pstrFxn, pulAddr); ++ ++ hNldr = hNldrNode->pNldr; ++ /* Called from NODE_Create(), NODE_Delete(), or NODE_Run(). */ ++ if (hNldrNode->fDynamic && *hNldrNode->pfPhaseSplit) { ++ switch (hNldrNode->phase) { ++ case NLDR_CREATE: ++ root = hNldrNode->createLib; ++ break; ++ case NLDR_EXECUTE: ++ root = hNldrNode->executeLib; ++ break; ++ case NLDR_DELETE: ++ root = hNldrNode->deleteLib; ++ break; ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ } else { ++ /* for Overlay nodes or non-split Dynamic nodes */ ++ root = hNldrNode->root; ++ } ++ status1 = hNldr->dbllFxns.getCAddrFxn(root.lib, pstrFxn, &pSym); ++ if (!status1) ++ status1 = hNldr->dbllFxns.getAddrFxn(root.lib, pstrFxn, &pSym); ++ ++ /* If symbol not found, check dependent libraries */ ++ if (!status1) { ++ for (i = 0; i < root.nDepLibs; i++) { ++ status1 = hNldr->dbllFxns.getAddrFxn(root.pDepLibs[i]. ++ lib, pstrFxn, &pSym); ++ if (!status1) { ++ status1 = hNldr->dbllFxns.getCAddrFxn(root. ++ pDepLibs[i].lib, pstrFxn, &pSym); ++ } ++ if (status1) { ++ /* Symbol found */ ++ break; ++ } ++ } ++ } ++ /* Check persistent libraries */ ++ if (!status1) { ++ for (i = 0; i < hNldrNode->nPersLib; i++) { ++ status1 = hNldr->dbllFxns.getAddrFxn(hNldrNode-> ++ persLib[i].lib, pstrFxn, &pSym); ++ if (!status1) { ++ status1 = ++ hNldr->dbllFxns.getCAddrFxn(hNldrNode-> ++ persLib[i].lib, pstrFxn, &pSym); ++ } ++ if (status1) { ++ /* Symbol found */ ++ break; ++ } ++ } ++ } ++ ++ if (status1) { ++ *pulAddr = pSym->value; ++ } else { ++ GT_1trace(NLDR_debugMask, GT_6CLASS, ++ "NLDR_GetFxnAddr: Symbol not found: " ++ "%s\n", pstrFxn); ++ status = DSP_ESYMBOL; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== NLDR_GetRmmManager ======== ++ * Given a NLDR object, retrieve RMM Manager Handle ++ */ ++DSP_STATUS NLDR_GetRmmManager(struct NLDR_OBJECT *hNldrObject, ++ OUT struct RMM_TargetObj **phRmmMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct NLDR_OBJECT *pNldrObject = hNldrObject; ++ DBC_Require(phRmmMgr != NULL); ++ GT_2trace(NLDR_debugMask, GT_ENTER, "NLDR_GetRmmManager(0x%x, 0x%x)\n", ++ hNldrObject, phRmmMgr); ++ if (MEM_IsValidHandle(hNldrObject, NLDR_SIGNATURE)) { ++ *phRmmMgr = pNldrObject->rmm; ++ } else { ++ *phRmmMgr = NULL; ++ status = DSP_EHANDLE; ++ GT_0trace(NLDR_debugMask, GT_7CLASS, ++ "NLDR_GetRmmManager:Invalid handle"); ++ } ++ ++ GT_2trace(NLDR_debugMask, GT_ENTER, "Exit NLDR_GetRmmManager: status " ++ "0x%x\n\tphRmmMgr: 0x%x\n", status, *phRmmMgr); ++ ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phRmmMgr != NULL) && ++ (*phRmmMgr == NULL))); ++ ++ return status; ++} ++ ++/* ++ * ======== NLDR_Init ======== ++ * Initialize the NLDR module. ++ */ ++bool NLDR_Init(void) ++{ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!NLDR_debugMask.flags); ++ GT_create(&NLDR_debugMask, "DL"); /* "DL" for DLdr */ ++ ++ RMM_init(); ++ } ++ ++ cRefs++; ++ ++ GT_1trace(NLDR_debugMask, GT_5CLASS, "NLDR_Init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure(cRefs > 0); ++ return true; ++} ++ ++/* ++ * ======== NLDR_Load ======== ++ */ ++DSP_STATUS NLDR_Load(struct NLDR_NODEOBJECT *hNldrNode, enum NLDR_PHASE phase) ++{ ++ struct NLDR_OBJECT *hNldr; ++ struct DSP_UUID libUUID; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNldrNode, NLDR_NODESIGNATURE)); ++ ++ hNldr = hNldrNode->pNldr; ++ ++ GT_2trace(NLDR_debugMask, GT_ENTER, "NLDR_Load(0x%x, 0x%x)\n", ++ hNldrNode, phase); ++ ++ if (hNldrNode->fDynamic) { ++ hNldrNode->phase = phase; ++ ++ libUUID = hNldrNode->uuid; ++ ++ /* At this point, we may not know if node is split into ++ * different libraries. So we'll go ahead and load the ++ * library, and then save the pointer to the appropriate ++ * location after we know. */ ++ ++ status = LoadLib(hNldrNode, &hNldrNode->root, libUUID, false, ++ hNldrNode->libPath, phase, 0); ++ ++ if (DSP_SUCCEEDED(status)) { ++ if (*hNldrNode->pfPhaseSplit) { ++ switch (phase) { ++ case NLDR_CREATE: ++ hNldrNode->createLib = hNldrNode->root; ++ break; ++ ++ case NLDR_EXECUTE: ++ hNldrNode->executeLib = hNldrNode->root; ++ break; ++ ++ case NLDR_DELETE: ++ hNldrNode->deleteLib = hNldrNode->root; ++ break; ++ ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ } ++ } ++ } else { ++ if (hNldrNode->fOverlay) ++ status = LoadOvly(hNldrNode, phase); ++ ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== NLDR_Unload ======== ++ */ ++DSP_STATUS NLDR_Unload(struct NLDR_NODEOBJECT *hNldrNode, enum NLDR_PHASE phase) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct LibNode *pRootLib = NULL; ++ s32 i = 0; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNldrNode, NLDR_NODESIGNATURE)); ++ GT_2trace(NLDR_debugMask, GT_ENTER, "NLDR_Unload(0x%x, 0x%x)\n", ++ hNldrNode, phase); ++ if (hNldrNode != NULL) { ++ if (hNldrNode->fDynamic) { ++ if (*hNldrNode->pfPhaseSplit) { ++ switch (phase) { ++ case NLDR_CREATE: ++ pRootLib = &hNldrNode->createLib; ++ break; ++ case NLDR_EXECUTE: ++ pRootLib = &hNldrNode->executeLib; ++ break; ++ case NLDR_DELETE: ++ pRootLib = &hNldrNode->deleteLib; ++ /* Unload persistent libraries */ ++ for (i = 0; i < hNldrNode->nPersLib; ++ i++) { ++ UnloadLib(hNldrNode, ++ &hNldrNode->persLib[i]); ++ } ++ hNldrNode->nPersLib = 0; ++ break; ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ } else { ++ /* Unload main library */ ++ pRootLib = &hNldrNode->root; ++ } ++ UnloadLib(hNldrNode, pRootLib); ++ } else { ++ if (hNldrNode->fOverlay) ++ UnloadOvly(hNldrNode, phase); ++ ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== AddOvlyInfo ======== ++ */ ++static DSP_STATUS AddOvlyInfo(void *handle, struct DBLL_SectInfo *sectInfo, ++ u32 addr, u32 nBytes) ++{ ++ char *pNodeName; ++ char *pSectName = (char *)sectInfo->name; ++ bool fExists = false; ++ char seps = ':'; ++ char *pch; ++ u16 i; ++ struct NLDR_OBJECT *hNldr = (struct NLDR_OBJECT *)handle; ++ DSP_STATUS status = DSP_SOK; ++ ++ /* Is this an overlay section (load address != run address)? */ ++ if (sectInfo->loadAddr == sectInfo->runAddr) ++ goto func_end; ++ ++ /* Find the node it belongs to */ ++ for (i = 0; i < hNldr->nOvlyNodes; i++) { ++ pNodeName = hNldr->ovlyTable[i].pNodeName; ++ DBC_Require(pNodeName); ++ if (strncmp(pNodeName, pSectName + 1, ++ strlen(pNodeName)) == 0) { ++ /* Found the node */ ++ break; ++ } ++ } ++ if (!(i < hNldr->nOvlyNodes)) ++ goto func_end; ++ ++ /* Determine which phase this section belongs to */ ++ for (pch = pSectName + 1; *pch && *pch != seps; pch++) ++ ;; ++ ++ if (*pch) { ++ pch++; /* Skip over the ':' */ ++ if (strncmp(pch, PCREATE, strlen(PCREATE)) == 0) { ++ status = AddOvlySect(hNldr, &hNldr->ovlyTable[i]. ++ pCreateSects, sectInfo, &fExists, addr, nBytes); ++ if (DSP_SUCCEEDED(status) && !fExists) ++ hNldr->ovlyTable[i].nCreateSects++; ++ ++ } else ++ if (strncmp(pch, PDELETE, strlen(PDELETE)) == 0) { ++ status = AddOvlySect(hNldr, &hNldr->ovlyTable[i]. ++ pDeleteSects, sectInfo, &fExists, ++ addr, nBytes); ++ if (DSP_SUCCEEDED(status) && !fExists) ++ hNldr->ovlyTable[i].nDeleteSects++; ++ ++ } else ++ if (strncmp(pch, PEXECUTE, strlen(PEXECUTE)) == 0) { ++ status = AddOvlySect(hNldr, &hNldr->ovlyTable[i]. ++ pExecuteSects, sectInfo, &fExists, ++ addr, nBytes); ++ if (DSP_SUCCEEDED(status) && !fExists) ++ hNldr->ovlyTable[i].nExecuteSects++; ++ ++ } else { ++ /* Put in "other" sectins */ ++ status = AddOvlySect(hNldr, &hNldr->ovlyTable[i]. ++ pOtherSects, sectInfo, &fExists, ++ addr, nBytes); ++ if (DSP_SUCCEEDED(status) && !fExists) ++ hNldr->ovlyTable[i].nOtherSects++; ++ ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== AddOvlyNode ========= ++ * Callback function passed to DCD_GetObjects. ++ */ ++static DSP_STATUS AddOvlyNode(struct DSP_UUID *pUuid, ++ enum DSP_DCDOBJTYPE objType, ++ IN void *handle) ++{ ++ struct NLDR_OBJECT *hNldr = (struct NLDR_OBJECT *)handle; ++ char *pNodeName = NULL; ++ char *pBuf = NULL; ++ u32 uLen; ++ struct DCD_GENERICOBJ objDef; ++ DSP_STATUS status = DSP_SOK; ++ ++ if (objType != DSP_DCDNODETYPE) ++ goto func_end; ++ ++ status = DCD_GetObjectDef(hNldr->hDcdMgr, pUuid, objType, &objDef); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* If overlay node, add to the list */ ++ if (objDef.objData.nodeObj.usLoadType == NLDR_OVLYLOAD) { ++ if (hNldr->ovlyTable == NULL) { ++ hNldr->nOvlyNodes++; ++ } else { ++ /* Add node to table */ ++ hNldr->ovlyTable[hNldr->nNode].uuid = *pUuid; ++ DBC_Require(objDef.objData.nodeObj.ndbProps.acName); ++ uLen = strlen(objDef.objData.nodeObj.ndbProps.acName); ++ pNodeName = objDef.objData.nodeObj.ndbProps.acName; ++ pBuf = MEM_Calloc(uLen + 1, MEM_PAGED); ++ if (pBuf == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ strncpy(pBuf, pNodeName, uLen); ++ hNldr->ovlyTable[hNldr->nNode].pNodeName = pBuf; ++ hNldr->nNode++; ++ } ++ } ++ } ++ /* These were allocated in DCD_GetObjectDef */ ++ if (objDef.objData.nodeObj.pstrCreatePhaseFxn) ++ MEM_Free(objDef.objData.nodeObj.pstrCreatePhaseFxn); ++ ++ if (objDef.objData.nodeObj.pstrExecutePhaseFxn) ++ MEM_Free(objDef.objData.nodeObj.pstrExecutePhaseFxn); ++ ++ if (objDef.objData.nodeObj.pstrDeletePhaseFxn) ++ MEM_Free(objDef.objData.nodeObj.pstrDeletePhaseFxn); ++ ++ if (objDef.objData.nodeObj.pstrIAlgName) ++ MEM_Free(objDef.objData.nodeObj.pstrIAlgName); ++ ++func_end: ++ return status; ++} ++ ++/* ++ * ======== AddOvlySect ======== ++ */ ++static DSP_STATUS AddOvlySect(struct NLDR_OBJECT *hNldr, ++ struct OvlySect **pList, ++ struct DBLL_SectInfo *pSectInfo, bool *pExists, ++ u32 addr, u32 nBytes) ++{ ++ struct OvlySect *pNewSect = NULL; ++ struct OvlySect *pLastSect; ++ struct OvlySect *pSect; ++ DSP_STATUS status = DSP_SOK; ++ ++ pSect = pLastSect = *pList; ++ *pExists = false; ++ while (pSect) { ++ /* ++ * Make sure section has not already been added. Multiple ++ * 'write' calls may be made to load the section. ++ */ ++ if (pSect->loadAddr == addr) { ++ /* Already added */ ++ *pExists = true; ++ break; ++ } ++ pLastSect = pSect; ++ pSect = pSect->pNextSect; ++ } ++ ++ if (!pSect) { ++ /* New section */ ++ pNewSect = MEM_Calloc(sizeof(struct OvlySect), MEM_PAGED); ++ if (pNewSect == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ pNewSect->loadAddr = addr; ++ pNewSect->runAddr = pSectInfo->runAddr + ++ (addr - pSectInfo->loadAddr); ++ pNewSect->size = nBytes; ++ pNewSect->page = pSectInfo->type; ++ } ++ ++ /* Add to the list */ ++ if (DSP_SUCCEEDED(status)) { ++ if (*pList == NULL) { ++ /* First in the list */ ++ *pList = pNewSect; ++ } else { ++ pLastSect->pNextSect = pNewSect; ++ } ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== fakeOvlyWrite ======== ++ */ ++static s32 fakeOvlyWrite(void *handle, u32 dspAddr, void *buf, u32 nBytes, ++ s32 mtype) ++{ ++ return (s32)nBytes; ++} ++ ++/* ++ * ======== FreeSects ======== ++ */ ++static void FreeSects(struct NLDR_OBJECT *hNldr, struct OvlySect *pPhaseSects, ++ u16 nAlloc) ++{ ++ struct OvlySect *pSect = pPhaseSects; ++ u16 i = 0; ++ bool fRet; ++ ++ while (pSect && i < nAlloc) { ++ /* 'Deallocate' */ ++ /* segid - page not supported yet */ ++ /* Reserved memory */ ++ fRet = RMM_free(hNldr->rmm, 0, pSect->runAddr, pSect->size, ++ true); ++ DBC_Assert(fRet); ++ pSect = pSect->pNextSect; ++ i++; ++ } ++} ++ ++/* ++ * ======== GetSymbolValue ======== ++ * Find symbol in library's base image. If not there, check dependent ++ * libraries. ++ */ ++static bool GetSymbolValue(void *handle, void *pArg, void *rmmHandle, ++ char *name, struct DBLL_Symbol **sym) ++{ ++ struct NLDR_OBJECT *hNldr = (struct NLDR_OBJECT *)handle; ++ struct NLDR_NODEOBJECT *hNldrNode = (struct NLDR_NODEOBJECT *)rmmHandle; ++ struct LibNode *root = (struct LibNode *)pArg; ++ u16 i; ++ bool status = false; ++ ++ /* check the base image */ ++ status = hNldr->dbllFxns.getAddrFxn(hNldr->baseLib, name, sym); ++ if (!status) ++ status = hNldr->dbllFxns.getCAddrFxn(hNldr->baseLib, name, sym); ++ ++ /* ++ * Check in root lib itself. If the library consists of ++ * multiple object files linked together, some symbols in the ++ * library may need to be resolved. ++ */ ++ if (!status) { ++ status = hNldr->dbllFxns.getAddrFxn(root->lib, name, sym); ++ if (!status) { ++ status = ++ hNldr->dbllFxns.getCAddrFxn(root->lib, name, sym); ++ } ++ } ++ ++ /* ++ * Check in root lib's dependent libraries, but not dependent ++ * libraries' dependents. ++ */ ++ if (!status) { ++ for (i = 0; i < root->nDepLibs; i++) { ++ status = hNldr->dbllFxns.getAddrFxn(root->pDepLibs[i]. ++ lib, name, sym); ++ if (!status) { ++ status = hNldr->dbllFxns.getCAddrFxn(root-> ++ pDepLibs[i].lib, name, sym); ++ } ++ if (status) { ++ /* Symbol found */ ++ break; ++ } ++ } ++ } ++ /* ++ * Check in persistent libraries ++ */ ++ if (!status) { ++ for (i = 0; i < hNldrNode->nPersLib; i++) { ++ status = hNldr->dbllFxns.getAddrFxn(hNldrNode-> ++ persLib[i].lib, name, sym); ++ if (!status) { ++ status = hNldr->dbllFxns.getCAddrFxn ++ (hNldrNode->persLib[i].lib, name, sym); ++ } ++ if (status) { ++ /* Symbol found */ ++ break; ++ } ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== LoadLib ======== ++ * Recursively load library and all its dependent libraries. The library ++ * we're loading is specified by a uuid. ++ */ ++static DSP_STATUS LoadLib(struct NLDR_NODEOBJECT *hNldrNode, ++ struct LibNode *root, struct DSP_UUID uuid, ++ bool rootPersistent, struct DBLL_LibraryObj **libPath, ++ enum NLDR_PHASE phase, u16 depth) ++{ ++ struct NLDR_OBJECT *hNldr = hNldrNode->pNldr; ++ u16 nLibs = 0; /* Number of dependent libraries */ ++ u16 nPLibs = 0; /* Number of persistent libraries */ ++ u16 nLoaded = 0; /* Number of dep. libraries loaded */ ++ u16 i; ++ u32 entry; ++ u32 dwBufSize = NLDR_MAXPATHLENGTH; ++ DBLL_Flags flags = DBLL_SYMB | DBLL_CODE | DBLL_DATA | DBLL_DYNAMIC; ++ struct DBLL_Attrs newAttrs; ++ char *pszFileName = NULL; ++ struct DSP_UUID *depLibUUIDs = NULL; ++ bool *persistentDepLibs = NULL; ++ DSP_STATUS status = DSP_SOK; ++ bool fStatus = false; ++ struct LibNode *pDepLib; ++ ++ if (depth > MAXDEPTH) { ++ /* Error */ ++ DBC_Assert(false); ++ } ++ root->lib = NULL; ++ /* Allocate a buffer for library file name of size DBL_MAXPATHLENGTH */ ++ pszFileName = MEM_Calloc(DBLL_MAXPATHLENGTH, MEM_PAGED); ++ if (pszFileName == NULL) ++ status = DSP_EMEMORY; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Get the name of the library */ ++ if (depth == 0) { ++ status = DCD_GetLibraryName(hNldrNode->pNldr->hDcdMgr, ++ &uuid, pszFileName, &dwBufSize, phase, ++ hNldrNode->pfPhaseSplit); ++ } else { ++ /* Dependent libraries are registered with a phase */ ++ status = DCD_GetLibraryName(hNldrNode->pNldr->hDcdMgr, ++ &uuid, pszFileName, &dwBufSize, NLDR_NOPHASE, ++ NULL); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Open the library, don't load symbols */ ++ status = hNldr->dbllFxns.openFxn(hNldr->dbll, pszFileName, ++ DBLL_NOLOAD, &root->lib); ++ } ++ /* Done with file name */ ++ if (pszFileName) ++ MEM_Free(pszFileName); ++ ++ /* Check to see if library not already loaded */ ++ if (DSP_SUCCEEDED(status) && rootPersistent) { ++ fStatus = findInPersistentLibArray(hNldrNode, root->lib); ++ /* Close library */ ++ if (fStatus) { ++ hNldr->dbllFxns.closeFxn(root->lib); ++ return DSP_SALREADYLOADED; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Check for circular dependencies. */ ++ for (i = 0; i < depth; i++) { ++ if (root->lib == libPath[i]) { ++ /* This condition could be checked by a ++ * tool at build time. */ ++ status = DSP_EDYNLOAD; ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Add library to current path in dependency tree */ ++ libPath[depth] = root->lib; ++ depth++; ++ /* Get number of dependent libraries */ ++ status = DCD_GetNumDepLibs(hNldrNode->pNldr->hDcdMgr, &uuid, ++ &nLibs, &nPLibs, phase); ++ } ++ DBC_Assert(nLibs >= nPLibs); ++ if (DSP_SUCCEEDED(status)) { ++ if (!(*hNldrNode->pfPhaseSplit)) ++ nPLibs = 0; ++ ++ /* nLibs = #of dependent libraries */ ++ root->nDepLibs = nLibs - nPLibs; ++ if (nLibs > 0) { ++ depLibUUIDs = MEM_Calloc(sizeof(struct DSP_UUID) * ++ nLibs, MEM_PAGED); ++ persistentDepLibs = ++ MEM_Calloc(sizeof(bool) * nLibs, MEM_PAGED); ++ if (!depLibUUIDs || !persistentDepLibs) ++ status = DSP_EMEMORY; ++ ++ if (root->nDepLibs > 0) { ++ /* Allocate arrays for dependent lib UUIDs, ++ * lib nodes */ ++ root->pDepLibs = MEM_Calloc ++ (sizeof(struct LibNode) * ++ (root->nDepLibs), MEM_PAGED); ++ if (!(root->pDepLibs)) ++ status = DSP_EMEMORY; ++ ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Get the dependent library UUIDs */ ++ status = DCD_GetDepLibs(hNldrNode->pNldr-> ++ hDcdMgr, &uuid, nLibs, depLibUUIDs, ++ persistentDepLibs, phase); ++ } ++ } ++ } ++ ++ /* ++ * Recursively load dependent libraries. ++ */ ++ if (DSP_SUCCEEDED(status) && persistentDepLibs) { ++ for (i = 0; i < nLibs; i++) { ++ /* If root library is NOT persistent, and dep library ++ * is, then record it. If root library IS persistent, ++ * the deplib is already included */ ++ if (!rootPersistent && persistentDepLibs[i] && ++ *hNldrNode->pfPhaseSplit) { ++ if ((hNldrNode->nPersLib) > MAXLIBS) { ++ status = DSP_EDYNLOAD; ++ break; ++ } ++ ++ /* Allocate library outside of phase */ ++ pDepLib = &hNldrNode->persLib[hNldrNode-> ++ nPersLib]; ++ } else { ++ if (rootPersistent) ++ persistentDepLibs[i] = true; ++ ++ ++ /* Allocate library within phase */ ++ pDepLib = &root->pDepLibs[nLoaded]; ++ } ++ ++ if (depLibUUIDs) { ++ status = LoadLib(hNldrNode, pDepLib, ++ depLibUUIDs[i], ++ persistentDepLibs[i], libPath, ++ phase, ++ depth); ++ } else { ++ status = DSP_EMEMORY; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ if ((status != DSP_SALREADYLOADED) && ++ !rootPersistent && persistentDepLibs[i] && ++ *hNldrNode->pfPhaseSplit) { ++ (hNldrNode->nPersLib)++; ++ } else { ++ if (!persistentDepLibs[i] || ++ !(*hNldrNode->pfPhaseSplit)) { ++ nLoaded++; ++ } ++ } ++ } else { ++ break; ++ } ++ } ++ } ++ ++ /* Now we can load the root library */ ++ if (DSP_SUCCEEDED(status)) { ++ newAttrs = hNldr->dbllAttrs; ++ newAttrs.symArg = root; ++ newAttrs.rmmHandle = hNldrNode; ++ newAttrs.wHandle = hNldrNode->pPrivRef; ++ newAttrs.baseImage = false; ++ ++ status = hNldr->dbllFxns.loadFxn(root->lib, flags, &newAttrs, ++ &entry); ++ } ++ ++ /* ++ * In case of failure, unload any dependent libraries that ++ * were loaded, and close the root library. ++ * (Persistent libraries are unloaded from the very top) ++ */ ++ if (DSP_FAILED(status)) { ++ if (phase != NLDR_EXECUTE) { ++ for (i = 0; i < hNldrNode->nPersLib; i++) ++ UnloadLib(hNldrNode, &hNldrNode->persLib[i]); ++ ++ hNldrNode->nPersLib = 0; ++ } ++ for (i = 0; i < nLoaded; i++) ++ UnloadLib(hNldrNode, &root->pDepLibs[i]); ++ ++ if (root->lib) ++ hNldr->dbllFxns.closeFxn(root->lib); ++ ++ } ++ ++ /* Going up one node in the dependency tree */ ++ depth--; ++ ++ if (depLibUUIDs) { ++ MEM_Free(depLibUUIDs); ++ depLibUUIDs = NULL; ++ } ++ ++ if (persistentDepLibs) { ++ MEM_Free(persistentDepLibs); ++ persistentDepLibs = NULL; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== LoadOvly ======== ++ */ ++static DSP_STATUS LoadOvly(struct NLDR_NODEOBJECT *hNldrNode, ++ enum NLDR_PHASE phase) ++{ ++ struct NLDR_OBJECT *hNldr = hNldrNode->pNldr; ++ struct OvlyNode *pONode = NULL; ++ struct OvlySect *pPhaseSects = NULL; ++ struct OvlySect *pOtherSects = NULL; ++ u16 i; ++ u16 nAlloc = 0; ++ u16 nOtherAlloc = 0; ++ u16 *pRefCount = NULL; ++ u16 *pOtherRef = NULL; ++ u32 nBytes; ++ struct OvlySect *pSect; ++ DSP_STATUS status = DSP_SOK; ++ ++ /* Find the node in the table */ ++ for (i = 0; i < hNldr->nOvlyNodes; i++) { ++ if (IsEqualUUID(hNldrNode->uuid, hNldr->ovlyTable[i].uuid)) { ++ /* Found it */ ++ pONode = &(hNldr->ovlyTable[i]); ++ break; ++ } ++ } ++ ++ DBC_Assert(i < hNldr->nOvlyNodes); ++ switch (phase) { ++ case NLDR_CREATE: ++ pRefCount = &(pONode->createRef); ++ pOtherRef = &(pONode->otherRef); ++ pPhaseSects = pONode->pCreateSects; ++ pOtherSects = pONode->pOtherSects; ++ break; ++ ++ case NLDR_EXECUTE: ++ pRefCount = &(pONode->executeRef); ++ pPhaseSects = pONode->pExecuteSects; ++ break; ++ ++ case NLDR_DELETE: ++ pRefCount = &(pONode->deleteRef); ++ pPhaseSects = pONode->pDeleteSects; ++ break; ++ ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ ++ DBC_Assert(pRefCount != NULL); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ if (pRefCount == NULL) ++ goto func_end; ++ ++ if (*pRefCount != 0) ++ goto func_end; ++ ++ /* 'Allocate' memory for overlay sections of this phase */ ++ pSect = pPhaseSects; ++ while (pSect) { ++ /* allocate */ /* page not supported yet */ ++ /* reserve */ /* align */ ++ status = RMM_alloc(hNldr->rmm, 0, pSect->size, 0, ++ &(pSect->runAddr), true); ++ if (DSP_SUCCEEDED(status)) { ++ pSect = pSect->pNextSect; ++ nAlloc++; ++ } else { ++ break; ++ } ++ } ++ if (pOtherRef && *pOtherRef == 0) { ++ /* 'Allocate' memory for other overlay sections ++ * (create phase) */ ++ if (DSP_SUCCEEDED(status)) { ++ pSect = pOtherSects; ++ while (pSect) { ++ /* page not supported */ /* align */ ++ /* reserve */ ++ status = RMM_alloc(hNldr->rmm, 0, pSect->size, ++ 0, &(pSect->runAddr), true); ++ if (DSP_SUCCEEDED(status)) { ++ pSect = pSect->pNextSect; ++ nOtherAlloc++; ++ } else { ++ break; ++ } ++ } ++ } ++ } ++ if (*pRefCount == 0) { ++ if (DSP_SUCCEEDED(status)) { ++ /* Load sections for this phase */ ++ pSect = pPhaseSects; ++ while (pSect && DSP_SUCCEEDED(status)) { ++ nBytes = (*hNldr->ovlyFxn)(hNldrNode->pPrivRef, ++ pSect->runAddr, pSect->loadAddr, ++ pSect->size, pSect->page); ++ if (nBytes != pSect->size) ++ status = DSP_EFAIL; ++ ++ pSect = pSect->pNextSect; ++ } ++ } ++ } ++ if (pOtherRef && *pOtherRef == 0) { ++ if (DSP_SUCCEEDED(status)) { ++ /* Load other sections (create phase) */ ++ pSect = pOtherSects; ++ while (pSect && DSP_SUCCEEDED(status)) { ++ nBytes = (*hNldr->ovlyFxn)(hNldrNode->pPrivRef, ++ pSect->runAddr, pSect->loadAddr, ++ pSect->size, pSect->page); ++ if (nBytes != pSect->size) ++ status = DSP_EFAIL; ++ ++ pSect = pSect->pNextSect; ++ } ++ } ++ } ++ if (DSP_FAILED(status)) { ++ /* 'Deallocate' memory */ ++ FreeSects(hNldr, pPhaseSects, nAlloc); ++ FreeSects(hNldr, pOtherSects, nOtherAlloc); ++ } ++func_end: ++ if (DSP_SUCCEEDED(status) && (pRefCount != NULL)) { ++ *pRefCount += 1; ++ if (pOtherRef) ++ *pOtherRef += 1; ++ ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== RemoteAlloc ======== ++ */ ++static DSP_STATUS RemoteAlloc(void **pRef, u16 space, u32 size, ++ u32 align, u32 *dspAddr, ++ OPTIONAL s32 segmentId, OPTIONAL s32 req, ++ bool reserve) ++{ ++ struct NLDR_NODEOBJECT *hNode = (struct NLDR_NODEOBJECT *)pRef; ++ struct NLDR_OBJECT *hNldr; ++ struct RMM_TargetObj *rmm; ++ u16 memPhaseBit = MAXFLAGS; ++ u16 segid = 0; ++ u16 i; ++ u16 memType; ++ u32 nWords; ++ struct RMM_Addr *pRmmAddr = (struct RMM_Addr *)dspAddr; ++ bool fReq = false; ++ DSP_STATUS status = DSP_EMEMORY; /* Set to fail */ ++ DBC_Require(MEM_IsValidHandle(hNode, NLDR_NODESIGNATURE)); ++ DBC_Require(space == DBLL_CODE || space == DBLL_DATA || ++ space == DBLL_BSS); ++ hNldr = hNode->pNldr; ++ rmm = hNldr->rmm; ++ /* Convert size to DSP words */ ++ nWords = (size + hNldr->usDSPWordSize - 1) / hNldr->usDSPWordSize; ++ /* Modify memory 'align' to account for DSP cache line size */ ++ align = findLcm(GEM_CACHE_LINE_SIZE, align); ++ GT_1trace(NLDR_debugMask, GT_7CLASS, ++ "RemoteAlloc: memory align to 0x%x \n", align); ++ if (segmentId != -1) { ++ pRmmAddr->segid = segmentId; ++ segid = segmentId; ++ fReq = req; ++ } else { ++ switch (hNode->phase) { ++ case NLDR_CREATE: ++ memPhaseBit = CREATEDATAFLAGBIT; ++ break; ++ case NLDR_DELETE: ++ memPhaseBit = DELETEDATAFLAGBIT; ++ break; ++ case NLDR_EXECUTE: ++ memPhaseBit = EXECUTEDATAFLAGBIT; ++ break; ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ if (space == DBLL_CODE) ++ memPhaseBit++; ++ ++ if (memPhaseBit < MAXFLAGS) ++ segid = hNode->segId[memPhaseBit]; ++ ++ /* Determine if there is a memory loading requirement */ ++ if ((hNode->codeDataFlagMask >> memPhaseBit) & 0x1) ++ fReq = true; ++ ++ } ++ memType = (space == DBLL_CODE) ? DYNM_CODE : DYNM_DATA; ++ ++ /* Find an appropriate segment based on space */ ++ if (segid == NULLID) { ++ /* No memory requirements of preferences */ ++ DBC_Assert(!fReq); ++ goto func_cont; ++ } ++ if (segid <= MAXSEGID) { ++ DBC_Assert(segid < hNldr->nSegs); ++ /* Attempt to allocate from segid first. */ ++ pRmmAddr->segid = segid; ++ status = RMM_alloc(rmm, segid, nWords, align, dspAddr, false); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NLDR_debugMask, GT_6CLASS, ++ "RemoteAlloc:Unable allocate " ++ "from segment %d.\n", segid); ++ } ++ } else { ++ /* segid > MAXSEGID ==> Internal or external memory */ ++ DBC_Assert(segid == MEMINTERNALID || segid == MEMEXTERNALID); ++ /* Check for any internal or external memory segment, ++ * depending on segid.*/ ++ memType |= segid == MEMINTERNALID ? ++ DYNM_INTERNAL : DYNM_EXTERNAL; ++ for (i = 0; i < hNldr->nSegs; i++) { ++ if ((hNldr->segTable[i] & memType) != memType) ++ continue; ++ ++ status = RMM_alloc(rmm, i, nWords, align, dspAddr, ++ false); ++ if (DSP_SUCCEEDED(status)) { ++ /* Save segid for freeing later */ ++ pRmmAddr->segid = i; ++ break; ++ } ++ } ++ } ++func_cont: ++ /* Haven't found memory yet, attempt to find any segment that works */ ++ if (status == DSP_EMEMORY && !fReq) { ++ GT_0trace(NLDR_debugMask, GT_6CLASS, ++ "RemoteAlloc: Preferred segment " ++ "unavailable, trying another segment.\n"); ++ for (i = 0; i < hNldr->nSegs; i++) { ++ /* All bits of memType must be set */ ++ if ((hNldr->segTable[i] & memType) != memType) ++ continue; ++ ++ status = RMM_alloc(rmm, i, nWords, align, dspAddr, ++ false); ++ if (DSP_SUCCEEDED(status)) { ++ /* Save segid */ ++ pRmmAddr->segid = i; ++ break; ++ } ++ } ++ } ++ ++ return status; ++} ++ ++static DSP_STATUS RemoteFree(void **pRef, u16 space, u32 dspAddr, ++ u32 size, bool reserve) ++{ ++ struct NLDR_OBJECT *hNldr = (struct NLDR_OBJECT *)pRef; ++ struct RMM_TargetObj *rmm; ++ u32 nWords; ++ DSP_STATUS status = DSP_EMEMORY; /* Set to fail */ ++ ++ DBC_Require(MEM_IsValidHandle(hNldr, NLDR_SIGNATURE)); ++ ++ rmm = hNldr->rmm; ++ ++ /* Convert size to DSP words */ ++ nWords = (size + hNldr->usDSPWordSize - 1) / hNldr->usDSPWordSize; ++ ++ if (RMM_free(rmm, space, dspAddr, nWords, reserve)) ++ status = DSP_SOK; ++ ++ return status; ++} ++ ++/* ++ * ======== UnloadLib ======== ++ */ ++static void UnloadLib(struct NLDR_NODEOBJECT *hNldrNode, struct LibNode *root) ++{ ++ struct DBLL_Attrs newAttrs; ++ struct NLDR_OBJECT *hNldr = hNldrNode->pNldr; ++ u16 i; ++ ++ DBC_Assert(root != NULL); ++ ++ /* Unload dependent libraries */ ++ for (i = 0; i < root->nDepLibs; i++) ++ UnloadLib(hNldrNode, &root->pDepLibs[i]); ++ ++ root->nDepLibs = 0; ++ ++ newAttrs = hNldr->dbllAttrs; ++ newAttrs.rmmHandle = hNldr->rmm; ++ newAttrs.wHandle = hNldrNode->pPrivRef; ++ newAttrs.baseImage = false; ++ newAttrs.symArg = root; ++ ++ if (root->lib) { ++ /* Unload the root library */ ++ hNldr->dbllFxns.unloadFxn(root->lib, &newAttrs); ++ hNldr->dbllFxns.closeFxn(root->lib); ++ } ++ ++ /* Free dependent library list */ ++ if (root->pDepLibs) { ++ MEM_Free(root->pDepLibs); ++ root->pDepLibs = NULL; ++ } ++} ++ ++/* ++ * ======== UnloadOvly ======== ++ */ ++static void UnloadOvly(struct NLDR_NODEOBJECT *hNldrNode, enum NLDR_PHASE phase) ++{ ++ struct NLDR_OBJECT *hNldr = hNldrNode->pNldr; ++ struct OvlyNode *pONode = NULL; ++ struct OvlySect *pPhaseSects = NULL; ++ struct OvlySect *pOtherSects = NULL; ++ u16 i; ++ u16 nAlloc = 0; ++ u16 nOtherAlloc = 0; ++ u16 *pRefCount = NULL; ++ u16 *pOtherRef = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ /* Find the node in the table */ ++ for (i = 0; i < hNldr->nOvlyNodes; i++) { ++ if (IsEqualUUID(hNldrNode->uuid, hNldr->ovlyTable[i].uuid)) { ++ /* Found it */ ++ pONode = &(hNldr->ovlyTable[i]); ++ break; ++ } ++ } ++ ++ DBC_Assert(i < hNldr->nOvlyNodes); ++ switch (phase) { ++ case NLDR_CREATE: ++ pRefCount = &(pONode->createRef); ++ pPhaseSects = pONode->pCreateSects; ++ nAlloc = pONode->nCreateSects; ++ break; ++ case NLDR_EXECUTE: ++ pRefCount = &(pONode->executeRef); ++ pPhaseSects = pONode->pExecuteSects; ++ nAlloc = pONode->nExecuteSects; ++ break; ++ case NLDR_DELETE: ++ pRefCount = &(pONode->deleteRef); ++ pOtherRef = &(pONode->otherRef); ++ pPhaseSects = pONode->pDeleteSects; ++ /* 'Other' overlay sections are unloaded in the delete phase */ ++ pOtherSects = pONode->pOtherSects; ++ nAlloc = pONode->nDeleteSects; ++ nOtherAlloc = pONode->nOtherSects; ++ break; ++ default: ++ DBC_Assert(false); ++ break; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(pRefCount && (*pRefCount > 0)); ++ if (pRefCount && (*pRefCount > 0)) { ++ *pRefCount -= 1; ++ if (pOtherRef) { ++ DBC_Assert(*pOtherRef > 0); ++ *pOtherRef -= 1; ++ } ++ } ++ } ++ if (pRefCount && (*pRefCount == 0)) { ++ /* 'Deallocate' memory */ ++ FreeSects(hNldr, pPhaseSects, nAlloc); ++ } ++ if (pOtherRef && *pOtherRef == 0) ++ FreeSects(hNldr, pOtherSects, nOtherAlloc); ++ ++} ++ ++/* ++ * ======== findInPersistentLibArray ======== ++ */ ++static bool findInPersistentLibArray(struct NLDR_NODEOBJECT *hNldrNode, ++ struct DBLL_LibraryObj *lib) ++{ ++ s32 i = 0; ++ ++ for (i = 0; i < hNldrNode->nPersLib; i++) { ++ if (lib == hNldrNode->persLib[i].lib) ++ return true; ++ ++ } ++ ++ return false; ++} ++ ++/* ++ * ================ Find LCM (Least Common Multiplier === ++ */ ++static u32 findLcm(u32 a, u32 b) ++{ ++ u32 retVal; ++ ++ retVal = a * b / findGcf(a, b); ++ ++ return retVal; ++} ++ ++/* ++ * ================ Find GCF (Greatest Common Factor ) === ++ */ ++static u32 findGcf(u32 a, u32 b) ++{ ++ u32 c; ++ ++ /* Get the GCF (Greatest common factor between the numbers, ++ * using Euclidian Algo */ ++ while ((c = (a % b))) { ++ a = b; ++ b = c; ++ } ++ return b; ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/node.c b/drivers/dsp/bridge/rmgr/node.c +new file mode 100644 +index 0000000..178b802 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/node.c +@@ -0,0 +1,3544 @@ ++/* ++ * node.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== node.c ======== ++ * ++ * Description: ++ * DSP/BIOS Bridge Node Manager. ++ * ++ * Public Functions: ++ * NODE_Allocate ++ * NODE_AllocMsgBuf ++ * NODE_ChangePriority ++ * NODE_Connect ++ * NODE_Create ++ * NODE_CreateMgr ++ * NODE_Delete ++ * NODE_DeleteMgr ++ * NODE_EnumNodes ++ * NODE_Exit ++ * NODE_FreeMsgBuf ++ * NODE_GetAttr ++ * NODE_GetChannelId ++ * NODE_GetMessage ++ * NODE_GetStrmMgr ++ * NODE_Init ++ * NODE_OnExit ++ * NODE_Pause ++ * NODE_PutMessage ++ * NODE_RegisterNotify ++ * NODE_Run ++ * NODE_Terminate ++ * ++ *! Revision History: ++ *! ================= ++ *! 12-Apr-2004 hp Compile IVA only for 24xx ++ *! 09-Feb-2004 vp Updated to support IVA. ++ *! 07-Apr-2003 map Eliminated references to old DLDR ++ *! 26-Mar-2003 vp Commented the call to DSP deep sleep in Node_Delete ++ *! function. ++ *! 18-Feb-2003 vp Code review updates. ++ *! 06-Feb-2003 kc Fixed FreeStream to release streams correctly. ++ *! 23-Jan-2003 map Removed call to DISP_DoCinit within Write() ++ *! 03-Jan-2003 map Only unload code after phase has executed if ++ *! overlay or split dynload phases ++ *! 18-Oct-2002 vp Ported to Linux platform. ++ *! 06-Nov-2002 map Fixed NODE_Run on NODE_PAUSED bug ++ *! 12-Oct-2002 map Fixed DeleteNode bug in NODE_Create ++ *! 11-Sep-2002 rr DeleteNode frees the memory for strmConnect and dcd obj ++ *! 29-Aug-2002 map Modified Ovly and Write to use ARM-side copy ++ *! 22-May-2002 sg Changed use of cbData for PWR calls. ++ *! 17-May-2002 jeh Removed LoadLoaderFxns(). Get address of RMS_cinit() ++ *! function. Call DISP_DoCinit() from Write(), if .cinit. ++ *! 13-May-2002 sg Added timeout to wake/sleep calls. ++ *! 02-May-2002 sg Added wake/sleep of DSP to support "nap" mode. ++ *! 18-Apr-2002 jeh Use dynamic loader if compile flag is set. ++ *! 13-Feb-2002 jeh Get uSysStackSize from DSP_NDBPROPS. ++ *! 07-Jan-2002 ag STRMMODE_ZEROCOPY(shared memory buffer swap) enabled. ++ *! 17-Dec-2001 ag STRMMODE_RDMA(DDMA) enabled. ++ *! 12-Dec-2001 ag Check for valid stream mode in NODE_Connect(). ++ *! 04-Dec-2001 jeh Check for node sufficiently connected in NODE_Create(). ++ *! 15-Nov-2001 jeh Removed DBC_Require(pNode->hXlator != NULL) from ++ *! NODE_AllocMsgBuf(), and check node type != NODE_DEVICE. ++ *! 11-Sep-2001 ag Zero-copy messaging support. ++ *! 28-Aug-2001 jeh Overlay/dynamic loader infrastructure added. Removed ++ *! NODE_GetDispatcher, excess node states. ++ *! 07-Aug-2001 jeh Removed critical section for dispatcher. ++ *! 26-Jul-2001 jeh Get ZL dll name through CFG. ++ *! 05-Jun-2001 jeh Assume DSP_STRMATTRS.uBufsize in GPP bytes. ++ *! 11-May-2001 jeh Some code review cleanup. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 15-Dec-2000 sg Convert IALG_Fxn address from byte addr to word addr. ++ *! 04-Dec-2000 jeh Call MSG Get and Put functions. ++ *! 04-Dec-2000 ag Added SM support for node messaging. ++ *! 10-Nov-2000 rr: NODE_MIN/MAX Priority is defined in dspdefs.h. ++ *! 27-Oct-2000 jeh Added NODE_AllocMsgBuf(), NODE_FreeMsgBuf(). ++ *! 11-Oct-2000 jeh Changed NODE_EnumNodeInfo to NODE_EnumNodes. Added ++ *! NODE_CloseOrphans(). Remove NODE_RegisterNotifyAllNodes ++ *! 19-Jun-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/proc.h> ++#include <dspbridge/strm.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/ntfy.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/cmm.h> ++#include <dspbridge/cod.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/msg.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/dbdcd.h> ++#include <dspbridge/disp.h> ++#include <dspbridge/rms_sh.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmd.h> ++#include <dspbridge/wmdioctl.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/gb.h> ++#ifdef DEBUG ++#include <dspbridge/uuidutil.h> ++#include <dspbridge/dbg.h> ++#endif ++ ++/* ----------------------------------- This */ ++#include <dspbridge/nodepriv.h> ++#include <dspbridge/node.h> ++ ++/* Static/Dynamic Loader includes */ ++#include <dspbridge/dbll.h> ++#include <dspbridge/nldr.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/drv.h> ++#include <dspbridge/drvdefs.h> ++#include <dspbridge/dbreg.h> ++#include <dspbridge/resourcecleanup.h> ++#endif ++ ++ ++#define NODE_SIGNATURE 0x45444f4e /* "EDON" */ ++#define NODEMGR_SIGNATURE 0x52474d4e /* "RGMN" */ ++ ++#define HOSTPREFIX "/host" ++#define PIPEPREFIX "/dbpipe" ++ ++#define MaxInputs(h) ((h)->dcdProps.objData.nodeObj.ndbProps.uNumInputStreams) ++#define MaxOutputs(h) ((h)->dcdProps.objData.nodeObj.ndbProps.uNumOutputStreams) ++ ++#define NODE_GetPriority(h) ((h)->nPriority) ++#define NODE_SetPriority(hNode, nPriority) ((hNode)->nPriority = nPriority) ++#define NODE_SetState(hNode, state) ((hNode)->nState = state) ++ ++#define MAXPIPES 100 /* Max # of /pipe connections (CSL limit) */ ++#define MAXDEVSUFFIXLEN 2 /* Max(Log base 10 of MAXPIPES, MAXSTREAMS) */ ++ ++#define PIPENAMELEN (sizeof(PIPEPREFIX) + MAXDEVSUFFIXLEN) ++#define HOSTNAMELEN (sizeof(HOSTPREFIX) + MAXDEVSUFFIXLEN) ++ ++#define MAXDEVNAMELEN 32 /* DSP_NDBPROPS.acName size */ ++#define CREATEPHASE 1 ++#define EXECUTEPHASE 2 ++#define DELETEPHASE 3 ++ ++/* Define default STRM parameters */ ++/* ++ * TBD: Put in header file, make global DSP_STRMATTRS with defaults, ++ * or make defaults configurable. ++ */ ++#define DEFAULTBUFSIZE 32 ++#define DEFAULTNBUFS 2 ++#define DEFAULTSEGID 0 ++#define DEFAULTALIGNMENT 0 ++#define DEFAULTTIMEOUT 10000 ++ ++#define RMSQUERYSERVER 0 ++#define RMSCONFIGURESERVER 1 ++#define RMSCREATENODE 2 ++#define RMSEXECUTENODE 3 ++#define RMSDELETENODE 4 ++#define RMSCHANGENODEPRIORITY 5 ++#define RMSREADMEMORY 6 ++#define RMSWRITEMEMORY 7 ++#define RMSCOPY 8 ++#define MAXTIMEOUT 2000 ++ ++#define NUMRMSFXNS 9 ++ ++#define PWR_TIMEOUT 500 /* default PWR timeout in msec */ ++ ++#define STACKSEGLABEL "L1DSRAM_HEAP" /* Label for DSP Stack Segment Address */ ++ ++/* ++ * ======== NODE_MGR ======== ++ */ ++struct NODE_MGR { ++ u32 dwSignature; /* For object validation */ ++ struct DEV_OBJECT *hDevObject; /* Device object */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ struct DCD_MANAGER *hDcdMgr; /* Proc/Node data manager */ ++ struct DISP_OBJECT *hDisp; /* Node dispatcher */ ++ struct LST_LIST *nodeList; /* List of all allocated nodes */ ++ u32 uNumNodes; /* Number of nodes in nodeList */ ++ u32 uNumCreated; /* Number of nodes *created* on DSP */ ++ struct GB_TMap *pipeMap; /* Pipe connection bit map */ ++ struct GB_TMap *pipeDoneMap; /* Pipes that are half free */ ++ struct GB_TMap *chnlMap; /* Channel allocation bit map */ ++ struct GB_TMap *dmaChnlMap; /* DMA Channel allocation bit map */ ++ struct GB_TMap *zChnlMap; /* Zero-Copy Channel alloc bit map */ ++ struct NTFY_OBJECT *hNtfy; /* Manages registered notifications */ ++ struct SYNC_CSOBJECT *hSync; /* For critical sections */ ++ u32 ulFxnAddrs[NUMRMSFXNS]; /* RMS function addresses */ ++ struct MSG_MGR *hMsg; ++ ++ /* Processor properties needed by Node Dispatcher */ ++ u32 ulNumChnls; /* Total number of channels */ ++ u32 ulChnlOffset; /* Offset of chnl ids rsvd for RMS */ ++ u32 ulChnlBufSize; /* Buffer size for data to RMS */ ++ DSP_PROCFAMILY procFamily; /* eg, 5000 */ ++ DSP_PROCTYPE procType; /* eg, 5510 */ ++ u32 uDSPWordSize; /* Size of DSP word on host bytes */ ++ u32 uDSPDataMauSize; /* Size of DSP data MAU */ ++ u32 uDSPMauSize; /* Size of MAU */ ++ s32 nMinPri; /* Minimum runtime priority for node */ ++ s32 nMaxPri; /* Maximum runtime priority for node */ ++ ++ struct STRM_MGR *hStrmMgr; /* STRM manager */ ++ ++ /* Loader properties */ ++ struct NLDR_OBJECT *hNldr; /* Handle to loader */ ++ struct NLDR_FXNS nldrFxns; /* Handle to loader functions */ ++ bool fLoaderInit; /* Loader Init function succeeded? */ ++}; ++ ++/* ++ * ======== CONNECTTYPE ======== ++ */ ++enum CONNECTTYPE { ++ NOTCONNECTED = 0, ++ NODECONNECT, ++ HOSTCONNECT, ++ DEVICECONNECT, ++} ; ++ ++/* ++ * ======== STREAM ======== ++ */ ++struct STREAM { ++ enum CONNECTTYPE type; /* Type of stream connection */ ++ u32 devId; /* pipe or channel id */ ++}; ++ ++/* ++ * ======== NODE_OBJECT ======== ++ */ ++struct NODE_OBJECT { ++ struct LST_ELEM listElem; ++ u32 dwSignature; /* For object validation */ ++ struct NODE_MGR *hNodeMgr; /* The manager of this node */ ++ struct PROC_OBJECT *hProcessor; /* Back pointer to processor */ ++ struct DSP_UUID nodeId; /* Node's ID */ ++ s32 nPriority; /* Node's current priority */ ++ u32 uTimeout; /* Timeout for blocking NODE calls */ ++ u32 uHeapSize; /* Heap Size */ ++ u32 uDSPHeapVirtAddr; /* Heap Size */ ++ u32 uGPPHeapVirtAddr; /* Heap Size */ ++ enum NODE_TYPE nType; /* Type of node: message, task, etc */ ++ enum NODE_STATE nState; /* NODE_ALLOCATED, NODE_CREATED, ... */ ++ u32 uNumInputs; /* Current number of inputs */ ++ u32 uNumOutputs; /* Current number of outputs */ ++ u32 uMaxInputIndex; /* Current max input stream index */ ++ u32 uMaxOutputIndex; /* Current max output stream index */ ++ struct STREAM *inputs; /* Node's input streams */ ++ struct STREAM *outputs; /* Node's output streams */ ++ struct NODE_CREATEARGS createArgs; /* Args for node create function */ ++ NODE_ENV nodeEnv; /* Environment returned by RMS */ ++ struct DCD_GENERICOBJ dcdProps; /* Node properties from DCD */ ++ struct DSP_CBDATA *pArgs; /* Optional args to pass to node */ ++ struct NTFY_OBJECT *hNtfy; /* Manages registered notifications */ ++ char *pstrDevName; /* device name, if device node */ ++ struct SYNC_OBJECT *hSyncDone; /* Synchronize NODE_Terminate */ ++ s32 nExitStatus; /* execute function return status */ ++ ++ /* Information needed for NODE_GetAttr() */ ++ DSP_HNODE hDeviceOwner; /* If dev node, task that owns it */ ++ u32 uNumGPPInputs; /* Current # of from GPP streams */ ++ u32 uNumGPPOutputs; /* Current # of to GPP streams */ ++ /* Current stream connections */ ++ struct DSP_STREAMCONNECT *streamConnect; ++ ++ /* Message queue */ ++ struct MSG_QUEUE *hMsgQueue; ++ ++ /* These fields used for SM messaging */ ++ struct CMM_XLATOROBJECT *hXlator; /* Node's SM address translator */ ++ ++ /* Handle to pass to dynamic loader */ ++ struct NLDR_NODEOBJECT *hNldrNode; ++ bool fLoaded; /* Code is (dynamically) loaded */ ++ bool fPhaseSplit; /* Phases split in many libs or ovly */ ++ ++} ; ++ ++/* Default buffer attributes */ ++static struct DSP_BUFFERATTR NODE_DFLTBUFATTRS = { ++ 0, /* cbStruct */ ++ 1, /* uSegment */ ++ 0, /* uAlignment */ ++}; ++ ++static void DeleteNode(struct NODE_OBJECT *hNode); ++static void DeleteNodeMgr(struct NODE_MGR *hNodeMgr); ++static void FillStreamConnect(struct NODE_OBJECT *hNode1, ++ struct NODE_OBJECT *hNode2, u32 uStream1, ++ u32 uStream2); ++static void FillStreamDef(struct NODE_OBJECT *hNode, ++ struct NODE_STRMDEF *pstrmDef, ++ struct DSP_STRMATTR *pAttrs); ++static void FreeStream(struct NODE_MGR *hNodeMgr, struct STREAM stream); ++static DSP_STATUS GetFxnAddress(struct NODE_OBJECT *hNode, u32 *pulFxnAddr, ++ u32 uPhase); ++static DSP_STATUS GetNodeProps(struct DCD_MANAGER *hDcdMgr, ++ struct NODE_OBJECT *hNode, ++ CONST struct DSP_UUID *pNodeId, ++ struct DCD_GENERICOBJ *pdcdProps); ++static DSP_STATUS GetProcProps(struct NODE_MGR *hNodeMgr, ++ struct DEV_OBJECT *hDevObject); ++static DSP_STATUS GetRMSFxns(struct NODE_MGR *hNodeMgr); ++static u32 Ovly(void *pPrivRef, u32 ulDspRunAddr, u32 ulDspLoadAddr, ++ u32 ulNumBytes, u32 nMemSpace); ++static u32 Write(void *pPrivRef, u32 ulDspAddr, void *pBuf, ++ u32 ulNumBytes, u32 nMemSpace); ++ ++#if GT_TRACE ++static struct GT_Mask NODE_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++#ifdef DSP_DMM_DEBUG ++extern u32 DMM_MemMapDump(struct DMM_OBJECT *hDmmMgr); ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++/* Dynamic loader functions. */ ++static struct NLDR_FXNS nldrFxns = { ++ NLDR_Allocate, ++ NLDR_Create, ++ NLDR_Delete, ++ NLDR_Exit, ++ NLDR_Free, ++ NLDR_GetFxnAddr, ++ NLDR_Init, ++ NLDR_Load, ++ NLDR_Unload, ++}; ++ ++enum NODE_STATE NODE_GetState(HANDLE hNode) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ if (!MEM_IsValidHandle(pNode, NODE_SIGNATURE)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_GetState:hNode 0x%x\n", pNode); ++ return -1; ++ } else ++ return pNode->nState; ++ ++} ++ ++/* ++ * ======== NODE_Allocate ======== ++ * Purpose: ++ * Allocate GPP resources to manage a node on the DSP. ++ */ ++DSP_STATUS NODE_Allocate(struct PROC_OBJECT *hProcessor, ++ IN CONST struct DSP_UUID *pNodeId, ++ OPTIONAL IN CONST struct DSP_CBDATA *pArgs, ++ OPTIONAL IN CONST struct DSP_NODEATTRIN *pAttrIn, ++ OUT struct NODE_OBJECT **phNode) ++{ ++ struct NODE_MGR *hNodeMgr; ++ struct DEV_OBJECT *hDevObject; ++ struct NODE_OBJECT *pNode = NULL; ++ enum NODE_TYPE nodeType = NODE_TASK; ++ struct NODE_MSGARGS *pmsgArgs; ++ struct NODE_TASKARGS *ptaskArgs; ++ u32 uNumStreams; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_OBJECT *hCmmMgr = NULL; /* Shared memory manager hndl */ ++ u32 procId; ++ char *label; ++ u32 pulValue; ++ u32 dynextBase; ++ u32 offSet = 0; ++ u32 ulStackSegAddr, ulStackSegVal; ++ u32 ulGppMemBase; ++ struct CFG_HOSTRES hostRes; ++ u32 pMappedAddr = 0; ++ u32 mapAttrs = 0x0; ++ struct DSP_PROCESSORSTATE procStatus; ++#ifdef DSP_DMM_DEBUG ++ struct DMM_OBJECT *hDmmMgr; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++#endif ++ ++#ifndef RES_CLEANUP_DISABLE ++ HANDLE hDrvObject; ++ HANDLE nodeRes; ++ u32 hProcess; ++ struct PROCESS_CONTEXT *pPctxt = NULL; ++ DSP_STATUS res_status = DSP_SOK; ++#endif ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hProcessor != NULL); ++ DBC_Require(phNode != NULL); ++ DBC_Require(pNodeId != NULL); ++ ++ GT_5trace(NODE_debugMask, GT_ENTER, "NODE_Allocate: \thProcessor: " ++ "0x%x\tpNodeId: 0x%x\tpArgs: 0x%x\tpAttrIn: " ++ "0x%x\tphNode: 0x%x\n", hProcessor, pNodeId, pArgs, pAttrIn, ++ phNode); ++ ++ *phNode = NULL; ++ ++ status = PROC_GetProcessorId(hProcessor, &procId); ++ ++ status = PROC_GetDevObject(hProcessor, &hDevObject); ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetNodeManager(hDevObject, &hNodeMgr); ++ if (hNodeMgr == NULL) ++ status = DSP_EFAIL; ++ ++ } ++ if (procId != DSP_UNIT) ++ goto func_cont; ++ ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt ++ to send the message */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: proc Status 0x%x\n", ++ procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ ++ /* Assuming that 0 is not a valid function address */ ++ if (hNodeMgr->ulFxnAddrs[0] == 0) { ++ /* No RMS on target - we currently can't handle this */ ++ GT_0trace(NODE_debugMask, GT_5CLASS, "No RMS functions in base " ++ "image. Node allocation fails.\n"); ++ status = DSP_EFAIL; ++ } else { ++ /* Validate pAttrIn fields, if non-NULL */ ++ if (pAttrIn) { ++ /* Check if pAttrIn->iPriority is within range */ ++ if (pAttrIn->iPriority < hNodeMgr->nMinPri || ++ pAttrIn->iPriority > hNodeMgr->nMaxPri) ++ status = DSP_ERANGE; ++ } ++ } ++func_cont: ++ /* Allocate node object and fill in */ ++ if (DSP_FAILED(status)) ++ goto func_cont2; ++ ++ MEM_AllocObject(pNode, struct NODE_OBJECT, NODE_SIGNATURE); ++ if (pNode == NULL) { ++ status = DSP_EMEMORY; ++ goto func_cont1; ++ } ++ pNode->hNodeMgr = hNodeMgr; ++ /* This critical section protects GetNodeProps */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (procId != DSP_UNIT) ++ goto func_cont3; ++ ++ /* Get DSP_NDBPROPS from node database */ ++ status = GetNodeProps(hNodeMgr->hDcdMgr, pNode, pNodeId, ++ &(pNode->dcdProps)); ++ if (DSP_FAILED(status)) ++ goto func_cont3; ++ ++ pNode->nodeId = *pNodeId; ++ pNode->hProcessor = hProcessor; ++ pNode->nType = pNode->dcdProps.objData.nodeObj.ndbProps.uNodeType; ++ pNode->uTimeout = pNode->dcdProps.objData.nodeObj.ndbProps.uTimeout; ++ pNode->nPriority = pNode->dcdProps.objData.nodeObj.ndbProps.iPriority; ++ ++ /* Currently only C64 DSP builds support Node Dynamic * heaps */ ++ /* Allocate memory for node heap */ ++ pNode->createArgs.asa.taskArgs.uHeapSize = 0; ++ pNode->createArgs.asa.taskArgs.uDSPHeapAddr = 0; ++ pNode->createArgs.asa.taskArgs.uDSPHeapResAddr = 0; ++ pNode->createArgs.asa.taskArgs.uGPPHeapAddr = 0; ++ if (!pAttrIn) ++ goto func_cont3; ++ ++ /* Check if we have a user allocated node heap */ ++ if (!(pAttrIn->pGPPVirtAddr)) ++ goto func_cont3; ++ ++ /* check for page aligned Heap size */ ++ if (((pAttrIn->uHeapSize) & (PG_SIZE_4K - 1))) { ++ GT_1trace(NODE_debugMask, GT_7CLASS, ++ "NODE_Allocate: node heap page size" ++ " not aligned to 4K page, size=0x%x \n", ++ pAttrIn->uHeapSize); ++ status = DSP_EINVALIDARG; ++ } else { ++ pNode->createArgs.asa.taskArgs.uHeapSize = pAttrIn->uHeapSize; ++ pNode->createArgs.asa.taskArgs.uGPPHeapAddr = ++ (u32)pAttrIn->pGPPVirtAddr; ++ } ++ if (DSP_FAILED(status)) ++ goto func_cont3; ++ ++ status = PROC_ReserveMemory(hProcessor, ++ pNode->createArgs.asa.taskArgs.uHeapSize + PAGE_SIZE, ++ (void **)&(pNode->createArgs.asa.taskArgs. ++ uDSPHeapResAddr)); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate:Failed to reserve " ++ "memory for Heap: 0x%x\n", status); ++ } else { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: DSPProcessor_Reserve" ++ " Memory successful: 0x%x\n", status); ++ } ++#ifdef DSP_DMM_DEBUG ++ status = DMM_GetHandle(pProcObject, &hDmmMgr); ++ if (DSP_SUCCEEDED(status)) ++ DMM_MemMapDump(hDmmMgr); ++#endif ++ if (DSP_FAILED(status)) ++ goto func_cont3; ++ ++ mapAttrs |= DSP_MAPLITTLEENDIAN; ++ mapAttrs |= DSP_MAPELEMSIZE32; ++ mapAttrs |= DSP_MAPVIRTUALADDR; ++ status = PROC_Map(hProcessor, (void *)pAttrIn->pGPPVirtAddr, ++ pNode->createArgs.asa.taskArgs.uHeapSize, ++ (void *)pNode->createArgs.asa.taskArgs.uDSPHeapResAddr, ++ (void **)&pMappedAddr, mapAttrs); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to map memory" ++ " for Heap: 0x%x\n", status); ++ } else { ++ pNode->createArgs.asa.taskArgs.uDSPHeapAddr = ++ (u32) pMappedAddr; ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate:DSPProcessor_Map" ++ " successful: 0x%x\n", status); ++ } ++ ++func_cont3: ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++func_cont1: ++ if (pAttrIn != NULL) { ++ /* Overrides of NBD properties */ ++ pNode->uTimeout = pAttrIn->uTimeout; ++ pNode->nPriority = pAttrIn->iPriority; ++ } ++func_cont2: ++ /* Create object to manage notifications */ ++ if (DSP_SUCCEEDED(status)) ++ status = NTFY_Create(&pNode->hNtfy); ++ ++ if (DSP_SUCCEEDED(status)) { ++ nodeType = NODE_GetType(pNode); ++ /* Allocate DSP_STREAMCONNECT array for device, task, and ++ * dais socket nodes. */ ++ if (nodeType != NODE_MESSAGE) { ++ uNumStreams = MaxInputs(pNode) + MaxOutputs(pNode); ++ pNode->streamConnect = MEM_Calloc(uNumStreams * ++ sizeof(struct DSP_STREAMCONNECT), ++ MEM_PAGED); ++ if (uNumStreams > 0 && pNode->streamConnect == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ if (DSP_SUCCEEDED(status) && (nodeType == NODE_TASK || ++ nodeType == NODE_DAISSOCKET)) { ++ /* Allocate arrays for maintainig stream connections */ ++ pNode->inputs = ++ MEM_Calloc(MaxInputs(pNode) * ++ sizeof(struct STREAM), MEM_PAGED); ++ pNode->outputs = ++ MEM_Calloc(MaxOutputs(pNode) * ++ sizeof(struct STREAM), MEM_PAGED); ++ ptaskArgs = &(pNode->createArgs.asa.taskArgs); ++ ptaskArgs->strmInDef = ++ MEM_Calloc(MaxInputs(pNode) * ++ sizeof(struct NODE_STRMDEF), ++ MEM_PAGED); ++ ptaskArgs->strmOutDef = ++ MEM_Calloc(MaxOutputs(pNode) * ++ sizeof(struct NODE_STRMDEF), ++ MEM_PAGED); ++ if ((MaxInputs(pNode) > 0 && (pNode->inputs == NULL || ++ ptaskArgs->strmInDef == NULL)) || ++ (MaxOutputs(pNode) > 0 && (pNode->outputs == NULL || ++ ptaskArgs->strmOutDef == NULL))) ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_SUCCEEDED(status) && (nodeType != NODE_DEVICE)) { ++ /* Create an event that will be posted when RMS_EXIT is ++ * received. */ ++ status = SYNC_OpenEvent(&pNode->hSyncDone, NULL); ++ if (DSP_SUCCEEDED(status)) { ++ /*Get the shared mem mgr for this nodes dev object */ ++ status = CMM_GetHandle(hProcessor, &hCmmMgr); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to" ++ " get CMM Mgr handle: 0x%x\n", status); ++ } else { ++ /* Allocate a SM addr translator for this node ++ * w/ deflt attr */ ++ status = CMM_XlatorCreate(&pNode->hXlator, ++ hCmmMgr, NULL); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed" ++ " to create SM translator: 0x%x\n", ++ status); ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in message args */ ++ if ((pArgs != NULL) && (pArgs->cbData > 0)) { ++ pmsgArgs = &(pNode->createArgs.asa.msgArgs); ++ pmsgArgs->pData = MEM_Calloc(pArgs->cbData, ++ MEM_PAGED); ++ if (pmsgArgs->pData == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ pmsgArgs->uArgLength = pArgs->cbData; ++ memcpy(pmsgArgs->pData, pArgs->cData, ++ pArgs->cbData); ++ } ++ } ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status) && nodeType != NODE_DEVICE) { ++ /* Create a message queue for this node */ ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnMsgCreateQueue)(hNodeMgr->hMsg, ++ &pNode->hMsgQueue, 0, ++ pNode->createArgs.asa.msgArgs.uMaxMessages, ++ pNode); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Create object for dynamic loading */ ++ ++ status = hNodeMgr->nldrFxns.pfnAllocate(hNodeMgr->hNldr, ++ (void *) pNode, ++ &pNode->dcdProps.objData.nodeObj, ++ &pNode->hNldrNode, ++ &pNode->fPhaseSplit); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to " ++ "allocate NLDR node: 0x%x\n", status); ++ } ++ } ++ ++ /* Comapare value read from Node Properties and check if it is same as ++ * STACKSEGLABEL, if yes read the Address of STACKSEGLABEL, calculate ++ * GPP Address, Read the value in that address and override the ++ * uStackSeg value in task args */ ++ if (DSP_SUCCEEDED(status) && ++ (char *)pNode->dcdProps.objData.nodeObj.ndbProps.uStackSegName != ++ NULL) { ++ label = MEM_Calloc(sizeof(STACKSEGLABEL)+1, MEM_PAGED); ++ strncpy(label, STACKSEGLABEL, sizeof(STACKSEGLABEL)+1); ++ ++ if (strcmp((char *)pNode->dcdProps.objData.nodeObj. ++ ndbProps.uStackSegName, label) == 0) { ++ status = hNodeMgr->nldrFxns.pfnGetFxnAddr(pNode-> ++ hNldrNode, "DYNEXT_BEG", &dynextBase); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to get Address for " ++ "DYNEXT_BEG: 0x%x\n", status); ++ } ++ ++ status = hNodeMgr->nldrFxns.pfnGetFxnAddr(pNode-> ++ hNldrNode, "L1DSRAM_HEAP", &pulValue); ++ ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to get Address for " ++ "L1DSRAM_HEAP: 0x%x\n", status); ++ } ++ ++ status = CFG_GetHostResources((struct CFG_DEVNODE *) ++ DRV_GetFirstDevExtension(), &hostRes); ++ ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Allocate: Failed to get host resource " ++ "0x%x\n", status); ++ } ++ ++ ulGppMemBase = hostRes.dwMemBase[1]; ++ offSet = pulValue - dynextBase; ++ ulStackSegAddr = ulGppMemBase + offSet; ++ ulStackSegVal = (u32)*((REG_UWORD32 *) ++ ((u32)(ulStackSegAddr))); ++ ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "StackSegVal =0x%x\n", ulStackSegVal); ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "ulStackSegAddr = 0x%x\n", ulStackSegAddr); ++ ++ pNode->createArgs.asa.taskArgs.uStackSeg = ++ ulStackSegVal; ++ ++ } ++ ++ if (label) ++ MEM_Free(label); ++ ++ } ++ ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Add the node to the node manager's list of allocated ++ * nodes. */ ++ LST_InitElem((struct LST_ELEM *)pNode); ++ NODE_SetState(pNode, NODE_ALLOCATED); ++ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ ++ if (DSP_SUCCEEDED(status)) { ++ LST_PutTail(hNodeMgr->nodeList, ++ (struct LST_ELEM *) pNode); ++ ++(hNodeMgr->uNumNodes); ++ } ++ ++ /* Exit critical section */ ++ (void) SYNC_LeaveCS(hNodeMgr->hSync); ++ ++ /* Preset this to assume phases are split ++ * (for overlay and dll) */ ++ pNode->fPhaseSplit = true; ++ ++ if (DSP_SUCCEEDED(status)) ++ *phNode = pNode; ++ ++ ++ /* Notify all clients registered for DSP_NODESTATECHANGE. */ ++ PROC_NotifyAllClients(hProcessor, DSP_NODESTATECHANGE); ++ } else { ++ /* Cleanup */ ++ if (pNode) ++ DeleteNode(pNode); ++ ++ } ++ ++#ifndef RES_CLEANUP_DISABLE ++ if (DSP_SUCCEEDED(status)) { ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, ++ REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDrvObject, ++ &pPctxt, *phNode, 0); ++ if (pPctxt == NULL) { ++ DRV_InsertProcContext( ++ (struct DRV_OBJECT *)hDrvObject, ++ &pPctxt); ++ if (pPctxt != NULL) { ++ DRV_ProcUpdatestate(pPctxt, ++ PROC_RES_ALLOCATED); ++ DRV_ProcSetPID(pPctxt, hProcess); ++ pPctxt->hProcessor = ++ (DSP_HPROCESSOR)hProcessor; ++ } ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ res_status = CFG_GetObject((u32 *)&hDrvObject, ++ REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDrvObject, ++ &pPctxt, *phNode, 0); ++ if (pPctxt != NULL) { ++ DRV_InsertNodeResElement(*phNode, &nodeRes, ++ pPctxt); ++ DRV_ProcNodeUpdateHeapStatus(nodeRes, true); ++ DRV_ProcNodeUpdateStatus(nodeRes, true); ++ } ++ } ++ } ++#endif ++ DBC_Ensure((DSP_FAILED(status) && (*phNode == NULL)) || ++ (DSP_SUCCEEDED(status) ++ && MEM_IsValidHandle((*phNode), NODE_SIGNATURE))); ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_AllocMsgBuf ======== ++ * Purpose: ++ * Allocates buffer for zero copy messaging. ++ */ ++DBAPI NODE_AllocMsgBuf(struct NODE_OBJECT *hNode, u32 uSize, ++ OPTIONAL IN OUT struct DSP_BUFFERATTR *pAttr, ++ OUT u8 **pBuffer) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ DSP_STATUS status = DSP_SOK; ++ bool bVirtAddr = false; ++ bool bSetInfo; ++ u32 procId; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBuffer != NULL); ++ ++ DBC_Require(uSize > 0); ++ ++ GT_4trace(NODE_debugMask, GT_ENTER, ++ "NODE_AllocMsgBuf: hNode: 0x%x\tuSize:" ++ " 0x%x\tpAttr: 0x%x\tpBuffer: %d\n", pNode, uSize, pAttr, ++ pBuffer); ++ ++ if (!MEM_IsValidHandle(pNode, NODE_SIGNATURE)) ++ status = DSP_EHANDLE; ++ ++ if (NODE_GetType(pNode) == NODE_DEVICE) ++ status = DSP_ENODETYPE; ++ ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ if (pAttr == NULL) ++ pAttr = &NODE_DFLTBUFATTRS; /* set defaults */ ++ ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ if (procId != DSP_UNIT) { ++ DBC_Assert(NULL); ++ goto func_end; ++ } ++ /* If segment ID includes MEM_SETVIRTUALSEGID then pBuffer is a ++ * virt address, so set this info in this node's translator ++ * object for future ref. If MEM_GETVIRTUALSEGID then retrieve ++ * virtual address from node's translator. */ ++ if ((pAttr->uSegment & MEM_SETVIRTUALSEGID) || ++ (pAttr->uSegment & MEM_GETVIRTUALSEGID)) { ++ bVirtAddr = true; ++ bSetInfo = (pAttr->uSegment & MEM_SETVIRTUALSEGID) ? ++ true : false; ++ pAttr->uSegment &= ~MEM_MASKVIRTUALSEGID; /* clear mask bits */ ++ /* Set/get this node's translators virtual address base/size */ ++ status = CMM_XlatorInfo(pNode->hXlator, pBuffer, uSize, ++ pAttr->uSegment, bSetInfo); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_7CLASS, ++ "NODE_AllocMsgBuf " ++ "failed: 0x%lx\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status) && (!bVirtAddr)) { ++ if (pAttr->uSegment != 1) { ++ /* Node supports single SM segment only. */ ++ status = DSP_EBADSEGID; ++ } ++ /* Arbitrary SM buffer alignment not supported for host side ++ * allocs, but guaranteed for the following alignment ++ * values. */ ++ switch (pAttr->uAlignment) { ++ case 0: ++ case 1: ++ case 2: ++ case 4: ++ break; ++ default: ++ /* alignment value not suportted */ ++ status = DSP_EALIGNMENT; ++ break; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* allocate physical buffer from segId in node's ++ * translator */ ++ (void)CMM_XlatorAllocBuf(pNode->hXlator, pBuffer, ++ uSize); ++ if (*pBuffer == NULL) { ++ GT_0trace(NODE_debugMask, GT_7CLASS, ++ "NODE_AllocMsgBuf: " ++ "ERROR: Out of shared memory.\n"); ++ status = DSP_EMEMORY; ++ } ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_ChangePriority ======== ++ * Purpose: ++ * Change the priority of a node in the allocated state, or that is ++ * currently running or paused on the target. ++ */ ++DSP_STATUS NODE_ChangePriority(struct NODE_OBJECT *hNode, s32 nPriority) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ struct NODE_MGR *hNodeMgr = NULL; ++ enum NODE_TYPE nodeType; ++ enum NODE_STATE state; ++ DSP_STATUS status = DSP_SOK; ++ u32 procId; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_2trace(NODE_debugMask, GT_ENTER, "NODE_ChangePriority: " ++ "hNode: 0x%x\tnPriority: %d\n", hNode, nPriority); ++ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ GT_1trace(NODE_debugMask, GT_7CLASS, ++ "Invalid NODE Handle: 0x%x\n", hNode); ++ status = DSP_EHANDLE; ++ } else { ++ hNodeMgr = hNode->hNodeMgr; ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_TASK && nodeType != NODE_DAISSOCKET) ++ status = DSP_ENODETYPE; ++ else if (nPriority < hNodeMgr->nMinPri || ++ nPriority > hNodeMgr->nMaxPri) ++ status = DSP_ERANGE; ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ state = NODE_GetState(hNode); ++ if (state == NODE_ALLOCATED || state == NODE_PAUSED) { ++ NODE_SetPriority(hNode, nPriority); ++ } else { ++ if (state != NODE_RUNNING) { ++ status = DSP_EWRONGSTATE; ++ goto func_cont; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_GetProcessorId(pNode->hProcessor, ++ &procId); ++ if (procId == DSP_UNIT) { ++ status = DISP_NodeChangePriority(hNodeMgr-> ++ hDisp, hNode, ++ hNodeMgr->ulFxnAddrs[RMSCHANGENODEPRIORITY], ++ hNode->nodeEnv, nPriority); ++ } ++ if (DSP_SUCCEEDED(status)) ++ NODE_SetPriority(hNode, nPriority); ++ ++ } ++ } ++func_cont: ++ /* Leave critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_Connect ======== ++ * Purpose: ++ * Connect two nodes on the DSP, or a node on the DSP to the GPP. ++ */ ++DSP_STATUS NODE_Connect(struct NODE_OBJECT *hNode1, u32 uStream1, ++ struct NODE_OBJECT *hNode2, ++ u32 uStream2, OPTIONAL IN struct DSP_STRMATTR *pAttrs, ++ OPTIONAL IN struct DSP_CBDATA *pConnParam) ++{ ++ struct NODE_MGR *hNodeMgr; ++ char *pstrDevName = NULL; ++ enum NODE_TYPE node1Type = NODE_TASK; ++ enum NODE_TYPE node2Type = NODE_TASK; ++ struct NODE_STRMDEF *pstrmDef; ++ struct NODE_STRMDEF *pInput = NULL; ++ struct NODE_STRMDEF *pOutput = NULL; ++ struct NODE_OBJECT *hDevNode; ++ struct NODE_OBJECT *hNode; ++ struct STREAM *pStream; ++ GB_BitNum pipeId = GB_NOBITS; ++ GB_BitNum chnlId = GB_NOBITS; ++ CHNL_MODE uMode; ++ u32 dwLength; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ GT_5trace(NODE_debugMask, GT_ENTER, ++ "NODE_Connect: hNode1: 0x%x\tuStream1:" ++ " %d\thNode2: 0x%x\tuStream2: %d\tpAttrs: 0x%x\n", hNode1, ++ uStream1, hNode2, uStream2, pAttrs); ++ if (DSP_SUCCEEDED(status)) { ++ if ((hNode1 != (struct NODE_OBJECT *) DSP_HGPPNODE && ++ !MEM_IsValidHandle(hNode1, NODE_SIGNATURE)) || ++ (hNode2 != (struct NODE_OBJECT *) DSP_HGPPNODE && ++ !MEM_IsValidHandle(hNode2, NODE_SIGNATURE))) ++ status = DSP_EHANDLE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* The two nodes must be on the same processor */ ++ if (hNode1 != (struct NODE_OBJECT *)DSP_HGPPNODE && ++ hNode2 != (struct NODE_OBJECT *)DSP_HGPPNODE && ++ hNode1->hNodeMgr != hNode2->hNodeMgr) ++ status = DSP_EFAIL; ++ /* Cannot connect a node to itself */ ++ if (hNode1 == hNode2) ++ status = DSP_EFAIL; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* NODE_GetType() will return NODE_GPP if hNode = ++ * DSP_HGPPNODE. */ ++ node1Type = NODE_GetType(hNode1); ++ node2Type = NODE_GetType(hNode2); ++ /* Check stream indices ranges */ ++ if ((node1Type != NODE_GPP && node1Type != NODE_DEVICE && ++ uStream1 >= MaxOutputs(hNode1)) || (node2Type != NODE_GPP && ++ node2Type != NODE_DEVICE && uStream2 >= MaxInputs(hNode2))) ++ status = DSP_EVALUE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* ++ * Only the following types of connections are allowed: ++ * task/dais socket < == > task/dais socket ++ * task/dais socket < == > device ++ * task/dais socket < == > GPP ++ * ++ * ie, no message nodes, and at least one task or dais ++ * socket node. ++ */ ++ if (node1Type == NODE_MESSAGE || node2Type == NODE_MESSAGE || ++ (node1Type != NODE_TASK && node1Type != NODE_DAISSOCKET && ++ node2Type != NODE_TASK && node2Type != NODE_DAISSOCKET)) ++ status = DSP_EFAIL; ++ } ++ /* ++ * Check stream mode. Default is STRMMODE_PROCCOPY. ++ */ ++ if (DSP_SUCCEEDED(status) && pAttrs) { ++ if (pAttrs->lMode != STRMMODE_PROCCOPY) ++ status = DSP_ESTRMMODE; /* illegal stream mode */ ++ ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ if (node1Type != NODE_GPP) { ++ hNodeMgr = hNode1->hNodeMgr; ++ } else { ++ DBC_Assert(hNode2 != (struct NODE_OBJECT *)DSP_HGPPNODE); ++ hNodeMgr = hNode2->hNodeMgr; ++ } ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* Nodes must be in the allocated state */ ++ if (node1Type != NODE_GPP && NODE_GetState(hNode1) != NODE_ALLOCATED) ++ status = DSP_EWRONGSTATE; ++ ++ if (node2Type != NODE_GPP && NODE_GetState(hNode2) != NODE_ALLOCATED) ++ status = DSP_EWRONGSTATE; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Check that stream indices for task and dais socket nodes ++ * are not already be used. (Device nodes checked later) */ ++ if (node1Type == NODE_TASK || node1Type == NODE_DAISSOCKET) { ++ pOutput = &(hNode1->createArgs.asa.taskArgs. ++ strmOutDef[uStream1]); ++ if (pOutput->szDevice != NULL) ++ status = DSP_EALREADYCONNECTED; ++ ++ } ++ if (node2Type == NODE_TASK || node2Type == NODE_DAISSOCKET) { ++ pInput = &(hNode2->createArgs.asa.taskArgs. ++ strmInDef[uStream2]); ++ if (pInput->szDevice != NULL) ++ status = DSP_EALREADYCONNECTED; ++ ++ } ++ } ++ /* Connecting two task nodes? */ ++ if (DSP_SUCCEEDED(status) && ((node1Type == NODE_TASK || ++ node1Type == NODE_DAISSOCKET) && (node2Type == NODE_TASK || ++ node2Type == NODE_DAISSOCKET))) { ++ /* Find available pipe */ ++ pipeId = GB_findandset(hNodeMgr->pipeMap); ++ if (pipeId == GB_NOBITS) { ++ status = DSP_ENOMORECONNECTIONS; ++ } else { ++ hNode1->outputs[uStream1].type = NODECONNECT; ++ hNode2->inputs[uStream2].type = NODECONNECT; ++ hNode1->outputs[uStream1].devId = pipeId; ++ hNode2->inputs[uStream2].devId = pipeId; ++ pOutput->szDevice = MEM_Calloc(PIPENAMELEN + 1, ++ MEM_PAGED); ++ pInput->szDevice = MEM_Calloc(PIPENAMELEN + 1, ++ MEM_PAGED); ++ if (pOutput->szDevice == NULL || ++ pInput->szDevice == NULL) { ++ /* Undo the connection */ ++ if (pOutput->szDevice) ++ MEM_Free(pOutput->szDevice); ++ ++ if (pInput->szDevice) ++ MEM_Free(pInput->szDevice); ++ ++ pOutput->szDevice = NULL; ++ pInput->szDevice = NULL; ++ GB_clear(hNodeMgr->pipeMap, pipeId); ++ status = DSP_EMEMORY; ++ } else { ++ /* Copy "/dbpipe<pipId>" name to device names */ ++ sprintf(pOutput->szDevice, "%s%d", ++ PIPEPREFIX, pipeId); ++ strcpy(pInput->szDevice, pOutput->szDevice); ++ } ++ } ++ } ++ /* Connecting task node to host? */ ++ if (DSP_SUCCEEDED(status) && (node1Type == NODE_GPP || ++ node2Type == NODE_GPP)) { ++ if (node1Type == NODE_GPP) { ++ uMode = CHNL_MODETODSP; ++ } else { ++ DBC_Assert(node2Type == NODE_GPP); ++ uMode = CHNL_MODEFROMDSP; ++ } ++ /* Reserve a channel id. We need to put the name "/host<id>" ++ * in the node's createArgs, but the host ++ * side channel will not be opened until DSPStream_Open is ++ * called for this node. */ ++ if (pAttrs) { ++ if (pAttrs->lMode == STRMMODE_RDMA) { ++ chnlId = GB_findandset(hNodeMgr->dmaChnlMap); ++ /* dma chans are 2nd transport chnl set ++ * ids(e.g. 16-31)*/ ++ (chnlId != GB_NOBITS) ? ++ (chnlId = chnlId + hNodeMgr->ulNumChnls) : ++ chnlId; ++ } else if (pAttrs->lMode == STRMMODE_ZEROCOPY) { ++ chnlId = GB_findandset(hNodeMgr->zChnlMap); ++ /* zero-copy chans are 3nd transport set ++ * (e.g. 32-47) */ ++ (chnlId != GB_NOBITS) ? (chnlId = chnlId + ++ (2 * hNodeMgr->ulNumChnls)) : chnlId; ++ } else { /* must be PROCCOPY */ ++ DBC_Assert(pAttrs->lMode == STRMMODE_PROCCOPY); ++ chnlId = GB_findandset(hNodeMgr->chnlMap); ++ /* e.g. 0-15 */ ++ } ++ } else { ++ /* default to PROCCOPY */ ++ chnlId = GB_findandset(hNodeMgr->chnlMap); ++ } ++ if (chnlId == GB_NOBITS) { ++ status = DSP_ENOMORECONNECTIONS; ++ goto func_cont2; ++ } ++ pstrDevName = MEM_Calloc(HOSTNAMELEN + 1, MEM_PAGED); ++ if (pstrDevName != NULL) ++ goto func_cont2; ++ ++ if (pAttrs) { ++ if (pAttrs->lMode == STRMMODE_RDMA) { ++ GB_clear(hNodeMgr->dmaChnlMap, chnlId - ++ hNodeMgr->ulNumChnls); ++ } else if (pAttrs->lMode == STRMMODE_ZEROCOPY) { ++ GB_clear(hNodeMgr->zChnlMap, chnlId - ++ (2*hNodeMgr->ulNumChnls)); ++ } else { ++ DBC_Assert(pAttrs->lMode == STRMMODE_PROCCOPY); ++ GB_clear(hNodeMgr->chnlMap, chnlId); ++ } ++ } else { ++ GB_clear(hNodeMgr->chnlMap, chnlId); ++ } ++ status = DSP_EMEMORY; ++func_cont2: ++ if (DSP_SUCCEEDED(status)) { ++ if (hNode1 == (struct NODE_OBJECT *) DSP_HGPPNODE) { ++ hNode2->inputs[uStream2].type = HOSTCONNECT; ++ hNode2->inputs[uStream2].devId = chnlId; ++ pInput->szDevice = pstrDevName; ++ } else { ++ hNode1->outputs[uStream1].type = HOSTCONNECT; ++ hNode1->outputs[uStream1].devId = chnlId; ++ pOutput->szDevice = pstrDevName; ++ } ++ sprintf(pstrDevName, "%s%d", HOSTPREFIX, chnlId); ++ } ++ } ++ /* Connecting task node to device node? */ ++ if (DSP_SUCCEEDED(status) && ((node1Type == NODE_DEVICE) || ++ (node2Type == NODE_DEVICE))) { ++ if (node2Type == NODE_DEVICE) { ++ /* node1 == > device */ ++ hDevNode = hNode2; ++ hNode = hNode1; ++ pStream = &(hNode1->outputs[uStream1]); ++ pstrmDef = pOutput; ++ } else { ++ /* device == > node2 */ ++ hDevNode = hNode1; ++ hNode = hNode2; ++ pStream = &(hNode2->inputs[uStream2]); ++ pstrmDef = pInput; ++ } ++ /* Set up create args */ ++ pStream->type = DEVICECONNECT; ++ dwLength = strlen(hDevNode->pstrDevName); ++ if (pConnParam != NULL) { ++ pstrmDef->szDevice = MEM_Calloc(dwLength + 1 + ++ (u32) pConnParam->cbData, ++ MEM_PAGED); ++ } else { ++ pstrmDef->szDevice = MEM_Calloc(dwLength + 1, ++ MEM_PAGED); ++ } ++ if (pstrmDef->szDevice == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Copy device name */ ++ strncpy(pstrmDef->szDevice, hDevNode->pstrDevName, ++ dwLength); ++ if (pConnParam != NULL) { ++ strncat(pstrmDef->szDevice, ++ (char *)pConnParam->cData, ++ (u32)pConnParam->cbData); ++ } ++ hDevNode->hDeviceOwner = hNode; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in create args */ ++ if (node1Type == NODE_TASK || node1Type == NODE_DAISSOCKET) { ++ hNode1->createArgs.asa.taskArgs.uNumOutputs++; ++ FillStreamDef(hNode1, pOutput, pAttrs); ++ } ++ if (node2Type == NODE_TASK || node2Type == NODE_DAISSOCKET) { ++ hNode2->createArgs.asa.taskArgs.uNumInputs++; ++ FillStreamDef(hNode2, pInput, pAttrs); ++ } ++ /* Update hNode1 and hNode2 streamConnect */ ++ if (node1Type != NODE_GPP && node1Type != NODE_DEVICE) { ++ hNode1->uNumOutputs++; ++ if (uStream1 > hNode1->uMaxOutputIndex) ++ hNode1->uMaxOutputIndex = uStream1; ++ ++ } ++ if (node2Type != NODE_GPP && node2Type != NODE_DEVICE) { ++ hNode2->uNumInputs++; ++ if (uStream2 > hNode2->uMaxInputIndex) ++ hNode2->uMaxInputIndex = uStream2; ++ ++ } ++ FillStreamConnect(hNode1, hNode2, uStream1, uStream2); ++ } ++func_cont: ++ /* end of SYNC_EnterCS */ ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_Create ======== ++ * Purpose: ++ * Create a node on the DSP by remotely calling the node's create function. ++ */ ++DSP_STATUS NODE_Create(struct NODE_OBJECT *hNode) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ struct NODE_MGR *hNodeMgr; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ u32 ulCreateFxn; ++ enum NODE_TYPE nodeType; ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ bool bJustWokeDSP = false; ++ struct DSP_CBDATA cbData; ++ u32 procId = 255; ++ struct DSP_PROCESSORSTATE procStatus; ++ struct PROC_OBJECT *hProcessor; ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++#endif ++ ++ DBC_Require(cRefs > 0); ++ GT_1trace(NODE_debugMask, GT_ENTER, "NODE_Create: hNode: 0x%x\n", ++ hNode); ++ hProcessor = hNode->hProcessor; ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt to create ++ new node */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "NODE_Create:" ++ " proc Status 0x%x\n", procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ /* create struct DSP_CBDATA struct for PWR calls */ ++ cbData.cbData = PWR_TIMEOUT; ++ nodeType = NODE_GetType(hNode); ++ hNodeMgr = hNode->hNodeMgr; ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ /* Get access to node dispatcher */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* Check node state */ ++ if (NODE_GetState(hNode) != NODE_ALLOCATED) ++ status = DSP_EWRONGSTATE; ++ ++ if (DSP_SUCCEEDED(status)) ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ ++ if (DSP_FAILED(status)) ++ goto func_cont2; ++ ++ if (procId != DSP_UNIT) ++ goto func_cont2; ++ ++ /* Make sure streams are properly connected */ ++ if ((hNode->uNumInputs && hNode->uMaxInputIndex > ++ hNode->uNumInputs - 1) || ++ (hNode->uNumOutputs && hNode->uMaxOutputIndex > ++ hNode->uNumOutputs - 1)) ++ status = DSP_ENOTCONNECTED; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* If node's create function is not loaded, load it */ ++ /* Boost the OPP level to max level that DSP can be requested */ ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ if (pdata->cpu_set_freq) { ++ (*pdata->cpu_set_freq)(pdata->mpu_speed[VDD1_OPP3]); ++ ++ if (pdata->dsp_get_opp) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "opp level" ++ "after setting to VDD1_OPP3 is %d\n", ++ (*pdata->dsp_get_opp)()); ++ } ++ } ++#endif ++ status = hNodeMgr->nldrFxns.pfnLoad(hNode->hNldrNode, ++ NLDR_CREATE); ++ /* Get address of node's create function */ ++ if (DSP_SUCCEEDED(status)) { ++ hNode->fLoaded = true; ++ if (nodeType != NODE_DEVICE) { ++ status = GetFxnAddress(hNode, &ulCreateFxn, ++ CREATEPHASE); ++ } ++ } else { ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Create: failed to load" ++ " create code: 0x%x\n", status); ++ } ++ /* Request the lowest OPP level*/ ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ if (pdata->cpu_set_freq) { ++ (*pdata->cpu_set_freq)(pdata->mpu_speed[VDD1_OPP1]); ++ ++ if (pdata->dsp_get_opp) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "opp level" ++ "after setting to VDD1_OPP1 is %d\n", ++ (*pdata->dsp_get_opp)()); ++ } ++ } ++#endif ++ /* Get address of iAlg functions, if socket node */ ++ if (DSP_SUCCEEDED(status)) { ++ if (nodeType == NODE_DAISSOCKET) { ++ status = hNodeMgr->nldrFxns.pfnGetFxnAddr ++ (hNode->hNldrNode, hNode->dcdProps. ++ objData.nodeObj.pstrIAlgName, ++ &hNode->createArgs.asa.taskArgs. ++ ulDaisArg); ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ if (nodeType != NODE_DEVICE) { ++ status = DISP_NodeCreate(hNodeMgr->hDisp, hNode, ++ hNodeMgr->ulFxnAddrs[RMSCREATENODE], ++ ulCreateFxn, &(hNode->createArgs), ++ &(hNode->nodeEnv)); ++ if (DSP_SUCCEEDED(status)) { ++ /* Set the message queue id to the node env ++ * pointer */ ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ (*pIntfFxns->pfnMsgSetQueueId)(hNode->hMsgQueue, ++ hNode->nodeEnv); ++ } ++ } ++ } ++ /* Phase II/Overlays: Create, execute, delete phases possibly in ++ * different files/sections. */ ++ if (hNode->fLoaded && hNode->fPhaseSplit) { ++ /* If create code was dynamically loaded, we can now unload ++ * it. */ ++ status1 = hNodeMgr->nldrFxns.pfnUnload(hNode->hNldrNode, ++ NLDR_CREATE); ++ hNode->fLoaded = false; ++ } ++ if (DSP_FAILED(status1)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Create: Failed to unload " ++ "create code: 0x%x\n", status1); ++ } ++func_cont2: ++ /* Update node state and node manager state */ ++ if (DSP_SUCCEEDED(status)) { ++ NODE_SetState(hNode, NODE_CREATED); ++ hNodeMgr->uNumCreated++; ++ goto func_cont; ++ } ++ if (status != DSP_EWRONGSTATE) { ++ /* Put back in NODE_ALLOCATED state if error occurred */ ++ NODE_SetState(hNode, NODE_ALLOCATED); ++ } ++ if (procId == DSP_UNIT) { ++ /* If node create failed, see if should sleep DSP now */ ++ if (bJustWokeDSP == true) { ++ /* Check to see if partial create happened on DSP */ ++ if (hNode->nodeEnv == (u32)NULL) { ++ /* No environment allocated on DSP, re-sleep ++ * DSP now */ ++ PROC_Ctrl(hNode->hProcessor, WMDIOCTL_DEEPSLEEP, ++ &cbData); ++ } else { ++ /* Increment count, sleep later when node fully ++ * deleted */ ++ hNodeMgr->uNumCreated++; ++ } ++ } ++ } ++func_cont: ++ /* Free access to node dispatcher */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++func_end: ++ if (DSP_SUCCEEDED(status)) { ++ PROC_NotifyClients(hNode->hProcessor, DSP_NODESTATECHANGE); ++ NTFY_Notify(hNode->hNtfy, DSP_NODESTATECHANGE); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== NODE_CreateMgr ======== ++ * Purpose: ++ * Create a NODE Manager object. ++ */ ++DSP_STATUS NODE_CreateMgr(OUT struct NODE_MGR **phNodeMgr, ++ struct DEV_OBJECT *hDevObject) ++{ ++ u32 i; ++ struct NODE_MGR *pNodeMgr = NULL; ++ struct DISP_ATTRS dispAttrs; ++ char *szZLFile = ""; ++ struct NLDR_ATTRS nldrAttrs; ++ DSP_STATUS status = DSP_SOK; ++ u32 devType; ++ DBC_Require(cRefs > 0); ++ DBC_Require(phNodeMgr != NULL); ++ DBC_Require(hDevObject != NULL); ++ GT_2trace(NODE_debugMask, GT_ENTER, "NODE_CreateMgr: phNodeMgr: 0x%x\t" ++ "hDevObject: 0x%x\n", phNodeMgr, hDevObject); ++ *phNodeMgr = NULL; ++ /* Allocate Node manager object */ ++ MEM_AllocObject(pNodeMgr, struct NODE_MGR, NODEMGR_SIGNATURE); ++ if (pNodeMgr) { ++ pNodeMgr->hDevObject = hDevObject; ++ pNodeMgr->nodeList = LST_Create(); ++ pNodeMgr->pipeMap = GB_create(MAXPIPES); ++ pNodeMgr->pipeDoneMap = GB_create(MAXPIPES); ++ if (pNodeMgr->nodeList == NULL || pNodeMgr->pipeMap == NULL || ++ pNodeMgr->pipeDoneMap == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(NODE_debugMask, GT_6CLASS, ++ "NODE_CreateMgr: Memory " ++ "allocation failed\n"); ++ } else { ++ status = NTFY_Create(&pNodeMgr->hNtfy); ++ } ++ pNodeMgr->uNumCreated = 0; ++ } else { ++ GT_0trace(NODE_debugMask, GT_6CLASS, ++ "NODE_CreateMgr: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } ++ /* get devNodeType */ ++ if (DSP_SUCCEEDED(status)) ++ status = DEV_GetDevType(hDevObject, &devType); ++ ++ /* Create the DCD Manager */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DCD_CreateManager(szZLFile, &pNodeMgr->hDcdMgr); ++ if (DSP_SUCCEEDED(status)) ++ status = GetProcProps(pNodeMgr, hDevObject); ++ ++ } ++ /* Create NODE Dispatcher */ ++ if (DSP_SUCCEEDED(status)) { ++ dispAttrs.ulChnlOffset = pNodeMgr->ulChnlOffset; ++ dispAttrs.ulChnlBufSize = pNodeMgr->ulChnlBufSize; ++ dispAttrs.procFamily = pNodeMgr->procFamily; ++ dispAttrs.procType = pNodeMgr->procType; ++ status = DISP_Create(&pNodeMgr->hDisp, hDevObject, &dispAttrs); ++ } ++ /* Create a STRM Manager */ ++ if (DSP_SUCCEEDED(status)) ++ status = STRM_Create(&pNodeMgr->hStrmMgr, hDevObject); ++ ++ if (DSP_SUCCEEDED(status)) { ++ DEV_GetIntfFxns(hDevObject, &pNodeMgr->pIntfFxns); ++ /* Get MSG queue manager */ ++ DEV_GetMsgMgr(hDevObject, &pNodeMgr->hMsg); ++ status = SYNC_InitializeCS(&pNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ status = DSP_EMEMORY; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pNodeMgr->chnlMap = GB_create(pNodeMgr->ulNumChnls); ++ /* dma chnl map. ulNumChnls is # per transport */ ++ pNodeMgr->dmaChnlMap = GB_create(pNodeMgr->ulNumChnls); ++ pNodeMgr->zChnlMap = GB_create(pNodeMgr->ulNumChnls); ++ if ((pNodeMgr->chnlMap == NULL) || ++ (pNodeMgr->dmaChnlMap == NULL) || ++ (pNodeMgr->zChnlMap == NULL)) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Block out reserved channels */ ++ for (i = 0; i < pNodeMgr->ulChnlOffset; i++) ++ GB_set(pNodeMgr->chnlMap, i); ++ ++ /* Block out channels reserved for RMS */ ++ GB_set(pNodeMgr->chnlMap, pNodeMgr->ulChnlOffset); ++ GB_set(pNodeMgr->chnlMap, pNodeMgr->ulChnlOffset + 1); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* NO RM Server on the IVA */ ++ if (devType != IVA_UNIT) { ++ /* Get addresses of any RMS functions loaded */ ++ status = GetRMSFxns(pNodeMgr); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_6CLASS, ++ "NODE_CreateMgr: Failed to" ++ " get RMS functions: status = 0x%x", status); ++ } ++ } ++ } ++ ++ /* Get loader functions and create loader */ ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(NODE_debugMask, GT_1CLASS, ++ "NODE_CreateMgr: using dynamic loader\n"); ++ pNodeMgr->nldrFxns = nldrFxns; /* Dynamic loader functions */ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ nldrAttrs.pfnOvly = Ovly; ++ nldrAttrs.pfnWrite = Write; ++ nldrAttrs.usDSPWordSize = pNodeMgr->uDSPWordSize; ++ nldrAttrs.usDSPMauSize = pNodeMgr->uDSPMauSize; ++ pNodeMgr->fLoaderInit = pNodeMgr->nldrFxns.pfnInit(); ++ status = pNodeMgr->nldrFxns.pfnCreate(&pNodeMgr->hNldr, ++ hDevObject, &nldrAttrs); ++ if (DSP_FAILED(status)) { ++ GT_1trace(NODE_debugMask, GT_6CLASS, ++ "NODE_CreateMgr: Failed to " ++ "create loader: status = 0x%x\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) ++ *phNodeMgr = pNodeMgr; ++ else ++ DeleteNodeMgr(pNodeMgr); ++ ++ DBC_Ensure((DSP_FAILED(status) && (*phNodeMgr == NULL)) || ++ (DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle((*phNodeMgr), NODEMGR_SIGNATURE))); ++ ++ return status; ++} ++ ++/* ++ * ======== NODE_Delete ======== ++ * Purpose: ++ * Delete a node on the DSP by remotely calling the node's delete function. ++ * Loads the node's delete function if necessary. Free GPP side resources ++ * after node's delete function returns. ++ */ ++DSP_STATUS NODE_Delete(struct NODE_OBJECT *hNode) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ struct NODE_MGR *hNodeMgr; ++ struct PROC_OBJECT *hProcessor; ++ struct DISP_OBJECT *hDisp; ++ u32 ulDeleteFxn; ++ enum NODE_TYPE nodeType; ++ enum NODE_STATE state; ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ struct DSP_CBDATA cbData; ++ u32 procId; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ ++#ifndef RES_CLEANUP_DISABLE ++ u32 hProcess; ++ HANDLE nodeRes; ++ HANDLE hDrvObject; ++ struct PROCESS_CONTEXT *pCtxt = NULL; ++ DSP_STATUS res_status = DSP_SOK; ++#endif ++ struct DSP_PROCESSORSTATE procStatus; ++ DBC_Require(cRefs > 0); ++ GT_1trace(NODE_debugMask, GT_ENTER, "NODE_Delete: hNode: 0x%x\n", ++ hNode); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ /* create struct DSP_CBDATA struct for PWR call */ ++ cbData.cbData = PWR_TIMEOUT; ++ hNodeMgr = hNode->hNodeMgr; ++ hProcessor = hNode->hProcessor; ++ hDisp = hNodeMgr->hDisp; ++ nodeType = NODE_GetType(hNode); ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ state = NODE_GetState(hNode); ++ /* Execute delete phase code for non-device node in all cases ++ * except when the node was only allocated. Delete phase must be ++ * executed even if create phase was executed, but failed. ++ * If the node environment pointer is non-NULL, the delete phase ++ * code must be executed. */ ++ if (!(state == NODE_ALLOCATED && hNode->nodeEnv == (u32)NULL) && ++ nodeType != NODE_DEVICE) { ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ if (DSP_FAILED(status)) ++ goto func_cont1; ++ ++ if (procId == DSP_UNIT || procId == IVA_UNIT) { ++ /* If node has terminated, execute phase code will ++ * have already been unloaded in NODE_OnExit(). If the ++ * node is PAUSED, the execute phase is loaded, and it ++ * is now ok to unload it. If the node is running, we ++ * will unload the execute phase only after deleting ++ * the node. */ ++ if (state == NODE_PAUSED && hNode->fLoaded && ++ hNode->fPhaseSplit) { ++ /* Ok to unload execute code as long as node ++ * is not * running */ ++ status1 = hNodeMgr->nldrFxns.pfnUnload(hNode-> ++ hNldrNode, NLDR_EXECUTE); ++ hNode->fLoaded = false; ++ NODE_SetState(hNode, NODE_DONE); ++ } ++ /* Load delete phase code if not loaded or if haven't ++ * * unloaded EXECUTE phase */ ++ if ((!(hNode->fLoaded) || (state == NODE_RUNNING)) && ++ hNode->fPhaseSplit) { ++ status = hNodeMgr->nldrFxns.pfnLoad(hNode-> ++ hNldrNode, NLDR_DELETE); ++ if (DSP_SUCCEEDED(status)) { ++ hNode->fLoaded = true; ++ } else { ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Delete: failed to " ++ "load delete code: 0x%x\n", ++ status); ++ } ++ } ++ } ++func_cont1: ++ if (DSP_SUCCEEDED(status)) { ++ /* Unblock a thread trying to terminate the node */ ++ (void)SYNC_SetEvent(hNode->hSyncDone); ++ if (procId == DSP_UNIT) { ++ /* ulDeleteFxn = address of node's delete ++ * function */ ++ status = GetFxnAddress(hNode, &ulDeleteFxn, ++ DELETEPHASE); ++ } else if (procId == IVA_UNIT) ++ ulDeleteFxn = (u32)hNode->nodeEnv; ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ GT_1trace(NODE_debugMask, GT_4CLASS, ++ "NODE_Delete: proc Status " ++ "0x%x\n", procStatus.iState); ++ if (procStatus.iState != PROC_ERROR) { ++ status = DISP_NodeDelete(hDisp, hNode, ++ hNodeMgr->ulFxnAddrs[RMSDELETENODE], ++ ulDeleteFxn, hNode->nodeEnv); ++ } else ++ NODE_SetState(hNode, NODE_DONE); ++ ++ /* Unload execute, if not unloaded, and delete ++ * function */ ++ if (state == NODE_RUNNING && ++ hNode->fPhaseSplit) { ++ status1 = hNodeMgr->nldrFxns.pfnUnload( ++ hNode->hNldrNode, NLDR_EXECUTE); ++ } ++ if (DSP_FAILED(status1)) { ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Delete: failed to" ++ "unload execute code: 0x%x\n", ++ status1); ++ } ++ status1 = hNodeMgr->nldrFxns.pfnUnload( ++ hNode->hNldrNode, NLDR_DELETE); ++ hNode->fLoaded = false; ++ if (DSP_FAILED(status1)) { ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Delete: failed to" ++ "unload delete code: 0x%x\n", ++ status1); ++ } ++ } ++ } ++ } ++ /* Free host side resources even if a failure occurred */ ++ /* Remove node from hNodeMgr->nodeList */ ++ LST_RemoveElem(hNodeMgr->nodeList, (struct LST_ELEM *) hNode); ++ hNodeMgr->uNumNodes--; ++ /* Decrement count of nodes created on DSP */ ++ if ((state != NODE_ALLOCATED) || ((state == NODE_ALLOCATED) && ++ (hNode->nodeEnv != (u32) NULL))) ++ hNodeMgr->uNumCreated--; ++ /* Free host-side resources allocated by NODE_Create() ++ * DeleteNode() fails if SM buffers not freed by client! */ ++#ifndef RES_CLEANUP_DISABLE ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_FAILED(res_status)) ++ goto func_cont; ++ DRV_GetProcContext(0, (struct DRV_OBJECT *)hDrvObject, ++ &pCtxt, hNode, 0); ++ if (pCtxt == NULL) ++ goto func_cont; ++ if (DRV_GetNodeResElement(hNode, &nodeRes, pCtxt) != DSP_ENOTFOUND) { ++ GT_0trace(NODE_debugMask, GT_5CLASS, "\nNODE_Delete12:\n"); ++ DRV_ProcNodeUpdateStatus(nodeRes, false); ++ } ++#endif ++func_cont: ++ GT_0trace(NODE_debugMask, GT_ENTER, "\nNODE_Delete13:\n "); ++ DeleteNode(hNode); ++#ifndef RES_CLEANUP_DISABLE ++ GT_0trace(NODE_debugMask, GT_5CLASS, "\nNODE_Delete2:\n "); ++ if (pCtxt != NULL) ++ DRV_RemoveNodeResElement(nodeRes, (HANDLE)pCtxt); ++#endif ++ GT_0trace(NODE_debugMask, GT_ENTER, "\nNODE_Delete3:\n "); ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ PROC_NotifyClients(hProcessor, DSP_NODESTATECHANGE); ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_DeleteMgr ======== ++ * Purpose: ++ * Delete the NODE Manager. ++ */ ++DSP_STATUS NODE_DeleteMgr(struct NODE_MGR *hNodeMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNodeMgr, NODEMGR_SIGNATURE)); ++ ++ GT_1trace(NODE_debugMask, GT_ENTER, "NODE_DeleteMgr: hNodeMgr: 0x%x\n", ++ hNodeMgr); ++ DeleteNodeMgr(hNodeMgr); ++ ++ return status; ++} ++ ++/* ++ * ======== NODE_EnumNodes ======== ++ * Purpose: ++ * Enumerate currently allocated nodes. ++ */ ++DSP_STATUS NODE_EnumNodes(struct NODE_MGR *hNodeMgr, IN DSP_HNODE *aNodeTab, ++ u32 uNodeTabSize, OUT u32 *puNumNodes, ++ OUT u32 *puAllocated) ++{ ++ struct NODE_OBJECT *hNode; ++ u32 i; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNodeMgr, NODEMGR_SIGNATURE)); ++ DBC_Require(aNodeTab != NULL || uNodeTabSize == 0); ++ DBC_Require(puNumNodes != NULL); ++ DBC_Require(puAllocated != NULL); ++ GT_5trace(NODE_debugMask, GT_ENTER, "NODE_EnumNodes: hNodeMgr: 0x%x\t" ++ "aNodeTab: %d\tuNodeTabSize: 0x%x\tpuNumNodes: 0x%x\t" ++ "puAllocated\n", hNodeMgr, aNodeTab, uNodeTabSize, puNumNodes, ++ puAllocated); ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ if (hNodeMgr->uNumNodes > uNodeTabSize) { ++ *puAllocated = hNodeMgr->uNumNodes; ++ *puNumNodes = 0; ++ status = DSP_ESIZE; ++ } else { ++ hNode = (struct NODE_OBJECT *)LST_First(hNodeMgr-> ++ nodeList); ++ for (i = 0; i < hNodeMgr->uNumNodes; i++) { ++ DBC_Assert(MEM_IsValidHandle(hNode, ++ NODE_SIGNATURE)); ++ aNodeTab[i] = hNode; ++ hNode = (struct NODE_OBJECT *)LST_Next ++ (hNodeMgr->nodeList, ++ (struct LST_ELEM *)hNode); ++ } ++ *puAllocated = *puNumNodes = hNodeMgr->uNumNodes; ++ } ++ } ++ /* end of SYNC_EnterCS */ ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ return status; ++} ++ ++/* ++ * ======== NODE_Exit ======== ++ * Purpose: ++ * Discontinue usage of NODE module. ++ */ ++void NODE_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "Entered NODE_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== NODE_FreeMsgBuf ======== ++ * Purpose: ++ * Frees the message buffer. ++ */ ++DSP_STATUS NODE_FreeMsgBuf(struct NODE_OBJECT *hNode, IN u8 *pBuffer, ++ OPTIONAL struct DSP_BUFFERATTR *pAttr) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ DSP_STATUS status = DSP_SOK; ++ u32 procId; ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBuffer != NULL); ++ DBC_Require(pNode != NULL); ++ DBC_Require(pNode->hXlator != NULL); ++ GT_3trace(NODE_debugMask, GT_ENTER, "NODE_FreeMsgBuf: hNode: 0x%x\t" ++ "pBuffer: 0x%x\tpAttr: 0x%x\n", hNode, pBuffer, pAttr); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) ++ status = DSP_EHANDLE; ++ ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ if (procId == DSP_UNIT) { ++ if (DSP_SUCCEEDED(status)) { ++ if (pAttr == NULL) { ++ /* set defaults */ ++ pAttr = &NODE_DFLTBUFATTRS; ++ } ++ /* Node supports single SM segment only */ ++ if (pAttr->uSegment != 1) ++ status = DSP_EBADSEGID; ++ ++ /* pBuffer is clients Va. */ ++ status = CMM_XlatorFreeBuf(pNode->hXlator, pBuffer); ++ if (DSP_FAILED(status)) ++ status = DSP_EFAIL; ++ else ++ status = DSP_SOK; ++ ++ } ++ } else { ++ DBC_Assert(NULL); /* BUG */ ++ } ++ return status; ++} ++ ++/* ++ * ======== NODE_GetAttr ======== ++ * Purpose: ++ * Copy the current attributes of the specified node into a DSP_NODEATTR ++ * structure. ++ */ ++DSP_STATUS NODE_GetAttr(struct NODE_OBJECT *hNode, ++ OUT struct DSP_NODEATTR *pAttr, u32 uAttrSize) ++{ ++ struct NODE_MGR *hNodeMgr; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(cRefs > 0); ++ DBC_Require(pAttr != NULL); ++ DBC_Require(uAttrSize >= sizeof(struct DSP_NODEATTR)); ++ GT_3trace(NODE_debugMask, GT_ENTER, "NODE_GetAttr: hNode: " ++ "0x%x\tpAttr: 0x%x \tuAttrSize: 0x%x\n", hNode, pAttr, ++ uAttrSize); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ hNodeMgr = hNode->hNodeMgr; ++ /* Enter hNodeMgr critical section (since we're accessing ++ * data that could be changed by NODE_ChangePriority() and ++ * NODE_Connect(). */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ pAttr->cbStruct = sizeof(struct DSP_NODEATTR); ++ /* DSP_NODEATTRIN */ ++ pAttr->inNodeAttrIn.cbStruct = ++ sizeof(struct DSP_NODEATTRIN); ++ pAttr->inNodeAttrIn.iPriority = hNode->nPriority; ++ pAttr->inNodeAttrIn.uTimeout = hNode->uTimeout; ++ pAttr->inNodeAttrIn.uHeapSize = ++ hNode->createArgs.asa.taskArgs.uHeapSize; ++ pAttr->inNodeAttrIn.pGPPVirtAddr = (void *) ++ hNode->createArgs.asa.taskArgs.uGPPHeapAddr; ++ pAttr->uInputs = hNode->uNumGPPInputs; ++ pAttr->uOutputs = hNode->uNumGPPOutputs; ++ /* DSP_NODEINFO */ ++ GetNodeInfo(hNode, &(pAttr->iNodeInfo)); ++ } ++ /* end of SYNC_EnterCS */ ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ } ++ return status; ++} ++ ++/* ++ * ======== NODE_GetChannelId ======== ++ * Purpose: ++ * Get the channel index reserved for a stream connection between the ++ * host and a node. ++ */ ++DSP_STATUS NODE_GetChannelId(struct NODE_OBJECT *hNode, u32 uDir, u32 uIndex, ++ OUT u32 *pulId) ++{ ++ enum NODE_TYPE nodeType; ++ DSP_STATUS status = DSP_EVALUE; ++ DBC_Require(cRefs > 0); ++ DBC_Require(uDir == DSP_TONODE || uDir == DSP_FROMNODE); ++ DBC_Require(pulId != NULL); ++ GT_4trace(NODE_debugMask, GT_ENTER, "NODE_GetChannelId: hNode: " ++ "0x%x\tuDir: %d\tuIndex: %d\tpulId: 0x%x\n", hNode, uDir, ++ uIndex, pulId); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ return status; ++ } ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_TASK && nodeType != NODE_DAISSOCKET) { ++ status = DSP_ENODETYPE; ++ return status; ++ } ++ if (uDir == DSP_TONODE) { ++ if (uIndex < MaxInputs(hNode)) { ++ if (hNode->inputs[uIndex].type == HOSTCONNECT) { ++ *pulId = hNode->inputs[uIndex].devId; ++ status = DSP_SOK; ++ } ++ } ++ } else { ++ DBC_Assert(uDir == DSP_FROMNODE); ++ if (uIndex < MaxOutputs(hNode)) { ++ if (hNode->outputs[uIndex].type == HOSTCONNECT) { ++ *pulId = hNode->outputs[uIndex].devId; ++ status = DSP_SOK; ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== NODE_GetMessage ======== ++ * Purpose: ++ * Retrieve a message from a node on the DSP. ++ */ ++DSP_STATUS NODE_GetMessage(struct NODE_OBJECT *hNode, OUT struct DSP_MSG *pMsg, ++ u32 uTimeout) ++{ ++ struct NODE_MGR *hNodeMgr; ++ enum NODE_TYPE nodeType; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ void *pTmpBuf; ++ struct DSP_PROCESSORSTATE procStatus; ++ struct PROC_OBJECT *hProcessor; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pMsg != NULL); ++ GT_3trace(NODE_debugMask, GT_ENTER, ++ "NODE_GetMessage: hNode: 0x%x\tpMsg: " ++ "0x%x\tuTimeout: 0x%x\n", hNode, pMsg, uTimeout); ++ hProcessor = hNode->hProcessor; ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt to get the ++ message */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "NODE_GetMessage:" ++ " proc Status 0x%x\n", procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ hNodeMgr = hNode->hNodeMgr; ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_MESSAGE && nodeType != NODE_TASK && ++ nodeType != NODE_DAISSOCKET) { ++ status = DSP_ENODETYPE; ++ goto func_end; ++ } ++ /* This function will block unless a message is available. Since ++ * DSPNode_RegisterNotify() allows notification when a message ++ * is available, the system can be designed so that ++ * DSPNode_GetMessage() is only called when a message is ++ * available. */ ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnMsgGet)(hNode->hMsgQueue, pMsg, uTimeout); ++ /* Check if message contains SM descriptor */ ++ if (DSP_FAILED(status) || !(pMsg->dwCmd & DSP_RMSBUFDESC)) ++ goto func_end; ++ ++ /* Translate DSP byte addr to GPP Va. */ ++ pTmpBuf = CMM_XlatorTranslate(hNode->hXlator, ++ (void *)(pMsg->dwArg1 * hNode->hNodeMgr->uDSPWordSize), ++ CMM_DSPPA2PA); ++ if (pTmpBuf != NULL) { ++ /* now convert this GPP Pa to Va */ ++ pTmpBuf = CMM_XlatorTranslate(hNode->hXlator, pTmpBuf, ++ CMM_PA2VA); ++ if (pTmpBuf != NULL) { ++ /* Adjust SM size in msg */ ++ pMsg->dwArg1 = (u32) pTmpBuf; ++ pMsg->dwArg2 *= hNode->hNodeMgr->uDSPWordSize; ++ } else { ++ GT_0trace(NODE_debugMask, GT_7CLASS, "NODE_GetMessage: " ++ "Failed SM translation!\n"); ++ status = DSP_ETRANSLATE; ++ } ++ } else { ++ GT_0trace(NODE_debugMask, GT_7CLASS, "NODE_GetMessage: Failed " ++ "SM Pa/Pa translation!\n"); ++ status = DSP_ETRANSLATE; ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_GetNldrObj ======== ++ */ ++DSP_STATUS NODE_GetNldrObj(struct NODE_MGR *hNodeMgr, ++ struct NLDR_OBJECT **phNldrObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct NODE_MGR *pNodeMgr = hNodeMgr; ++ DBC_Require(phNldrObj != NULL); ++ GT_2trace(NODE_debugMask, GT_ENTER, ++ "Entered NODE_GetNldrObj, hNodeMgr: " ++ "0x%x\n\tphNldrObj: 0x%x\n", hNodeMgr, phNldrObj); ++ if (!MEM_IsValidHandle(hNodeMgr, NODEMGR_SIGNATURE)) ++ status = DSP_EHANDLE; ++ else ++ *phNldrObj = pNodeMgr->hNldr; ++ ++ GT_2trace(NODE_debugMask, GT_ENTER, ++ "Exit NODE_GetNldrObj: status 0x%x\n\t" ++ "phNldrObj: 0x%x\n", status, *phNldrObj); ++ DBC_Ensure(DSP_SUCCEEDED(status) || ((phNldrObj != NULL) && ++ (*phNldrObj == NULL))); ++ return status; ++} ++ ++/* ++ * ======== NODE_GetStrmMgr ======== ++ * Purpose: ++ * Returns the Stream manager. ++ */ ++DSP_STATUS NODE_GetStrmMgr(struct NODE_OBJECT *hNode, ++ struct STRM_MGR **phStrmMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) ++ status = DSP_EHANDLE; ++ else ++ *phStrmMgr = hNode->hNodeMgr->hStrmMgr; ++ ++ return status; ++} ++ ++/* ++ * ======== NODE_GetLoadType ======== ++ */ ++enum NLDR_LOADTYPE NODE_GetLoadType(struct NODE_OBJECT *hNode) ++{ ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_GetLoadType: Failed. hNode:" ++ " 0x%x\n", hNode); ++ return -1; ++ } else ++ return hNode->dcdProps.objData.nodeObj.usLoadType; ++} ++ ++/* ++ * ======== NODE_GetTimeout ======== ++ * Purpose: ++ * Returns the timeout value for this node. ++ */ ++u32 NODE_GetTimeout(struct NODE_OBJECT *hNode) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_GetTimeout: Failed. hNode:" ++ " 0x%x\n", hNode); ++ return 0; ++ } else ++ return hNode->uTimeout; ++} ++ ++/* ++ * ======== NODE_GetType ======== ++ * Purpose: ++ * Returns the node type. ++ */ ++enum NODE_TYPE NODE_GetType(struct NODE_OBJECT *hNode) ++{ ++ enum NODE_TYPE nodeType; ++ ++ if (hNode == (struct NODE_OBJECT *) DSP_HGPPNODE) ++ nodeType = NODE_GPP; ++ else { ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) ++ nodeType = -1; ++ else ++ nodeType = hNode->nType; ++ } ++ return nodeType; ++} ++ ++/* ++ * ======== NODE_Init ======== ++ * Purpose: ++ * Initialize the NODE module. ++ */ ++bool NODE_Init(void) ++{ ++ bool fRetVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!NODE_debugMask.flags); ++ GT_create(&NODE_debugMask, "NO"); /* "NO" for NOde */ ++ } ++ ++ if (fRetVal) ++ cRefs++; ++ ++ GT_1trace(NODE_debugMask, GT_5CLASS, "NODE_Init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fRetVal && (cRefs > 0)) || (!fRetVal && (cRefs >= 0))); ++ return fRetVal; ++} ++ ++/* ++ * ======== NODE_OnExit ======== ++ * Purpose: ++ * Gets called when RMS_EXIT is received for a node. ++ */ ++void NODE_OnExit(struct NODE_OBJECT *hNode, s32 nStatus) ++{ ++ DBC_Assert(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ /* Set node state to done */ ++ NODE_SetState(hNode, NODE_DONE); ++ hNode->nExitStatus = nStatus; ++ if (hNode->fLoaded && hNode->fPhaseSplit) { ++ (void)hNode->hNodeMgr->nldrFxns.pfnUnload(hNode->hNldrNode, ++ NLDR_EXECUTE); ++ hNode->fLoaded = false; ++ } ++ /* Unblock call to NODE_Terminate */ ++ (void) SYNC_SetEvent(hNode->hSyncDone); ++ /* Notify clients */ ++ PROC_NotifyClients(hNode->hProcessor, DSP_NODESTATECHANGE); ++ NTFY_Notify(hNode->hNtfy, DSP_NODESTATECHANGE); ++} ++ ++/* ++ * ======== NODE_Pause ======== ++ * Purpose: ++ * Suspend execution of a node currently running on the DSP. ++ */ ++DSP_STATUS NODE_Pause(struct NODE_OBJECT *hNode) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ enum NODE_TYPE nodeType; ++ enum NODE_STATE state; ++ struct NODE_MGR *hNodeMgr; ++ DSP_STATUS status = DSP_SOK; ++ u32 procId; ++ struct DSP_PROCESSORSTATE procStatus; ++ struct PROC_OBJECT *hProcessor; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(NODE_debugMask, GT_ENTER, "NODE_Pause: hNode: 0x%x\n", hNode); ++ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_TASK && nodeType != NODE_DAISSOCKET) ++ status = DSP_ENODETYPE; ++ ++ } ++ ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ ++ if (procId == IVA_UNIT) ++ status = DSP_ENOTIMPL; ++ ++ if (DSP_SUCCEEDED(status)) { ++ hNodeMgr = hNode->hNodeMgr; ++ ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ ++ if (DSP_SUCCEEDED(status)) { ++ state = NODE_GetState(hNode); ++ /* Check node state */ ++ if (state != NODE_RUNNING) ++ status = DSP_EWRONGSTATE; ++ ++ hProcessor = hNode->hProcessor; ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt ++ to send the message */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, ++ "NODE_Pause: proc Status 0x%x\n", ++ procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = DISP_NodeChangePriority(hNodeMgr-> ++ hDisp, hNode, ++ hNodeMgr->ulFxnAddrs[RMSCHANGENODEPRIORITY], ++ hNode->nodeEnv, NODE_SUSPENDEDPRI); ++ } ++ ++ /* Update state */ ++ if (DSP_SUCCEEDED(status)) { ++ NODE_SetState(hNode, NODE_PAUSED); ++ } else { ++ GT_1trace(NODE_debugMask, GT_6CLASS, ++ "NODE_Pause: Failed. hNode:" ++ " 0x%x\n", hNode); ++ } ++ } ++ /* End of SYNC_EnterCS */ ++ /* Leave critical section */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ PROC_NotifyClients(hNode->hProcessor, ++ DSP_NODESTATECHANGE); ++ NTFY_Notify(hNode->hNtfy, DSP_NODESTATECHANGE); ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_PutMessage ======== ++ * Purpose: ++ * Send a message to a message node, task node, or XDAIS socket node. This ++ * function will block until the message stream can accommodate the ++ * message, or a timeout occurs. ++ */ ++DSP_STATUS NODE_PutMessage(struct NODE_OBJECT *hNode, ++ IN CONST struct DSP_MSG *pMsg, u32 uTimeout) ++{ ++ struct NODE_MGR *hNodeMgr = NULL; ++ enum NODE_TYPE nodeType; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ enum NODE_STATE state; ++ DSP_STATUS status = DSP_SOK; ++ void *pTmpBuf; ++ struct DSP_MSG newMsg; ++ struct DSP_PROCESSORSTATE procStatus; ++ struct PROC_OBJECT *hProcessor; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pMsg != NULL); ++ GT_3trace(NODE_debugMask, GT_ENTER, ++ "NODE_PutMessage: hNode: 0x%x\tpMsg: " ++ "0x%x\tuTimeout: 0x%x\n", hNode, pMsg, uTimeout); ++ hProcessor = hNode->hProcessor; ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in bad state then don't attempt sending the ++ message */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "NODE_PutMessage:" ++ " proc Status 0x%x\n", procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) ++ status = DSP_EHANDLE; ++ else { ++ hNodeMgr = hNode->hNodeMgr; ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_MESSAGE && nodeType != NODE_TASK && ++ nodeType != NODE_DAISSOCKET) ++ status = DSP_ENODETYPE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Check node state. Can't send messages to a node after ++ * we've sent the RMS_EXIT command. There is still the ++ * possibility that NODE_Terminate can be called after we've ++ * checked the state. Could add another SYNC object to ++ * prevent this (can't use hNodeMgr->hSync, since we don't ++ * want to block other NODE functions). However, the node may ++ * still exit on its own, before this message is sent. */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ state = NODE_GetState(hNode); ++ if (state == NODE_TERMINATING || state == NODE_DONE) ++ status = DSP_EWRONGSTATE; ++ ++ } ++ /* end of SYNC_EnterCS */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* assign pMsg values to new msg */ ++ newMsg = *pMsg; ++ /* Now, check if message contains a SM buffer descriptor */ ++ if (pMsg->dwCmd & DSP_RMSBUFDESC) { ++ /* Translate GPP Va to DSP physical buf Ptr. */ ++ pTmpBuf = CMM_XlatorTranslate(hNode->hXlator, ++ (void *)newMsg.dwArg1, CMM_VA2DSPPA); ++ if (pTmpBuf != NULL) { ++ /* got translation, convert to MAUs in msg */ ++ if (hNode->hNodeMgr->uDSPWordSize != 0) { ++ newMsg.dwArg1 = ++ (u32)pTmpBuf / ++ hNode->hNodeMgr->uDSPWordSize; ++ /* MAUs */ ++ newMsg.dwArg2 /= hNode->hNodeMgr->uDSPWordSize; ++ } else { ++ GT_0trace(NODE_debugMask, GT_7CLASS, ++ "NODE_PutMessage: " ++ "uDSPWordSize is zero!\n"); ++ status = DSP_EFAIL; /* bad DSPWordSize */ ++ } ++ } else { /* failed to translate buffer address */ ++ GT_0trace(NODE_debugMask, GT_7CLASS, ++ "NODE_PutMessage: Failed to" ++ " translate SM address\n"); ++ status = DSP_ETRANSLATE; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnMsgPut)(hNode->hMsgQueue, ++ &newMsg, uTimeout); ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified on specific events for this node. ++ */ ++DSP_STATUS NODE_RegisterNotify(struct NODE_OBJECT *hNode, u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hNotification != NULL); ++ ++ GT_4trace(NODE_debugMask, GT_ENTER, ++ "NODE_RegisterNotify: hNode: 0x%x\t" ++ "uEventMask: 0x%x\tuNotifyType: 0x%x\thNotification: 0x%x\n", ++ hNode, uEventMask, uNotifyType, hNotification); ++ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ /* Check if event mask is a valid node related event */ ++ if (uEventMask & ~(DSP_NODESTATECHANGE | ++ DSP_NODEMESSAGEREADY)) ++ status = DSP_EVALUE; ++ ++ /* Check if notify type is valid */ ++ if (uNotifyType != DSP_SIGNALEVENT) ++ status = DSP_EVALUE; ++ ++ /* Only one Notification can be registered at a ++ * time - Limitation */ ++ if (uEventMask == (DSP_NODESTATECHANGE | ++ DSP_NODEMESSAGEREADY)) ++ status = DSP_EVALUE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ if (uEventMask == DSP_NODESTATECHANGE) { ++ status = NTFY_Register(hNode->hNtfy, hNotification, ++ uEventMask & DSP_NODESTATECHANGE, uNotifyType); ++ } else { ++ /* Send Message part of event mask to MSG */ ++ pIntfFxns = hNode->hNodeMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnMsgRegisterNotify) ++ (hNode->hMsgQueue, ++ uEventMask & DSP_NODEMESSAGEREADY, uNotifyType, ++ hNotification); ++ } ++ ++ } ++ return status; ++} ++ ++/* ++ * ======== NODE_Run ======== ++ * Purpose: ++ * Start execution of a node's execute phase, or resume execution of a node ++ * that has been suspended (via NODE_NodePause()) on the DSP. Load the ++ * node's execute function if necessary. ++ */ ++DSP_STATUS NODE_Run(struct NODE_OBJECT *hNode) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ struct NODE_MGR *hNodeMgr; ++ enum NODE_TYPE nodeType; ++ enum NODE_STATE state; ++ u32 ulExecuteFxn; ++ u32 ulFxnAddr; ++ DSP_STATUS status = DSP_SOK; ++ u32 procId; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct DSP_PROCESSORSTATE procStatus; ++ struct PROC_OBJECT *hProcessor; ++ ++ DBC_Require(cRefs > 0); ++ GT_1trace(NODE_debugMask, GT_ENTER, "NODE_Run: hNode: 0x%x\n", hNode); ++ hProcessor = hNode->hProcessor; ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt to run the node */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "NODE_Run:" ++ " proc Status 0x%x\n", procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ nodeType = NODE_GetType(hNode); ++ if (nodeType == NODE_DEVICE) ++ status = DSP_ENODETYPE; ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ hNodeMgr = hNode->hNodeMgr; ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ /* Enter critical section */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ state = NODE_GetState(hNode); ++ if (state != NODE_CREATED && state != NODE_PAUSED) ++ status = DSP_EWRONGSTATE; ++ ++ if (DSP_SUCCEEDED(status)) ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ ++ if (DSP_FAILED(status)) ++ goto func_cont1; ++ ++ if ((procId != DSP_UNIT) && (procId != IVA_UNIT)) ++ goto func_cont1; ++ ++ if (state == NODE_CREATED) { ++ /* If node's execute function is not loaded, load it */ ++ if (!(hNode->fLoaded) && hNode->fPhaseSplit) { ++ status = hNodeMgr->nldrFxns.pfnLoad(hNode->hNldrNode, ++ NLDR_EXECUTE); ++ if (DSP_SUCCEEDED(status)) { ++ hNode->fLoaded = true; ++ } else { ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Run: failed to load " ++ "execute code:0x%x\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get address of node's execute function */ ++ if (procId == IVA_UNIT) ++ ulExecuteFxn = (u32) hNode->nodeEnv; ++ else { ++ status = GetFxnAddress(hNode, &ulExecuteFxn, ++ EXECUTEPHASE); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ ulFxnAddr = hNodeMgr->ulFxnAddrs[RMSEXECUTENODE]; ++ status = DISP_NodeRun(hNodeMgr->hDisp, hNode, ulFxnAddr, ++ ulExecuteFxn, hNode->nodeEnv); ++ } ++ } else if (state == NODE_PAUSED) { ++ ulFxnAddr = hNodeMgr->ulFxnAddrs[RMSCHANGENODEPRIORITY]; ++ status = DISP_NodeChangePriority(hNodeMgr->hDisp, hNode, ++ ulFxnAddr, hNode->nodeEnv, ++ NODE_GetPriority(hNode)); ++ } else { ++ /* We should never get here */ ++ DBC_Assert(false); ++ } ++func_cont1: ++ /* Update node state. */ ++ if (DSP_SUCCEEDED(status)) ++ NODE_SetState(hNode, NODE_RUNNING); ++ else /* Set state back to previous value */ ++ NODE_SetState(hNode, state); ++ /*End of SYNC_EnterCS */ ++ /* Exit critical section */ ++func_cont: ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ PROC_NotifyClients(hNode->hProcessor, ++ DSP_NODESTATECHANGE); ++ NTFY_Notify(hNode->hNtfy, DSP_NODESTATECHANGE); ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== NODE_Terminate ======== ++ * Purpose: ++ * Signal a node running on the DSP that it should exit its execute phase ++ * function. ++ */ ++DSP_STATUS NODE_Terminate(struct NODE_OBJECT *hNode, OUT DSP_STATUS *pStatus) ++{ ++ struct NODE_OBJECT *pNode = (struct NODE_OBJECT *)hNode; ++ struct NODE_MGR *hNodeMgr = NULL; ++ enum NODE_TYPE nodeType; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ enum NODE_STATE state; ++ struct DSP_MSG msg, killmsg; ++ DSP_STATUS status = DSP_SOK; ++ u32 procId, killTimeOut; ++ struct DEH_MGR *hDehMgr; ++ struct DSP_PROCESSORSTATE procStatus; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pStatus != NULL); ++ ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Terminate: hNode: 0x%x\n", hNode); ++ ++ if (pNode->hProcessor == NULL) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, ++ "NODE_Terminate: pNode->hProcessor = 0x%x\n", ++ pNode->hProcessor); ++ goto func_end; ++ } ++ status = PROC_GetProcessorId(pNode->hProcessor, &procId); ++ ++ if (DSP_SUCCEEDED(status)) { ++ hNodeMgr = hNode->hNodeMgr; ++ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) ++ status = DSP_EHANDLE; ++ else { ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_TASK && nodeType != ++ NODE_DAISSOCKET) ++ status = DSP_ENODETYPE; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Check node state */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ state = NODE_GetState(hNode); ++ if (state != NODE_RUNNING) { ++ status = DSP_EWRONGSTATE; ++ /* Set the exit status if node terminated on ++ * its own. */ ++ if (state == NODE_DONE) ++ *pStatus = hNode->nExitStatus; ++ ++ } else { ++ NODE_SetState(hNode, NODE_TERMINATING); ++ } ++ } ++ /* end of SYNC_EnterCS */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* ++ * Send exit message. Do not change state to NODE_DONE ++ * here. That will be done in callback. ++ */ ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_Terminate: env = 0x%x\n", hNode->nodeEnv); ++ ++ status = PROC_GetState(pNode->hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ /* If processor is in error state then don't attempt to send ++ * A kill task command */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_4CLASS, "NODE_Terminate:" ++ " proc Status 0x%x\n", procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_cont; ++ } ++ ++ msg.dwCmd = RMS_EXIT; ++ msg.dwArg1 = hNode->nodeEnv; ++ killmsg.dwCmd = RMS_KILLTASK; ++ killmsg.dwArg1 = hNode->nodeEnv; ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ ++ if (hNode->uTimeout > MAXTIMEOUT) ++ killTimeOut = MAXTIMEOUT; ++ else ++ killTimeOut = (hNode->uTimeout)*2; ++ ++ status = (*pIntfFxns->pfnMsgPut)(hNode->hMsgQueue, &msg, ++ hNode->uTimeout); ++ if (DSP_SUCCEEDED(status)) { ++ /* Wait on synchronization object that will be ++ * posted in the callback on receiving RMS_EXIT ++ * message, or by NODE_Delete. Check for valid hNode, ++ * in case posted by NODE_Delete(). */ ++ status = SYNC_WaitOnEvent(hNode->hSyncDone, ++ killTimeOut/2); ++ if (DSP_FAILED(status)) { ++ if (status == DSP_ETIMEOUT) { ++ status = (*pIntfFxns->pfnMsgPut) ++ (hNode->hMsgQueue, &killmsg, ++ hNode->uTimeout); ++ if (DSP_SUCCEEDED(status)) { ++ status = SYNC_WaitOnEvent ++ (hNode->hSyncDone, ++ killTimeOut/2); ++ if (DSP_FAILED(status)) { ++ /* Here it goes the part ++ * of the simulation of ++ * the DSP exception */ ++ DEV_GetDehMgr(hNodeMgr-> ++ hDevObject, &hDehMgr); ++ if (hDehMgr) { ++ (*pIntfFxns-> ++ pfnDehNotify)(hDehMgr, ++ DSP_SYSERROR, ++ DSP_EXCEPTIONABORT); ++ status = DSP_EFAIL; ++ } ++ } else ++ status = DSP_SOK; ++ } ++ } else ++ status = DSP_EFAIL; ++ } else /* Convert SYNC status to DSP status */ ++ status = DSP_SOK; ++ } ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) { ++ /* Enter CS before getting exit status, in case node was ++ * deleted. */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ /* Make sure node wasn't deleted while we blocked */ ++ if (!MEM_IsValidHandle(hNode, NODE_SIGNATURE)) { ++ status = DSP_EFAIL; ++ } else { ++ *pStatus = hNode->nExitStatus; ++ GT_1trace(NODE_debugMask, GT_ENTER, ++ "NODE_Terminate: env = 0x%x " ++ "succeeded.\n", hNode->nodeEnv); ++ } ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ } /*End of SYNC_EnterCS */ ++func_end: ++ return status; ++} ++ ++/* ++ * ======== DeleteNode ======== ++ * Purpose: ++ * Free GPP resources allocated in NODE_Allocate() or NODE_Connect(). ++ */ ++static void DeleteNode(struct NODE_OBJECT *hNode) ++{ ++ struct NODE_MGR *hNodeMgr; ++ struct CMM_XLATOROBJECT *hXlator; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ u32 i; ++ enum NODE_TYPE nodeType; ++ struct STREAM stream; ++ struct NODE_MSGARGS msgArgs; ++ struct NODE_TASKARGS taskArgs; ++#ifdef DSP_DMM_DEBUG ++ struct DMM_OBJECT *hDmmMgr; ++ struct PROC_OBJECT *pProcObject = ++ (struct PROC_OBJECT *)hNode->hProcessor; ++#endif ++ DSP_STATUS status; ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ hNodeMgr = hNode->hNodeMgr; ++ if (!MEM_IsValidHandle(hNodeMgr, NODEMGR_SIGNATURE)) ++ return; ++ hXlator = hNode->hXlator; ++ nodeType = NODE_GetType(hNode); ++ if (nodeType != NODE_DEVICE) { ++ msgArgs = hNode->createArgs.asa.msgArgs; ++ if (msgArgs.pData) ++ MEM_Free(msgArgs.pData); ++ ++ /* Free MSG queue */ ++ if (hNode->hMsgQueue) { ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ (*pIntfFxns->pfnMsgDeleteQueue) (hNode->hMsgQueue); ++ hNode->hMsgQueue = NULL; ++ ++ } ++ if (hNode->hSyncDone) ++ (void) SYNC_CloseEvent(hNode->hSyncDone); ++ ++ /* Free all stream info */ ++ if (hNode->inputs) { ++ for (i = 0; i < MaxInputs(hNode); i++) { ++ stream = hNode->inputs[i]; ++ FreeStream(hNodeMgr, stream); ++ } ++ MEM_Free(hNode->inputs); ++ hNode->inputs = NULL; ++ } ++ if (hNode->outputs) { ++ for (i = 0; i < MaxOutputs(hNode); i++) { ++ stream = hNode->outputs[i]; ++ FreeStream(hNodeMgr, stream); ++ } ++ MEM_Free(hNode->outputs); ++ hNode->outputs = NULL; ++ } ++ taskArgs = hNode->createArgs.asa.taskArgs; ++ if (taskArgs.strmInDef) { ++ for (i = 0; i < MaxInputs(hNode); i++) { ++ if (taskArgs.strmInDef[i].szDevice) { ++ MEM_Free(taskArgs.strmInDef[i]. ++ szDevice); ++ taskArgs.strmInDef[i].szDevice = NULL; ++ } ++ } ++ MEM_Free(taskArgs.strmInDef); ++ taskArgs.strmInDef = NULL; ++ } ++ if (taskArgs.strmOutDef) { ++ for (i = 0; i < MaxOutputs(hNode); i++) { ++ if (taskArgs.strmOutDef[i].szDevice) { ++ MEM_Free(taskArgs.strmOutDef[i]. ++ szDevice); ++ taskArgs.strmOutDef[i].szDevice = NULL; ++ } ++ } ++ MEM_Free(taskArgs.strmOutDef); ++ taskArgs.strmOutDef = NULL; ++ } ++ if (taskArgs.uDSPHeapResAddr) { ++ status = PROC_UnMap(hNode->hProcessor, ++ (void *)taskArgs.uDSPHeapAddr); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(NODE_debugMask, GT_5CLASS, ++ "DSPProcessor_UnMap succeeded.\n"); ++ } else { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "DSPProcessor_UnMap failed." ++ " Status = 0x%x\n", (u32)status); ++ } ++ status = PROC_UnReserveMemory(hNode->hProcessor, ++ (void *)taskArgs.uDSPHeapResAddr); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(NODE_debugMask, GT_5CLASS, ++ "DSPProcessor_UnReserveMemory " ++ "succeeded.\n"); ++ } else { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "DSPProcessor_UnReserveMemory " ++ "failed. Status = 0x%x\n", ++ (u32)status); ++ } ++#ifdef DSP_DMM_DEBUG ++ status = DMM_GetHandle(pProcObject, &hDmmMgr); ++ if (DSP_SUCCEEDED(status)) ++ DMM_MemMapDump(hDmmMgr); ++#endif ++ } ++ } ++ if (nodeType != NODE_MESSAGE) { ++ if (hNode->streamConnect) { ++ MEM_Free(hNode->streamConnect); ++ hNode->streamConnect = NULL; ++ } ++ } ++ if (hNode->pstrDevName) { ++ MEM_Free(hNode->pstrDevName); ++ hNode->pstrDevName = NULL; ++ } ++ ++ if (hNode->hNtfy) { ++ NTFY_Delete(hNode->hNtfy); ++ hNode->hNtfy = NULL; ++ } ++ ++ /* These were allocated in DCD_GetObjectDef (via NODE_Allocate) */ ++ if (hNode->dcdProps.objData.nodeObj.pstrCreatePhaseFxn) { ++ MEM_Free(hNode->dcdProps.objData.nodeObj.pstrCreatePhaseFxn); ++ hNode->dcdProps.objData.nodeObj.pstrCreatePhaseFxn = NULL; ++ } ++ ++ if (hNode->dcdProps.objData.nodeObj.pstrExecutePhaseFxn) { ++ MEM_Free(hNode->dcdProps.objData.nodeObj.pstrExecutePhaseFxn); ++ hNode->dcdProps.objData.nodeObj.pstrExecutePhaseFxn = NULL; ++ } ++ ++ if (hNode->dcdProps.objData.nodeObj.pstrDeletePhaseFxn) { ++ MEM_Free(hNode->dcdProps.objData.nodeObj.pstrDeletePhaseFxn); ++ hNode->dcdProps.objData.nodeObj.pstrDeletePhaseFxn = NULL; ++ } ++ ++ if (hNode->dcdProps.objData.nodeObj.pstrIAlgName) { ++ MEM_Free(hNode->dcdProps.objData.nodeObj.pstrIAlgName); ++ hNode->dcdProps.objData.nodeObj.pstrIAlgName = NULL; ++ } ++ ++ /* Free all SM address translator resources */ ++ if (hXlator) { ++ (void) CMM_XlatorDelete(hXlator, TRUE); /* force free */ ++ hXlator = NULL; ++ } ++ ++ if (hNode->hNldrNode) { ++ hNodeMgr->nldrFxns.pfnFree(hNode->hNldrNode); ++ hNode->hNldrNode = NULL; ++ } ++ ++ MEM_FreeObject(hNode); ++ hNode = NULL; ++} ++ ++/* ++ * ======== DeleteNodeMgr ======== ++ * Purpose: ++ * Frees the node manager. ++ */ ++static void DeleteNodeMgr(struct NODE_MGR *hNodeMgr) ++{ ++ struct NODE_OBJECT *hNode; ++ ++ if (MEM_IsValidHandle(hNodeMgr, NODEMGR_SIGNATURE)) { ++ /* Free resources */ ++ if (hNodeMgr->hDcdMgr) ++ DCD_DestroyManager(hNodeMgr->hDcdMgr); ++ ++ /* Remove any elements remaining in lists */ ++ if (hNodeMgr->nodeList) { ++ while ((hNode = ++ (struct NODE_OBJECT *)LST_GetHead(hNodeMgr-> ++ nodeList))) ++ DeleteNode(hNode); ++ ++ DBC_Assert(LST_IsEmpty(hNodeMgr->nodeList)); ++ LST_Delete(hNodeMgr->nodeList); ++ } ++ if (hNodeMgr->hNtfy) ++ NTFY_Delete(hNodeMgr->hNtfy); ++ ++ if (hNodeMgr->pipeMap) ++ GB_delete(hNodeMgr->pipeMap); ++ ++ if (hNodeMgr->pipeDoneMap) ++ GB_delete(hNodeMgr->pipeDoneMap); ++ ++ if (hNodeMgr->chnlMap) ++ GB_delete(hNodeMgr->chnlMap); ++ ++ if (hNodeMgr->dmaChnlMap) ++ GB_delete(hNodeMgr->dmaChnlMap); ++ ++ if (hNodeMgr->zChnlMap) ++ GB_delete(hNodeMgr->zChnlMap); ++ ++ if (hNodeMgr->hDisp) ++ DISP_Delete(hNodeMgr->hDisp); ++ ++ if (hNodeMgr->hSync) ++ SYNC_DeleteCS(hNodeMgr->hSync); ++ ++ if (hNodeMgr->hStrmMgr) ++ STRM_Delete(hNodeMgr->hStrmMgr); ++ ++ /* Delete the loader */ ++ if (hNodeMgr->hNldr) ++ hNodeMgr->nldrFxns.pfnDelete(hNodeMgr->hNldr); ++ ++ if (hNodeMgr->fLoaderInit) ++ hNodeMgr->nldrFxns.pfnExit(); ++ ++ MEM_FreeObject(hNodeMgr); ++ } ++} ++ ++/* ++ * ======== FillStreamConnect ======== ++ * Purpose: ++ * Fills stream information. ++ */ ++static void FillStreamConnect(struct NODE_OBJECT *hNode1, ++ struct NODE_OBJECT *hNode2, ++ u32 uStream1, u32 uStream2) ++{ ++ u32 uStrmIndex; ++ struct DSP_STREAMCONNECT *pStrm1 = NULL; ++ struct DSP_STREAMCONNECT *pStrm2 = NULL; ++ enum NODE_TYPE node1Type = NODE_TASK; ++ enum NODE_TYPE node2Type = NODE_TASK; ++ ++ node1Type = NODE_GetType(hNode1); ++ node2Type = NODE_GetType(hNode2); ++ if (hNode1 != (struct NODE_OBJECT *)DSP_HGPPNODE) { ++ ++ if (node1Type != NODE_DEVICE) { ++ uStrmIndex = hNode1->uNumInputs + ++ hNode1->uNumOutputs - 1; ++ pStrm1 = &(hNode1->streamConnect[uStrmIndex]); ++ pStrm1->cbStruct = sizeof(struct DSP_STREAMCONNECT); ++ pStrm1->uThisNodeStreamIndex = uStream1; ++ } ++ ++ if (hNode2 != (struct NODE_OBJECT *)DSP_HGPPNODE) { ++ /* NODE == > NODE */ ++ if (node1Type != NODE_DEVICE) { ++ pStrm1->hConnectedNode = hNode2; ++ pStrm1->uiConnectedNodeID = hNode2->nodeId; ++ pStrm1->uConnectedNodeStreamIndex = uStream2; ++ pStrm1->lType = CONNECTTYPE_NODEOUTPUT; ++ } ++ if (node2Type != NODE_DEVICE) { ++ uStrmIndex = hNode2->uNumInputs + ++ hNode2->uNumOutputs - 1; ++ pStrm2 = &(hNode2->streamConnect[uStrmIndex]); ++ pStrm2->cbStruct = ++ sizeof(struct DSP_STREAMCONNECT); ++ pStrm2->uThisNodeStreamIndex = uStream2; ++ pStrm2->hConnectedNode = hNode1; ++ pStrm2->uiConnectedNodeID = hNode1->nodeId; ++ pStrm2->uConnectedNodeStreamIndex = uStream1; ++ pStrm2->lType = CONNECTTYPE_NODEINPUT; ++ } ++ } else if (node1Type != NODE_DEVICE) ++ pStrm1->lType = CONNECTTYPE_GPPOUTPUT; ++ } else { ++ /* GPP == > NODE */ ++ DBC_Assert(hNode2 != (struct NODE_OBJECT *)DSP_HGPPNODE); ++ uStrmIndex = hNode2->uNumInputs + hNode2->uNumOutputs - 1; ++ pStrm2 = &(hNode2->streamConnect[uStrmIndex]); ++ pStrm2->cbStruct = sizeof(struct DSP_STREAMCONNECT); ++ pStrm2->uThisNodeStreamIndex = uStream2; ++ pStrm2->lType = CONNECTTYPE_GPPINPUT; ++ } ++} ++ ++/* ++ * ======== FillStreamDef ======== ++ * Purpose: ++ * Fills Stream attributes. ++ */ ++static void FillStreamDef(struct NODE_OBJECT *hNode, ++ struct NODE_STRMDEF *pstrmDef, ++ struct DSP_STRMATTR *pAttrs) ++{ ++ struct NODE_MGR *hNodeMgr = hNode->hNodeMgr; ++ ++ if (pAttrs != NULL) { ++ pstrmDef->uNumBufs = pAttrs->uNumBufs; ++ pstrmDef->uBufsize = pAttrs->uBufsize / hNodeMgr-> ++ uDSPDataMauSize; ++ pstrmDef->uSegid = pAttrs->uSegid; ++ pstrmDef->uAlignment = pAttrs->uAlignment; ++ pstrmDef->uTimeout = pAttrs->uTimeout; ++ } else { ++ pstrmDef->uNumBufs = DEFAULTNBUFS; ++ pstrmDef->uBufsize = DEFAULTBUFSIZE / hNodeMgr-> ++ uDSPDataMauSize; ++ pstrmDef->uSegid = DEFAULTSEGID; ++ pstrmDef->uAlignment = DEFAULTALIGNMENT; ++ pstrmDef->uTimeout = DEFAULTTIMEOUT; ++ } ++} ++ ++/* ++ * ======== FreeStream ======== ++ * Purpose: ++ * Updates the channel mask and frees the pipe id. ++ */ ++static void FreeStream(struct NODE_MGR *hNodeMgr, struct STREAM stream) ++{ ++ /* Free up the pipe id unless other node has not yet been deleted. */ ++ if (stream.type == NODECONNECT) { ++ if (GB_test(hNodeMgr->pipeDoneMap, stream.devId)) { ++ /* The other node has already been deleted */ ++ GB_clear(hNodeMgr->pipeDoneMap, stream.devId); ++ GB_clear(hNodeMgr->pipeMap, stream.devId); ++ } else { ++ /* The other node has not been deleted yet */ ++ GB_set(hNodeMgr->pipeDoneMap, stream.devId); ++ } ++ } else if (stream.type == HOSTCONNECT) { ++ if (stream.devId < hNodeMgr->ulNumChnls) { ++ GB_clear(hNodeMgr->chnlMap, stream.devId); ++ } else if (stream.devId < (2 * hNodeMgr->ulNumChnls)) { ++ /* dsp-dma */ ++ GB_clear(hNodeMgr->dmaChnlMap, stream.devId - ++ (1 * hNodeMgr->ulNumChnls)); ++ } else if (stream.devId < (3 * hNodeMgr->ulNumChnls)) { ++ /* zero-copy */ ++ GB_clear(hNodeMgr->zChnlMap, stream.devId - ++ (2 * hNodeMgr->ulNumChnls)); ++ } ++ } ++} ++ ++/* ++ * ======== GetFxnAddress ======== ++ * Purpose: ++ * Retrieves the address for create, execute or delete phase for a node. ++ */ ++static DSP_STATUS GetFxnAddress(struct NODE_OBJECT *hNode, u32 *pulFxnAddr, ++ u32 uPhase) ++{ ++ char *pstrFxnName = NULL; ++ struct NODE_MGR *hNodeMgr = hNode->hNodeMgr; ++ DSP_STATUS status = DSP_SOK; ++ DBC_Require(NODE_GetType(hNode) == NODE_TASK || ++ NODE_GetType(hNode) == NODE_DAISSOCKET || ++ NODE_GetType(hNode) == NODE_MESSAGE); ++ ++ switch (uPhase) { ++ case CREATEPHASE: ++ pstrFxnName = hNode->dcdProps.objData.nodeObj. ++ pstrCreatePhaseFxn; ++ break; ++ case EXECUTEPHASE: ++ pstrFxnName = hNode->dcdProps.objData.nodeObj. ++ pstrExecutePhaseFxn; ++ break; ++ case DELETEPHASE: ++ pstrFxnName = hNode->dcdProps.objData.nodeObj. ++ pstrDeletePhaseFxn; ++ break; ++ default: ++ /* Should never get here */ ++ DBC_Assert(false); ++ break; ++ } ++ ++ status = hNodeMgr->nldrFxns.pfnGetFxnAddr(hNode->hNldrNode, pstrFxnName, ++ pulFxnAddr); ++ ++ return status; ++} ++ ++/* ++ * ======== GetNodeInfo ======== ++ * Purpose: ++ * Retrieves the node information. ++ */ ++void GetNodeInfo(struct NODE_OBJECT *hNode, struct DSP_NODEINFO *pNodeInfo) ++{ ++ u32 i; ++ ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ DBC_Require(pNodeInfo != NULL); ++ ++ pNodeInfo->cbStruct = sizeof(struct DSP_NODEINFO); ++ pNodeInfo->nbNodeDatabaseProps = hNode->dcdProps.objData.nodeObj. ++ ndbProps; ++ pNodeInfo->uExecutionPriority = hNode->nPriority; ++ pNodeInfo->hDeviceOwner = hNode->hDeviceOwner; ++ pNodeInfo->uNumberStreams = hNode->uNumInputs + hNode->uNumOutputs; ++ pNodeInfo->uNodeEnv = hNode->nodeEnv; ++ ++ pNodeInfo->nsExecutionState = NODE_GetState(hNode); ++ ++ /* Copy stream connect data */ ++ for (i = 0; i < hNode->uNumInputs + hNode->uNumOutputs; i++) ++ pNodeInfo->scStreamConnection[i] = hNode->streamConnect[i]; ++ ++} ++ ++/* ++ * ======== GetNodeProps ======== ++ * Purpose: ++ * Retrieve node properties. ++ */ ++static DSP_STATUS GetNodeProps(struct DCD_MANAGER *hDcdMgr, ++ struct NODE_OBJECT *hNode, ++ CONST struct DSP_UUID *pNodeId, ++ struct DCD_GENERICOBJ *pdcdProps) ++{ ++ u32 uLen; ++ struct NODE_MSGARGS *pMsgArgs; ++ struct NODE_TASKARGS *pTaskArgs; ++ enum NODE_TYPE nodeType = NODE_TASK; ++ struct DSP_NDBPROPS *pndbProps = &(pdcdProps->objData.nodeObj.ndbProps); ++ DSP_STATUS status = DSP_SOK; ++#ifdef DEBUG ++ char szUuid[MAXUUIDLEN]; ++#endif ++ ++ status = DCD_GetObjectDef(hDcdMgr, (struct DSP_UUID *)pNodeId, ++ DSP_DCDNODETYPE, pdcdProps); ++ ++ if (DSP_SUCCEEDED(status)) { ++ hNode->nType = nodeType = pndbProps->uNodeType; ++ ++#ifdef DEBUG ++ /* Create UUID value to set in registry. */ ++ UUID_UuidToString((struct DSP_UUID *)pNodeId, szUuid, ++ MAXUUIDLEN); ++ DBG_Trace(DBG_LEVEL7, "\n** (node) UUID: %s\n", szUuid); ++#endif ++ ++ /* Fill in message args that come from NDB */ ++ if (nodeType != NODE_DEVICE) { ++ pMsgArgs = &(hNode->createArgs.asa.msgArgs); ++ pMsgArgs->uSegid = pdcdProps->objData.nodeObj.uMsgSegid; ++ pMsgArgs->uNotifyType = pdcdProps->objData.nodeObj. ++ uMsgNotifyType; ++ pMsgArgs->uMaxMessages = pndbProps->uMessageDepth; ++#ifdef DEBUG ++ DBG_Trace(DBG_LEVEL7, ++ "** (node) Max Number of Messages: 0x%x\n", ++ pMsgArgs->uMaxMessages); ++#endif ++ } else { ++ /* Copy device name */ ++ DBC_Require(pndbProps->acName); ++ uLen = strlen(pndbProps->acName); ++ DBC_Assert(uLen < MAXDEVNAMELEN); ++ hNode->pstrDevName = MEM_Calloc(uLen + 1, MEM_PAGED); ++ if (hNode->pstrDevName == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ strncpy(hNode->pstrDevName, ++ pndbProps->acName, uLen); ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in create args that come from NDB */ ++ if (nodeType == NODE_TASK || nodeType == NODE_DAISSOCKET) { ++ pTaskArgs = &(hNode->createArgs.asa.taskArgs); ++ pTaskArgs->nPriority = pndbProps->iPriority; ++ pTaskArgs->uStackSize = pndbProps->uStackSize; ++ pTaskArgs->uSysStackSize = pndbProps->uSysStackSize; ++ pTaskArgs->uStackSeg = pndbProps->uStackSeg; ++#ifdef DEBUG ++ DBG_Trace(DBG_LEVEL7, ++ "** (node) Priority: 0x%x\n" "** (node) Stack" ++ " Size: 0x%x words\n" "** (node) System Stack" ++ " Size: 0x%x words\n" "** (node) Stack" ++ " Segment: 0x%x\n\n", ++ "** (node) profile count : 0x%x \n \n", ++ pTaskArgs->nPriority, pTaskArgs->uStackSize, ++ pTaskArgs->uSysStackSize, ++ pTaskArgs->uStackSeg, ++ pndbProps->uCountProfiles); ++#endif ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== GetProcProps ======== ++ * Purpose: ++ * Retrieve the processor properties. ++ */ ++static DSP_STATUS GetProcProps(struct NODE_MGR *hNodeMgr, ++ struct DEV_OBJECT *hDevObject) ++{ ++ struct CFG_DEVNODE *hDevNode; ++ struct CFG_HOSTRES hostRes; ++ DSP_STATUS status = DSP_SOK; ++ ++ status = DEV_GetDevNode(hDevObject, &hDevNode); ++ if (DSP_SUCCEEDED(status)) ++ status = CFG_GetHostResources(hDevNode, &hostRes); ++ ++ if (DSP_SUCCEEDED(status)) { ++ hNodeMgr->ulChnlOffset = hostRes.dwChnlOffset; ++ hNodeMgr->ulChnlBufSize = hostRes.dwChnlBufSize; ++ hNodeMgr->ulNumChnls = hostRes.dwNumChnls; ++ ++ /* ++ * PROC will add an API to get DSP_PROCESSORINFO. ++ * Fill in default values for now. ++ */ ++ /* TODO -- Instead of hard coding, take from registry */ ++ hNodeMgr->procFamily = 6000; ++ hNodeMgr->procType = 6410; ++ hNodeMgr->nMinPri = DSP_NODE_MIN_PRIORITY; ++ hNodeMgr->nMaxPri = DSP_NODE_MAX_PRIORITY; ++ hNodeMgr->uDSPWordSize = DSPWORDSIZE; ++ hNodeMgr->uDSPDataMauSize = DSPWORDSIZE; ++ hNodeMgr->uDSPMauSize = 1; ++ ++ } ++ return status; ++} ++ ++ ++ ++/* ++ * ======== NODE_GetUUIDProps ======== ++ * Purpose: ++ * Fetch Node UUID properties from DCD/DOF file. ++ */ ++DSP_STATUS NODE_GetUUIDProps(DSP_HPROCESSOR hProcessor, ++ IN CONST struct DSP_UUID *pNodeId, ++ OUT struct DSP_NDBPROPS *pNodeProps) ++{ ++ struct NODE_MGR *hNodeMgr = NULL; ++ struct DEV_OBJECT *hDevObject; ++ DSP_STATUS status = DSP_SOK; ++ struct DCD_NODEPROPS dcdNodeProps; ++ struct DSP_PROCESSORSTATE procStatus; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hProcessor != NULL); ++ DBC_Require(pNodeId != NULL); ++ ++ if (hProcessor == NULL || pNodeId == NULL) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ status = PROC_GetState(hProcessor, &procStatus, ++ sizeof(struct DSP_PROCESSORSTATE)); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ /* If processor is in error state then don't attempt ++ to send the message */ ++ if (procStatus.iState == PROC_ERROR) { ++ GT_1trace(NODE_debugMask, GT_5CLASS, ++ "NODE_GetUUIDProps: proc Status 0x%x\n", ++ procStatus.iState); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ ++ GT_3trace(NODE_debugMask, GT_ENTER, ++ "NODE_GetUUIDProps: " "\thProcessor: " ++ "0x%x\tpNodeId: 0x%x" "\tpNodeProps: 0x%x\n", hProcessor, ++ pNodeId, pNodeProps); ++ ++ status = PROC_GetDevObject(hProcessor, &hDevObject); ++ if (DSP_SUCCEEDED(status) && hDevObject != NULL) { ++ status = DEV_GetNodeManager(hDevObject, &hNodeMgr); ++ if (hNodeMgr == NULL) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ } ++ ++ /* ++ * Enter the critical section. This is needed because ++ * DCD_GetObjectDef will ultimately end up calling DBLL_open/close, ++ * which needs to be protected in order to not corrupt the zlib manager ++ * (COD). ++ */ ++ status = SYNC_EnterCS(hNodeMgr->hSync); ++ ++ if (DSP_SUCCEEDED(status)) { ++ dcdNodeProps.pstrCreatePhaseFxn = NULL; ++ dcdNodeProps.pstrExecutePhaseFxn = NULL; ++ dcdNodeProps.pstrDeletePhaseFxn = NULL; ++ dcdNodeProps.pstrIAlgName = NULL; ++ ++ status = DCD_GetObjectDef(hNodeMgr->hDcdMgr, ++ (struct DSP_UUID *) pNodeId, ++ DSP_DCDNODETYPE, ++ (struct DCD_GENERICOBJ *) &dcdNodeProps); ++ if (DSP_SUCCEEDED(status)) { ++ *pNodeProps = dcdNodeProps.ndbProps; ++ if (dcdNodeProps.pstrCreatePhaseFxn) ++ MEM_Free(dcdNodeProps.pstrCreatePhaseFxn); ++ ++ if (dcdNodeProps.pstrExecutePhaseFxn) ++ MEM_Free(dcdNodeProps.pstrExecutePhaseFxn); ++ ++ if (dcdNodeProps.pstrDeletePhaseFxn) ++ MEM_Free(dcdNodeProps.pstrDeletePhaseFxn); ++ ++ if (dcdNodeProps.pstrIAlgName) ++ MEM_Free(dcdNodeProps.pstrIAlgName); ++ } ++ /* Leave the critical section, we're done. */ ++ (void)SYNC_LeaveCS(hNodeMgr->hSync); ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== GetRMSFxns ======== ++ * Purpose: ++ * Retrieve the RMS functions. ++ */ ++static DSP_STATUS GetRMSFxns(struct NODE_MGR *hNodeMgr) ++{ ++ s32 i; ++ struct DEV_OBJECT *hDev = hNodeMgr->hDevObject; ++ DSP_STATUS status = DSP_SOK; ++ ++ static char *pszFxns[NUMRMSFXNS] = { ++ "RMS_queryServer", /* RMSQUERYSERVER */ ++ "RMS_configureServer", /* RMSCONFIGURESERVER */ ++ "RMS_createNode", /* RMSCREATENODE */ ++ "RMS_executeNode", /* RMSEXECUTENODE */ ++ "RMS_deleteNode", /* RMSDELETENODE */ ++ "RMS_changeNodePriority", /* RMSCHANGENODEPRIORITY */ ++ "RMS_readMemory", /* RMSREADMEMORY */ ++ "RMS_writeMemory", /* RMSWRITEMEMORY */ ++ "RMS_copy", /* RMSCOPY */ ++ }; ++ ++ for (i = 0; i < NUMRMSFXNS; i++) { ++ status = DEV_GetSymbol(hDev, pszFxns[i], ++ &(hNodeMgr->ulFxnAddrs[i])); ++ if (DSP_FAILED(status)) { ++ if (status == COD_E_SYMBOLNOTFOUND) { ++ /* ++ * May be loaded dynamically (in the future), ++ * but return an error for now. ++ */ ++ GT_1trace(NODE_debugMask, GT_6CLASS, ++ "RMS function: %s " ++ "currently not loaded\n", pszFxns[i]); ++ } else { ++ GT_2trace(NODE_debugMask, GT_6CLASS, ++ "GetRMSFxns: Symbol not " ++ "found: %s\tstatus = 0x%x\n", ++ pszFxns[i], status); ++ break; ++ } ++ } ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== Ovly ======== ++ * Purpose: ++ * Called during overlay.Sends command to RMS to copy a block of data. ++ */ ++static u32 Ovly(void *pPrivRef, u32 ulDspRunAddr, u32 ulDspLoadAddr, ++ u32 ulNumBytes, u32 nMemSpace) ++{ ++ struct NODE_OBJECT *hNode = (struct NODE_OBJECT *)pPrivRef; ++ struct NODE_MGR *hNodeMgr; ++ u32 ulBytes = 0; ++ u32 ulSize; ++ u32 ulTimeout; ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *hWmdContext; ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ ++ hNodeMgr = hNode->hNodeMgr; ++ ++ ulSize = ulNumBytes / hNodeMgr->uDSPWordSize; ++ ulTimeout = hNode->uTimeout; ++ ++ /* Call new MemCopy function */ ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ status = DEV_GetWMDContext(hNodeMgr->hDevObject, &hWmdContext); ++ status = (*pIntfFxns->pfnBrdMemCopy)(hWmdContext, ulDspRunAddr, ++ ulDspLoadAddr, ulNumBytes, (u32) nMemSpace); ++ ++ if (DSP_SUCCEEDED(status)) ++ ulBytes = ulNumBytes; ++ ++ return ulBytes; ++} ++ ++/* ++ * ======== Write ======== ++ */ ++static u32 Write(void *pPrivRef, u32 ulDspAddr, void *pBuf, ++ u32 ulNumBytes, u32 nMemSpace) ++{ ++ struct NODE_OBJECT *hNode = (struct NODE_OBJECT *) pPrivRef; ++ struct NODE_MGR *hNodeMgr; ++ u16 memType; ++ u32 ulTimeout; ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *hWmdContext; ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ ++ DBC_Require(MEM_IsValidHandle(hNode, NODE_SIGNATURE)); ++ DBC_Require(nMemSpace & DBLL_CODE || nMemSpace & DBLL_DATA); ++ ++ hNodeMgr = hNode->hNodeMgr; ++ ++ ulTimeout = hNode->uTimeout; ++ memType = (nMemSpace & DBLL_CODE) ? RMS_CODE : RMS_DATA; ++ ++ /* Call new MemWrite function */ ++ pIntfFxns = hNodeMgr->pIntfFxns; ++ status = DEV_GetWMDContext(hNodeMgr->hDevObject, &hWmdContext); ++ status = (*pIntfFxns->pfnBrdMemWrite) (hWmdContext, pBuf, ulDspAddr, ++ ulNumBytes, memType); ++ ++ return ulNumBytes; ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/proc.c b/drivers/dsp/bridge/rmgr/proc.c +new file mode 100644 +index 0000000..332e01a +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/proc.c +@@ -0,0 +1,1985 @@ ++/* ++ * proc.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== proc.c ======== ++ * Description: ++ * Processor interface at the driver level. ++ * ++ * Public Functions: ++ * PROC_Attach ++ * PROC_Ctrl ++ * PROC_Detach ++ * PROC_EnumNodes ++ * PROC_GetResourceInfo ++ * PROC_Exit ++ * PROC_FlushMemory ++ * PROC_GetState ++ * PROC_GetProcessorId ++ * PROC_GetTrace ++ * PROC_Init ++ * PROC_Load ++ * PROC_Map ++ * PROC_NotifyClients ++ * PROC_RegisterNotify ++ * PROC_ReserveMemory ++ * PROC_Start ++ * PROC_UnMap ++ * PROC_UnReserveMemory ++ * PROC_InvalidateMemory ++ ++ *! Revision History ++ *! ======== ======== ++ *! 04-Apr-2007 sh Added PROC_InvalidateMemory API ++ *! 19-Apr-2004 sb Aligned DMM definitions with Symbian ++ *! Used MEM_FlushCache instead of OS specific API ++ *! Integrated Alan's code review updates ++ *! 08-Mar-2004 sb Added the Dynamic Memory Mapping feature ++ *! 08-Mar-2004 vp Added g_pszLastCoff member to PROC_OBJECT. ++ *! This is required for multiprocessor environment. ++ *! 09-Feb-2004 vp Added PROC_GetProcessorID function ++ *! 22-Apr-2003 vp Fixed issue with the string that stores coff file name ++ *! 03-Apr-2003 sb Fix DEH deregistering bug ++ *! 26-Mar-2003 vp Commented the call to DSP deep sleep in PROC_Start function. ++ *! 18-Feb-2003 vp Code review updates. ++ *! 18-Oct-2002 vp Ported to Linux platform. ++ *! 22-May-2002 sg Do IOCTL-to-PWR translation before calling PWR_SleepDSP. ++ *! 14-May-2002 sg Use CSL_Atoi() instead of atoi(). ++ *! 13-May-2002 sg Propagate PWR return codes upwards. ++ *! 07-May-2002 sg Added check for, and call to PWR functions in PROC_Ctrl. ++ *! 02-May-2002 sg Added "nap" mode: put DSP to sleep once booted. ++ *! 01-Apr-2002 jeh Assume word addresses in PROC_GetTrace(). ++ *! 29-Nov-2001 jeh Don't call DEH function if hDehMgr == NULL. ++ *! 05-Nov-2001 kc: Updated PROC_RegisterNotify and PROC_GetState to support ++ *! DEH module. ++ *! 09-Oct-2001 jeh Fix number of bytes calculated in PROC_GetTrace(). ++ *! 11-Sep-2001 jeh Delete MSG manager in PROC_Monitor() to fix memory leak. ++ *! 29-Aug-2001 rr: DCD_AutoRegister and IOOnLoaded moved before COD_LoadBase ++ *! to facilitate the external loading. ++ *! 14-Aug-2001 ag DCD_AutoRegister() now called before IOOnLoaded() fxn. ++ *! 21-Jun-2001 rr: MSG_Create is done only the first time. ++ *! 02-May-2001 jeh Return failure in PROC_Load if IOOnLoaded function returns ++ *! error other than E_NOTIMPL. ++ *! 03-Apr-2001 sg: Changed DSP_DCD_ENOAUTOREGISTER to DSP_EDCDNOAUTOREGISTER. ++ *! 13-Feb-2001 kc: DSP/BIOS Bridge name updates. ++ *! 05-Jan-2001 rr: PROC_LOAD MSG_Create error is checked. ++ *! 15-Dec-2000 rr: IoOnLoaded is checked for WSX_STATUS. We fail to load ++ *! if DEV_Create2 fails; ie, no non-RMS targets can be ++ *! loaded. ++ *! 12-Dec-2000 rr: PROC_Start's DEV_Create2 is checked for WSX_STATUS. ++ *! 28-Nov-2000 jeh Added call to IO OnLoaded function to PROC_Load(). ++ *! 29-Nov-2000 rr: Incorporated code review changes. ++ *! 03-Nov-2000 rr: Auto_Register happens after PROC_Load. ++ *! 06-Oct-2000 rr: Updated to ver 0.9. PROC_Start calls DEV_Create2 and ++ *! WMD_BRD_STOP is always followed by DEV_Destroy2. ++ *! 05-Sep-2000 rr: PROC_GetTrace calculates the Trace symbol for 55 in a ++ *! different way. ++ *! 10-Aug-2000 rr: PROC_NotifyClients, PROC_GetProcessorHandle Added ++ *! 07-Aug-2000 rr: PROC_IDLE/SYNCINIT/UNKNOWN state removed. ++ *! WMD fxns are checked for WSX_STATUS. ++ *! PROC_Attach does not alter the state of the BRD. ++ *! PROC_Run removed. ++ *! 04-Aug-2000 rr: All the functions return DSP_EHANDLE if proc handle is ++ *! invalid ++ *! 27-Jul-2000 rr: PROC_GetTrace and PROC_Load implemented. Updated to ++ *! ver 0.8 API. ++ *! 06-Jul-2000 rr: Created. ++ */ ++ ++/* ------------------------------------ Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/sync.h> ++/* ----------------------------------- Mini Driver */ ++#include <dspbridge/wmd.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/cod.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/procpriv.h> ++#include <dspbridge/dmm.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/mgr.h> ++#include <dspbridge/node.h> ++#include <dspbridge/nldr.h> ++#include <dspbridge/rmm.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbdcd.h> ++#include <dspbridge/dbreg.h> ++#include <dspbridge/msg.h> ++#include <dspbridge/wmdioctl.h> ++#include <dspbridge/drv.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/proc.h> ++#include <dspbridge/pwr.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/resourcecleanup.h> ++#endif ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define PROC_SIGNATURE 0x434F5250 /* "PROC" (in reverse). */ ++#define MAXCMDLINELEN 255 ++#define PROC_ENVPROCID "PROC_ID=%d" ++#define MAXPROCIDLEN (8 + 5) ++#define PROC_DFLT_TIMEOUT 10000 /* Time out in milliseconds */ ++#define PWR_TIMEOUT 500 /* Sleep/wake timout in msec */ ++#define EXTEND "_EXT_END" /* Extmem end addr in DSP binary */ ++ ++extern char *iva_img; ++/* The PROC_OBJECT structure. */ ++struct PROC_OBJECT { ++ struct LST_ELEM link; /* Link to next PROC_OBJECT */ ++ u32 dwSignature; /* Used for object validation */ ++ struct DEV_OBJECT *hDevObject; /* Device this PROC represents */ ++ u32 hProcess; /* Process owning this Processor */ ++ struct MGR_OBJECT *hMgrObject; /* Manager Object Handle */ ++ u32 uAttachCount; /* Processor attach count */ ++ u32 uProcessor; /* Processor number */ ++ u32 uTimeout; /* Time out count */ ++ enum DSP_PROCSTATE sState; /* Processor state */ ++ u32 ulUnit; /* DDSP unit number */ ++ bool bIsAlreadyAttached; /* ++ * True if the Device below has ++ * GPP Client attached ++ */ ++ struct NTFY_OBJECT *hNtfy; /* Manages notifications */ ++ struct WMD_DEV_CONTEXT *hWmdContext; /* WMD Context Handle */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ char *g_pszLastCoff; ++} ; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask PROC_DebugMask = { NULL, NULL }; /* WCD MGR Mask */ ++#endif ++ ++static u32 cRefs; ++ ++struct SYNC_CSOBJECT *hProcLock; /* For critical sections */ ++ ++/* ----------------------------------- Function Prototypes */ ++static DSP_STATUS PROC_Monitor(struct PROC_OBJECT *hProcessor); ++static s32 GetEnvpCount(char **envp); ++static char **PrependEnvp(char **newEnvp, char **envp, s32 cEnvp, s32 cNewEnvp, ++ char *szVar); ++ ++ ++/* ++ * ======== PROC_Attach ======== ++ * Purpose: ++ * Prepare for communication with a particular DSP processor, and return ++ * a handle to the processor object. ++ */ ++DSP_STATUS ++PROC_Attach(u32 uProcessor, OPTIONAL CONST struct DSP_PROCESSORATTRIN *pAttrIn, ++ OUT DSP_HPROCESSOR *phProcessor) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEV_OBJECT *hDevObject; ++ struct PROC_OBJECT *pProcObject = NULL; ++ struct MGR_OBJECT *hMgrObject = NULL; ++ struct DRV_OBJECT *hDrvObject = NULL; ++ u32 devType; ++ ++#ifndef RES_CLEANUP_DISABLE ++ HANDLE hDRVObject; ++ u32 hProcess; ++ DSP_STATUS res_status = DSP_SOK; ++ struct PROCESS_CONTEXT *pPctxt = NULL; ++#endif ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phProcessor != NULL); ++ ++ GT_3trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Attach, args:\n\t" ++ "uProcessor: 0x%x\n\tpAttrIn: 0x%x\n\tphProcessor:" ++ "0x%x\n", uProcessor, pAttrIn, phProcessor); ++ /* Get the Driver and Manager Object Handles */ ++ status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(status)) { ++ status = CFG_GetObject((u32 *)&hMgrObject, REG_MGR_OBJECT); ++ if (DSP_FAILED(status)) { ++ /* don't propogate CFG errors from this PROC function */ ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: DSP_FAILED to get" ++ "the Manager Object.\n", status); ++ } ++ } else { ++ /* don't propogate CFG errors from this PROC function */ ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: failed to get the" ++ " DriverObject, 0x%x!\n", status); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get the Device Object */ ++ status = DRV_GetDevObject(uProcessor, hDrvObject, &hDevObject); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: failed to get" ++ " DevObject, 0x%x!\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetDevType(hDevObject, &devType); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: failed to get" ++ " DevType, 0x%x!\n", status); ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* If we made it this far, create the Proceesor object: */ ++ MEM_AllocObject(pProcObject, struct PROC_OBJECT, PROC_SIGNATURE); ++ /* Fill out the Processor Object: */ ++ if (pProcObject == NULL) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach:Out of memeory \n"); ++ status = DSP_EFAIL; ++ goto func_end; ++ } ++ pProcObject->hDevObject = hDevObject; ++ pProcObject->hMgrObject = hMgrObject; ++ pProcObject->uProcessor = devType; ++ /* Get Caller Process and store it */ ++ /* Return PID instead of process handle */ ++ pProcObject->hProcess = current->pid; ++ ++ if (pAttrIn) ++ pProcObject->uTimeout = pAttrIn->uTimeout; ++ else ++ pProcObject->uTimeout = PROC_DFLT_TIMEOUT; ++ ++ status = DEV_GetIntfFxns(hDevObject, &pProcObject->pIntfFxns); ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetWMDContext(hDevObject, ++ &pProcObject->hWmdContext); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach Could not" ++ " get the WMD Context.\n", status); ++ MEM_FreeObject(pProcObject); ++ } ++ } else { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach Could not get" ++ " the DEV_ Interface fxns.\n", status); ++ MEM_FreeObject(pProcObject); ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Create the Notification Object */ ++ /* This is created with no event mask, no notify mask ++ * and no valid handle to the notification. They all get ++ * filled up when PROC_RegisterNotify is called */ ++ status = NTFY_Create(&pProcObject->hNtfy); ++ if (DSP_SUCCEEDED(status)) { ++ /* Insert the Processor Object into the DEV List. ++ * Return handle to this Processor Object: ++ * Find out if the Device is already attached to a ++ * Processor. If so, return AlreadyAttached status */ ++ LST_InitElem(&pProcObject->link); ++ status = DEV_InsertProcObject(pProcObject->hDevObject, ++ (u32)pProcObject, ++ &pProcObject->bIsAlreadyAttached); ++ if (DSP_SUCCEEDED(status)) { ++ if (pProcObject->bIsAlreadyAttached) { ++ status = DSP_SALREADYATTACHED; ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Attach: Processor " ++ "Already Attached!\n"); ++ } ++ } else { ++ if (pProcObject->hNtfy) ++ NTFY_Delete(pProcObject->hNtfy); ++ ++ MEM_FreeObject(pProcObject); ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: failed to insert " ++ "Proc Object into DEV, 0x%x!\n", status); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ *phProcessor = (DSP_HPROCESSOR)pProcObject; ++ (void)PROC_NotifyClients(pProcObject, ++ DSP_PROCESSORATTACH); ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Attach: Processor " ++ "Attach Success!\n"); ++ } ++ } else { ++ /* Don't leak memory if DSP_FAILED */ ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Attach: Could not allocate " ++ "storage for notification \n"); ++ MEM_FreeObject(pProcObject); ++ } ++func_end: ++#ifndef RES_CLEANUP_DISABLE ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDRVObject, REG_DRV_OBJECT); ++ if (DSP_FAILED(res_status)) ++ goto func_cont; ++ ++ DRV_GetProcContext(hProcess, (struct DRV_OBJECT *)hDRVObject, ++ &pPctxt, NULL, 0); ++ if (pPctxt == NULL) { ++ DRV_InsertProcContext((struct DRV_OBJECT *)hDRVObject, &pPctxt); ++ if (pPctxt != NULL) { ++ DRV_ProcUpdatestate(pPctxt, PROC_RES_ALLOCATED); ++ DRV_ProcSetPID(pPctxt, hProcess); ++ } ++ } ++func_cont: ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDRVObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDRVObject, &pPctxt, ++ NULL, 0); ++ if (pPctxt != NULL) ++ pPctxt->hProcessor = (DSP_HPROCESSOR)*phProcessor; ++ ++ } ++#endif ++ DBC_Ensure((status == DSP_EFAIL && *phProcessor == NULL) || ++ (DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) || ++ (status == DSP_SALREADYATTACHED && ++ MEM_IsValidHandle(pProcObject, PROC_SIGNATURE))); ++ GT_2trace(PROC_DebugMask, GT_ENTER, "Exiting PROC_Attach, results:\n\t" ++ "status: 0x%x\n\thProcessor: 0x%x\n", status, *phProcessor); ++ ++ return status; ++} ++ ++static DSP_STATUS GetExecFile(struct CFG_DEVNODE *hDevNode, ++ struct DEV_OBJECT *hDevObject, ++ u32 size, char *execFile) ++{ ++ s32 devType; ++ s32 len; ++ ++ DEV_GetDevType(hDevObject, (u32 *) &devType); ++ if (devType == DSP_UNIT) { ++ return CFG_GetExecFile(hDevNode, size, execFile); ++ } else if (devType == IVA_UNIT) { ++ if (iva_img) { ++ len = strlen(iva_img); ++ strncpy(execFile, iva_img, len + 1); ++ return DSP_SOK; ++ } ++ } ++ return DSP_EFILE; ++} ++ ++/* ++ * ======== PROC_AutoStart ======== = ++ * Purpose: ++ * A Particular device gets loaded with the default image ++ * if the AutoStart flag is set. ++ * Parameters: ++ * hDevObject: Handle to the Device ++ * Returns: ++ * DSP_SOK: On Successful Loading ++ * DSP_EFAIL General Failure ++ * Requires: ++ * hDevObject != NULL ++ * Ensures: ++ */ ++DSP_STATUS PROC_AutoStart(struct CFG_DEVNODE *hDevNode, ++ struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ u32 dwAutoStart = 0; /* autostart flag */ ++ struct PROC_OBJECT *pProcObject; ++ struct PROC_OBJECT *hProcObject; ++ char szExecFile[MAXCMDLINELEN]; ++ char *argv[2]; ++ struct MGR_OBJECT *hMgrObject = NULL; ++ s32 devType; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hDevNode != NULL); ++ DBC_Require(hDevObject != NULL); ++ ++ GT_2trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_AutoStart, args:\n\t" ++ "hDevNode: 0x%x\thDevObject: 0x%x\n", hDevNode, hDevObject); ++ /* Create a Dummy PROC Object */ ++ if (DSP_FAILED(CFG_GetObject((u32 *)&hMgrObject, ++ REG_MGR_OBJECT))) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: DSP_FAILED to " ++ "Get MGR Object\n"); ++ goto func_end; ++ } ++ MEM_AllocObject(pProcObject, struct PROC_OBJECT, PROC_SIGNATURE); ++ if (pProcObject == NULL) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: DSP_FAILED " ++ "to Create a dummy Processor\n"); ++ goto func_end; ++ } ++ GT_0trace(PROC_DebugMask, GT_1CLASS, "NTFY Created \n"); ++ pProcObject->hDevObject = hDevObject; ++ pProcObject->hMgrObject = hMgrObject; ++ hProcObject = pProcObject; ++ if (DSP_SUCCEEDED(DEV_GetIntfFxns(hDevObject, ++ &pProcObject->pIntfFxns))) { ++ if (DSP_SUCCEEDED(DEV_GetWMDContext(hDevObject, ++ &pProcObject->hWmdContext))) { ++ status = DSP_SOK; ++ } else { ++ MEM_FreeObject(hProcObject); ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: Failed " ++ "to get WMD Context \n"); ++ } ++ } else { ++ MEM_FreeObject(hProcObject); ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: Failed to " ++ "get IntFxns \n"); ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Stop the Device, put it into standby mode */ ++ status = PROC_Stop(hProcObject); ++ if (DSP_FAILED(CFG_GetAutoStart(hDevNode, &dwAutoStart)) || ++ !dwAutoStart) { ++ status = DSP_EFAIL; ++ /* DSP_FAILED to Get s32 Fxn or Wmd Context */ ++ GT_0trace(PROC_DebugMask, GT_1CLASS, "PROC_AutoStart: " ++ "CFG_GetAutoStart DSP_FAILED \n"); ++ goto func_cont; ++ } ++ /* Get the default executable for this board... */ ++ DEV_GetDevType(hDevObject, (u32 *)&devType); ++ pProcObject->uProcessor = devType; ++ if (DSP_SUCCEEDED(GetExecFile(hDevNode, hDevObject, ++ sizeof(szExecFile), szExecFile))) { ++ argv[0] = szExecFile; ++ argv[1] = NULL; ++ /* ...and try to load it: */ ++ status = PROC_Load(hProcObject, 1, (CONST char **)argv, NULL); ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_Start(hProcObject); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_AutoStart: Processor started " ++ "running\n"); ++ } else { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: DSP_FAILED To " ++ "Start \n"); ++ } ++ } else { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_AutoStart: DSP_FAILED to Load\n"); ++ } ++ } else { ++ status = DSP_EFILE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, "PROC_AutoStart: " ++ "No Exec file found \n"); ++ } ++func_cont: ++ MEM_FreeObject(hProcObject); ++func_end: ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Exiting PROC_AutoStart, status:0x%x\n", status); ++ return status; ++} ++ ++/* ++ * ======== PROC_Ctrl ======== ++ * Purpose: ++ * Pass control information to the GPP device driver managing the ++ * DSP processor. ++ * ++ * This will be an OEM-only function, and not part of the DSP/BIOS Bridge ++ * application developer's API. ++ * Call the WMD_ICOTL Fxn with the Argument This is a Synchronous ++ * Operation. arg can be null. ++ */ ++DSP_STATUS PROC_Ctrl(DSP_HPROCESSOR hProcessor, u32 dwCmd, ++ IN struct DSP_CBDATA *arg) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = hProcessor; ++ u32 timeout = 0; ++ ++ DBC_Require(cRefs > 0); ++ GT_3trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_Ctrl, args:\n\thProcessor:" ++ " 0x%x\n\tdwCmd: 0x%x\n\targ: 0x%x\n", hProcessor, dwCmd, arg); ++ ++ if (MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ /* intercept PWR deep sleep command */ ++ if (dwCmd == WMDIOCTL_DEEPSLEEP) { ++ timeout = arg->cbData; ++ status = PWR_SleepDSP(PWR_DEEPSLEEP, timeout); ++ } ++ /* intercept PWR emergency sleep command */ ++ else if (dwCmd == WMDIOCTL_EMERGENCYSLEEP) { ++ timeout = arg->cbData; ++ status = PWR_SleepDSP(PWR_EMERGENCYDEEPSLEEP, timeout); ++ } else if (dwCmd == PWR_DEEPSLEEP) { ++ /* timeout = arg->cbData; */ ++ status = PWR_SleepDSP(PWR_DEEPSLEEP, timeout); ++ } ++ /* intercept PWR wake commands */ ++ else if (dwCmd == WMDIOCTL_WAKEUP) { ++ timeout = arg->cbData; ++ status = PWR_WakeDSP(timeout); ++ } else if (dwCmd == PWR_WAKEUP) { ++ /* timeout = arg->cbData; */ ++ status = PWR_WakeDSP(timeout); ++ } else ++ if (DSP_SUCCEEDED ++ ((*pProcObject->pIntfFxns->pfnDevCntrl) ++ (pProcObject->hWmdContext, dwCmd, arg))) { ++ status = DSP_SOK; ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Ctrl: Failed \n"); ++ } ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Ctrl: InValid Processor Handle \n"); ++ } ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Exiting PROC_Ctrl, 0x%x\n", ++ status); ++ return status; ++} ++ ++/* ++ * ======== PROC_Detach ======== ++ * Purpose: ++ * Destroys the Processor Object. Removes the notification from the Dev ++ * List. ++ */ ++DSP_STATUS PROC_Detach(DSP_HPROCESSOR hProcessor) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++#ifndef RES_CLEANUP_DISABLE ++ HANDLE hDRVObject; ++ u32 hProcess; ++ DSP_STATUS res_status = DSP_SOK; ++ struct PROCESS_CONTEXT *pPctxt = NULL; ++#endif ++ DBC_Require(cRefs > 0); ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Detach, args:\n\t" ++ "hProcessor: 0x%x\n", hProcessor); ++ ++ if (MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ /* Notify the Client */ ++ NTFY_Notify(pProcObject->hNtfy, DSP_PROCESSORDETACH); ++ /* Remove the notification memory */ ++ if (pProcObject->hNtfy) ++ NTFY_Delete(pProcObject->hNtfy); ++ ++ if (pProcObject->g_pszLastCoff) { ++ MEM_Free(pProcObject->g_pszLastCoff); ++ pProcObject->g_pszLastCoff = NULL; ++ } ++ ++#ifndef RES_CLEANUP_DISABLE ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDRVObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDRVObject, &pPctxt, ++ NULL, 0); ++ if (pPctxt != NULL) { ++ DRV_ProcFreeDMMRes(pPctxt); ++ pPctxt->hProcessor = NULL; ++ } ++ } ++#endif ++ ++ /* Remove the Proc from the DEV List */ ++ (void)DEV_RemoveProcObject(pProcObject->hDevObject, ++ (u32)pProcObject); ++ /* Free the Processor Object */ ++ MEM_FreeObject(pProcObject); ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Detach: InValid Processor Handle \n"); ++ } ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Exiting PROC_Detach, 0x%x\n", ++ status); ++ return status; ++} ++ ++/* ++ * ======== PROC_EnumNodes ======== ++ * Purpose: ++ * Enumerate and get configuration information about nodes allocated ++ * on a DSP processor. ++ */ ++DSP_STATUS PROC_EnumNodes(DSP_HPROCESSOR hProcessor, OUT DSP_HNODE *aNodeTab, ++ IN u32 uNodeTabSize, OUT u32 *puNumNodes, ++ OUT u32 *puAllocated) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct NODE_MGR *hNodeMgr = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(aNodeTab != NULL || uNodeTabSize == 0); ++ DBC_Require(puNumNodes != NULL); ++ DBC_Require(puAllocated != NULL); ++ ++ GT_5trace(PROC_DebugMask, GT_ENTER, "Entered PROC_EnumNodes, args:\n\t" ++ "hProcessor: 0x%x\n\taNodeTab: 0x%x\n\tuNodeTabSize: " ++ " 0x%x\n\t puNumNodes 0x%x\n\t puAllocated: 0x%x\n", ++ hProcessor, aNodeTab, uNodeTabSize, puNumNodes, ++ puAllocated); ++ if (MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ if (DSP_SUCCEEDED(DEV_GetNodeManager(pProcObject->hDevObject, ++ &hNodeMgr))) { ++ if (hNodeMgr) { ++ status = NODE_EnumNodes(hNodeMgr, aNodeTab, ++ uNodeTabSize, ++ puNumNodes, ++ puAllocated); ++ } ++ } ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, "PROC_EnumNodes: " ++ "InValid Processor Handle \n"); ++ } ++ GT_6trace(PROC_DebugMask, GT_ENTER, "Exit PROC_EnumNodes, args:\n\t" ++ "hProcessor: 0x%x\n\taNodeTab: 0x%x\n\tuNodeTabSize: " ++ " 0x%x\n\t puNumNodes 0x%x\n\t puAllocated: 0x%x\n\t " ++ "status: 0x%x \n", hProcessor, aNodeTab, uNodeTabSize, ++ puNumNodes, puAllocated, status); ++ ++ return status; ++} ++ ++/* ++ * ======== PROC_FlushMemory ======== ++ * Purpose: ++ * Flush cache ++ */ ++DSP_STATUS PROC_FlushMemory(DSP_HPROCESSOR hProcessor, void *pMpuAddr, ++ u32 ulSize, u32 ulFlags) ++{ ++ /* Keep STATUS here for future additions to this function */ ++ DSP_STATUS status = DSP_SOK; ++ enum DSP_FLUSHTYPE FlushMemType = PROC_WRITEBACK_INVALIDATE_MEM; ++ DBC_Require(cRefs > 0); ++ ++ GT_4trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_FlushMemory, args:\n\t" ++ "hProcessor: 0x%x pMpuAddr: 0x%x ulSize 0x%x, ulFlags 0x%x\n", ++ hProcessor, pMpuAddr, ulSize, ulFlags); ++ /* Critical section */ ++ (void)SYNC_EnterCS(hProcLock); ++ MEM_FlushCache(pMpuAddr, ulSize, FlushMemType); ++ (void)SYNC_LeaveCS(hProcLock); ++ ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Leaving PROC_FlushMemory [0x%x]", ++ status); ++ return status; ++} ++ ++ ++/* ++ * ======== PROC_InvalidateMemory ======== ++ * Purpose: ++ * Invalidates the memory specified ++ */ ++DSP_STATUS PROC_InvalidateMemory(DSP_HPROCESSOR hProcessor, void *pMpuAddr, ++ u32 ulSize) ++{ ++ /* Keep STATUS here for future additions to this function */ ++ DSP_STATUS status = DSP_SOK; ++ enum DSP_FLUSHTYPE FlushMemType = PROC_INVALIDATE_MEM; ++ DBC_Require(cRefs > 0); ++ GT_3trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_InvalidateMemory, args:\n\t" ++ "hProcessor: 0x%x pMpuAddr: 0x%x ulSize 0x%x\n", hProcessor, ++ pMpuAddr, ulSize); ++ (void)SYNC_EnterCS(hProcLock); ++ MEM_FlushCache(pMpuAddr, ulSize, FlushMemType); ++ (void)SYNC_LeaveCS(hProcLock); ++ ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Leaving PROC_InvalidateMemory [0x%x]", status); ++ return status; ++} ++ ++/* ++ * ======== PROC_GetResourceInfo ======== ++ * Purpose: ++ * Enumerate the resources currently available on a processor. ++ */ ++DSP_STATUS PROC_GetResourceInfo(DSP_HPROCESSOR hProcessor, u32 uResourceType, ++ OUT struct DSP_RESOURCEINFO *pResourceInfo, ++ u32 uResourceInfoSize) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct NODE_MGR *hNodeMgr = NULL; ++ struct NLDR_OBJECT *hNldr = NULL; ++ struct RMM_TargetObj *rmm = NULL; ++ struct IO_MGR *hIOMgr = NULL; /* IO manager handle */ ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pResourceInfo != NULL); ++ DBC_Require(uResourceInfoSize >= sizeof(struct DSP_RESOURCEINFO)); ++ ++ GT_4trace(PROC_DebugMask, GT_ENTER, "Entered PROC_GetResourceInfo,\n\t" ++ "hProcessor: 0x%x\n\tuResourceType: 0x%x\n\tpResourceInfo:" ++ " 0x%x\n\t uResourceInfoSize 0x%x\n", hProcessor, ++ uResourceType, pResourceInfo, uResourceInfoSize); ++ if (!MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_GetResourceInfo: InValid " ++ "Processor Handle \n"); ++ goto func_end; ++ } ++ switch (uResourceType) { ++ case DSP_RESOURCE_DYNDARAM: ++ case DSP_RESOURCE_DYNSARAM: ++ case DSP_RESOURCE_DYNEXTERNAL: ++ case DSP_RESOURCE_DYNSRAM: ++ if (DSP_FAILED(DEV_GetNodeManager(pProcObject->hDevObject, ++ &hNodeMgr))) ++ goto func_end; ++ ++ if (DSP_SUCCEEDED(NODE_GetNldrObj(hNodeMgr, &hNldr))) { ++ if (DSP_SUCCEEDED(NLDR_GetRmmManager(hNldr, &rmm))) { ++ DBC_Assert(rmm != NULL); ++ status = DSP_EVALUE; ++ if (RMM_stat(rmm, ++ (enum DSP_MEMTYPE)uResourceType, ++ (struct DSP_MEMSTAT *)&(pResourceInfo-> ++ result.memStat))) ++ status = DSP_SOK; ++ } ++ } ++ break; ++ case DSP_RESOURCE_PROCLOAD: ++ status = DEV_GetIOMgr(pProcObject->hDevObject, &hIOMgr); ++ status = pProcObject->pIntfFxns->pfnIOGetProcLoad(hIOMgr, ++ (struct DSP_PROCLOADSTAT *)&(pResourceInfo-> ++ result.procLoadStat)); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "Error in procLoadStat function 0x%x\n", status); ++ } ++ break; ++ default: ++ status = DSP_EFAIL; ++ break; ++ } ++func_end: ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Exiting PROC_GetResourceInfo, " ++ "status 0x%x\n", status); ++ return status; ++} ++ ++/* ++ * ======== PROC_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count is ++ * 0. ++ */ ++void PROC_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ if (hProcLock) ++ (void)SYNC_DeleteCS(hProcLock); ++ ++ cRefs--; ++ ++ GT_1trace(PROC_DebugMask, GT_5CLASS, ++ "Entered PROC_Exit, ref count:0x%x\n", cRefs); ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== PROC_GetDevObject ======== ++ * Purpose: ++ * Return the Dev Object handle for a given Processor. ++ * ++ */ ++DSP_STATUS PROC_GetDevObject(DSP_HPROCESSOR hProcessor, ++ struct DEV_OBJECT **phDevObject) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phDevObject != NULL); ++ ++ if (MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ *phDevObject = pProcObject->hDevObject; ++ status = DSP_SOK; ++ } else { ++ *phDevObject = NULL; ++ } ++ ++ DBC_Ensure((DSP_SUCCEEDED(status) && *phDevObject != NULL) || ++ (DSP_FAILED(status) && *phDevObject == NULL)); ++ ++ return status; ++} ++ ++/* ++ * ======== PROC_GetState ======== ++ * Purpose: ++ * Report the state of the specified DSP processor. ++ */ ++DSP_STATUS PROC_GetState(DSP_HPROCESSOR hProcessor, ++ OUT struct DSP_PROCESSORSTATE *pProcStatus, ++ u32 uStateInfoSize) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ BRD_STATUS brdStatus; ++ struct DEH_MGR *hDehMgr; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pProcStatus != NULL); ++ DBC_Require(uStateInfoSize >= sizeof(struct DSP_PROCESSORSTATE)); ++ ++ GT_3trace(PROC_DebugMask, GT_ENTER, "Entering PROC_GetState, args:\n\t" ++ "pProcStatus: 0x%x\n\thProcessor: 0x%x\n\t uStateInfoSize" ++ " 0x%x\n", pProcStatus, hProcessor, uStateInfoSize); ++ if (MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ /* First, retrieve BRD state information */ ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns->pfnBrdStatus) ++ (pProcObject->hWmdContext, &brdStatus))) { ++ switch (brdStatus) { ++ case BRD_STOPPED: ++ pProcStatus->iState = PROC_STOPPED; ++ break; ++ case BRD_DSP_HIBERNATION: ++ /* Fall through */ ++ case BRD_RUNNING: ++ pProcStatus->iState = PROC_RUNNING; ++ break; ++ case BRD_LOADED: ++ pProcStatus->iState = PROC_LOADED; ++ break; ++ case BRD_ERROR: ++ pProcStatus->iState = PROC_ERROR; ++ break; ++ default: ++ pProcStatus->iState = 0xFF; ++ status = DSP_EFAIL; ++ break; ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_GetState: General Failure" ++ " to read the PROC Status \n"); ++ } ++ /* Next, retrieve error information, if any */ ++ status = DEV_GetDehMgr(pProcObject->hDevObject, &hDehMgr); ++ if (DSP_SUCCEEDED(status) && hDehMgr) { ++ status = (*pProcObject->pIntfFxns->pfnDehGetInfo) ++ (hDehMgr, &(pProcStatus->errInfo)); ++ if (DSP_FAILED(status)) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_GetState: Failed " ++ "retrieve exception info.\n"); ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_GetState: Failed to " ++ "retrieve DEH handle.\n"); ++ } ++ } else { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_GetState:InValid Processor Handle \n"); ++ } ++ GT_2trace(PROC_DebugMask, GT_ENTER, ++ "Exiting PROC_GetState, results:\n\t" ++ "status: 0x%x\n\tpProcStatus: 0x%x\n", status, ++ pProcStatus->iState); ++ return status; ++} ++ ++/* ++ * ======== PROC_GetTrace ======== ++ * Purpose: ++ * Retrieve the current contents of the trace buffer, located on the ++ * Processor. Predefined symbols for the trace buffer must have been ++ * configured into the DSP executable. ++ * Details: ++ * We support using the symbols SYS_PUTCBEG and SYS_PUTCEND to define a ++ * trace buffer, only. Treat it as an undocumented feature. ++ * This call is destructive, meaning the processor is placed in the monitor ++ * state as a result of this function. ++ */ ++DSP_STATUS PROC_GetTrace(DSP_HPROCESSOR hProcessor, u8 *pBuf, u32 uMaxSize) ++{ ++ DSP_STATUS status; ++ status = DSP_ENOTIMPL; ++ return status; ++} ++ ++/* ++ * ======== PROC_Init ======== ++ * Purpose: ++ * Initialize PROC's private state, keeping a reference count on each call ++ */ ++bool PROC_Init(void) ++{ ++ bool fRetval = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ /* Set the Trace mask */ ++ DBC_Assert(!PROC_DebugMask.flags); ++ GT_create(&PROC_DebugMask, "PR"); /* "PR" for Processor */ ++ ++ (void)SYNC_InitializeCS(&hProcLock); ++ } ++ ++ if (fRetval) ++ cRefs++; ++ ++ GT_1trace(PROC_DebugMask, GT_5CLASS, ++ "Entered PROC_Init, ref count:0x%x\n", cRefs); ++ DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0))); ++ ++ return fRetval; ++} ++ ++/* ++ * ======== PROC_Load ======== ++ * Purpose: ++ * Reset a processor and load a new base program image. ++ * This will be an OEM-only function, and not part of the DSP/BIOS Bridge ++ * application developer's API. ++ */ ++DSP_STATUS PROC_Load(DSP_HPROCESSOR hProcessor, IN CONST s32 iArgc, ++ IN CONST char **aArgv, IN CONST char **aEnvp) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct IO_MGR *hIOMgr; /* IO manager handle */ ++ struct MSG_MGR *hMsgMgr; ++ struct COD_MANAGER *hCodMgr; /* Code manager handle */ ++ char *pargv0; /* temp argv[0] ptr */ ++ char **newEnvp; /* Updated envp[] array. */ ++ char szProcID[MAXPROCIDLEN]; /* Size of "PROC_ID=<n>" */ ++ s32 cEnvp; /* Num elements in envp[]. */ ++ s32 cNewEnvp; /* " " in newEnvp[] */ ++ s32 nProcID = 0; /* Anticipate MP version. */ ++ struct DCD_MANAGER *hDCDHandle; ++ struct DMM_OBJECT *hDmmMgr; ++ u32 dwExtEnd; ++ u32 uProcId; ++#ifdef DEBUG ++ BRD_STATUS uBrdState; ++#endif ++#ifdef OPT_LOAD_TIME_INSTRUMENTATION ++ struct timeval tv1; ++ struct timeval tv2; ++#endif ++ DBC_Require(cRefs > 0); ++ DBC_Require(iArgc > 0); ++ DBC_Require(aArgv != NULL); ++#ifdef OPT_LOAD_TIME_INSTRUMENTATION ++ do_gettimeofday(&tv1); ++#endif ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++#endif ++ GT_2trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Load, args:\n\t" ++ "hProcessor: 0x%x\taArgv: 0x%x\n", hProcessor, aArgv[0]); ++ /* Call the WMD_BRD_Load Fxn */ ++ if (!MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Load: Invalid Processor Handle..\n"); ++ goto func_end; ++ } ++ if (pProcObject->bIsAlreadyAttached) { ++ status = DSP_EATTACHED; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load Abort becuase a GPP " ++ "Client is already attached status 0x%x \n", status); ++ goto func_end; ++ } ++ if (DSP_FAILED(DEV_GetCodMgr(pProcObject->hDevObject, &hCodMgr))) { ++ status = DSP_EFAIL; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, "PROC_Load: DSP_FAILED in " ++ "DEV_GetCodMgr status 0x%x \n", status); ++ goto func_end; ++ } ++ status = PROC_Stop(hProcessor); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: DSP_FAILED to Place the" ++ " Processor in Stop Mode(PROC_STOP) status 0x%x \n", ++ status); ++ goto func_end; ++ } ++ /* Place the board in the monitor state. */ ++ status = PROC_Monitor(hProcessor); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: DSP_FAILED to Place the" ++ " Processor in Monitor Mode(PROC_IDLE) status 0x%x\n", ++ status); ++ goto func_end; ++ } ++ /* Save ptr to original argv[0]. */ ++ pargv0 = (char *)aArgv[0]; ++ /*Prepend "PROC_ID=<nProcID>"to envp array for target.*/ ++ cEnvp = GetEnvpCount((char **)aEnvp); ++ cNewEnvp = (cEnvp ? (cEnvp + 1) : (cEnvp + 2)); ++ newEnvp = MEM_Calloc(cNewEnvp * sizeof(char **), MEM_PAGED); ++ if (newEnvp) { ++ status = snprintf(szProcID, MAXPROCIDLEN, PROC_ENVPROCID, ++ nProcID); ++ if (status == -1) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, "PROC_Load: " ++ "Proc ID string overflow \n"); ++ status = DSP_EFAIL; ++ } else { ++ newEnvp = PrependEnvp(newEnvp, (char **)aEnvp, cEnvp, ++ cNewEnvp, szProcID); ++ /* Get the DCD Handle */ ++ status = MGR_GetDCDHandle(pProcObject->hMgrObject, ++ (u32 *)&hDCDHandle); ++ if (DSP_SUCCEEDED(status)) { ++ /* Before proceeding with new load, ++ * check if a previously registered COFF ++ * exists. ++ * If yes, unregister nodes in previously ++ * registered COFF. If any error occurred, ++ * set previously registered COFF to NULL. */ ++ if (pProcObject->g_pszLastCoff != NULL) { ++ status = DCD_AutoUnregister(hDCDHandle, ++ pProcObject->g_pszLastCoff); ++ /* Regardless of auto unregister status, ++ * free previously allocated ++ * memory. */ ++ MEM_Free(pProcObject->g_pszLastCoff); ++ pProcObject->g_pszLastCoff = NULL; ++ } ++ } ++ /* On success, do COD_OpenBase() */ ++ status = COD_OpenBase(hCodMgr, (char *)aArgv[0], ++ COD_SYMB); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: COD_OpenBase " ++ "failed (0x%x)\n", status); ++ } ++ } ++ } else { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ " PROC_Load:Out of Memory \n"); ++ status = DSP_EMEMORY; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Auto-register data base */ ++ /* Get the DCD Handle */ ++ status = MGR_GetDCDHandle(pProcObject->hMgrObject, ++ (u32 *)&hDCDHandle); ++ if (DSP_SUCCEEDED(status)) { ++ /* Auto register nodes in specified COFF ++ * file. If registration did not fail, ++ * (status = DSP_SOK or DSP_EDCDNOAUTOREGISTER) ++ * save the name of the COFF file for ++ * de-registration in the future. */ ++ status = DCD_AutoRegister(hDCDHandle, (char *)aArgv[0]); ++ if (status == DSP_EDCDNOAUTOREGISTER) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: No Auto " ++ "Register section. Proceeding..\n"); ++ status = DSP_SOK; ++ } ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: Failed to " ++ "Auto Register..\n"); ++ } else { ++ DBC_Assert(pProcObject->g_pszLastCoff == NULL); ++ /* Allocate memory for pszLastCoff */ ++ pProcObject->g_pszLastCoff = MEM_Calloc( ++ (strlen((char *)aArgv[0]) + 1), ++ MEM_PAGED); ++ /* If memory allocated, save COFF file name*/ ++ if (pProcObject->g_pszLastCoff) { ++ strncpy(pProcObject->g_pszLastCoff, ++ (char *)aArgv[0], ++ (strlen((char *)aArgv[0]) + 1)); ++ } ++ } ++ } ++ } ++ /* Update shared memory address and size */ ++ if (DSP_SUCCEEDED(status)) { ++ /* Create the message manager. This must be done ++ * before calling the IOOnLoaded function. */ ++ DEV_GetMsgMgr(pProcObject->hDevObject, &hMsgMgr); ++ if (!hMsgMgr) { ++ status = MSG_Create(&hMsgMgr, pProcObject->hDevObject, ++ (MSG_ONEXIT)NODE_OnExit); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ DEV_SetMsgMgr(pProcObject->hDevObject, hMsgMgr); ++ } ++ if (status == DSP_ENOTIMPL) { ++ /* It's OK not to have a message manager */ ++ status = DSP_SOK; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Set the Device object's message manager */ ++ status = DEV_GetIOMgr(pProcObject->hDevObject, &hIOMgr); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ status = (*pProcObject->pIntfFxns->pfnIOOnLoaded)(hIOMgr); ++ if (status == DSP_ENOTIMPL) { ++ /* Ok not to implement this function */ ++ status = DSP_SOK; ++ } else { ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: Failed to get shared " ++ "memory or message buffer address " ++ "from COFF status 0x%x\n", status); ++ status = DSP_EFAIL; ++ } ++ } ++ } else { ++ status = DSP_EFAIL; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: DSP_FAILED in " ++ "MSG_Create status 0x%x\n", status); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Now, attempt to load an exec: */ ++ ++ /* Boost the OPP level to Maximum level supported by baseport*/ ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ if (pdata->cpu_set_freq) ++ (*pdata->cpu_set_freq)(pdata->mpu_speed[VDD1_OPP5]); ++#endif ++ status = COD_LoadBase(hCodMgr, iArgc, (char **)aArgv, ++ DEV_BrdWriteFxn, ++ pProcObject->hDevObject, NULL); ++ if (DSP_FAILED(status)) { ++ if (status == COD_E_OPENFAILED) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load:Failure to Load the EXE\n"); ++ } ++ if (status == COD_E_SYMBOLNOTFOUND) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load:Could not parse the file\n"); ++ } else { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: DSP_FAILED in " ++ "COD_Load status 0x%x \n", status); ++ } ++ } ++ /* Requesting the lowest opp supported*/ ++#if defined(CONFIG_BRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ) ++ if (pdata->cpu_set_freq) ++ (*pdata->cpu_set_freq)(pdata->mpu_speed[VDD1_OPP1]); ++#endif ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Update the Processor status to loaded */ ++ status = (*pProcObject->pIntfFxns->pfnBrdSetState) ++ (pProcObject->hWmdContext, BRD_LOADED); ++ if (DSP_SUCCEEDED(status)) { ++ pProcObject->sState = PROC_LOADED; ++ if (pProcObject->hNtfy) { ++ PROC_NotifyClients(pProcObject, ++ DSP_PROCESSORSTATECHANGE); ++ } ++ } else { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load, pfnBrdSetState " ++ "failed: 0x%x\n", status); ++ status = DSP_EFAIL; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = PROC_GetProcessorId(hProcessor, &uProcId); ++ if (uProcId == DSP_UNIT) { ++ /* Use all available DSP address space after EXTMEM ++ * for DMM */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMgr, EXTEND, ++ &dwExtEnd); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Load: Failed on " ++ "COD_GetSymValue %s.\n", ++ EXTEND); ++ } ++ } ++ /* Reset DMM structs and add an initial free chunk*/ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetDmmMgr(pProcObject->hDevObject, ++ &hDmmMgr); ++ if (DSP_SUCCEEDED(status)) { ++ /* Set dwExtEnd to DMM START u8 ++ * address */ ++ dwExtEnd = (dwExtEnd + 1) * DSPWORDSIZE; ++ /* DMM memory is from EXT_END */ ++ status = DMM_CreateTables(hDmmMgr, ++ dwExtEnd, DMMPOOLSIZE); ++ } ++ } ++ } ++ } ++ /* Restore the original argv[0] */ ++ MEM_Free(newEnvp); ++ aArgv[0] = pargv0; ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns->pfnBrdStatus) ++ (pProcObject->hWmdContext, &uBrdState))) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Load: Processor Loaded\n"); ++ DBC_Assert(uBrdState == BRD_LOADED); ++ } ++ } ++#endif ++func_end: ++#ifdef DEBUG ++ if (DSP_FAILED(status)) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, "PROC_Load: " ++ "Processor Load Failed.\n"); ++ ++ } ++#endif ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Exiting PROC_Load, status: 0x%x\n", status); ++ DBC_Ensure((DSP_SUCCEEDED(status) && pProcObject->sState == PROC_LOADED) ++ || DSP_FAILED(status)); ++#ifdef OPT_LOAD_TIME_INSTRUMENTATION ++ do_gettimeofday(&tv2); ++ if (tv2.tv_usec < tv1.tv_usec) { ++ tv2.tv_usec += 1000000; ++ tv2.tv_sec--; ++ } ++ GT_2trace(PROC_DebugMask, GT_1CLASS, ++ "Proc_Load: time to load %d sec and %d usec \n", ++ tv2.tv_sec - tv1.tv_sec, tv2.tv_usec - tv1.tv_usec); ++#endif ++ return status; ++} ++ ++/* ++ * ======== PROC_Map ======== ++ * Purpose: ++ * Maps a MPU buffer to DSP address space. ++ */ ++DSP_STATUS PROC_Map(DSP_HPROCESSOR hProcessor, void *pMpuAddr, u32 ulSize, ++ void *pReqAddr, void **ppMapAddr, u32 ulMapAttr) ++{ ++ u32 vaAlign; ++ u32 paAlign; ++ struct DMM_OBJECT *hDmmMgr; ++ u32 sizeAlign; ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ ++#ifndef RES_CLEANUP_DISABLE ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE dmmRes; ++ DSP_STATUS res_status = DSP_SOK; ++#endif ++ ++ GT_6trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Map, args:\n\t" ++ "hProcessor %x, pMpuAddr %x, ulSize %x, pReqAddr %x, " ++ "ulMapAttr %x, ppMapAddr %x\n", hProcessor, pMpuAddr, ulSize, ++ pReqAddr, ulMapAttr, ppMapAddr); ++ /* Calculate the page-aligned PA, VA and size */ ++ vaAlign = PG_ALIGN_LOW((u32) pReqAddr, PG_SIZE_4K); ++ paAlign = PG_ALIGN_LOW((u32) pMpuAddr, PG_SIZE_4K); ++ sizeAlign = PG_ALIGN_HIGH(ulSize + (u32)pMpuAddr - paAlign, ++ PG_SIZE_4K); ++ ++ GT_3trace(PROC_DebugMask, GT_ENTER, "PROC_Map: vaAlign %x, paAlign %x, " ++ "sizeAlign %x\n", vaAlign, paAlign, sizeAlign); ++ ++ /* Critical section */ ++ (void)SYNC_EnterCS(hProcLock); ++ status = DMM_GetHandle(pProcObject, &hDmmMgr); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Map: Failed to get DMM Mgr " ++ "handle: 0x%x\n", status); ++ } else { ++ status = DMM_MapMemory(hDmmMgr, vaAlign, sizeAlign); ++ } ++ /* Add mapping to the page tables. */ ++ if (DSP_SUCCEEDED(status)) { ++ ++ status = (*pProcObject->pIntfFxns->pfnBrdMemMap) ++ (pProcObject->hWmdContext, paAlign, vaAlign, sizeAlign, ++ ulMapAttr); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Mapped address = MSB of VA | LSB of PA */ ++ *ppMapAddr = (void *) (vaAlign | ((u32) pMpuAddr & ++ (PG_SIZE_4K - 1))); ++ } else { ++ DMM_UnMapMemory(hDmmMgr, vaAlign, &sizeAlign); ++ } ++ (void)SYNC_LeaveCS(hProcLock); ++ ++#ifndef RES_CLEANUP_DISABLE ++ if (DSP_SUCCEEDED(status)) { ++ /* Update the node and stream resource status */ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, ++ REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ if (DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDrvObject, &pCtxt, NULL, ++ (u32)pMpuAddr) != DSP_ENOTFOUND) { ++ DRV_InsertDMMResElement(&dmmRes, pCtxt); ++ DRV_UpdateDMMResElement(dmmRes, (u32)pMpuAddr, ++ ulSize, (u32)pReqAddr, ++ (u32)*ppMapAddr, hProcessor); ++ } ++ } ++ } ++#endif ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Leaving PROC_Map [0x%x]", status); ++ return status; ++} ++ ++/* ++ * ======== PROC_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified of specific processor events. ++ */ ++DSP_STATUS PROC_RegisterNotify(DSP_HPROCESSOR hProcessor, u32 uEventMask, ++ u32 uNotifyType, struct DSP_NOTIFICATION ++ *hNotification) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct DEH_MGR *hDehMgr; ++ ++ DBC_Require(hNotification != NULL); ++ DBC_Require(cRefs > 0); ++ ++ GT_4trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_RegisterNotify, args:\n\t" ++ "hProcessor: 0x%x\n\tuEventMask: 0x%x\n\tuNotifyMask:" ++ " 0x%x\n\t hNotification 0x%x\n", hProcessor, uEventMask, ++ uNotifyType, hNotification); ++ ++ /* Check processor handle */ ++ if (!MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_RegsiterNotify Invalid " ++ "ProcessorHandle 0x%x\n", hProcessor); ++ goto func_end; ++ } ++ /* Check if event mask is a valid processor related event */ ++ if (uEventMask & ~(DSP_PROCESSORSTATECHANGE | DSP_PROCESSORATTACH | ++ DSP_PROCESSORDETACH | DSP_PROCESSORRESTART | DSP_MMUFAULT | ++ DSP_SYSERROR)) ++ status = DSP_EVALUE; ++ ++ /* Check if notify type is valid */ ++ if (uNotifyType != DSP_SIGNALEVENT) ++ status = DSP_EVALUE; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* * If event mask is not DSP_SYSERROR or DSP_MMUFAULT, ++ * then register event immediately. */ ++ if (uEventMask & ~(DSP_SYSERROR | DSP_MMUFAULT)) { ++ status = NTFY_Register(pProcObject->hNtfy, ++ hNotification, uEventMask, uNotifyType); ++ /* * Special case alert, special case alert! ++ * If we're trying to *deregister* (i.e. uEventMask ++ * is 0), a DSP_SYSERROR or DSP_MMUFAULT notification, ++ * we have to deregister with the DEH manager. ++ * There's no way to know, based on uEventMask which ++ * manager the notification event was registered with, ++ * so if we're trying to deregister and NTFY_Register ++ * failed, we'll give the deh manager a shot. ++ */ ++ if ((uEventMask == 0) && DSP_FAILED(status)) { ++ status = DEV_GetDehMgr(pProcObject->hDevObject, ++ &hDehMgr); ++ DBC_Assert(pProcObject->pIntfFxns-> ++ pfnDehRegisterNotify); ++ status = (*pProcObject->pIntfFxns-> ++ pfnDehRegisterNotify) ++ (hDehMgr, uEventMask, uNotifyType, ++ hNotification); ++ } ++ } else { ++ status = DEV_GetDehMgr(pProcObject->hDevObject, ++ &hDehMgr); ++ DBC_Assert(pProcObject->pIntfFxns-> ++ pfnDehRegisterNotify); ++ status = (*pProcObject->pIntfFxns->pfnDehRegisterNotify) ++ (hDehMgr, uEventMask, uNotifyType, ++ hNotification); ++ if (DSP_FAILED(status)) ++ status = DSP_EFAIL; ++ ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== PROC_ReserveMemory ======== ++ * Purpose: ++ * Reserve a virtually contiguous region of DSP address space. ++ */ ++DSP_STATUS PROC_ReserveMemory(DSP_HPROCESSOR hProcessor, u32 ulSize, ++ void **ppRsvAddr) ++{ ++ struct DMM_OBJECT *hDmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ ++ GT_3trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_ReserveMemory, args:\n\t" ++ "hProcessor: 0x%x ulSize: 0x%x ppRsvAddr: 0x%x\n", hProcessor, ++ ulSize, ppRsvAddr); ++ status = DMM_GetHandle(pProcObject, &hDmmMgr); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, "PROC_ReserveMemory: " ++ "Failed to get DMM Mgr handle: 0x%x\n", status); ++ } else ++ status = DMM_ReserveMemory(hDmmMgr, ulSize, (u32 *)ppRsvAddr); ++ ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Leaving PROC_ReserveMemory [0x%x]", ++ status); ++ return status; ++} ++ ++/* ++ * ======== PROC_Start ======== ++ * Purpose: ++ * Start a processor running. ++ */ ++DSP_STATUS PROC_Start(DSP_HPROCESSOR hProcessor) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct COD_MANAGER *hCodMgr; /* Code manager handle */ ++ u32 dwDspAddr; /* Loaded code's entry point. */ ++#ifdef DEBUG ++ BRD_STATUS uBrdState; ++#endif ++ DBC_Require(cRefs > 0); ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Start, args:\n\t" ++ "hProcessor: 0x%x\n", hProcessor); ++ if (!MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Start :InValid Handle \n"); ++ goto func_end; ++ } ++ /* Call the WMD_BRD_Start */ ++ if (pProcObject->sState != PROC_LOADED) { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Start :Wrong state \n"); ++ status = DSP_EWRONGSTATE; ++ goto func_end; ++ } ++ status = DEV_GetCodMgr(pProcObject->hDevObject, &hCodMgr); ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "Processor Start DSP_FAILED " ++ "in Getting DEV_GetCodMgr status 0x%x\n", status); ++ goto func_cont; ++ } ++ status = COD_GetEntry(hCodMgr, &dwDspAddr); ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "Processor Start DSP_FAILED in " ++ "Getting COD_GetEntry status 0x%x\n", status); ++ goto func_cont; ++ } ++ status = (*pProcObject->pIntfFxns->pfnBrdStart) ++ (pProcObject->hWmdContext, dwDspAddr); ++ if (DSP_FAILED(status)) { ++ status = DSP_EFAIL; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Start Failed to Start the board\n"); ++ goto func_cont; ++ } ++ /* Call DEV_Create2 */ ++ status = DEV_Create2(pProcObject->hDevObject); ++ if (DSP_SUCCEEDED(status)) { ++ pProcObject->sState = PROC_RUNNING; ++ /* Deep sleep switces off the peripheral clocks. ++ * we just put the DSP CPU in idle in the idle loop. ++ * so there is no need to send a command to DSP */ ++ ++ if (pProcObject->hNtfy) { ++ PROC_NotifyClients(pProcObject, ++ DSP_PROCESSORSTATECHANGE); ++ } ++ GT_0trace(PROC_DebugMask, GT_1CLASS, "PROC_Start: Processor " ++ "Started and running \n"); ++ } else { ++ /* Failed to Create Node Manager and DISP Object ++ * Stop the Processor from running. Put it in STOPPED State */ ++ (void)(*pProcObject->pIntfFxns->pfnBrdStop)(pProcObject-> ++ hWmdContext); ++ status = DSP_EFAIL; ++ pProcObject->sState = PROC_STOPPED; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, "PROC_Start " ++ "Failed to Create the Node Manager\n"); ++ } ++func_cont: ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns->pfnBrdStatus) ++ (pProcObject->hWmdContext, &uBrdState))) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Start: Processor State is RUNNING \n"); ++ DBC_Assert(uBrdState != BRD_HIBERNATION); ++ } ++ } ++#endif ++func_end: ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Exiting PROC_Start, status 0x%x\n", status); ++ DBC_Ensure((DSP_SUCCEEDED(status) && pProcObject->sState == ++ PROC_RUNNING) || DSP_FAILED(status)); ++ return status; ++} ++ ++/* ++ * ======== PROC_Stop ======== ++ * Purpose: ++ * Stop a processor running. ++ */ ++DSP_STATUS PROC_Stop(DSP_HPROCESSOR hProcessor) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct MSG_MGR *hMsgMgr; ++ struct NODE_MGR *hNodeMgr; ++ DSP_HNODE hNode; ++ u32 uNodeTabSize = 1; ++ u32 uNumNodes = 0; ++ u32 uNodesAllocated = 0; ++#ifdef DEBUG ++ BRD_STATUS uBrdState; ++#endif ++ DBC_Require(cRefs > 0); ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Stop, args:\n\t" ++ "hProcessor: 0x%x\n", hProcessor); ++ if (!MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Stop :InValid Handle \n"); ++ goto func_end; ++ } ++ /* check if there are any running nodes */ ++ status = DEV_GetNodeManager(pProcObject->hDevObject, &hNodeMgr); ++ if (DSP_SUCCEEDED(status) && hNodeMgr) { ++ status = NODE_EnumNodes(hNodeMgr, &hNode, uNodeTabSize, ++ &uNumNodes, &uNodesAllocated); ++ if ((status == DSP_ESIZE) || (uNodesAllocated > 0)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "Can't stop device, Active " ++ "nodes = 0x%x \n", uNodesAllocated); ++ return DSP_EWRONGSTATE; ++ } ++ } ++ /* Call the WMD_BRD_Stop */ ++ /* It is OK to stop a device that does n't have nodes OR not started */ ++ status = (*pProcObject->pIntfFxns->pfnBrdStop)(pProcObject-> ++ hWmdContext); ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Stop: Processor Stopped, " ++ "i.e in standby mode \n"); ++ pProcObject->sState = PROC_STOPPED; ++ /* Destory the Node Manager, MSG Manager */ ++ if (DSP_SUCCEEDED(DEV_Destroy2(pProcObject->hDevObject))) { ++ /* Destroy the MSG by calling MSG_Delete */ ++ DEV_GetMsgMgr(pProcObject->hDevObject, &hMsgMgr); ++ if (hMsgMgr) { ++ MSG_Delete(hMsgMgr); ++ DEV_SetMsgMgr(pProcObject->hDevObject, NULL); ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns-> ++ pfnBrdStatus)(pProcObject->hWmdContext, ++ &uBrdState))) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Monitor:Processor Stopped \n"); ++ DBC_Assert(uBrdState == BRD_STOPPED); ++ } ++#endif ++ } else { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Stop Couldn't delete node manager \n"); ++ } ++ } else { ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Stop Failed to Stop the processor/device \n"); ++ } ++func_end: ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Exiting PROC_Stop, status 0x%x\n", ++ status); ++ ++ return status; ++} ++ ++/* ++ * ======== PROC_UnMap ======== ++ * Purpose: ++ * Removes a MPU buffer mapping from the DSP address space. ++ */ ++DSP_STATUS PROC_UnMap(DSP_HPROCESSOR hProcessor, void *pMapAddr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ struct DMM_OBJECT *hDmmMgr; ++ u32 vaAlign; ++ u32 sizeAlign; ++#ifndef RES_CLEANUP_DISABLE ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE dmmRes; ++ DSP_STATUS res_status = DSP_SOK; ++#endif ++ GT_2trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_UnMap, args:\n\thProcessor:" ++ "0x%x pMapAddr: 0x%x\n", hProcessor, pMapAddr); ++ ++ vaAlign = PG_ALIGN_LOW((u32) pMapAddr, PG_SIZE_4K); ++ ++ status = DMM_GetHandle(hProcessor, &hDmmMgr); ++ /* Critical section */ ++ (void)SYNC_EnterCS(hProcLock); ++ if (DSP_FAILED(status)) { ++ GT_1trace(PROC_DebugMask, GT_7CLASS, "PROC_UnMap: " ++ "Failed to get DMM Mgr handle: 0x%x\n", status); ++ } else { ++ /* Update DMM structures. Get the size to unmap. ++ This function returns error if the VA is not mapped */ ++ status = DMM_UnMapMemory(hDmmMgr, (u32) vaAlign, &sizeAlign); ++ } ++ /* Remove mapping from the page tables. */ ++ if (DSP_SUCCEEDED(status)) { ++ status = (*pProcObject->pIntfFxns->pfnBrdMemUnMap) ++ (pProcObject->hWmdContext, vaAlign, sizeAlign); ++ } ++ (void)SYNC_LeaveCS(hProcLock); ++#ifndef RES_CLEANUP_DISABLE ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "PROC_UnMap DRV_GetDMMResElement " ++ "pMapAddr:[0x%x]", pMapAddr); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Update the node and stream resource status */ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_FAILED(res_status)) ++ goto func_end; ++ ++ DRV_GetProcContext(hProcess, (struct DRV_OBJECT *)hDrvObject, ++ &pCtxt, NULL, (u32)pMapAddr); ++ if (pCtxt != NULL) { ++ if (DRV_GetDMMResElement((u32)pMapAddr, &dmmRes, pCtxt) != ++ DSP_ENOTFOUND) ++ DRV_RemoveDMMResElement(dmmRes, pCtxt); ++ } ++func_end: ++#endif ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Leaving PROC_UnMap [0x%x]", status); ++ return status; ++} ++ ++/* ++ * ======== PROC_UnReserveMemory ======== ++ * Purpose: ++ * Frees a previously reserved region of DSP address space. ++ */ ++DSP_STATUS PROC_UnReserveMemory(DSP_HPROCESSOR hProcessor, void *pRsvAddr) ++{ ++ struct DMM_OBJECT *hDmmMgr; ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcessor; ++ ++ GT_2trace(PROC_DebugMask, GT_ENTER, ++ "Entered PROC_UnReserveMemory, args:\n\t" ++ "hProcessor: 0x%x pRsvAddr: 0x%x\n", hProcessor, pRsvAddr); ++ ++ status = DMM_GetHandle(pProcObject, &hDmmMgr); ++ if (DSP_FAILED(status)) ++ GT_1trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_UnReserveMemory: Failed to get DMM Mgr " ++ "handle: 0x%x\n", status); ++ else ++ status = DMM_UnReserveMemory(hDmmMgr, (u32) pRsvAddr); ++ ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Leaving PROC_UnReserveMemory [0x%x]", ++ status); ++ ++ return status; ++} ++ ++/* ++ * ======== = PROC_Monitor ======== == ++ * Purpose: ++ * Place the Processor in Monitor State. This is an internal ++ * function and a requirement before Processor is loaded. ++ * This does a WMD_BRD_Stop, DEV_Destroy2 and WMD_BRD_Monitor. ++ * In DEV_Destroy2 we delete the node manager. ++ * Parameters: ++ * hProcObject: Handle to Processor Object ++ * Returns: ++ * DSP_SOK: Processor placed in monitor mode. ++ * !DSP_SOK: Failed to place processor in monitor mode. ++ * Requires: ++ * Valid Processor Handle ++ * Ensures: ++ * Success: ProcObject state is PROC_IDLE ++ */ ++static DSP_STATUS PROC_Monitor(struct PROC_OBJECT *hProcObject) ++{ ++ DSP_STATUS status = DSP_EFAIL; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProcObject; ++ struct MSG_MGR *hMsgMgr; ++#ifdef DEBUG ++ BRD_STATUS uBrdState; ++#endif ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)); ++ ++ GT_1trace(PROC_DebugMask, GT_ENTER, "Entered PROC_Monitor, args:\n\t" ++ "hProcessor: 0x%x\n", hProcObject); ++ /* This is needed only when Device is loaded when it is ++ * already 'ACTIVE' */ ++ /* Destory the Node Manager, MSG Manager */ ++ if (DSP_SUCCEEDED(DEV_Destroy2(pProcObject->hDevObject))) { ++ /* Destroy the MSG by calling MSG_Delete */ ++ DEV_GetMsgMgr(pProcObject->hDevObject, &hMsgMgr); ++ if (hMsgMgr) { ++ MSG_Delete(hMsgMgr); ++ DEV_SetMsgMgr(pProcObject->hDevObject, NULL); ++ } ++ } ++ /* Place the Board in the Monitor State */ ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns->pfnBrdMonitor) ++ (pProcObject->hWmdContext))) { ++ status = DSP_SOK; ++#ifdef DEBUG ++ if (DSP_SUCCEEDED((*pProcObject->pIntfFxns->pfnBrdStatus) ++ (pProcObject->hWmdContext, &uBrdState))) { ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_Monitor:Processor in " ++ "Monitor State\n"); ++ DBC_Assert(uBrdState == BRD_IDLE); ++ } ++#endif ++ } else { ++ /* Monitor Failure */ ++ GT_0trace(PROC_DebugMask, GT_7CLASS, ++ "PROC_Monitor: Processor Could not" ++ "be put in Monitor mode \n"); ++ } ++ GT_1trace(PROC_DebugMask, GT_ENTER, ++ "Exiting PROC_Monitor, status 0x%x\n", ++ status); ++#ifdef DEBUG ++ DBC_Ensure((DSP_SUCCEEDED(status) && uBrdState == BRD_IDLE) || ++ DSP_FAILED(status)); ++#endif ++ return status; ++} ++ ++/* ++ * ======== GetEnvpCount ======== ++ * Purpose: ++ * Return the number of elements in the envp array, including the ++ * terminating NULL element. ++ */ ++static s32 GetEnvpCount(char **envp) ++{ ++ s32 cRetval = 0; ++ if (envp) { ++ while (*envp++) ++ cRetval++; ++ ++ cRetval += 1; /* Include the terminating NULL in the count. */ ++ } ++ ++ return cRetval; ++} ++ ++/* ++ * ======== PrependEnvp ======== ++ * Purpose: ++ * Prepend an environment variable=value pair to the new envp array, and ++ * copy in the existing var=value pairs in the old envp array. ++ */ ++static char **PrependEnvp(char **newEnvp, char **envp, s32 cEnvp, s32 cNewEnvp, ++ char *szVar) ++{ ++ char **ppEnvp = newEnvp; ++ ++ DBC_Require(newEnvp); ++ ++ /* Prepend new environ var=value string */ ++ *newEnvp++ = szVar; ++ ++ /* Copy user's environment into our own. */ ++ while (cEnvp--) ++ *newEnvp++ = *envp++; ++ ++ /* Ensure NULL terminates the new environment strings array. */ ++ if (cEnvp == 0) ++ *newEnvp = NULL; ++ ++ return ppEnvp; ++} ++ ++/* ++ * ======== PROC_NotifyClients ======== ++ * Purpose: ++ * Notify the processor the events. ++ */ ++DSP_STATUS PROC_NotifyClients(DSP_HPROCESSOR hProc, u32 uEvents) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProc; ++ ++ DBC_Require(MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)); ++ DBC_Require(IsValidProcEvent(uEvents)); ++ DBC_Require(cRefs > 0); ++ ++ NTFY_Notify(pProcObject->hNtfy, uEvents); ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_NotifyClients :Signaled. \n"); ++ ++ return status; ++} ++ ++/* ++ * ======== PROC_NotifyAllClients ======== ++ * Purpose: ++ * Notify the processor the events. This includes notifying all clients ++ * attached to a particulat DSP. ++ */ ++DSP_STATUS PROC_NotifyAllClients(DSP_HPROCESSOR hProc, u32 uEvents) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProc; ++ ++ DBC_Require(MEM_IsValidHandle(pProcObject, PROC_SIGNATURE)); ++ DBC_Require(IsValidProcEvent(uEvents)); ++ DBC_Require(cRefs > 0); ++ ++ DEV_NotifyClients(pProcObject->hDevObject, uEvents); ++ ++ GT_0trace(PROC_DebugMask, GT_1CLASS, ++ "PROC_NotifyAllClients :Signaled. \n"); ++ ++ return status; ++} ++ ++/* ++ * ======== PROC_GetProcessorId ======== ++ * Purpose: ++ * Retrieves the processor ID. ++ */ ++DSP_STATUS PROC_GetProcessorId(DSP_HPROCESSOR hProc, u32 *procID) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct PROC_OBJECT *pProcObject = (struct PROC_OBJECT *)hProc; ++ ++ *procID = pProcObject->uProcessor; ++ ++ return status; ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/pwr.c b/drivers/dsp/bridge/rmgr/pwr.c +new file mode 100644 +index 0000000..50a3f79 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/pwr.c +@@ -0,0 +1,184 @@ ++/* ++ * pwr.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== PWR.c ======== ++ * PWR API for controlling DSP power states. ++ * ++ * Public Functions: ++ * PWR_SleepDSP ++ * PWR_WakeDSP ++ * ++ *! Revision History ++ *! ================ ++ *! 18-Feb-2003 vp Code review updates. ++ *! 18-Oct-2002 vp Ported to Linux platform. ++ *! 22-May-2002 sg Do PWR-to-IOCTL code mapping in PWR_SleepDSP. ++ *! 29-Apr-2002 sg Initial. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/pwr.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/devdefs.h> ++#include <dspbridge/drv.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmdioctl.h> ++ ++/* ++ * ======== PWR_SleepDSP ======== ++ * Send command to DSP to enter sleep state. ++ */ ++DSP_STATUS PWR_SleepDSP(IN CONST u32 sleepCode, IN CONST u32 timeout) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct WMD_DEV_CONTEXT *dwContext; ++ DSP_STATUS status = DSP_EFAIL; ++ struct DEV_OBJECT *hDevObject = NULL; ++ u32 ioctlcode = 0; ++ u32 arg = timeout; ++ ++ for (hDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ hDevObject != NULL; ++ hDevObject = ++ (struct DEV_OBJECT *)DRV_GetNextDevObject ++ ((u32)hDevObject)) { ++ if (DSP_FAILED(DEV_GetWMDContext(hDevObject, ++ (struct WMD_DEV_CONTEXT **)&dwContext))) { ++ continue; ++ } ++ if (DSP_FAILED(DEV_GetIntfFxns(hDevObject, ++ (struct WMD_DRV_INTERFACE **)&pIntfFxns))) { ++ continue; ++ } ++ if (sleepCode == PWR_DEEPSLEEP) ++ ioctlcode = WMDIOCTL_DEEPSLEEP; ++ else if (sleepCode == PWR_EMERGENCYDEEPSLEEP) ++ ioctlcode = WMDIOCTL_EMERGENCYSLEEP; ++ else ++ status = DSP_EINVALIDARG; ++ ++ if (status != DSP_EINVALIDARG) { ++ status = (*pIntfFxns->pfnDevCntrl)(dwContext, ++ ioctlcode, (void *)&arg); ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== PWR_WakeDSP ======== ++ * Send command to DSP to wake it from sleep. ++ */ ++DSP_STATUS PWR_WakeDSP(IN CONST u32 timeout) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct WMD_DEV_CONTEXT *dwContext; ++ DSP_STATUS status = DSP_EFAIL; ++ struct DEV_OBJECT *hDevObject = NULL; ++ u32 arg = timeout; ++ ++ for (hDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ hDevObject != NULL; ++ hDevObject = (struct DEV_OBJECT *)DRV_GetNextDevObject ++ ((u32)hDevObject)) { ++ if (DSP_SUCCEEDED(DEV_GetWMDContext(hDevObject, ++ (struct WMD_DEV_CONTEXT **)&dwContext))) { ++ if (DSP_SUCCEEDED(DEV_GetIntfFxns(hDevObject, ++ (struct WMD_DRV_INTERFACE **)&pIntfFxns))) { ++ status = (*pIntfFxns->pfnDevCntrl)(dwContext, ++ WMDIOCTL_WAKEUP, (void *)&arg); ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== PWR_PM_PreScale======== ++ * Sends pre-notification message to DSP. ++ */ ++DSP_STATUS PWR_PM_PreScale(IN u16 voltage_domain, u32 level) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct WMD_DEV_CONTEXT *dwContext; ++ DSP_STATUS status = DSP_EFAIL; ++ struct DEV_OBJECT *hDevObject = NULL; ++ u32 arg[2]; ++ ++ arg[0] = voltage_domain; ++ arg[1] = level; ++ ++ for (hDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ hDevObject != NULL; ++ hDevObject = (struct DEV_OBJECT *)DRV_GetNextDevObject ++ ((u32)hDevObject)) { ++ if (DSP_SUCCEEDED(DEV_GetWMDContext(hDevObject, ++ (struct WMD_DEV_CONTEXT **)&dwContext))) { ++ if (DSP_SUCCEEDED(DEV_GetIntfFxns(hDevObject, ++ (struct WMD_DRV_INTERFACE **)&pIntfFxns))) { ++ status = (*pIntfFxns->pfnDevCntrl)(dwContext, ++ WMDIOCTL_PRESCALE_NOTIFY, ++ (void *)&arg); ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== PWR_PM_PostScale======== ++ * Sends post-notification message to DSP. ++ */ ++DSP_STATUS PWR_PM_PostScale(IN u16 voltage_domain, u32 level) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct WMD_DEV_CONTEXT *dwContext; ++ DSP_STATUS status = DSP_EFAIL; ++ struct DEV_OBJECT *hDevObject = NULL; ++ u32 arg[2]; ++ ++ arg[0] = voltage_domain; ++ arg[1] = level; ++ ++ for (hDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject(); ++ hDevObject != NULL; ++ hDevObject = (struct DEV_OBJECT *)DRV_GetNextDevObject ++ ((u32)hDevObject)) { ++ if (DSP_SUCCEEDED(DEV_GetWMDContext(hDevObject, ++ (struct WMD_DEV_CONTEXT **)&dwContext))) { ++ if (DSP_SUCCEEDED(DEV_GetIntfFxns(hDevObject, ++ (struct WMD_DRV_INTERFACE **)&pIntfFxns))) { ++ status = (*pIntfFxns->pfnDevCntrl)(dwContext, ++ WMDIOCTL_POSTSCALE_NOTIFY, ++ (void *)&arg); ++ } ++ } ++ } ++ return status; ++ ++} ++ ++ +diff --git a/drivers/dsp/bridge/rmgr/rmm.c b/drivers/dsp/bridge/rmgr/rmm.c +new file mode 100644 +index 0000000..575f675 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/rmm.c +@@ -0,0 +1,604 @@ ++/* ++ * rmm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== rmm.c ======== ++ * Description: ++ * ++ * This memory manager provides general heap management and arbitrary ++ * alignment for any number of memory segments. ++ * ++ * Notes: ++ * ++ * Memory blocks are allocated from the end of the first free memory ++ * block large enough to satisfy the request. Alignment requirements ++ * are satisfied by "sliding" the block forward until its base satisfies ++ * the alignment specification; if this is not possible then the next ++ * free block large enough to hold the request is tried. ++ * ++ * Since alignment can cause the creation of a new free block - the ++ * unused memory formed between the start of the original free block ++ * and the start of the allocated block - the memory manager must free ++ * this memory to prevent a memory leak. ++ * ++ * Overlay memory is managed by reserving through RMM_alloc, and freeing ++ * it through RMM_free. The memory manager prevents DSP code/data that is ++ * overlayed from being overwritten as long as the memory it runs at has ++ * been allocated, and not yet freed. ++ * ++ *! Revision History ++ *! ================ ++ *! 18-Feb-2003 vp Code review updates. ++ *! 18-Oct-2002 vp Ported to Linux Platform. ++ *! 24-Sep-2002 map Updated from Code Review ++ *! 25-Jun-2002 jeh Free from segid passed to RMM_free(). ++ *! 24-Apr-2002 jeh Determine segid based on address in RMM_free(). (No way ++ *! to keep track of segid with dynamic loader library.) ++ *! 16-Oct-2001 jeh Based on gen tree rm.c. Added support for overlays. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/rmm.h> ++ ++#define RMM_TARGSIGNATURE 0x544d4d52 /* "TMMR" */ ++ ++/* ++ * ======== RMM_Header ======== ++ * This header is used to maintain a list of free memory blocks. ++ */ ++struct RMM_Header { ++ struct RMM_Header *next; /* form a free memory link list */ ++ u32 size; /* size of the free memory */ ++ u32 addr; /* DSP address of memory block */ ++} ; ++ ++/* ++ * ======== RMM_OvlySect ======== ++ * Keeps track of memory occupied by overlay section. ++ */ ++struct RMM_OvlySect { ++ struct LST_ELEM listElem; ++ u32 addr; /* Start of memory section */ ++ u32 size; /* Length (target MAUs) of section */ ++ s32 page; /* Memory page */ ++}; ++ ++/* ++ * ======== RMM_TargetObj ======== ++ */ ++struct RMM_TargetObj { ++ u32 dwSignature; ++ struct RMM_Segment *segTab; ++ struct RMM_Header **freeList; ++ u32 numSegs; ++ struct LST_LIST *ovlyList; /* List of overlay memory in use */ ++}; ++ ++#if GT_TRACE ++static struct GT_Mask RMM_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++static bool allocBlock(struct RMM_TargetObj *target, u32 segid, u32 size, ++ u32 align, u32 *dspAddr); ++static bool freeBlock(struct RMM_TargetObj *target, u32 segid, u32 addr, ++ u32 size); ++ ++/* ++ * ======== RMM_alloc ======== ++ */ ++DSP_STATUS RMM_alloc(struct RMM_TargetObj *target, u32 segid, u32 size, ++ u32 align, u32 *dspAddr, bool reserve) ++{ ++ struct RMM_OvlySect *sect; ++ struct RMM_OvlySect *prevSect = NULL; ++ struct RMM_OvlySect *newSect; ++ u32 addr; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(target, RMM_TARGSIGNATURE)); ++ DBC_Require(dspAddr != NULL); ++ DBC_Require(size > 0); ++ DBC_Require(reserve || (target->numSegs > 0)); ++ DBC_Require(cRefs > 0); ++ ++ GT_6trace(RMM_debugMask, GT_ENTER, ++ "RMM_alloc(0x%lx, 0x%lx, 0x%lx, 0x%lx, " ++ "0x%lx, 0x%lx)\n", target, segid, size, align, dspAddr, ++ reserve); ++ if (!reserve) { ++ if (!allocBlock(target, segid, size, align, dspAddr)) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Increment the number of allocated blocks in this ++ * segment */ ++ target->segTab[segid].number++; ++ } ++ goto func_end; ++ } ++ /* An overlay section - See if block is already in use. If not, ++ * insert into the list in ascending address size. */ ++ addr = *dspAddr; ++ sect = (struct RMM_OvlySect *)LST_First(target->ovlyList); ++ /* Find place to insert new list element. List is sorted from ++ * smallest to largest address. */ ++ while (sect != NULL) { ++ if (addr <= sect->addr) { ++ /* Check for overlap with sect */ ++ if ((addr + size > sect->addr) || (prevSect && ++ (prevSect->addr + prevSect->size > addr))) { ++ status = DSP_EOVERLAYMEMORY; ++ } ++ break; ++ } ++ prevSect = sect; ++ sect = (struct RMM_OvlySect *)LST_Next(target->ovlyList, ++ (struct LST_ELEM *)sect); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* No overlap - allocate list element for new section. */ ++ newSect = MEM_Calloc(sizeof(struct RMM_OvlySect), MEM_PAGED); ++ if (newSect == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ LST_InitElem((struct LST_ELEM *)newSect); ++ newSect->addr = addr; ++ newSect->size = size; ++ newSect->page = segid; ++ if (sect == NULL) { ++ /* Put new section at the end of the list */ ++ LST_PutTail(target->ovlyList, ++ (struct LST_ELEM *)newSect); ++ } else { ++ /* Put new section just before sect */ ++ LST_InsertBefore(target->ovlyList, ++ (struct LST_ELEM *)newSect, ++ (struct LST_ELEM *)sect); ++ } ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== RMM_create ======== ++ */ ++DSP_STATUS RMM_create(struct RMM_TargetObj **pTarget, ++ struct RMM_Segment segTab[], u32 numSegs) ++{ ++ struct RMM_Header *hptr; ++ struct RMM_Segment *sptr, *tmp; ++ struct RMM_TargetObj *target; ++ s32 i; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(pTarget != NULL); ++ DBC_Require(numSegs == 0 || segTab != NULL); ++ ++ GT_3trace(RMM_debugMask, GT_ENTER, ++ "RMM_create(0x%lx, 0x%lx, 0x%lx)\n", ++ pTarget, segTab, numSegs); ++ ++ /* Allocate DBL target object */ ++ MEM_AllocObject(target, struct RMM_TargetObj, RMM_TARGSIGNATURE); ++ ++ if (target == NULL) { ++ GT_0trace(RMM_debugMask, GT_6CLASS, ++ "RMM_create: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ target->numSegs = numSegs; ++ if (!(numSegs > 0)) ++ goto func_cont; ++ ++ /* Allocate the memory for freelist from host's memory */ ++ target->freeList = MEM_Calloc(numSegs * sizeof(struct RMM_Header *), ++ MEM_PAGED); ++ if (target->freeList == NULL) { ++ GT_0trace(RMM_debugMask, GT_6CLASS, ++ "RMM_create: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ /* Allocate headers for each element on the free list */ ++ for (i = 0; i < (s32) numSegs; i++) { ++ target->freeList[i] = ++ MEM_Calloc(sizeof(struct RMM_Header), ++ MEM_PAGED); ++ if (target->freeList[i] == NULL) { ++ GT_0trace(RMM_debugMask, GT_6CLASS, ++ "RMM_create: Memory " ++ "allocation failed\n"); ++ status = DSP_EMEMORY; ++ break; ++ } ++ } ++ /* Allocate memory for initial segment table */ ++ target->segTab = MEM_Calloc(numSegs * ++ sizeof(struct RMM_Segment), MEM_PAGED); ++ if (target->segTab == NULL) { ++ GT_0trace(RMM_debugMask, GT_6CLASS, ++ "RMM_create: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } else { ++ /* Initialize segment table and free list */ ++ sptr = target->segTab; ++ for (i = 0, tmp = segTab; numSegs > 0; numSegs--, i++) { ++ *sptr = *tmp; ++ hptr = target->freeList[i]; ++ hptr->addr = tmp->base; ++ hptr->size = tmp->length; ++ hptr->next = NULL; ++ tmp++; ++ sptr++; ++ } ++ } ++ } ++func_cont: ++ /* Initialize overlay memory list */ ++ if (DSP_SUCCEEDED(status)) { ++ target->ovlyList = LST_Create(); ++ if (target->ovlyList == NULL) { ++ GT_0trace(RMM_debugMask, GT_6CLASS, ++ "RMM_create: Memory allocation failed\n"); ++ status = DSP_EMEMORY; ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ *pTarget = target; ++ } else { ++ *pTarget = NULL; ++ if (target) ++ RMM_delete(target); ++ ++ } ++ ++ DBC_Ensure((DSP_SUCCEEDED(status) && MEM_IsValidHandle((*pTarget), ++ RMM_TARGSIGNATURE)) || (DSP_FAILED(status) && *pTarget == ++ NULL)); ++ ++ return status; ++} ++ ++/* ++ * ======== RMM_delete ======== ++ */ ++void RMM_delete(struct RMM_TargetObj *target) ++{ ++ struct RMM_OvlySect *pSect; ++ struct RMM_Header *hptr; ++ struct RMM_Header *next; ++ u32 i; ++ ++ DBC_Require(MEM_IsValidHandle(target, RMM_TARGSIGNATURE)); ++ ++ GT_1trace(RMM_debugMask, GT_ENTER, "RMM_delete(0x%lx)\n", target); ++ ++ if (target->segTab != NULL) ++ MEM_Free(target->segTab); ++ ++ if (target->ovlyList) { ++ while ((pSect = (struct RMM_OvlySect *)LST_GetHead ++ (target->ovlyList))) { ++ MEM_Free(pSect); ++ } ++ DBC_Assert(LST_IsEmpty(target->ovlyList)); ++ LST_Delete(target->ovlyList); ++ } ++ ++ if (target->freeList != NULL) { ++ /* Free elements on freelist */ ++ for (i = 0; i < target->numSegs; i++) { ++ hptr = next = target->freeList[i]; ++ while (next) { ++ hptr = next; ++ next = hptr->next; ++ MEM_Free(hptr); ++ } ++ } ++ MEM_Free(target->freeList); ++ } ++ ++ MEM_FreeObject(target); ++} ++ ++/* ++ * ======== RMM_exit ======== ++ */ ++void RMM_exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(RMM_debugMask, GT_5CLASS, "RMM_exit() ref count: 0x%x\n", ++ cRefs); ++ ++ if (cRefs == 0) ++ MEM_Exit(); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== RMM_free ======== ++ */ ++bool RMM_free(struct RMM_TargetObj *target, u32 segid, u32 addr, u32 size, ++ bool reserved) ++ ++{ ++ struct RMM_OvlySect *sect; ++ bool retVal = true; ++ ++ DBC_Require(MEM_IsValidHandle(target, RMM_TARGSIGNATURE)); ++ ++ DBC_Require(reserved || segid < target->numSegs); ++ DBC_Require(reserved || (addr >= target->segTab[segid].base && ++ (addr + size) <= (target->segTab[segid].base + ++ target->segTab[segid].length))); ++ ++ GT_5trace(RMM_debugMask, GT_ENTER, ++ "RMM_free(0x%lx, 0x%lx, 0x%lx, 0x%lx, " ++ "0x%lx)\n", target, segid, addr, size, reserved); ++ /* ++ * Free or unreserve memory. ++ */ ++ if (!reserved) { ++ retVal = freeBlock(target, segid, addr, size); ++ if (retVal) ++ target->segTab[segid].number--; ++ ++ } else { ++ /* Unreserve memory */ ++ sect = (struct RMM_OvlySect *)LST_First(target->ovlyList); ++ while (sect != NULL) { ++ if (addr == sect->addr) { ++ DBC_Assert(size == sect->size); ++ /* Remove from list */ ++ LST_RemoveElem(target->ovlyList, ++ (struct LST_ELEM *)sect); ++ MEM_Free(sect); ++ break; ++ } ++ sect = (struct RMM_OvlySect *)LST_Next(target->ovlyList, ++ (struct LST_ELEM *)sect); ++ } ++ if (sect == NULL) ++ retVal = false; ++ ++ } ++ return retVal; ++} ++ ++/* ++ * ======== RMM_init ======== ++ */ ++bool RMM_init(void) ++{ ++ bool retVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ DBC_Assert(!RMM_debugMask.flags); ++ GT_create(&RMM_debugMask, "RM"); /* "RM" for RMm */ ++ ++ retVal = MEM_Init(); ++ ++ if (!retVal) ++ MEM_Exit(); ++ ++ } ++ ++ if (retVal) ++ cRefs++; ++ ++ GT_1trace(RMM_debugMask, GT_5CLASS, ++ "RMM_init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((retVal && (cRefs > 0)) || (!retVal && (cRefs >= 0))); ++ ++ return retVal; ++} ++ ++/* ++ * ======== RMM_stat ======== ++ */ ++bool RMM_stat(struct RMM_TargetObj *target, enum DSP_MEMTYPE segid, ++ struct DSP_MEMSTAT *pMemStatBuf) ++{ ++ struct RMM_Header *head; ++ bool retVal = false; ++ u32 maxFreeSize = 0; ++ u32 totalFreeSize = 0; ++ u32 freeBlocks = 0; ++ ++ DBC_Require(pMemStatBuf != NULL); ++ DBC_Assert(target != NULL); ++ ++ if ((u32) segid < target->numSegs) { ++ head = target->freeList[segid]; ++ ++ /* Collect data from freeList */ ++ while (head != NULL) { ++ maxFreeSize = max(maxFreeSize, head->size); ++ totalFreeSize += head->size; ++ freeBlocks++; ++ head = head->next; ++ } ++ ++ /* ulSize */ ++ pMemStatBuf->ulSize = target->segTab[segid].length; ++ ++ /* ulNumFreeBlocks */ ++ pMemStatBuf->ulNumFreeBlocks = freeBlocks; ++ ++ /* ulTotalFreeSize */ ++ pMemStatBuf->ulTotalFreeSize = totalFreeSize; ++ ++ /* ulLenMaxFreeBlock */ ++ pMemStatBuf->ulLenMaxFreeBlock = maxFreeSize; ++ ++ /* ulNumAllocBlocks */ ++ pMemStatBuf->ulNumAllocBlocks = target->segTab[segid].number; ++ ++ retVal = true; ++ } ++ ++ return retVal; ++} ++ ++/* ++ * ======== balloc ======== ++ * This allocation function allocates memory from the lowest addresses ++ * first. ++ */ ++static bool allocBlock(struct RMM_TargetObj *target, u32 segid, u32 size, ++ u32 align, u32 *dspAddr) ++{ ++ struct RMM_Header *head; ++ struct RMM_Header *prevhead = NULL; ++ struct RMM_Header *next; ++ u32 tmpalign; ++ u32 alignbytes; ++ u32 hsize; ++ u32 allocsize; ++ u32 addr; ++ ++ alignbytes = (align == 0) ? 1 : align; ++ prevhead = NULL; ++ head = target->freeList[segid]; ++ ++ do { ++ hsize = head->size; ++ next = head->next; ++ ++ addr = head->addr; /* alloc from the bottom */ ++ ++ /* align allocation */ ++ (tmpalign = (u32) addr % alignbytes); ++ if (tmpalign != 0) ++ tmpalign = alignbytes - tmpalign; ++ ++ allocsize = size + tmpalign; ++ ++ if (hsize >= allocsize) { /* big enough */ ++ if (hsize == allocsize && prevhead != NULL) { ++ prevhead->next = next; ++ MEM_Free(head); ++ } else { ++ head->size = hsize - allocsize; ++ head->addr += allocsize; ++ } ++ ++ /* free up any hole created by alignment */ ++ if (tmpalign) ++ freeBlock(target, segid, addr, tmpalign); ++ ++ *dspAddr = addr + tmpalign; ++ return true; ++ } ++ ++ prevhead = head; ++ head = next; ++ ++ } while (head != NULL); ++ ++ return false; ++} ++ ++/* ++ * ======== freeBlock ======== ++ * TO DO: freeBlock() allocates memory, which could result in failure. ++ * Could allocate an RMM_Header in RMM_alloc(), to be kept in a pool. ++ * freeBlock() could use an RMM_Header from the pool, freeing as blocks ++ * are coalesced. ++ */ ++static bool freeBlock(struct RMM_TargetObj *target, u32 segid, u32 addr, ++ u32 size) ++{ ++ struct RMM_Header *head; ++ struct RMM_Header *thead; ++ struct RMM_Header *rhead; ++ bool retVal = true; ++ ++ /* Create a memory header to hold the newly free'd block. */ ++ rhead = MEM_Calloc(sizeof(struct RMM_Header), MEM_PAGED); ++ if (rhead == NULL) { ++ retVal = false; ++ } else { ++ /* search down the free list to find the right place for addr */ ++ head = target->freeList[segid]; ++ ++ if (addr >= head->addr) { ++ while (head->next != NULL && addr > head->next->addr) ++ head = head->next; ++ ++ thead = head->next; ++ ++ head->next = rhead; ++ rhead->next = thead; ++ rhead->addr = addr; ++ rhead->size = size; ++ } else { ++ *rhead = *head; ++ head->next = rhead; ++ head->addr = addr; ++ head->size = size; ++ thead = rhead->next; ++ } ++ ++ /* join with upper block, if possible */ ++ if (thead != NULL && (rhead->addr + rhead->size) == ++ thead->addr) { ++ head->next = rhead->next; ++ thead->size = size + thead->size; ++ thead->addr = addr; ++ MEM_Free(rhead); ++ rhead = thead; ++ } ++ ++ /* join with the lower block, if possible */ ++ if ((head->addr + head->size) == rhead->addr) { ++ head->next = rhead->next; ++ head->size = head->size + rhead->size; ++ MEM_Free(rhead); ++ } ++ } ++ ++ return retVal; ++} ++ +diff --git a/drivers/dsp/bridge/rmgr/strm.c b/drivers/dsp/bridge/rmgr/strm.c +new file mode 100644 +index 0000000..bd55fd3 +--- /dev/null ++++ b/drivers/dsp/bridge/rmgr/strm.c +@@ -0,0 +1,1066 @@ ++/* ++ * strm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== strm.c ======== ++ * Description: ++ * DSP/BIOS Bridge Stream Manager. ++ * ++ * Public Functions: ++ * STRM_AllocateBuffer ++ * STRM_Close ++ * STRM_Create ++ * STRM_Delete ++ * STRM_Exit ++ * STRM_FreeBuffer ++ * STRM_GetEventHandle ++ * STRM_GetInfo ++ * STRM_Idle ++ * STRM_Init ++ * STRM_Issue ++ * STRM_Open ++ * STRM_PrepareBuffer ++ * STRM_Reclaim ++ * STRM_RegisterNotify ++ * STRM_Select ++ * STRM_UnprepareBuffer ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================= ++ *! 18-Feb-2003 vp Code review updates. ++ *! 18-Oct-2002 vp Ported to Linux platform. ++ *! 13-Mar-2002 map pStrm init'd to NULL in STRM_Open to prevent error ++ *! 12-Mar-2002 map Changed return var to WSX "wStatus" instead of "status" ++ *! in DEV and CMM function calls to avoid confusion. ++ *! Return DSP_SOK instead of S_OK from API fxns. ++ *! 12-Mar-2002 map Changed FAILED(..) to DSP_FAILED(..) ++ *! 25-Jan-2002 ag Allow neg seg ids(e.g. DSP_SHMSEG0) to denote SM. ++ *! 15-Nov-2001 ag Added STRMMODE & SM for DMA/ZCopy streaming. ++ *! Changed DSP_STREAMINFO to STRM_INFO in STRM_GetInfo(). ++ *! Use strm timeout value for dma flush timeout. ++ *! 09-May-2001 jeh Code review cleanup. ++ *! 06-Feb-2001 kc Updated DBC_Ensure in STRM_Select to check timeout. ++ *! 23-Oct-2000 jeh Allow NULL STRM_ATTRS passed to STRM_Open() for DLL ++ *! tests to pass. ++ *! 25-Sep-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Mini Driver */ ++#include <dspbridge/wmd.h> ++ ++/* ----------------------------------- Resource Manager */ ++#include <dspbridge/nodepriv.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/cmm.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/strm.h> ++ ++#ifndef RES_CLEANUP_DISABLE ++#include <dspbridge/cfg.h> ++#include <dspbridge/dbreg.h> ++#include <dspbridge/resourcecleanup.h> ++#endif ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define STRM_SIGNATURE 0x4d525453 /* "MRTS" */ ++#define STRMMGR_SIGNATURE 0x5254534d /* "RTSM" */ ++ ++#define DEFAULTTIMEOUT 10000 ++#define DEFAULTNUMBUFS 2 ++ ++/* ++ * ======== STRM_MGR ======== ++ * The STRM_MGR contains device information needed to open the underlying ++ * channels of a stream. ++ */ ++struct STRM_MGR { ++ u32 dwSignature; ++ struct DEV_OBJECT *hDev; /* Device for this processor */ ++ struct CHNL_MGR *hChnlMgr; /* Channel manager */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ struct SYNC_CSOBJECT *hSync; /* For critical sections */ ++} ; ++ ++/* ++ * ======== STRM_OBJECT ======== ++ * This object is allocated in STRM_Open(). ++ */ ++ struct STRM_OBJECT { ++ u32 dwSignature; ++ struct STRM_MGR *hStrmMgr; ++ struct CHNL_OBJECT *hChnl; ++ u32 uDir; /* DSP_TONODE or DSP_FROMNODE */ ++ u32 uTimeout; ++ u32 uNumBufs; /* Max # of bufs allowed in stream */ ++ u32 uNBufsInStrm; /* Current # of bufs in stream */ ++ u32 ulNBytes; /* bytes transferred since idled */ ++ enum DSP_STREAMSTATE strmState; /* STREAM_IDLE, STREAM_READY, ... */ ++ HANDLE hUserEvent; /* Saved for STRM_GetInfo() */ ++ enum DSP_STRMMODE lMode; /* STRMMODE_[PROCCOPY][ZEROCOPY]... */ ++ u32 uDMAChnlId; /* DMA chnl id */ ++ u32 uDMAPriority; /* DMA priority:DMAPRI_[LOW][HIGH] */ ++ u32 uSegment; /* >0 is SM segment.=0 is local heap */ ++ u32 uAlignment; /* Alignment for stream bufs */ ++ struct CMM_XLATOROBJECT *hXlator; /* Stream's SM address translator */ ++} ; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask STRM_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++static u32 cRefs; /* module reference count */ ++ ++/* ----------------------------------- Function Prototypes */ ++static DSP_STATUS DeleteStrm(struct STRM_OBJECT *hStrm); ++static void DeleteStrmMgr(struct STRM_MGR *hStrmMgr); ++ ++/* ++ * ======== STRM_AllocateBuffer ======== ++ * Purpose: ++ * Allocates buffers for a stream. ++ */ ++DSP_STATUS STRM_AllocateBuffer(struct STRM_OBJECT *hStrm, u32 uSize, ++ OUT u8 **apBuffer, u32 uNumBufs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 uAllocated = 0; ++ u32 i; ++ #ifndef RES_CLEANUP_DISABLE ++ DSP_STATUS res_status = DSP_SOK; ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE hSTRMRes; ++ #endif ++ DBC_Require(cRefs > 0); ++ DBC_Require(apBuffer != NULL); ++ ++ GT_4trace(STRM_debugMask, GT_ENTER, "STRM_AllocateBuffer: hStrm: 0x%x\t" ++ "uSize: 0x%x\tapBuffer: 0x%x\tuNumBufs: 0x%x\n", ++ hStrm, uSize, apBuffer, uNumBufs); ++ if (MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ /* ++ * Allocate from segment specified at time of stream open. ++ */ ++ if (uSize == 0) ++ status = DSP_ESIZE; ++ ++ } ++ if (DSP_FAILED(status)) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ for (i = 0; i < uNumBufs; i++) { ++ DBC_Assert(hStrm->hXlator != NULL); ++ (void)CMM_XlatorAllocBuf(hStrm->hXlator, &apBuffer[i], uSize); ++ if (apBuffer[i] == NULL) { ++ GT_0trace(STRM_debugMask, GT_7CLASS, ++ "STRM_AllocateBuffer: " ++ "DSP_FAILED to alloc shared memory.\n"); ++ status = DSP_EMEMORY; ++ uAllocated = i; ++ break; ++ } ++ } ++ if (DSP_FAILED(status)) ++ STRM_FreeBuffer(hStrm, apBuffer, uAllocated); ++ ++#ifndef RES_CLEANUP_DISABLE ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_FAILED(res_status)) ++ goto func_end; ++ ++ DRV_GetProcContext(hProcess, (struct DRV_OBJECT *)hDrvObject, ++ &pCtxt, NULL, 0); ++ if (pCtxt != NULL) { ++ if (DRV_GetSTRMResElement(hStrm, &hSTRMRes, pCtxt) != ++ DSP_ENOTFOUND) { ++ DRV_ProcUpdateSTRMRes(uNumBufs, hSTRMRes, pCtxt); ++ } ++ } ++#endif ++func_end: ++ return status; ++} ++ ++/* ++ * ======== STRM_Close ======== ++ * Purpose: ++ * Close a stream opened with STRM_Open(). ++ */ ++DSP_STATUS STRM_Close(struct STRM_OBJECT *hStrm) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct CHNL_INFO chnlInfo; ++ DSP_STATUS status = DSP_SOK; ++ ++ ++#ifndef RES_CLEANUP_DISABLE ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE hSTRMRes; ++ DSP_STATUS res_status = DSP_SOK; ++#endif ++ ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(STRM_debugMask, GT_ENTER, "STRM_Close: hStrm: 0x%x\n", hStrm); ++ ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ /* Have all buffers been reclaimed? If not, return ++ * DSP_EPENDING */ ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnChnlGetInfo) (hStrm->hChnl, &chnlInfo); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ ++ if (chnlInfo.cIOCs > 0 || chnlInfo.cIOReqs > 0) { ++ status = DSP_EPENDING; ++ } else { ++ ++ status = DeleteStrm(hStrm); ++ ++ if (DSP_FAILED(status)) { ++ /* we already validated the handle. */ ++ DBC_Assert(status != DSP_EHANDLE); ++ ++ /* make sure we return a documented result */ ++ status = DSP_EFAIL; ++ } ++ } ++ } ++#ifndef RES_CLEANUP_DISABLE ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Update the node and stream resource status */ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_FAILED(res_status)) ++ goto func_end; ++ ++ DRV_GetProcContext(hProcess, (struct DRV_OBJECT *)hDrvObject, ++ &pCtxt, NULL, 0); ++ if (pCtxt != NULL) { ++ if (DRV_GetSTRMResElement(hStrm, &hSTRMRes, pCtxt) != ++ DSP_ENOTFOUND) { ++ DRV_ProcRemoveSTRMResElement(hSTRMRes, pCtxt); ++ } ++ } ++func_end: ++#endif ++ DBC_Ensure(status == DSP_SOK || status == DSP_EHANDLE || ++ status == DSP_EPENDING || status == DSP_EFAIL); ++ ++ return status; ++} ++ ++/* ++ * ======== STRM_Create ======== ++ * Purpose: ++ * Create a STRM manager object. ++ */ ++DSP_STATUS STRM_Create(OUT struct STRM_MGR **phStrmMgr, struct DEV_OBJECT *hDev) ++{ ++ struct STRM_MGR *pStrmMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(phStrmMgr != NULL); ++ DBC_Require(hDev != NULL); ++ ++ GT_2trace(STRM_debugMask, GT_ENTER, "STRM_Create: phStrmMgr: " ++ "0x%x\thDev: 0x%x\n", phStrmMgr, hDev); ++ *phStrmMgr = NULL; ++ /* Allocate STRM manager object */ ++ MEM_AllocObject(pStrmMgr, struct STRM_MGR, STRMMGR_SIGNATURE); ++ if (pStrmMgr == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(STRM_debugMask, GT_6CLASS, "STRM_Create: " ++ "MEM_AllocObject() failed!\n "); ++ } else { ++ pStrmMgr->hDev = hDev; ++ } ++ /* Get Channel manager and WMD function interface */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetChnlMgr(hDev, &(pStrmMgr->hChnlMgr)); ++ if (DSP_SUCCEEDED(status)) { ++ (void) DEV_GetIntfFxns(hDev, &(pStrmMgr->pIntfFxns)); ++ DBC_Assert(pStrmMgr->pIntfFxns != NULL); ++ } else { ++ GT_1trace(STRM_debugMask, GT_6CLASS, "STRM_Create: " ++ "Failed to get channel manager! status = " ++ "0x%x\n", status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_InitializeCS(&pStrmMgr->hSync); ++ ++ if (DSP_SUCCEEDED(status)) ++ *phStrmMgr = pStrmMgr; ++ else ++ DeleteStrmMgr(pStrmMgr); ++ ++ DBC_Ensure(DSP_SUCCEEDED(status) && ++ (MEM_IsValidHandle((*phStrmMgr), STRMMGR_SIGNATURE) || ++ (DSP_FAILED(status) && *phStrmMgr == NULL))); ++ ++ return status; ++} ++ ++/* ++ * ======== STRM_Delete ======== ++ * Purpose: ++ * Delete the STRM Manager Object. ++ */ ++void STRM_Delete(struct STRM_MGR *hStrmMgr) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(MEM_IsValidHandle(hStrmMgr, STRMMGR_SIGNATURE)); ++ ++ GT_1trace(STRM_debugMask, GT_ENTER, "STRM_Delete: hStrmMgr: 0x%x\n", ++ hStrmMgr); ++ ++ DeleteStrmMgr(hStrmMgr); ++ ++ DBC_Ensure(!MEM_IsValidHandle(hStrmMgr, STRMMGR_SIGNATURE)); ++} ++ ++/* ++ * ======== STRM_Exit ======== ++ * Purpose: ++ * Discontinue usage of STRM module. ++ */ ++void STRM_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ cRefs--; ++ ++ GT_1trace(STRM_debugMask, GT_5CLASS, ++ "Entered STRM_Exit, ref count: 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== STRM_FreeBuffer ======== ++ * Purpose: ++ * Frees the buffers allocated for a stream. ++ */ ++DSP_STATUS STRM_FreeBuffer(struct STRM_OBJECT *hStrm, u8 **apBuffer, ++ u32 uNumBufs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 i = 0; ++ ++ #ifndef RES_CLEANUP_DISABLE ++ DSP_STATUS res_status = DSP_SOK; ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE hSTRMRes = NULL; ++ #endif ++ DBC_Require(cRefs > 0); ++ DBC_Require(apBuffer != NULL); ++ ++ GT_3trace(STRM_debugMask, GT_ENTER, "STRM_FreeBuffer: hStrm: 0x%x\t" ++ "apBuffer: 0x%x\tuNumBufs: 0x%x\n", hStrm, apBuffer, uNumBufs); ++ ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) ++ status = DSP_EHANDLE; ++ ++ if (DSP_SUCCEEDED(status)) { ++ for (i = 0; i < uNumBufs; i++) { ++ DBC_Assert(hStrm->hXlator != NULL); ++ status = CMM_XlatorFreeBuf(hStrm->hXlator, apBuffer[i]); ++ if (DSP_FAILED(status)) { ++ GT_0trace(STRM_debugMask, GT_7CLASS, ++ "STRM_FreeBuffer: DSP_FAILED" ++ " to free shared memory.\n"); ++ break; ++ } ++ apBuffer[i] = NULL; ++ } ++ } ++#ifndef RES_CLEANUP_DISABLE ++ /* Update the node and stream resource status */ ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDrvObject, &pCtxt, ++ NULL, 0); ++ if (pCtxt != NULL) { ++ if (DRV_GetSTRMResElement(hStrm, hSTRMRes, pCtxt) != ++ DSP_ENOTFOUND) { ++ DRV_ProcUpdateSTRMRes(uNumBufs-i, hSTRMRes, ++ pCtxt); ++ } ++ } ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== STRM_GetInfo ======== ++ * Purpose: ++ * Retrieves information about a stream. ++ */ ++DSP_STATUS STRM_GetInfo(struct STRM_OBJECT *hStrm, ++ OUT struct STRM_INFO *pStreamInfo, ++ u32 uStreamInfoSize) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct CHNL_INFO chnlInfo; ++ DSP_STATUS status = DSP_SOK; ++ void *pVirtBase = NULL; /* NULL if no SM used */ ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pStreamInfo != NULL); ++ DBC_Require(uStreamInfoSize >= sizeof(struct STRM_INFO)); ++ ++ GT_3trace(STRM_debugMask, GT_ENTER, "STRM_GetInfo: hStrm: 0x%x\t" ++ "pStreamInfo: 0x%x\tuStreamInfoSize: 0x%x\n", hStrm, ++ pStreamInfo, uStreamInfoSize); ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ if (uStreamInfoSize < sizeof(struct STRM_INFO)) { ++ /* size of users info */ ++ status = DSP_ESIZE; ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnChnlGetInfo) (hStrm->hChnl, &chnlInfo); ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ if (hStrm->hXlator) { ++ /* We have a translator */ ++ DBC_Assert(hStrm->uSegment > 0); ++ CMM_XlatorInfo(hStrm->hXlator, (u8 **)&pVirtBase, 0, ++ hStrm->uSegment, false); ++ } ++ pStreamInfo->uSegment = hStrm->uSegment; ++ pStreamInfo->lMode = hStrm->lMode; ++ pStreamInfo->pVirtBase = pVirtBase; ++ pStreamInfo->pUser->uNumberBufsAllowed = hStrm->uNumBufs; ++ pStreamInfo->pUser->uNumberBufsInStream = chnlInfo.cIOCs + ++ chnlInfo.cIOReqs; ++ /* # of bytes transferred since last call to DSPStream_Idle() */ ++ pStreamInfo->pUser->ulNumberBytes = chnlInfo.cPosition; ++ pStreamInfo->pUser->hSyncObjectHandle = chnlInfo.hEvent; ++ /* Determine stream state based on channel state and info */ ++ if (chnlInfo.dwState & CHNL_STATEEOS) { ++ pStreamInfo->pUser->ssStreamState = STREAM_DONE; ++ } else { ++ if (chnlInfo.cIOCs > 0) ++ pStreamInfo->pUser->ssStreamState = STREAM_READY; ++ else if (chnlInfo.cIOReqs > 0) ++ pStreamInfo->pUser->ssStreamState = STREAM_PENDING; ++ else ++ pStreamInfo->pUser->ssStreamState = STREAM_IDLE; ++ ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== STRM_Idle ======== ++ * Purpose: ++ * Idles a particular stream. ++ */ ++DSP_STATUS STRM_Idle(struct STRM_OBJECT *hStrm, bool fFlush) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_2trace(STRM_debugMask, GT_ENTER, "STRM_Idle: hStrm: 0x%x\t" ++ "fFlush: 0x%x\n", hStrm, fFlush); ++ ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ ++ status = (*pIntfFxns->pfnChnlIdle) (hStrm->hChnl, ++ hStrm->uTimeout, fFlush); ++ } ++ return status; ++} ++ ++/* ++ * ======== STRM_Init ======== ++ * Purpose: ++ * Initialize the STRM module. ++ */ ++bool STRM_Init(void) ++{ ++ bool fRetVal = true; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++#if GT_TRACE ++ DBC_Assert(!STRM_debugMask.flags); ++ GT_create(&STRM_debugMask, "ST"); /* "ST" for STrm */ ++#endif ++ } ++ ++ if (fRetVal) ++ cRefs++; ++ ++ GT_1trace(STRM_debugMask, GT_5CLASS, "STRM_Init(), ref count: 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fRetVal && (cRefs > 0)) || (!fRetVal && (cRefs >= 0))); ++ ++ return fRetVal; ++} ++ ++/* ++ * ======== STRM_Issue ======== ++ * Purpose: ++ * Issues a buffer on a stream ++ */ ++DSP_STATUS STRM_Issue(struct STRM_OBJECT *hStrm, IN u8 *pBuf, u32 ulBytes, ++ u32 ulBufSize, u32 dwArg) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ void *pTmpBuf = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBuf != NULL); ++ ++ GT_4trace(STRM_debugMask, GT_ENTER, "STRM_Issue: hStrm: 0x%x\tpBuf: " ++ "0x%x\tulBytes: 0x%x\tdwArg: 0x%x\n", hStrm, pBuf, ulBytes, ++ dwArg); ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ ++ if (hStrm->uSegment != 0) { ++ pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator, ++ (void *)pBuf, CMM_VA2DSPPA); ++ if (pTmpBuf == NULL) ++ status = DSP_ETRANSLATE; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = (*pIntfFxns->pfnChnlAddIOReq) ++ (hStrm->hChnl, pBuf, ulBytes, ulBufSize, ++ (u32) pTmpBuf, dwArg); ++ } ++ if (DSP_FAILED(status)) { ++ if (status == CHNL_E_NOIORPS) ++ status = DSP_ESTREAMFULL; ++ else ++ status = DSP_EFAIL; ++ ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== STRM_Open ======== ++ * Purpose: ++ * Open a stream for sending/receiving data buffers to/from a task or ++ * XDAIS socket node on the DSP. ++ */ ++DSP_STATUS STRM_Open(struct NODE_OBJECT *hNode, u32 uDir, u32 uIndex, ++ IN struct STRM_ATTR *pAttr, OUT struct STRM_OBJECT **phStrm) ++{ ++ struct STRM_MGR *hStrmMgr; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ u32 ulChnlId; ++ struct STRM_OBJECT *pStrm = NULL; ++ CHNL_MODE uMode; ++ struct CHNL_ATTRS chnlAttrs; ++ DSP_STATUS status = DSP_SOK; ++ struct CMM_OBJECT *hCmmMgr = NULL; /* Shared memory manager hndl */ ++ ++ #ifndef RES_CLEANUP_DISABLE ++ DSP_STATUS res_status = DSP_SOK; ++ u32 hProcess; ++ HANDLE pCtxt = NULL; ++ HANDLE hDrvObject; ++ HANDLE hSTRMRes; ++ #endif ++ DBC_Require(cRefs > 0); ++ DBC_Require(phStrm != NULL); ++ DBC_Require(pAttr != NULL); ++ GT_5trace(STRM_debugMask, GT_ENTER, ++ "STRM_Open: hNode: 0x%x\tuDir: 0x%x\t" ++ "uIndex: 0x%x\tpAttr: 0x%x\tphStrm: 0x%x\n", ++ hNode, uDir, uIndex, pAttr, phStrm); ++ *phStrm = NULL; ++ if (uDir != DSP_TONODE && uDir != DSP_FROMNODE) { ++ status = DSP_EDIRECTION; ++ } else { ++ /* Get the channel id from the node (set in NODE_Connect()) */ ++ status = NODE_GetChannelId(hNode, uDir, uIndex, &ulChnlId); ++ } ++ if (DSP_SUCCEEDED(status)) ++ status = NODE_GetStrmMgr(hNode, &hStrmMgr); ++ ++ if (DSP_SUCCEEDED(status)) { ++ MEM_AllocObject(pStrm, struct STRM_OBJECT, STRM_SIGNATURE); ++ if (pStrm == NULL) { ++ status = DSP_EMEMORY; ++ GT_0trace(STRM_debugMask, GT_6CLASS, ++ "STRM_Open: MEM_AllocObject() failed!\n "); ++ } else { ++ pStrm->hStrmMgr = hStrmMgr; ++ pStrm->uDir = uDir; ++ pStrm->strmState = STREAM_IDLE; ++ pStrm->hUserEvent = pAttr->hUserEvent; ++ if (pAttr->pStreamAttrIn != NULL) { ++ pStrm->uTimeout = pAttr->pStreamAttrIn-> ++ uTimeout; ++ pStrm->uNumBufs = pAttr->pStreamAttrIn-> ++ uNumBufs; ++ pStrm->lMode = pAttr->pStreamAttrIn->lMode; ++ pStrm->uSegment = pAttr->pStreamAttrIn-> ++ uSegment; ++ pStrm->uAlignment = pAttr->pStreamAttrIn-> ++ uAlignment; ++ pStrm->uDMAChnlId = pAttr->pStreamAttrIn-> ++ uDMAChnlId; ++ pStrm->uDMAPriority = pAttr->pStreamAttrIn-> ++ uDMAPriority; ++ chnlAttrs.uIOReqs = pAttr->pStreamAttrIn-> ++ uNumBufs; ++ } else { ++ pStrm->uTimeout = DEFAULTTIMEOUT; ++ pStrm->uNumBufs = DEFAULTNUMBUFS; ++ pStrm->lMode = STRMMODE_PROCCOPY; ++ pStrm->uSegment = 0; /* local memory */ ++ pStrm->uAlignment = 0; ++ pStrm->uDMAChnlId = 0; ++ pStrm->uDMAPriority = 0; ++ chnlAttrs.uIOReqs = DEFAULTNUMBUFS; ++ } ++ chnlAttrs.hReserved1 = NULL; ++ /* DMA chnl flush timeout */ ++ chnlAttrs.hReserved2 = pStrm->uTimeout; ++ chnlAttrs.hEvent = NULL; ++ if (pAttr->hUserEvent != NULL) ++ chnlAttrs.hEvent = pAttr->hUserEvent; ++ ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ if ((pAttr->pVirtBase == NULL) || !(pAttr->ulVirtSize > 0)) ++ goto func_cont; ++ ++ DBC_Assert(pStrm->lMode != STRMMODE_LDMA); /* no System DMA */ ++ /* Get the shared mem mgr for this streams dev object */ ++ status = DEV_GetCmmMgr(hStrmMgr->hDev, &hCmmMgr); ++ if (DSP_FAILED(status)) { ++ GT_1trace(STRM_debugMask, GT_6CLASS, "STRM_Open: Failed to get " ++ "CMM Mgr handle: 0x%x\n", status); ++ } else { ++ /*Allocate a SM addr translator for this strm.*/ ++ status = CMM_XlatorCreate(&pStrm->hXlator, hCmmMgr, NULL); ++ if (DSP_FAILED(status)) { ++ GT_1trace(STRM_debugMask, GT_6CLASS, ++ "STRM_Open: Failed to " ++ "create SM translator: 0x%x\n", status); ++ } else { ++ DBC_Assert(pStrm->uSegment > 0); ++ /* Set translators Virt Addr attributes */ ++ status = CMM_XlatorInfo(pStrm->hXlator, ++ (u8 **)&pAttr->pVirtBase, pAttr->ulVirtSize, ++ pStrm->uSegment, true); ++ if (status != DSP_SOK) { ++ GT_0trace(STRM_debugMask, GT_6CLASS, ++ "STRM_Open: ERROR: " ++ "in setting CMM_XlatorInfo.\n"); ++ } ++ } ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) { ++ /* Open channel */ ++ uMode = (uDir == DSP_TONODE) ? ++ CHNL_MODETODSP : CHNL_MODEFROMDSP; ++ pIntfFxns = hStrmMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnChnlOpen) (&(pStrm->hChnl), ++ hStrmMgr->hChnlMgr, uMode, ulChnlId, &chnlAttrs); ++ if (DSP_FAILED(status)) { ++ /* ++ * over-ride non-returnable status codes so we return ++ * something documented ++ */ ++ if (status != DSP_EMEMORY && status != ++ DSP_EINVALIDARG && status != DSP_EFAIL) { ++ /* ++ * We got a status that's not return-able. ++ * Assert that we got something we were ++ * expecting (DSP_EHANDLE isn't acceptable, ++ * hStrmMgr->hChnlMgr better be valid or we ++ * assert here), and then return DSP_EFAIL. ++ */ ++ DBC_Assert(status == CHNL_E_OUTOFSTREAMS || ++ status == CHNL_E_BADCHANID || ++ status == CHNL_E_CHANBUSY || ++ status == CHNL_E_NOIORPS); ++ status = DSP_EFAIL; ++ } ++ GT_2trace(STRM_debugMask, GT_6CLASS, ++ "STRM_Open: Channel open failed, " ++ "chnl id = %d, status = 0x%x\n", ulChnlId, ++ status); ++ } ++ } ++ if (DSP_SUCCEEDED(status)) ++ *phStrm = pStrm; ++ else ++ (void)DeleteStrm(pStrm); ++ ++#ifndef RES_CLEANUP_DISABLE ++ /* Return PID instead of process handle */ ++ hProcess = current->pid; ++ ++ res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT); ++ if (DSP_SUCCEEDED(res_status)) { ++ DRV_GetProcContext(hProcess, ++ (struct DRV_OBJECT *)hDrvObject, &pCtxt, ++ hNode, 0); ++ if (pCtxt != NULL) ++ DRV_ProcInsertSTRMResElement(*phStrm, &hSTRMRes, pCtxt); ++ ++ } ++#endif ++ ++ /* ensure we return a documented error code */ ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle((*phStrm), STRM_SIGNATURE)) || ++ (*phStrm == NULL && (status == DSP_EHANDLE || ++ status == DSP_EDIRECTION || status == DSP_EVALUE || ++ status == DSP_EFAIL))); ++ return status; ++} ++ ++/* ++ * ======== STRM_Reclaim ======== ++ * Purpose: ++ * Relcaims a buffer from a stream. ++ */ ++DSP_STATUS STRM_Reclaim(struct STRM_OBJECT *hStrm, OUT u8 **pBufPtr, ++ u32 *pulBytes, u32 *pulBufSize, u32 *pdwArg) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct CHNL_IOC chnlIOC; ++ DSP_STATUS status = DSP_SOK; ++ void *pTmpBuf = NULL; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pBufPtr != NULL); ++ DBC_Require(pulBytes != NULL); ++ DBC_Require(pdwArg != NULL); ++ ++ GT_4trace(STRM_debugMask, GT_ENTER, ++ "STRM_Reclaim: hStrm: 0x%x\tpBufPtr: 0x%x" ++ "\tpulBytes: 0x%x\tpdwArg: 0x%x\n", hStrm, pBufPtr, pulBytes, ++ pdwArg); ++ ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ ++ status = (*pIntfFxns->pfnChnlGetIOC)(hStrm->hChnl, hStrm->uTimeout, ++ &chnlIOC); ++ if (DSP_FAILED(status)) { ++ GT_1trace(STRM_debugMask, GT_6CLASS, ++ "STRM_Reclaim: GetIOC failed! " ++ "Status = 0x%x\n", status); ++ } else { ++ *pulBytes = chnlIOC.cBytes; ++ if (pulBufSize) ++ *pulBufSize = chnlIOC.cBufSize; ++ ++ *pdwArg = chnlIOC.dwArg; ++ if (!CHNL_IsIOComplete(chnlIOC)) { ++ if (CHNL_IsTimedOut(chnlIOC)) { ++ status = DSP_ETIMEOUT; ++ } else { ++ /* Allow reclaims after idle to succeed */ ++ if (!CHNL_IsIOCancelled(chnlIOC)) ++ status = DSP_EFAIL; ++ ++ } ++ } ++ /* Translate zerocopy buffer if channel not canceled. */ ++ if (DSP_SUCCEEDED(status) && (!CHNL_IsIOCancelled(chnlIOC)) && ++ (hStrm->lMode == STRMMODE_ZEROCOPY)) { ++ /* ++ * This is a zero-copy channel so chnlIOC.pBuf ++ * contains the DSP address of SM. We need to ++ * translate it to a virtual address for the user ++ * thread to access. ++ * Note: Could add CMM_DSPPA2VA to CMM in the future. ++ */ ++ pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator, ++ chnlIOC.pBuf, CMM_DSPPA2PA); ++ if (pTmpBuf != NULL) { ++ /* now convert this GPP Pa to Va */ ++ pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator, ++ pTmpBuf, CMM_PA2VA); ++ } ++ if (pTmpBuf == NULL) { ++ GT_0trace(STRM_debugMask, GT_7CLASS, ++ "STRM_Reclaim: Failed " ++ "SM translation!\n"); ++ status = DSP_ETRANSLATE; ++ } ++ chnlIOC.pBuf = pTmpBuf; ++ } ++ *pBufPtr = chnlIOC.pBuf; ++ } ++func_end: ++ /* ensure we return a documented return code */ ++ DBC_Ensure(DSP_SUCCEEDED(status) || status == DSP_EHANDLE || ++ status == DSP_ETIMEOUT || status == DSP_ETRANSLATE || ++ status == DSP_EFAIL); ++ return status; ++} ++ ++/* ++ * ======== STRM_RegisterNotify ======== ++ * Purpose: ++ * Register to be notified on specific events for this stream. ++ */ ++DSP_STATUS STRM_RegisterNotify(struct STRM_OBJECT *hStrm, u32 uEventMask, ++ u32 uNotifyType, struct DSP_NOTIFICATION ++ *hNotification) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(hNotification != NULL); ++ ++ GT_4trace(STRM_debugMask, GT_ENTER, ++ "STRM_RegisterNotify: hStrm: 0x%x\t" ++ "uEventMask: 0x%x\tuNotifyType: 0x%x\thNotification: 0x%x\n", ++ hStrm, uEventMask, uNotifyType, hNotification); ++ if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else if ((uEventMask & ~((DSP_STREAMIOCOMPLETION) | ++ DSP_STREAMDONE)) != 0) { ++ status = DSP_EVALUE; ++ } else { ++ if (uNotifyType != DSP_SIGNALEVENT) ++ status = DSP_ENOTIMPL; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ ++ status = (*pIntfFxns->pfnChnlRegisterNotify)(hStrm->hChnl, ++ uEventMask, uNotifyType, hNotification); ++ } ++ /* ensure we return a documented return code */ ++ DBC_Ensure(DSP_SUCCEEDED(status) || status == DSP_EHANDLE || ++ status == DSP_ETIMEOUT || status == DSP_ETRANSLATE || ++ status == DSP_ENOTIMPL || status == DSP_EFAIL); ++ return status; ++} ++ ++/* ++ * ======== STRM_Select ======== ++ * Purpose: ++ * Selects a ready stream. ++ */ ++DSP_STATUS STRM_Select(IN struct STRM_OBJECT **aStrmTab, u32 nStrms, ++ OUT u32 *pMask, u32 uTimeout) ++{ ++ u32 uIndex; ++ struct CHNL_INFO chnlInfo; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct SYNC_OBJECT **hSyncEvents = NULL; ++ u32 i; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(cRefs > 0); ++ DBC_Require(aStrmTab != NULL); ++ DBC_Require(pMask != NULL); ++ DBC_Require(nStrms > 0); ++ ++ GT_4trace(STRM_debugMask, GT_ENTER, ++ "STRM_Select: aStrmTab: 0x%x \tnStrms: " ++ "0x%x\tpMask: 0x%x\tuTimeout: 0x%x\n", aStrmTab, ++ nStrms, pMask, uTimeout); ++ *pMask = 0; ++ for (i = 0; i < nStrms; i++) { ++ if (!MEM_IsValidHandle(aStrmTab[i], STRM_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ break; ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Determine which channels have IO ready */ ++ for (i = 0; i < nStrms; i++) { ++ pIntfFxns = aStrmTab[i]->hStrmMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnChnlGetInfo)(aStrmTab[i]->hChnl, ++ &chnlInfo); ++ if (DSP_FAILED(status)) { ++ break; ++ } else { ++ if (chnlInfo.cIOCs > 0) ++ *pMask |= (1 << i); ++ ++ } ++ } ++ if (DSP_SUCCEEDED(status) && uTimeout > 0 && *pMask == 0) { ++ /* Non-zero timeout */ ++ hSyncEvents = (struct SYNC_OBJECT **)MEM_Alloc(nStrms * ++ sizeof(struct SYNC_OBJECT *), MEM_PAGED); ++ if (hSyncEvents == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ for (i = 0; i < nStrms; i++) { ++ pIntfFxns = aStrmTab[i]->hStrmMgr->pIntfFxns; ++ status = (*pIntfFxns->pfnChnlGetInfo) ++ (aStrmTab[i]->hChnl, &chnlInfo); ++ if (DSP_FAILED(status)) ++ break; ++ else ++ hSyncEvents[i] = chnlInfo.hSyncEvent; ++ ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = SYNC_WaitOnMultipleEvents(hSyncEvents, nStrms, ++ uTimeout, &uIndex); ++ if (DSP_SUCCEEDED(status)) { ++ /* Since we waited on the event, we have to ++ * reset it */ ++ SYNC_SetEvent(hSyncEvents[uIndex]); ++ *pMask = 1 << uIndex; ++ } ++ } ++ } ++func_end: ++ if (hSyncEvents) ++ MEM_Free(hSyncEvents); ++ ++ DBC_Ensure((DSP_SUCCEEDED(status) && (*pMask != 0 || uTimeout == 0)) || ++ (DSP_FAILED(status) && *pMask == 0)); ++ ++ return status; ++} ++ ++/* ++ * ======== DeleteStrm ======== ++ * Purpose: ++ * Frees the resources allocated for a stream. ++ */ ++static DSP_STATUS DeleteStrm(struct STRM_OBJECT *hStrm) ++{ ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ DSP_STATUS status = DSP_SOK; ++ ++ if (MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) { ++ if (hStrm->hChnl) { ++ pIntfFxns = hStrm->hStrmMgr->pIntfFxns; ++ /* Channel close can fail only if the channel handle ++ * is invalid. */ ++ status = (*pIntfFxns->pfnChnlClose) (hStrm->hChnl); ++ /* Free all SM address translator resources */ ++ if (DSP_SUCCEEDED(status)) { ++ if (hStrm->hXlator) { ++ /* force free */ ++ (void)CMM_XlatorDelete(hStrm->hXlator, ++ true); ++ } ++ } ++ } ++ MEM_FreeObject(hStrm); ++ } else { ++ status = DSP_EHANDLE; ++ } ++ return status; ++} ++ ++/* ++ * ======== DeleteStrmMgr ======== ++ * Purpose: ++ * Frees stream manager. ++ */ ++static void DeleteStrmMgr(struct STRM_MGR *hStrmMgr) ++{ ++ if (MEM_IsValidHandle(hStrmMgr, STRMMGR_SIGNATURE)) { ++ ++ if (hStrmMgr->hSync) ++ SYNC_DeleteCS(hStrmMgr->hSync); ++ ++ MEM_FreeObject(hStrmMgr); ++ } ++} ++ +diff --git a/drivers/dsp/bridge/services/cfg.c b/drivers/dsp/bridge/services/cfg.c +new file mode 100644 +index 0000000..67656bf +--- /dev/null ++++ b/drivers/dsp/bridge/services/cfg.c +@@ -0,0 +1,483 @@ ++/* ++ * cfg.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cfgce.c ======== ++ * Purpose: ++ * Implementation of platform specific config services. ++ * ++ * Private Functions: ++ * CFG_Exit ++ * CFG_GetAutoStart ++ * CFG_GetDevObject ++ * CFG_GetDSPResources ++ * CFG_GetExecFile ++ * CFG_GetHostResources ++ * CFG_GetObject ++ * CFG_Init ++ * CFG_SetDevObject ++ * CFG_SetObject ++ * ++ * ++ *! Revision History: ++ *! ================ ++ *! 26-Arp-2004 hp Support for handling more than one Device. ++ *! 26-Feb-2003 kc Removed unused CFG fxns. ++ *! 10-Nov-2000 rr: CFG_GetBoardName local var initialized. ++ *! 30-Oct-2000 kc: Changed local var. names to use Hungarian notation. ++ *! 10-Aug-2000 rr: Cosmetic changes. ++ *! 26-Jul-2000 rr: Added CFG_GetDCDName. CFG_Get/SetObject(based on a flag) ++ *! replaces CFG_GetMgrObject & CFG_SetMgrObject. ++ *! 17-Jul-2000 rr: Added CFG_GetMgrObject & CFG_SetMgrObject. ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 31-Jan-2000 rr: Comments and bugfixes: modified after code review ++ *! 07-Jan-2000 rr: CFG_GetBoardName Ensure class checks strlen of the ++ *! read value from the registry against the passed in BufSize; ++ *! CFG_GetZLFile,CFG_GetWMDFileName and ++ *! CFG_GetExecFile also modified same way. ++ *! 06-Jan-2000 rr: CFG_GetSearchPath & CFG_GetWinBRIDGEDir removed. ++ *! 09-Dec-1999 rr: CFG_SetDevObject stores the DevNodeString pointer. ++ *! 03-Dec-1999 rr: CFG_GetDevObject reads stored DevObject from Registry. ++ *! CFG_GetDevNode reads the Devnodestring from the registry. ++ *! CFG_SetDevObject stores the registry path as ++ *! DevNodestring in the registry. ++ *! 02-Dec-1999 rr: CFG_debugMask is declared static now. stdwin.h included ++ *! 22-Nov-1999 kc: Added windows.h to remove warnings. ++ *! 25-Oct-1999 rr: CFG_GetHostResources reads the HostResource structure ++ *! from the registry which was set by the DRV Request ++ *! Resources. ++ *! 15-Oct-1999 rr: Changes in CFG_SetPrivateDword & HostResources reflecting ++ *! changes for drv.h resource structure and wsxreg.h new ++ *! entry(DevObject) Hard coded entries removed for those items ++ *! 08-Oct-1999 rr: CFG_SetPrivateDword modified. it sets devobject into the ++ *! registry. CFG_Get HostResources modified for opening up ++ *! two mem winodws. ++ *! 24-Sep-1999 rr: CFG_GetHostResources uses hardcoded Registry calls,uses NT ++ *! type of Resource Structure. ++ *! 19-Jul-1999 a0216266: Stubbed from cfgnt.c. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/reg.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/list.h> ++ ++struct DRV_EXT { ++ struct LST_ELEM link; ++ char szString[MAXREGPATHLENGTH]; ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask CFG_debugMask = { NULL, NULL }; /* CFG debug Mask */ ++#endif ++ ++/* ++ * ======== CFG_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CFG module. ++ */ ++void CFG_Exit(void) ++{ ++ GT_0trace(CFG_debugMask, GT_5CLASS, "Entered CFG_Exit\n"); ++} ++ ++/* ++ * ======== CFG_GetAutoStart ======== ++ * Purpose: ++ * Retreive the autostart mask, if any, for this board. ++ */ ++DSP_STATUS CFG_GetAutoStart(struct CFG_DEVNODE *hDevNode, ++ OUT u32 *pdwAutoStart) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 dwBufSize; ++ GT_2trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_GetAutoStart: \n\thDevNode:" ++ "0x%x\n\tpdwAutoStart: 0x%x\n", hDevNode, pdwAutoStart); ++ dwBufSize = sizeof(*pdwAutoStart); ++ if (!hDevNode) ++ status = CFG_E_INVALIDHDEVNODE; ++ if (!pdwAutoStart) ++ status = CFG_E_INVALIDPOINTER; ++ if (DSP_SUCCEEDED(status)) { ++ status = REG_GetValue(NULL, (char *)hDevNode, AUTOSTART, ++ (u8 *)pdwAutoStart, &dwBufSize); ++ if (DSP_FAILED(status)) ++ status = CFG_E_RESOURCENOTAVAIL; ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetAutoStart SUCCESS \n"); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_GetAutoStart Failed \n"); ++ } ++#endif ++ DBC_Ensure((status == DSP_SOK && ++ (*pdwAutoStart == 0 || *pdwAutoStart == 1)) ++ || status != DSP_SOK); ++ return status; ++} ++ ++/* ++ * ======== CFG_GetDevObject ======== ++ * Purpose: ++ * Retrieve the Device Object handle for a given devnode. ++ */ ++DSP_STATUS CFG_GetDevObject(struct CFG_DEVNODE *hDevNode, OUT u32 *pdwValue) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 dwBufSize; ++ GT_2trace(CFG_debugMask, GT_ENTER, "Entered CFG_GetDevObject, args: " ++ "\n\thDevNode: 0x%x\n\tpdwValue: 0x%x\n", hDevNode, ++ *pdwValue); ++ if (!hDevNode) ++ status = CFG_E_INVALIDHDEVNODE; ++ ++ if (!pdwValue) ++ status = CFG_E_INVALIDHDEVNODE; ++ ++ dwBufSize = sizeof(pdwValue); ++ if (DSP_SUCCEEDED(status)) { ++ ++ /* check the device string and then call the REG_SetValue*/ ++ if (!(strcmp((char *)((struct DRV_EXT *)hDevNode)->szString, ++ "TIOMAP1510"))) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "Fetching DSP Device from " ++ "Registry \n"); ++ status = REG_GetValue(NULL, (char *)hDevNode, ++ "DEVICE_DSP", ++ (u8 *)pdwValue, &dwBufSize); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "Failed to Identify the Device to Fetch \n"); ++ } ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ GT_1trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetDevObject SUCCESS DevObject" ++ ": 0x%x\n ", *pdwValue); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_GetDevObject Failed \n"); ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== CFG_GetDSPResources ======== ++ * Purpose: ++ * Get the DSP resources available to a given device. ++ */ ++DSP_STATUS CFG_GetDSPResources(struct CFG_DEVNODE *hDevNode, ++ OUT struct CFG_DSPRES *pDSPResTable) ++{ ++ DSP_STATUS status = DSP_SOK; /* return value */ ++ u32 dwResSize; ++ GT_2trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_GetDSPResources, args: " ++ "\n\thDevNode: 0x%x\n\tpDSPResTable: 0x%x\n", ++ hDevNode, pDSPResTable); ++ if (!hDevNode) { ++ status = CFG_E_INVALIDHDEVNODE; ++ } else if (!pDSPResTable) { ++ status = CFG_E_INVALIDPOINTER; ++ } else { ++ status = REG_GetValue(NULL, CONFIG, DSPRESOURCES, ++ (u8 *)pDSPResTable, ++ &dwResSize); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetDSPResources SUCCESS\n"); ++ } else { ++ status = CFG_E_RESOURCENOTAVAIL; ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_GetDSPResources Failed \n"); ++ } ++#ifdef DEBUG ++ /* assert that resource values are reasonable */ ++ DBC_Assert(pDSPResTable->uChipType < 256); ++ DBC_Assert(pDSPResTable->uWordSize > 0); ++ DBC_Assert(pDSPResTable->uWordSize < 32); ++ DBC_Assert(pDSPResTable->cChips > 0); ++ DBC_Assert(pDSPResTable->cChips < 256); ++#endif ++ return status; ++} ++ ++/* ++ * ======== CFG_GetExecFile ======== ++ * Purpose: ++ * Retreive the default executable, if any, for this board. ++ */ ++DSP_STATUS CFG_GetExecFile(struct CFG_DEVNODE *hDevNode, u32 ulBufSize, ++ OUT char *pstrExecFile) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 cExecSize = ulBufSize; ++ GT_3trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_GetExecFile:\n\tthDevNode: " ++ "0x%x\n\tulBufSize: 0x%x\n\tpstrExecFile: 0x%x\n", hDevNode, ++ ulBufSize, pstrExecFile); ++ if (!hDevNode) ++ status = CFG_E_INVALIDHDEVNODE; ++ ++ if (!pstrExecFile) ++ status = CFG_E_INVALIDPOINTER; ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = REG_GetValue(NULL, (char *)hDevNode, DEFEXEC, ++ (u8 *)pstrExecFile, &cExecSize); ++ if (DSP_FAILED(status)) ++ status = CFG_E_RESOURCENOTAVAIL; ++ else if (cExecSize > ulBufSize) ++ status = DSP_ESIZE; ++ ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ GT_1trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetExecFile SUCCESS Exec File" ++ "name : %s\n ", pstrExecFile); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_GetExecFile Failed \n"); ++ } ++#endif ++ DBC_Ensure(((status == DSP_SOK) && ++ (strlen(pstrExecFile) <= ulBufSize)) || (status != DSP_SOK)); ++ return status; ++} ++ ++/* ++ * ======== CFG_GetHostResources ======== ++ * Purpose: ++ * Get the Host allocated resources assigned to a given device. ++ */ ++DSP_STATUS CFG_GetHostResources(struct CFG_DEVNODE *hDevNode, ++ OUT struct CFG_HOSTRES *pHostResTable) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 dwBufSize; ++ GT_2trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_GetHostResources, args:\n\t" ++ "pHostResTable: 0x%x\n\thDevNode: 0x%x\n", ++ pHostResTable, hDevNode); ++ if (!hDevNode) ++ status = CFG_E_INVALIDHDEVNODE; ++ ++ if (!pHostResTable) ++ status = CFG_E_INVALIDPOINTER; ++ ++ if (DSP_SUCCEEDED(status)) { ++ dwBufSize = sizeof(struct CFG_HOSTRES); ++ if (DSP_FAILED(REG_GetValue(NULL, (char *)hDevNode, ++ CURRENTCONFIG, ++ (u8 *)pHostResTable, &dwBufSize))) { ++ status = CFG_E_RESOURCENOTAVAIL; ++ } ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetHostResources SUCCESS \n"); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_GetHostResources Failed \n"); ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== CFG_GetObject ======== ++ * Purpose: ++ * Retrieve the Object handle from the Registry ++ */ ++DSP_STATUS CFG_GetObject(OUT u32 *pdwValue, u32 dwType) ++{ ++ DSP_STATUS status = DSP_EINVALIDARG; ++ u32 dwBufSize; ++ DBC_Require(pdwValue != NULL); ++ GT_1trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_GetObject, args:pdwValue: " ++ "0x%x\n", *pdwValue); ++ dwBufSize = sizeof(pdwValue); ++ switch (dwType) { ++ case (REG_DRV_OBJECT): ++ status = REG_GetValue(NULL, CONFIG, DRVOBJECT, ++ (u8 *)pdwValue, ++ &dwBufSize); ++ break; ++ case (REG_MGR_OBJECT): ++ status = REG_GetValue(NULL, CONFIG, MGROBJECT, ++ (u8 *)pdwValue, ++ &dwBufSize); ++ break; ++ default: ++ break; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ GT_1trace(CFG_debugMask, GT_1CLASS, ++ "CFG_GetObject SUCCESS DrvObject: " ++ "0x%x\n ", *pdwValue); ++ } else { ++ status = CFG_E_RESOURCENOTAVAIL; ++ *pdwValue = 0; ++ GT_0trace(CFG_debugMask, GT_6CLASS, "CFG_GetObject Failed \n"); ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && *pdwValue != 0) || ++ (DSP_FAILED(status) && *pdwValue == 0)); ++ return status; ++} ++ ++/* ++ * ======== CFG_Init ======== ++ * Purpose: ++ * Initialize the CFG module's private state. ++ */ ++bool CFG_Init(void) ++{ ++ struct CFG_DSPRES dspResources; ++ GT_create(&CFG_debugMask, "CF"); /* CF for ConFig */ ++ GT_0trace(CFG_debugMask, GT_5CLASS, "Entered CFG_Init\n"); ++ GT_0trace(CFG_debugMask, GT_5CLASS, "Intializing DSP Registry Info \n"); ++ ++ dspResources.uChipType = DSPTYPE_64; ++ dspResources.cChips = 1; ++ dspResources.uWordSize = DSPWORDSIZE; ++ dspResources.cMemTypes = 0; ++ dspResources.aMemDesc[0].uMemType = 0; ++ dspResources.aMemDesc[0].ulMin = 0; ++ dspResources.aMemDesc[0].ulMax = 0; ++ if (DSP_SUCCEEDED(REG_SetValue(NULL, CONFIG, DSPRESOURCES, REG_BINARY, ++ (u8 *)&dspResources, sizeof(struct CFG_DSPRES)))) { ++ GT_0trace(CFG_debugMask, GT_5CLASS, ++ "Initialized DSP resources in " ++ "Registry \n"); ++ } else ++ GT_0trace(CFG_debugMask, GT_5CLASS, ++ "Failed to Initialize DSP resources" ++ " in Registry \n"); ++ return true; ++} ++ ++/* ++ * ======== CFG_SetDevObject ======== ++ * Purpose: ++ * Store the Device Object handle and devNode pointer for a given devnode. ++ */ ++DSP_STATUS CFG_SetDevObject(struct CFG_DEVNODE *hDevNode, u32 dwValue) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 dwBuffSize; ++ GT_2trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_SetDevObject, args: \n\t" ++ "hDevNode: 0x%x\n\tdwValue: 0x%x\n", hDevNode, dwValue); ++ if (!hDevNode) ++ status = CFG_E_INVALIDHDEVNODE; ++ ++ dwBuffSize = sizeof(dwValue); ++ if (DSP_SUCCEEDED(status)) { ++ /* Store the WCD device object in the Registry */ ++ ++ if (!(strcmp((char *)hDevNode, "TIOMAP1510"))) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "Registering the DSP Device \n"); ++ status = REG_SetValue(NULL, (char *)hDevNode, ++ "DEVICE_DSP", REG_DWORD,\ ++ (u8 *)&dwValue, dwBuffSize); ++ if (DSP_SUCCEEDED(status)) { ++ dwBuffSize = sizeof(hDevNode); ++ status = REG_SetValue(NULL, ++ (char *)hDevNode, "DEVNODESTRING_DSP", ++ REG_DWORD, (u8 *)&hDevNode, ++ dwBuffSize); ++ } ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "Failed to Register Device \n"); ++ } ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) { ++ GT_0trace(CFG_debugMask, GT_1CLASS, ++ "CFG_SetDevObject SUCCESS \n"); ++ } else { ++ GT_0trace(CFG_debugMask, GT_6CLASS, ++ "CFG_SetDevObject Failed \n"); ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== CFG_SetObject ======== ++ * Purpose: ++ * Store the Driver Object handle ++ */ ++DSP_STATUS CFG_SetObject(u32 dwValue, u32 dwType) ++{ ++ DSP_STATUS status = DSP_EINVALIDARG; ++ u32 dwBuffSize; ++ GT_1trace(CFG_debugMask, GT_ENTER, ++ "Entered CFG_SetObject, args: dwValue: " ++ "0x%x\n", dwValue); ++ dwBuffSize = sizeof(dwValue); ++ switch (dwType) { ++ case (REG_DRV_OBJECT): ++ status = REG_SetValue(NULL, CONFIG, DRVOBJECT, REG_DWORD, ++ (u8 *)&dwValue, dwBuffSize); ++ break; ++ case (REG_MGR_OBJECT): ++ status = REG_SetValue(NULL, CONFIG, MGROBJECT, REG_DWORD, ++ (u8 *) &dwValue, dwBuffSize); ++ break; ++ default: ++ break; ++ } ++#ifdef DEBUG ++ if (DSP_SUCCEEDED(status)) ++ GT_0trace(CFG_debugMask, GT_1CLASS, "CFG_SetObject SUCCESS \n"); ++ else ++ GT_0trace(CFG_debugMask, GT_6CLASS, "CFG_SetObject Failed \n"); ++ ++#endif ++ return status; ++} +diff --git a/drivers/dsp/bridge/services/clk.c b/drivers/dsp/bridge/services/clk.c +new file mode 100644 +index 0000000..b499b14 +--- /dev/null ++++ b/drivers/dsp/bridge/services/clk.c +@@ -0,0 +1,375 @@ ++/* ++ * clk.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== clk.c ======== ++ * Purpose: ++ * Clock and Timer services. ++ * ++ * Public Functions: ++ * CLK_Exit ++ * CLK_Init ++ * CLK_Enable ++ * CLK_Disable ++ * CLK_GetRate ++ * CLK_Set_32KHz ++ *! Revision History: ++ *! ================ ++ *! 08-May-2007 rg: moved all clock functions from sync module. ++ * And added CLK_Set_32KHz, CLK_Set_SysClk. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/clk.h> ++#include <dspbridge/util.h> ++ ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++ ++typedef volatile unsigned long REG_UWORD32; ++ ++#define SSI_Base 0x48058000 ++ ++#define SSI_BASE IO_ADDRESS(SSI_Base) ++ ++ ++struct SERVICES_Clk_t { ++ struct clk *clk_handle; ++ const char *clk_name; ++ int id; ++}; ++ ++/* The row order of the below array needs to match with the clock enumerations ++ * 'SERVICES_ClkId' provided in the header file.. any changes in the ++ * enumerations needs to be fixed in the array as well */ ++static struct SERVICES_Clk_t SERVICES_Clks[] = { ++ {NULL, "iva2_ck", -1}, ++ {NULL, "mailboxes_ick", -1}, ++ {NULL, "gpt5_fck", -1}, ++ {NULL, "gpt5_ick", -1}, ++ {NULL, "gpt6_fck", -1}, ++ {NULL, "gpt6_ick", -1}, ++ {NULL, "gpt7_fck", -1}, ++ {NULL, "gpt7_ick", -1}, ++ {NULL, "gpt8_fck", -1}, ++ {NULL, "gpt8_ick", -1}, ++ {NULL, "wdt_fck", 3}, ++ {NULL, "wdt_ick", 3}, ++ {NULL, "mcbsp_fck", 1}, ++ {NULL, "mcbsp_ick", 1}, ++ {NULL, "mcbsp_fck", 2}, ++ {NULL, "mcbsp_ick", 2}, ++ {NULL, "mcbsp_fck", 3}, ++ {NULL, "mcbsp_ick", 3}, ++ {NULL, "mcbsp_fck", 4}, ++ {NULL, "mcbsp_ick", 4}, ++ {NULL, "mcbsp_fck", 5}, ++ {NULL, "mcbsp_ick", 5}, ++ {NULL, "ssi_ssr_sst_fck", -1}, ++ {NULL, "ssi_ick", -1}, ++ {NULL, "omap_32k_fck", -1}, ++ {NULL, "sys_ck", -1}, ++ {NULL, ""} ++}; ++ ++/* Generic TIMER object: */ ++struct TIMER_OBJECT { ++ struct timer_list timer; ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask CLK_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++/* ++ * ======== CLK_Exit ======== ++ * Purpose: ++ * Cleanup CLK module. ++ */ ++void CLK_Exit(void) ++{ ++ int i = 0; ++ ++ GT_0trace(CLK_debugMask, GT_5CLASS, "CLK_Exit\n"); ++ /* Relinquish the clock handles */ ++ while (i < SERVICESCLK_NOT_DEFINED) { ++ if (SERVICES_Clks[i].clk_handle) ++ clk_put(SERVICES_Clks[i].clk_handle); ++ ++ SERVICES_Clks[i].clk_handle = NULL; ++ i++; ++ } ++ ++} ++ ++/* ++ * ======== CLK_Init ======== ++ * Purpose: ++ * Initialize CLK module. ++ */ ++bool CLK_Init(void) ++{ ++ static struct platform_device dspbridge_device; ++ struct clk *clk_handle; ++ int i = 0; ++ GT_create(&CLK_debugMask, "CK"); /* CK for CLK */ ++ GT_0trace(CLK_debugMask, GT_5CLASS, "CLK_Init\n"); ++ ++ dspbridge_device.dev.bus = &platform_bus_type; ++ ++ /* Get the clock handles from base port and store locally */ ++ while (i < SERVICESCLK_NOT_DEFINED) { ++ /* get the handle from BP */ ++ dspbridge_device.id = SERVICES_Clks[i].id; ++ ++ clk_handle = clk_get(&dspbridge_device.dev, ++ SERVICES_Clks[i].clk_name); ++ ++ if (!clk_handle) { ++ GT_2trace(CLK_debugMask, GT_7CLASS, ++ "CLK_Init: failed to get Clk handle %s, " ++ "CLK dev id = %d\n", ++ SERVICES_Clks[i].clk_name, ++ SERVICES_Clks[i].id); ++ /* should we fail here?? */ ++ } else { ++ GT_2trace(CLK_debugMask, GT_7CLASS, ++ "CLK_Init: PASS and Clk handle %s, " ++ "CLK dev id = %d\n", ++ SERVICES_Clks[i].clk_name, ++ SERVICES_Clks[i].id); ++ } ++ SERVICES_Clks[i].clk_handle = clk_handle; ++ i++; ++ } ++ ++ return true; ++} ++ ++/* ++ * ======== CLK_Enable ======== ++ * Purpose: ++ * Enable Clock . ++ * ++*/ ++DSP_STATUS CLK_Enable(IN enum SERVICES_ClkId clk_id) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct clk *pClk; ++ ++ DBC_Require(clk_id < SERVICESCLK_NOT_DEFINED); ++ GT_2trace(CLK_debugMask, GT_6CLASS, "CLK_Enable: CLK %s, " ++ "CLK dev id = %d\n", SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ ++ pClk = SERVICES_Clks[clk_id].clk_handle; ++ if (pClk) { ++ if (clk_enable(pClk) == 0x0) { ++ /* Success ? */ ++ } else { ++ pr_err("CLK_Enable: failed to Enable CLK %s, " ++ "CLK dev id = %d\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ } else { ++ pr_err("CLK_Enable: failed to get CLK %s, CLK dev id = %d\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ /* The SSI module need to configured not to have the Forced idle for ++ * master interface. If it is set to forced idle, the SSI module is ++ * transitioning to standby thereby causing the client in the DSP hang ++ * waiting for the SSI module to be active after enabling the clocks ++ */ ++ if (clk_id == SERVICESCLK_ssi_fck) ++ SSI_Clk_Prepare(true); ++ ++ return status; ++} ++/* ++ * ======== CLK_Set_32KHz ======== ++ * Purpose: ++ * To Set parent of a clock to 32KHz. ++ */ ++ ++DSP_STATUS CLK_Set_32KHz(IN enum SERVICES_ClkId clk_id) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct clk *pClk; ++ struct clk *pClkParent; ++ enum SERVICES_ClkId sys_32k_id = SERVICESCLK_sys_32k_ck; ++ pClkParent = SERVICES_Clks[sys_32k_id].clk_handle; ++ ++ DBC_Require(clk_id < SERVICESCLK_NOT_DEFINED); ++ GT_2trace(CLK_debugMask, GT_6CLASS, "CLK_Set_32KHz: CLK %s, " ++ "CLK dev id = %d is setting to 32KHz \n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ pClk = SERVICES_Clks[clk_id].clk_handle; ++ if (pClk) { ++ if (!(clk_set_parent(pClk, pClkParent) == 0x0)) { ++ GT_2trace(CLK_debugMask, GT_7CLASS, "CLK_Set_32KHz: " ++ "Failed to set to 32KHz %s, CLK dev id = %d\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== CLK_Disable ======== ++ * Purpose: ++ * Disable the clock. ++ * ++*/ ++DSP_STATUS CLK_Disable(IN enum SERVICES_ClkId clk_id) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct clk *pClk; ++ s32 clkUseCnt; ++ ++ DBC_Require(clk_id < SERVICESCLK_NOT_DEFINED); ++ GT_2trace(CLK_debugMask, GT_6CLASS, "CLK_Disable: CLK %s, " ++ "CLK dev id = %d\n", SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ ++ pClk = SERVICES_Clks[clk_id].clk_handle; ++ ++ clkUseCnt = CLK_Get_UseCnt(clk_id); ++ if (clkUseCnt == -1) { ++ pr_err("CLK_Disable: failed to get CLK Use count for CLK %s," ++ "CLK dev id = %d\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ } else if (clkUseCnt == 0) { ++ pr_err("CLK_Disable: CLK %s, CLK dev id= %d is already" ++ "disabled\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ return status; ++ } ++ if (clk_id == SERVICESCLK_ssi_ick) ++ SSI_Clk_Prepare(false); ++ ++ if (pClk) { ++ clk_disable(pClk); ++ } else { ++ pr_err("CLK_Disable: failed to get CLK %s," ++ "CLK dev id = %d\n", ++ SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ return status; ++} ++ ++/* ++ * ======== CLK_GetRate ======== ++ * Purpose: ++ * GetClock Speed. ++ * ++ */ ++ ++DSP_STATUS CLK_GetRate(IN enum SERVICES_ClkId clk_id, u32 *speedKhz) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct clk *pClk; ++ u32 clkSpeedHz; ++ ++ DBC_Require(clk_id < SERVICESCLK_NOT_DEFINED); ++ *speedKhz = 0x0; ++ ++ GT_2trace(CLK_debugMask, GT_7CLASS, "CLK_GetRate: CLK %s, " ++ "CLK dev Id = %d \n", SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ pClk = SERVICES_Clks[clk_id].clk_handle; ++ if (pClk) { ++ clkSpeedHz = clk_get_rate(pClk); ++ *speedKhz = clkSpeedHz / 1000; ++ GT_2trace(CLK_debugMask, GT_6CLASS, ++ "CLK_GetRate: clkSpeedHz = %d , " ++ "speedinKhz=%d\n", clkSpeedHz, *speedKhz); ++ } else { ++ GT_2trace(CLK_debugMask, GT_7CLASS, ++ "CLK_GetRate: failed to get CLK %s, " ++ "CLK dev Id = %d\n", SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ return status; ++} ++ ++s32 CLK_Get_UseCnt(IN enum SERVICES_ClkId clk_id) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct clk *pClk; ++ s32 useCount = -1; ++ DBC_Require(clk_id < SERVICESCLK_NOT_DEFINED); ++ ++ pClk = SERVICES_Clks[clk_id].clk_handle; ++ ++ if (pClk) { ++ useCount = pClk->usecount; /* FIXME: usecount shouldn't be used */ ++ } else { ++ GT_2trace(CLK_debugMask, GT_7CLASS, ++ "CLK_GetRate: failed to get CLK %s, " ++ "CLK dev Id = %d\n", SERVICES_Clks[clk_id].clk_name, ++ SERVICES_Clks[clk_id].id); ++ status = DSP_EFAIL; ++ } ++ return useCount; ++} ++ ++void SSI_Clk_Prepare(bool FLAG) ++{ ++ u32 ssi_sysconfig; ++ ssi_sysconfig = __raw_readl((SSI_BASE) + 0x10); ++ ++ if (FLAG) { ++ /* Set Autoidle, SIDLEMode to smart idle, and MIDLEmode to ++ * no idle ++ */ ++ ssi_sysconfig = 0x1011; ++ } else { ++ /* Set Autoidle, SIDLEMode to forced idle, and MIDLEmode to ++ * forced idle ++ */ ++ ssi_sysconfig = 0x1; ++ } ++ __raw_writel((u32)ssi_sysconfig, SSI_BASE + 0x10); ++} +diff --git a/drivers/dsp/bridge/services/csl.c b/drivers/dsp/bridge/services/csl.c +new file mode 100644 +index 0000000..dd33c2d +--- /dev/null ++++ b/drivers/dsp/bridge/services/csl.c +@@ -0,0 +1,173 @@ ++/* ++ * csl.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== cslce.c ======== ++ * Purpose: ++ * Provides platform independent C Standard library functions. ++ * ++ * Public Functions: ++ * CSL_Atoi ++ * CSL_Exit ++ * CSL_Init ++ * CSL_NumToAscii ++ * CSL_Strtokr ++ * ++ *! Revision History: ++ *! ================ ++ *! 07-Aug-2002 jeh: Added CSL_Strtokr(). ++ *! 21-Sep-2001 jeh: Added CSL_Strncmp(). Alphabetized functions. ++ *! 22-Nov-2000 map: Added CSL_Atoi and CSL_Strtok ++ *! 19-Nov-2000 kc: Added CSL_ByteSwap. ++ *! 09-Nov-2000 kc: Added CSL_Strncat. ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 15-Dec-1999 ag: Removed incorrect assertion CSL_NumToAscii() ++ *! 29-Oct-1999 kc: Added CSL_Wstrlen for UNICODE strings. ++ *! 30-Sep-1999 ag: Removed DBC assertion (!CSL_DebugMask.flags) in ++ * CSP_Init(). ++ *! 20-Sep-1999 ag: Added CSL_WcharToAnsi(). ++ *! Removed call to GT_set(). ++ *! 19-Jan-1998 cr: Code review cleanup. ++ *! 29-Dec-1997 cr: Made platform independant, using MS CRT code, and ++ *! combined csl32.c csl95.c and cslnt.c into csl.c. Also ++ *! changed CSL_lowercase to CSL_Uppercase. ++ *! 21-Aug-1997 gp: Fix to CSL_strcpyn to initialize Source string, the NT way. ++ *! 25-Jun-1997 cr: Created from csl95, added CSL_strcmp. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/csl.h> ++ ++/* Is character c in the string pstrDelim? */ ++#define IsDelimiter(c, pstrDelim) ((c != '\0') && \ ++ (strchr(pstrDelim, c) != NULL)) ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask CSL_DebugMask = { NULL, NULL }; /* GT trace var. */ ++#endif ++ ++/* ++ * ======== CSL_Exit ======== ++ * Purpose: ++ * Discontinue usage of the CSL module. ++ */ ++void CSL_Exit(void) ++{ ++ GT_0trace(CSL_DebugMask, GT_5CLASS, "CSL_Exit\n"); ++} ++ ++/* ++ * ======== CSL_Init ======== ++ * Purpose: ++ * Initialize the CSL module's private state. ++ */ ++bool CSL_Init(void) ++{ ++ GT_create(&CSL_DebugMask, "CS"); ++ ++ GT_0trace(CSL_DebugMask, GT_5CLASS, "CSL_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== CSL_NumToAscii ======== ++ * Purpose: ++ * Convert a 1 or 2 digit number to a 2 digit string. ++ */ ++void CSL_NumToAscii(OUT char *pstrNumber, u32 dwNum) ++{ ++ char tens; ++ ++ DBC_Require(dwNum < 100); ++ ++ if (dwNum < 100) { ++ tens = (char) dwNum / 10; ++ dwNum = dwNum % 10; ++ ++ if (tens) { ++ pstrNumber[0] = tens + '0'; ++ pstrNumber[1] = (char) dwNum + '0'; ++ pstrNumber[2] = '\0'; ++ } else { ++ pstrNumber[0] = (char) dwNum + '0'; ++ pstrNumber[1] = '\0'; ++ } ++ } else { ++ pstrNumber[0] = '\0'; ++ } ++} ++ ++ ++ ++ ++/* ++ * ======= CSL_Strtokr ======= ++ * Purpose: ++ * Re-entrant version of strtok. ++ */ ++char *CSL_Strtokr(IN char *pstrSrc, IN CONST char *szSeparators, ++ OUT char **ppstrLast) ++{ ++ char *pstrTemp; ++ char *pstrToken; ++ ++ DBC_Require(szSeparators != NULL); ++ DBC_Require(ppstrLast != NULL); ++ DBC_Require(pstrSrc != NULL || *ppstrLast != NULL); ++ ++ /* ++ * Set string location to beginning (pstrSrc != NULL) or to the ++ * beginning of the next token. ++ */ ++ pstrTemp = (pstrSrc != NULL) ? pstrSrc : *ppstrLast; ++ if (*pstrTemp == '\0') { ++ pstrToken = NULL; ++ } else { ++ pstrToken = pstrTemp; ++ while (*pstrTemp != '\0' && !IsDelimiter(*pstrTemp, ++ szSeparators)) { ++ pstrTemp++; ++ } ++ if (*pstrTemp != '\0') { ++ while (IsDelimiter(*pstrTemp, szSeparators)) { ++ /* TODO: Shouldn't we do this for ++ * only 1 char?? */ ++ *pstrTemp = '\0'; ++ pstrTemp++; ++ } ++ } ++ ++ /* Location in string for next call */ ++ *ppstrLast = pstrTemp; ++ } ++ ++ return pstrToken; ++} +diff --git a/drivers/dsp/bridge/services/dbg.c b/drivers/dsp/bridge/services/dbg.c +new file mode 100644 +index 0000000..5e1773f +--- /dev/null ++++ b/drivers/dsp/bridge/services/dbg.c +@@ -0,0 +1,119 @@ ++/* ++ * dbg.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dbgce.c ======== ++ * Purpose: ++ * Provide debugging services for DSP/BIOS Bridge Mini Drivers. ++ * ++ * Public Functions: ++ * DBG_Exit ++ * DBG_Init ++ * DBG_Trace ++ * ++ * Notes: ++ * Requires gt.h. ++ * ++ * This implementation does not create GT masks on a per WMD basis. ++ * There is currently no facility for a WMD to alter the GT mask. ++ * ++ *! Revision History: ++ *! ================ ++ *! 15-Feb-2000 rr: DBG_Trace prints based on the DebugZones. ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 29-Oct-1999 kc: Cleaned up for code review. ++ *! 10-Oct-1997 cr: Added DBG_Printf service. ++ *! 28-May-1997 cr: Added reference counting. ++ *! 23-May-1997 cr: Updated DBG_Trace to new gt interface. ++ *! 29-May-1996 gp: Removed WCD_ prefix. ++ *! 20-May-1996 gp: Remove DEBUG conditional compilation. ++ *! 15-May-1996 gp: Created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask DBG_debugMask = { NULL, NULL }; /* GT trace var. */ ++#endif ++ ++#if (defined(DEBUG) || defined (DDSP_DEBUG_PRODUCT)) && GT_TRACE ++ ++/* ++ * ======== DBG_Init ======== ++ * Purpose: ++ * Ensures trace capability is set up for link drivers. ++ */ ++bool DBG_Init(void) ++{ ++ GT_create(&DBG_debugMask, "WD"); /* for WmD (link driver) debug */ ++ ++ GT_0trace(DBG_debugMask, GT_5CLASS, "DBG_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== DBG_Trace ======== ++ * Purpose: ++ * Output a trace message to the debugger, if the given trace level ++ * is unmasked. ++ */ ++DSP_STATUS DBG_Trace(u8 bLevel, char *pstrFormat, ...) ++{ ++ s32 arg1, arg2, arg3, arg4, arg5, arg6; ++ va_list va; ++ ++ va_start(va, pstrFormat); ++ ++ arg1 = va_arg(va, s32); ++ arg2 = va_arg(va, s32); ++ arg3 = va_arg(va, s32); ++ arg4 = va_arg(va, s32); ++ arg5 = va_arg(va, s32); ++ arg6 = va_arg(va, s32); ++ ++ va_end(va); ++ ++ if (bLevel & *(DBG_debugMask).flags) ++ printk(pstrFormat, arg1, arg2, arg3, arg4, arg5, arg6); ++ ++ return DSP_SOK; ++} ++ ++/* ++ * ======== DBG_Exit ======== ++ * Purpose: ++ * Discontinue usage of the DBG module. ++ */ ++void DBG_Exit(void) ++{ ++ GT_0trace(DBG_debugMask, GT_5CLASS, "DBG_Exit\n"); ++} ++ ++#endif /* (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE */ +diff --git a/drivers/dsp/bridge/services/dpc.c b/drivers/dsp/bridge/services/dpc.c +new file mode 100644 +index 0000000..bd608d1 +--- /dev/null ++++ b/drivers/dsp/bridge/services/dpc.c +@@ -0,0 +1,274 @@ ++/* ++ * dpc.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== dpcce.c ======== ++ * Purpose: ++ * Deferred Procedure Call(DPC) Services. ++ * ++ * ++ * Public Functions: ++ * DPC_Create ++ * DPC_Destroy ++ * DPC_Exit ++ * DPC_Init ++ * DPC_Schedule ++ * ++ *! Revision History: ++ *! ================ ++ *! 28-Mar-2001 ag: Added #ifdef CHNL_NOIPCINTR to set DPC thread priority ++ *! to THREAD_PRIORITY_IDLE for polling IPC. ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 31-Jan-2000 rr: Changes after code review.Terminate thread,handle ++ *! modified.DPC_Destroy frees the DPC_Object only on ++ *! Successful termination of the thread and the handle. ++ *! 06-Jan-1999 ag: Format cleanup for code review. ++ *! Removed DPC_[Lower|Raise]IRQL[From|To]DispatchLevel. ++ *! 10-Dec-1999 ag: Added SetProcPermissions in DPC_DeferredProcedure(). ++ *! (Needed to access client(s) CHNL buffers). ++ *! 19-Sep-1999 a0216266: Stubbed from dpcnt.c. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/dpc.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define SIGNATURE 0x5f435044 /* "DPC_" (in reverse). */ ++ ++/* The DPC object, passed to our priority event callback routine: */ ++struct DPC_OBJECT { ++ u32 dwSignature; /* Used for object validation. */ ++ void *pRefData; /* Argument for client's DPC. */ ++ DPC_PROC pfnDPC; /* Client's DPC. */ ++ u32 numRequested; /* Number of requested DPC's. */ ++ u32 numScheduled; /* Number of executed DPC's. */ ++ struct tasklet_struct dpc_tasklet; ++ ++#ifdef DEBUG ++ u32 cEntryCount; /* Number of times DPC reentered. */ ++ u32 numRequestedMax; /* Keep track of max pending DPC's. */ ++#endif ++ ++ spinlock_t dpc_lock; ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask DPC_DebugMask = { NULL, NULL }; /* DPC Debug Mask */ ++#endif ++ ++/* ----------------------------------- Function Prototypes */ ++static void DPC_DeferredProcedure(IN unsigned long pDeferredContext); ++ ++/* ++ * ======== DPC_Create ======== ++ * Purpose: ++ * Create a DPC object, allowing a client's own DPC procedure to be ++ * scheduled for a call with client reference data. ++ */ ++DSP_STATUS DPC_Create(OUT struct DPC_OBJECT **phDPC, DPC_PROC pfnDPC, ++ void *pRefData) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DPC_OBJECT *pDPCObject = NULL; ++ ++ if ((phDPC != NULL) && (pfnDPC != NULL)) { ++ /* ++ * Allocate a DPC object to store information allowing our DPC ++ * callback to dispatch to the client's DPC. ++ */ ++ MEM_AllocObject(pDPCObject, struct DPC_OBJECT, SIGNATURE); ++ if (pDPCObject != NULL) { ++ tasklet_init(&pDPCObject->dpc_tasklet, ++ DPC_DeferredProcedure, ++ (u32) pDPCObject); ++ /* Fill out our DPC Object: */ ++ pDPCObject->pRefData = pRefData; ++ pDPCObject->pfnDPC = pfnDPC; ++ pDPCObject->numRequested = 0; ++ pDPCObject->numScheduled = 0; ++#ifdef DEBUG ++ pDPCObject->numRequestedMax = 0; ++ pDPCObject->cEntryCount = 0; ++#endif ++ spin_lock_init(&pDPCObject->dpc_lock); ++ *phDPC = pDPCObject; ++ } else { ++ GT_0trace(DPC_DebugMask, GT_6CLASS, ++ "DPC_Create: DSP_EMEMORY\n"); ++ status = DSP_EMEMORY; ++ } ++ } else { ++ GT_0trace(DPC_DebugMask, GT_6CLASS, ++ "DPC_Create: DSP_EPOINTER\n"); ++ status = DSP_EPOINTER; ++ } ++ DBC_Ensure((DSP_FAILED(status) && (!phDPC || (phDPC && *phDPC == NULL))) ++ || DSP_SUCCEEDED(status)); ++ return status; ++} ++ ++/* ++ * ======== DPC_Destroy ======== ++ * Purpose: ++ * Cancel the last scheduled DPC, and deallocate a DPC object previously ++ * allocated with DPC_Create(). Frees the Object only if the thread ++ * and the event terminated successfuly. ++ */ ++DSP_STATUS DPC_Destroy(struct DPC_OBJECT *hDPC) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DPC_OBJECT *pDPCObject = (struct DPC_OBJECT *)hDPC; ++ ++ if (MEM_IsValidHandle(hDPC, SIGNATURE)) { ++ ++ /* Free our DPC object: */ ++ if (DSP_SUCCEEDED(status)) { ++ tasklet_kill(&pDPCObject->dpc_tasklet); ++ MEM_FreeObject(pDPCObject); ++ pDPCObject = NULL; ++ GT_0trace(DPC_DebugMask, GT_2CLASS, ++ "DPC_Destroy: SUCCESS\n"); ++ } ++ } else { ++ GT_0trace(DPC_DebugMask, GT_6CLASS, ++ "DPC_Destroy: DSP_EHANDLE\n"); ++ status = DSP_EHANDLE; ++ } ++ DBC_Ensure((DSP_SUCCEEDED(status) && pDPCObject == NULL) ++ || DSP_FAILED(status)); ++ return status; ++} ++ ++/* ++ * ======== DPC_Exit ======== ++ * Purpose: ++ * Discontinue usage of the DPC module. ++ */ ++void DPC_Exit(void) ++{ ++ GT_0trace(DPC_DebugMask, GT_5CLASS, "Entered DPC_Exit\n"); ++} ++ ++/* ++ * ======== DPC_Init ======== ++ * Purpose: ++ * Initialize the DPC module's private state. ++ */ ++bool DPC_Init(void) ++{ ++ GT_create(&DPC_DebugMask, "DP"); ++ ++ GT_0trace(DPC_DebugMask, GT_5CLASS, "Entered DPC_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== DPC_Schedule ======== ++ * Purpose: ++ * Schedule a deferred procedure call to be executed at a later time. ++ * Latency and order of DPC execution is platform specific. ++ */ ++DSP_STATUS DPC_Schedule(struct DPC_OBJECT *hDPC) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DPC_OBJECT *pDPCObject = (struct DPC_OBJECT *)hDPC; ++ unsigned long flags; ++ ++ GT_1trace(DPC_DebugMask, GT_ENTER, "DPC_Schedule hDPC %x\n", hDPC); ++ if (MEM_IsValidHandle(hDPC, SIGNATURE)) { ++ /* Increment count of DPC's pending. Needs to be protected ++ * from ISRs since this function is called from process ++ * context also. */ ++ spin_lock_irqsave(&hDPC->dpc_lock, flags); ++ pDPCObject->numRequested++; ++ spin_unlock_irqrestore(&hDPC->dpc_lock, flags); ++ tasklet_schedule(&(hDPC->dpc_tasklet)); ++#ifdef DEBUG ++ if (pDPCObject->numRequested > pDPCObject->numScheduled + ++ pDPCObject->numRequestedMax) { ++ pDPCObject->numRequestedMax = pDPCObject->numRequested - ++ pDPCObject->numScheduled; ++ } ++#endif ++ /* If an interrupt occurs between incrementing numRequested and the ++ * assertion below, then DPC will get executed while returning from ++ * ISR, which will complete all requests and make numRequested equal ++ * to numScheduled, firing this assertion. This happens only when ++ * DPC is being scheduled in process context */ ++ } else { ++ GT_0trace(DPC_DebugMask, GT_6CLASS, ++ "DPC_Schedule: DSP_EHANDLE\n"); ++ status = DSP_EHANDLE; ++ } ++ GT_1trace(DPC_DebugMask, GT_ENTER, "DPC_Schedule status %x\n", status); ++ return status; ++} ++ ++/* ++ * ======== DeferredProcedure ======== ++ * Purpose: ++ * Main DPC routine. This is called by host OS DPC callback ++ * mechanism with interrupts enabled. ++ */ ++static void DPC_DeferredProcedure(IN unsigned long pDeferredContext) ++{ ++ struct DPC_OBJECT *pDPCObject = (struct DPC_OBJECT *)pDeferredContext; ++ /* read numRequested in local variable */ ++ u32 requested; ++ u32 serviced; ++ ++ DBC_Require(pDPCObject != NULL); ++ requested = pDPCObject->numRequested; ++ serviced = pDPCObject->numScheduled; ++ ++ GT_1trace(DPC_DebugMask, GT_ENTER, "> DPC_DeferredProcedure " ++ "pDeferredContext=%x\n", pDeferredContext); ++ /* Rollover taken care of using != instead of < */ ++ if (serviced != requested) { ++ if (pDPCObject->pfnDPC != NULL) { ++ /* Process pending DPC's: */ ++ do { ++ /* Call client's DPC: */ ++ (*(pDPCObject->pfnDPC))(pDPCObject->pRefData); ++ serviced++; ++ } while (serviced != requested); ++ } ++ pDPCObject->numScheduled = requested; ++ } ++ GT_2trace(DPC_DebugMask, GT_ENTER, ++ "< DPC_DeferredProcedure requested %d" ++ " serviced %d\n", requested, serviced); ++} ++ +diff --git a/drivers/dsp/bridge/services/kfile.c b/drivers/dsp/bridge/services/kfile.c +new file mode 100644 +index 0000000..ba1d26f +--- /dev/null ++++ b/drivers/dsp/bridge/services/kfile.c +@@ -0,0 +1,338 @@ ++/* ++ * kfile.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== kfilece.c ======== ++ * Purpose: ++ * This module provides file i/o services. ++ * ++ * Public Functions: ++ * KFILE_Close ++ * KFILE_Exit ++ * KFILE_Init ++ * KFILE_Open ++ * KFILE_Read ++ * KFILE_Seek ++ * KFILE_Tell ++ * ++ *! Revision History ++ *! ================ ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 22-Nov-1999 kc: Added changes from code review. ++ *! 12-Nov-1999 kc: Enabled CSL for UNICODE/ANSI string conversions. ++ *! 30-Sep-1999 ag: Changed KFILE_Read() GT level from _ENTER to _4CLASS. ++ *! Removed GT_set(). ++ *! 25-Aug-1999 ag: Changed MEM_Calloc allocation type to MEM_PAGED. ++ *! 13-Jul-1999 a0216266(ww - TID): Stubbed from kfilent.c. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/kfile.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define SIGNATURE 0x4c49464b /* hex code of KFIL (reversed) */ ++#define MAXFILENAMELENGTH 256 ++#define GENERAL_FAILURE 0xffffffff /* SetFilePointer error */ ++ ++/* The KFILE_FileObj abstracts the true file handle from a KFILE handle. */ ++struct KFILE_FileObj { ++ u32 dwSignature; ++ __kernel_pid_t owner_pid; /* PID of process that opened this file */ ++ char *fileName ; ++ bool isOpen ; ++ u32 size ; ++ u32 curPos ; ++ long hInternal; /* internal handle of file */ ++ struct file *fileDesc; ++ ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask KFILE_debugMask = { NULL, NULL }; /* Debug mask */ ++#endif ++ ++/* ++ * ======== KFILE_Close ======== ++ * Purpose: ++ * This function closes a file's stream. ++ */ ++s32 KFILE_Close(struct KFILE_FileObj *hFile) ++{ ++ s32 cRetVal = 0; /* 0 indicates success */ ++ s32 fRetVal = 0; ++ __kernel_pid_t curr_pid; ++ ++ GT_1trace(KFILE_debugMask, GT_ENTER, "KFILE_Close: hFile 0x%x\n", ++ hFile); ++ ++ /* Check for valid handle */ ++ if (MEM_IsValidHandle(hFile, SIGNATURE)) { ++ /* Close file only if opened by the same process (id). Otherwise ++ * Linux closes all open file handles when process exits.*/ ++ /* Return PID instead of process handle */ ++ curr_pid = (__kernel_pid_t)current->pid; ++ fRetVal = filp_close(hFile->fileDesc, NULL) ; ++ if (fRetVal) { ++ cRetVal = E_KFILE_ERROR; ++ GT_1trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Close: sys_close " ++ "returned %d\n", fRetVal); ++ } ++ MEM_FreeObject(hFile); ++ } else { ++ cRetVal = E_KFILE_INVALIDHANDLE; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, "KFILE_Close: " ++ "invalid file handle\n"); ++ } ++ return cRetVal; ++} ++ ++/* ++ * ======== KFILE_Exit ======== ++ * Purpose: ++ * Decrement reference count, and free resources when reference count ++ * is 0. ++ */ ++void KFILE_Exit(void) ++{ ++ GT_0trace(KFILE_debugMask, GT_5CLASS, "KFILE_Exit\n"); ++} ++ ++/* ++ * ======== KFILE_Init ======== ++ */ ++bool KFILE_Init(void) ++{ ++ GT_create(&KFILE_debugMask, "KF"); /* "KF" for KFile */ ++ ++ GT_0trace(KFILE_debugMask, GT_5CLASS, "KFILE_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== KFILE_Open ======== ++ * Purpose: ++ * Open a file for reading ONLY ++ */ ++struct KFILE_FileObj *KFILE_Open(CONST char *pszFileName, CONST char *pszMode) ++{ ++ struct KFILE_FileObj *hFile; /* file handle */ ++ DSP_STATUS status; ++ mm_segment_t fs; ++ ++ struct file*fileDesc = NULL; ++ DBC_Require(pszMode != NULL); ++ DBC_Require(pszFileName != NULL); ++ ++ GT_2trace(KFILE_debugMask, GT_ENTER, ++ "KFILE_Open: pszFileName %s, pszMode " ++ "%s\n", pszFileName, pszMode); ++ ++ /* create a KFILE object */ ++ MEM_AllocObject(hFile, struct KFILE_FileObj, SIGNATURE); ++ ++ if (hFile) { ++ fs = get_fs(); ++ set_fs(get_ds()); ++ /* Third argument is mode (permissions). Ignored unless creating file */ ++ fileDesc = filp_open(pszFileName, O_RDONLY, 0); ++ if ((IS_ERR(fileDesc)) || (fileDesc == NULL) || ++ (fileDesc->f_op == NULL) || (fileDesc->f_op->read == NULL) ++ || (fileDesc->f_op->llseek == NULL)) { ++ status = DSP_EFILE; ++ } else { ++ hFile->fileDesc = fileDesc; ++ hFile->fileName = (char *)pszFileName; ++ hFile->isOpen = true; ++ hFile->curPos = 0; ++ hFile->size = fileDesc->f_op->llseek(fileDesc, 0, ++ SEEK_END); ++ fileDesc->f_op->llseek(fileDesc, 0, SEEK_SET); ++ /* Return PID instead of process handle */ ++ hFile->owner_pid = current->pid; ++ ++ status = DSP_SOK; ++ } ++ set_fs(fs); ++ if (DSP_FAILED(status)) { ++ /* free memory, and clear handle */ ++ MEM_FreeObject(hFile); ++ hFile = NULL; ++ } ++ } else { ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Open: MEM_AllocObject failed\n"); ++ status = DSP_EMEMORY; ++ } ++ return hFile; ++} ++ ++/* ++ * ======== KFILE_Read ======== ++ * Purpose: ++ * Reads a specified number of bytes into a buffer. ++ */ ++s32 ++KFILE_Read(void __user*pBuffer, s32 cSize, s32 cCount, ++ struct KFILE_FileObj *hFile) ++{ ++ u32 dwBytesRead = 0; ++ s32 cRetVal = 0; ++ mm_segment_t fs; ++ ++ DBC_Require(pBuffer != NULL); ++ ++ GT_4trace(KFILE_debugMask, GT_4CLASS, ++ "KFILE_Read: buffer 0x%x, cSize 0x%x," ++ "cCount 0x%x, hFile 0x%x\n", pBuffer, cSize, cCount, hFile); ++ ++ /* check for valid file handle */ ++ if (MEM_IsValidHandle(hFile, SIGNATURE)) { ++ if ((cSize > 0) && (cCount > 0) && pBuffer) { ++ /* read from file */ ++ fs = get_fs(); ++ set_fs(get_ds()); ++ dwBytesRead = hFile->fileDesc->f_op->read(hFile-> ++ fileDesc, pBuffer, cSize *cCount, ++ &(hFile->fileDesc->f_pos)); ++ set_fs(fs); ++ if (dwBytesRead) { ++ cRetVal = dwBytesRead / cSize; ++ hFile->curPos += dwBytesRead; ++ DBC_Assert((dwBytesRead / cSize) <= \ ++ (u32)cCount); ++ } else { ++ cRetVal = E_KFILE_ERROR; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Read: sys_read() failed\n"); ++ } ++ } else { ++ cRetVal = DSP_EINVALIDARG; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Read: Invalid argument(s)\n"); ++ } ++ } else { ++ cRetVal = E_KFILE_INVALIDHANDLE; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Read: invalid file handle\n"); ++ } ++ ++ return cRetVal; ++} ++ ++/* ++ * ======== KFILE_Seek ======== ++ * Purpose: ++ * Sets the file position indicator. NOTE: we don't support seeking ++ * beyond the boundaries of a file. ++ */ ++s32 KFILE_Seek(struct KFILE_FileObj *hFile, s32 lOffset, s32 cOrigin) ++{ ++ s32 cRetVal = 0; /* 0 for success */ ++ u32 dwCurPos = 0; ++ ++ struct file *fileDesc = NULL; ++ ++ GT_3trace(KFILE_debugMask, GT_ENTER, "KFILE_Seek: hFile 0x%x, " ++ "lOffset 0x%x, cOrigin 0x%x\n", ++ hFile, lOffset, cOrigin); ++ ++ /* check for valid file handle */ ++ if (MEM_IsValidHandle(hFile, SIGNATURE)) { ++ /* based on the origin flag, move the internal pointer */ ++ ++ fileDesc = hFile->fileDesc; ++ switch (cOrigin) { ++ case KFILE_SEEK_SET: ++ dwCurPos = hFile->fileDesc->f_op->llseek(hFile-> ++ fileDesc, lOffset, SEEK_SET); ++ cRetVal = ((dwCurPos >= 0) ? 0 : E_KFILE_ERROR); ++ break; ++ ++ case KFILE_SEEK_CUR: ++ dwCurPos = hFile->fileDesc->f_op->llseek(hFile-> ++ fileDesc, lOffset, SEEK_CUR); ++ cRetVal = ((dwCurPos >= 0) ? 0 : E_KFILE_ERROR); ++ break; ++ case KFILE_SEEK_END: ++ dwCurPos = hFile->fileDesc->f_op->llseek(hFile-> ++ fileDesc, lOffset, SEEK_END); ++ cRetVal = ((dwCurPos >= 0) ? 0 : E_KFILE_ERROR); ++ break; ++ default: ++ cRetVal = E_KFILE_BADORIGINFLAG; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Seek:bad origin flag\n"); ++ break; ++ } ++ } else { ++ cRetVal = E_KFILE_INVALIDHANDLE; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Seek:invalid file handle\n"); ++ } ++ return cRetVal; ++} ++ ++/* ++ * ======== KFILE_Tell ======== ++ * Purpose: ++ * Reports the current value of the position indicator. We did not ++ * consider 64 bit long file size, which implies a 4GB file limit ++ * (2 to 32 power). ++ */ ++s32 KFILE_Tell(struct KFILE_FileObj *hFile) ++{ ++ u32 dwCurPos = 0; ++ s32 lRetVal = E_KFILE_ERROR; ++ ++ GT_1trace(KFILE_debugMask, GT_ENTER, "KFILE_Tell: hFile 0x%x\n", hFile); ++ ++ if (MEM_IsValidHandle(hFile, SIGNATURE)) { ++ ++ /* Get current position. */ ++ dwCurPos = hFile->fileDesc->f_op->llseek(hFile->fileDesc, 0, ++ SEEK_CUR); ++ if (dwCurPos >= 0) ++ lRetVal = dwCurPos; ++ ++ } else { ++ lRetVal = E_KFILE_INVALIDHANDLE; ++ GT_0trace(KFILE_debugMask, GT_6CLASS, ++ "KFILE_Seek:invalid file handle\n"); ++ } ++ return lRetVal; ++} ++ +diff --git a/drivers/dsp/bridge/services/list.c b/drivers/dsp/bridge/services/list.c +new file mode 100644 +index 0000000..7fa3e76 +--- /dev/null ++++ b/drivers/dsp/bridge/services/list.c +@@ -0,0 +1,285 @@ ++/* ++ * list.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== listce.c ======== ++ * Purpose ++ * Provides standard circular list handling functions. ++ * ++ * Public Functions: ++ * LST_Create ++ * LST_Delete ++ * LST_Exit ++ * LST_First ++ * LST_GetHead ++ * LST_Init ++ * LST_InitElem ++ * LST_InsertBefore ++ * LST_Next ++ * LST_PutTail ++ * LST_RemoveElem ++ * ++ *! Revision History ++ *! ================ ++ *! 06-Mar-2002 jeh Don't set element self to NULL in LST_RemoveElem(). ++ *! 10-Aug-2000 ag: Added LST_InsertBefore(). ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 22-Nov-1999 kc: Added changes from code review. ++ *! 10-Aug-1999 kc: Based on wsx-c18. ++ *! 16-Jun-1997 gp: Removed unnecessary enabling/disabling of interrupts around ++ *! list manipulation code. ++ *! 22-Oct-1996 gp: Added LST_RemoveElem, and LST_First/LST_Next iterators. ++ *! 10-Aug-1996 gp: Acquired from SMM for WinSPOX v. 1.1; renamed identifiers. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/list.h> ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask LST_debugMask = { NULL, NULL }; /* GT trace var. */ ++#endif ++ ++/* ++ * ======== LST_Create ======== ++ * Purpose: ++ * Allocates and initializes a circular list. ++ */ ++struct LST_LIST *LST_Create(void) ++{ ++ struct LST_LIST *pList; ++ ++ GT_0trace(LST_debugMask, GT_ENTER, "LST_Create: entered\n"); ++ ++ pList = (struct LST_LIST *) MEM_Calloc(sizeof(struct LST_LIST), ++ MEM_NONPAGED); ++ if (pList != NULL) { ++ pList->head.next = &pList->head; ++ pList->head.prev = &pList->head; ++ pList->head.self = NULL; ++ } ++ ++ return pList; ++} ++ ++/* ++ * ======== LST_Delete ======== ++ * Purpose: ++ * Removes a list by freeing its control structure's memory space. ++ */ ++void LST_Delete(struct LST_LIST *pList) ++{ ++ DBC_Require(pList != NULL); ++ ++ GT_1trace(LST_debugMask, GT_ENTER, "LST_Delete: pList 0x%x\n", pList); ++ ++ MEM_Free(pList); ++} ++ ++/* ++ * ======== LST_Exit ======== ++ * Purpose: ++ * Discontinue usage of the LST module. ++ */ ++void LST_Exit(void) ++{ ++ GT_0trace(LST_debugMask, GT_5CLASS, "LST_Exit\n"); ++} ++ ++/* ++ * ======== LST_First ======== ++ * Purpose: ++ * Returns a pointer to the first element of the list, or NULL if the ++ * list is empty. ++ */ ++struct LST_ELEM *LST_First(struct LST_LIST *pList) ++{ ++ struct LST_ELEM *pElem = NULL; ++ ++ DBC_Require(pList != NULL); ++ ++ GT_1trace(LST_debugMask, GT_ENTER, "LST_First: pList 0x%x\n", pList); ++ ++ if (!LST_IsEmpty(pList)) ++ pElem = pList->head.next; ++ ++ return pElem; ++} ++ ++/* ++ * ======== LST_GetHead ======== ++ * Purpose: ++ * "Pops" the head off the list and returns a pointer to it. ++ */ ++struct LST_ELEM *LST_GetHead(struct LST_LIST *pList) ++{ ++ struct LST_ELEM *pElem; ++ ++ DBC_Require(pList != NULL); ++ ++ GT_1trace(LST_debugMask, GT_ENTER, "LST_GetHead: pList 0x%x\n", pList); ++ ++ if (LST_IsEmpty(pList)) ++ return NULL; ++ ++ /* pElem is always valid because the list cannot be empty ++ * at this point */ ++ pElem = pList->head.next; ++ pList->head.next = pElem->next; ++ pElem->next->prev = &pList->head; ++ ++ return pElem->self; ++} ++ ++/* ++ * ======== LST_Init ======== ++ * Purpose: ++ * Initialize LST module private state. ++ */ ++bool LST_Init(void) ++{ ++ GT_create(&LST_debugMask, "LS"); /* LS for LSt module */ ++ ++ GT_0trace(LST_debugMask, GT_5CLASS, "LST_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== LST_InitElem ======== ++ * Purpose: ++ * Initializes a list element to default (cleared) values ++ */ ++void LST_InitElem(struct LST_ELEM *pElem) ++{ ++ DBC_Require(pElem != NULL); ++ ++ GT_1trace(LST_debugMask, GT_ENTER, "LST_InitElem: pElem 0x%x\n", pElem); ++ ++ if (pElem) { ++ pElem->next = NULL; ++ pElem->prev = NULL; ++ pElem->self = pElem; ++ } ++} ++ ++/* ++ * ======== LST_InsertBefore ======== ++ * Purpose: ++ * Insert the element before the existing element. ++ */ ++void LST_InsertBefore(struct LST_LIST *pList, struct LST_ELEM *pElem, ++ struct LST_ELEM *pElemExisting) ++{ ++ DBC_Require(pList != NULL); ++ DBC_Require(pElem != NULL); ++ DBC_Require(pElemExisting != NULL); ++ ++ GT_3trace(LST_debugMask, GT_ENTER, "LST_InsertBefore: pList 0x%x, " ++ "pElem 0x%x pElemExisting 0x%x\n", pList, pElem, ++ pElemExisting); ++ ++ pElemExisting->prev->next = pElem; ++ pElem->prev = pElemExisting->prev; ++ pElem->next = pElemExisting; ++ pElemExisting->prev = pElem; ++} ++ ++/* ++ * ======== LST_Next ======== ++ * Purpose: ++ * Returns a pointer to the next element of the list, or NULL if the ++ * next element is the head of the list or the list is empty. ++ */ ++struct LST_ELEM *LST_Next(struct LST_LIST *pList, struct LST_ELEM *pCurElem) ++{ ++ struct LST_ELEM *pNextElem = NULL; ++ ++ DBC_Require(pList != NULL); ++ DBC_Require(pCurElem != NULL); ++ ++ GT_2trace(LST_debugMask, GT_ENTER, ++ "LST_Next: pList 0x%x, pCurElem 0x%x\n", ++ pList, pCurElem); ++ ++ if (!LST_IsEmpty(pList)) { ++ if (pCurElem->next != &pList->head) ++ pNextElem = pCurElem->next; ++ } ++ ++ return pNextElem; ++} ++ ++/* ++ * ======== LST_PutTail ======== ++ * Purpose: ++ * Adds the specified element to the tail of the list ++ */ ++void LST_PutTail(struct LST_LIST *pList, struct LST_ELEM *pElem) ++{ ++ DBC_Require(pList != NULL); ++ DBC_Require(pElem != NULL); ++ ++ GT_2trace(LST_debugMask, GT_ENTER, ++ "LST_PutTail: pList 0x%x, pElem 0x%x\n", ++ pList, pElem); ++ ++ pElem->prev = pList->head.prev; ++ pElem->next = &pList->head; ++ pList->head.prev = pElem; ++ pElem->prev->next = pElem; ++ ++ DBC_Ensure(!LST_IsEmpty(pList)); ++} ++ ++/* ++ * ======== LST_RemoveElem ======== ++ * Purpose: ++ * Removes (unlinks) the given element from the list, if the list is not ++ * empty. Does not free the list element. ++ */ ++void LST_RemoveElem(struct LST_LIST *pList, struct LST_ELEM *pCurElem) ++{ ++ DBC_Require(pList != NULL); ++ DBC_Require(pCurElem != NULL); ++ ++ GT_2trace(LST_debugMask, GT_ENTER, ++ "LST_RemoveElem: pList 0x%x, pCurElem " ++ "0x%x\n", pList, pCurElem); ++ ++ if (!LST_IsEmpty(pList)) { ++ pCurElem->prev->next = pCurElem->next; ++ pCurElem->next->prev = pCurElem->prev; ++ ++ /* set elem fields to NULL to prevent illegal references */ ++ pCurElem->next = NULL; ++ pCurElem->prev = NULL; ++ } ++} ++ +diff --git a/drivers/dsp/bridge/services/mem.c b/drivers/dsp/bridge/services/mem.c +new file mode 100644 +index 0000000..0a10304 +--- /dev/null ++++ b/drivers/dsp/bridge/services/mem.c +@@ -0,0 +1,599 @@ ++/* ++ * mem.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mem.c ======== ++ * Purpose: ++ * Implementation of platform specific memory services. ++ * ++ * Public Functions: ++ * MEM_Alloc ++ * MEM_AllocPhysMem ++ * MEM_Calloc ++ * MEM_Exit ++ * MEM_FlushCache ++ * MEM_Free ++ * MEM_FreePhysMem ++ * MEM_Init ++ * MEM_ExtPhysPoolInit ++ * ++ *! Revision History: ++ *! ================= ++ *! 18-Jan-2004 hp: Added support for External physical memory pool ++ *! 19-Apr-2004 sb: Added Alloc/Free PhysMem, FlushCache, VirtualToPhysical ++ *! 01-Sep-2001 ag: Code cleanup. ++ *! 02-May-2001 ag: MEM_[UnMap]LinearAddress revamped to align Phys to Virt. ++ *! Set PAGE_PHYSICAL if phy addr <= 512MB. Opposite uSoft doc! ++ *! 29-Aug-2000 rr: MEM_LinearAddress does not check for 512MB for non-x86. ++ *! 28-Mar-2000 rr: MEM_LinearAddress changed.Handles address larger than 512MB ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 22-Nov-1999 kc: Added changes from code review. ++ *! 16-Aug-1999 kc: modified for WinCE. ++ *! 20-Mar-1999 ag: SP 4 fix in MEM_UMBCalloc(). ++ *! Mdl offset now ORed not added to userBuf. ++ *! 23-Dec-1997 cr: Code review changes. ++ *! 08-Dec-1997 cr: Prepared for code review. ++ *! 24-Jun-1997 cr: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/mem.h> ++#include <dspbridge/list.h> ++ ++/* ----------------------------------- Defines */ ++#define MEM_512MB 0x1fffffff ++#define memInfoSign 0x464E494D /* "MINF" (in reverse). */ ++ ++#ifdef DEBUG ++#define MEM_CHECK /* Use to detect source of memory leaks */ ++#endif ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask MEM_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static u32 cRefs; /* module reference count */ ++ ++static bool extPhysMemPoolEnabled; ++ ++struct extPhysMemPool { ++ u32 physMemBase; ++ u32 physMemSize; ++ u32 virtMemBase; ++ u32 nextPhysAllocPtr; ++}; ++ ++static struct extPhysMemPool extMemPool; ++ ++/* Information about each element allocated on heap */ ++struct memInfo { ++ struct LST_ELEM link; /* Must be first */ ++ size_t size; ++ void *caller; ++ u32 dwSignature; /* Should be last */ ++}; ++ ++#ifdef MEM_CHECK ++ ++/* ++ * This structure holds a linked list to all memory elements allocated on ++ * heap by DSP/BIOS Bridge. This is used to report memory leaks and free ++ * such elements while removing the DSP/BIOS Bridge driver ++ */ ++struct memMan { ++ struct LST_LIST lst; ++ spinlock_t lock; ++}; ++ ++static struct memMan mMan; ++ ++/* ++ * These functions are similar to LST_PutTail and LST_RemoveElem and are ++ * duplicated here to make MEM independent of LST ++ */ ++static inline void MLST_PutTail(struct LST_LIST *pList, struct LST_ELEM *pElem) ++{ ++ pElem->prev = pList->head.prev; ++ pElem->next = &pList->head; ++ pList->head.prev = pElem; ++ pElem->prev->next = pElem; ++ pElem->self = pElem; ++} ++ ++static inline void MLST_RemoveElem(struct LST_LIST *pList, ++ struct LST_ELEM *pCurElem) ++{ ++ pCurElem->prev->next = pCurElem->next; ++ pCurElem->next->prev = pCurElem->prev; ++ pCurElem->next = NULL; ++ pCurElem->prev = NULL; ++} ++ ++static void MEM_Check(void) ++{ ++ struct memInfo *pMem; ++ struct LST_ELEM *last = &mMan.lst.head; ++ struct LST_ELEM *curr = mMan.lst.head.next; ++ ++ if (!LST_IsEmpty(&mMan.lst)) { ++ GT_0trace(MEM_debugMask, GT_7CLASS, "*** MEMORY LEAK ***\n"); ++ GT_0trace(MEM_debugMask, GT_7CLASS, ++ "Addr Size Caller\n"); ++ while (curr != last) { ++ pMem = (struct memInfo *)curr; ++ curr = curr->next; ++ if ((u32)pMem > PAGE_OFFSET && ++ MEM_IsValidHandle(pMem, memInfoSign)) { ++ GT_3trace(MEM_debugMask, GT_7CLASS, ++ "%lx %d\t [<%p>]\n", ++ (u32) pMem + sizeof(struct memInfo), ++ pMem->size, pMem->caller); ++ MLST_RemoveElem(&mMan.lst, ++ (struct LST_ELEM *) pMem); ++ kfree(pMem); ++ } else { ++ GT_1trace(MEM_debugMask, GT_7CLASS, ++ "Invalid allocation or " ++ "Buffer underflow at %x\n", ++ (u32)pMem + sizeof(struct memInfo)); ++ break; ++ } ++ } ++ } ++ DBC_Ensure(LST_IsEmpty(&mMan.lst)); ++} ++ ++#endif ++ ++void MEM_ExtPhysPoolInit(u32 poolPhysBase, u32 poolSize) ++{ ++ u32 poolVirtBase; ++ ++ /* get the virtual address for the physical memory pool passed */ ++ poolVirtBase = (u32)ioremap(poolPhysBase, poolSize); ++ ++ if ((void **)poolVirtBase == NULL) { ++ GT_0trace(MEM_debugMask, GT_7CLASS, ++ "[PHYS_POOL]Mapping External " ++ "physical memory to virt failed \n"); ++ extPhysMemPoolEnabled = false; ++ } else { ++ extMemPool.physMemBase = poolPhysBase; ++ extMemPool.physMemSize = poolSize; ++ extMemPool.virtMemBase = poolVirtBase; ++ extMemPool.nextPhysAllocPtr = poolPhysBase; ++ extPhysMemPoolEnabled = true; ++ GT_3trace(MEM_debugMask, GT_1CLASS, ++ "ExtMemory Pool details " "Pool" ++ "Physical mem base = %0x " "Pool Physical mem size " ++ "= %0x" "Pool Virtual mem base = %0x \n", ++ poolPhysBase, poolSize, poolVirtBase); ++ } ++} ++ ++static void MEM_ExtPhysPoolRelease(void) ++{ ++ GT_0trace(MEM_debugMask, GT_1CLASS, ++ "Releasing External memory pool \n"); ++ if (extPhysMemPoolEnabled) { ++ iounmap((void *)(extMemPool.virtMemBase)); ++ extPhysMemPoolEnabled = false; ++ } ++} ++ ++/* ++ * ======== MEM_ExtPhysMemAlloc ======== ++ * Purpose: ++ * Allocate physically contiguous, uncached memory from external memory pool ++ */ ++ ++static void *MEM_ExtPhysMemAlloc(u32 bytes, u32 align, OUT u32 *pPhysAddr) ++{ ++ u32 newAllocPtr; ++ u32 offset; ++ u32 virtAddr; ++ ++ GT_2trace(MEM_debugMask, GT_1CLASS, ++ "Ext Memory Allocation" "bytes=0x%x , " ++ "align=0x%x \n", bytes, align); ++ if (align == 0) { ++ GT_0trace(MEM_debugMask, GT_7CLASS, ++ "ExtPhysical Memory Allocation " ++ "No alignment request in allocation call !! \n"); ++ align = 1; ++ } ++ if (bytes > ((extMemPool.physMemBase + extMemPool.physMemSize) ++ - extMemPool.nextPhysAllocPtr)) { ++ GT_1trace(MEM_debugMask, GT_7CLASS, ++ "ExtPhysical Memory Allocation " ++ "unable to allocate memory for bytes = 0x%x \n", ++ bytes); ++ pPhysAddr = NULL; ++ return NULL; ++ } else { ++ offset = (extMemPool.nextPhysAllocPtr & (align - 1)); ++ if (offset == 0) ++ newAllocPtr = extMemPool.nextPhysAllocPtr; ++ else ++ newAllocPtr = (extMemPool.nextPhysAllocPtr) + ++ (align - offset); ++ if ((newAllocPtr + bytes) <= ++ (extMemPool.physMemBase + extMemPool.physMemSize)) { ++ /* we can allocate */ ++ *pPhysAddr = newAllocPtr; ++ extMemPool.nextPhysAllocPtr = newAllocPtr + bytes; ++ virtAddr = extMemPool.virtMemBase + (newAllocPtr - ++ extMemPool.physMemBase); ++ GT_2trace(MEM_debugMask, GT_1CLASS, ++ "Ext Memory Allocation succedded " ++ "phys address=0x%x , virtaddress=0x%x \n", ++ newAllocPtr, virtAddr); ++ return (void *)virtAddr; ++ } else { ++ *pPhysAddr = 0; ++ return NULL; ++ } ++ } ++} ++ ++/* ++ * ======== MEM_Alloc ======== ++ * Purpose: ++ * Allocate memory from the paged or non-paged pools. ++ */ ++void *MEM_Alloc(u32 cBytes, enum MEM_POOLATTRS type) ++{ ++ struct memInfo *pMem = NULL; ++ ++ GT_2trace(MEM_debugMask, GT_ENTER, ++ "MEM_Alloc: cBytes 0x%x\ttype 0x%x\n", cBytes, type); ++ if (cBytes > 0) { ++ switch (type) { ++ case MEM_NONPAGED: ++ /* If non-paged memory required, see note at top of file. */ ++ case MEM_PAGED: ++#ifndef MEM_CHECK ++ pMem = kmalloc(cBytes, ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL); ++#else ++ pMem = kmalloc(cBytes + sizeof(struct memInfo), ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL); ++ if (pMem) { ++ pMem->size = cBytes; ++ pMem->caller = __builtin_return_address(0); ++ pMem->dwSignature = memInfoSign; ++ ++ spin_lock(&mMan.lock); ++ MLST_PutTail(&mMan.lst, ++ (struct LST_ELEM *)pMem); ++ spin_unlock(&mMan.lock); ++ ++ pMem = (void *)((u32)pMem + ++ sizeof(struct memInfo)); ++ } ++#endif ++ break; ++ case MEM_LARGEVIRTMEM: ++#ifndef MEM_CHECK ++ /* FIXME - Replace with 'vmalloc' after BP fix */ ++ pMem = __vmalloc(cBytes, ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL, PAGE_KERNEL); ++#else ++ /* FIXME - Replace with 'vmalloc' after BP fix */ ++ pMem = __vmalloc((cBytes + sizeof(struct memInfo)), ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL, PAGE_KERNEL); ++ if (pMem) { ++ pMem->size = cBytes; ++ pMem->caller = __builtin_return_address(0); ++ pMem->dwSignature = memInfoSign; ++ ++ spin_lock(&mMan.lock); ++ MLST_PutTail(&mMan.lst, ++ (struct LST_ELEM *) pMem); ++ spin_unlock(&mMan.lock); ++ ++ pMem = (void *)((u32)pMem + ++ sizeof(struct memInfo)); ++ } ++#endif ++ break; ++ ++ default: ++ GT_0trace(MEM_debugMask, GT_6CLASS, ++ "MEM_Alloc: unexpected " ++ "MEM_POOLATTRS value\n"); ++ break; ++ } ++ } ++ ++ return pMem; ++} ++ ++/* ++ * ======== MEM_AllocPhysMem ======== ++ * Purpose: ++ * Allocate physically contiguous, uncached memory ++ */ ++void *MEM_AllocPhysMem(u32 cBytes, u32 ulAlign, OUT u32 *pPhysicalAddress) ++{ ++ void *pVaMem = NULL; ++ dma_addr_t paMem; ++ ++ DBC_Require(cRefs > 0); ++ ++ GT_2trace(MEM_debugMask, GT_ENTER, ++ "MEM_AllocPhysMem: cBytes 0x%x\tulAlign" ++ "0x%x\n", cBytes, ulAlign); ++ ++ if (cBytes > 0) { ++ if (extPhysMemPoolEnabled) { ++ pVaMem = MEM_ExtPhysMemAlloc(cBytes, ulAlign, ++ (u32 *)&paMem); ++ } else ++ pVaMem = dma_alloc_coherent(NULL, cBytes, &paMem, ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL); ++ if (pVaMem == NULL) { ++ *pPhysicalAddress = 0; ++ GT_1trace(MEM_debugMask, GT_6CLASS, ++ "MEM_AllocPhysMem failed: " ++ "0x%x\n", pVaMem); ++ } else { ++ *pPhysicalAddress = paMem; ++ } ++ } ++ return pVaMem; ++} ++ ++/* ++ * ======== MEM_Calloc ======== ++ * Purpose: ++ * Allocate zero-initialized memory from the paged or non-paged pools. ++ */ ++void *MEM_Calloc(u32 cBytes, enum MEM_POOLATTRS type) ++{ ++ struct memInfo *pMem = NULL; ++ ++ GT_2trace(MEM_debugMask, GT_ENTER, ++ "MEM_Calloc: cBytes 0x%x\ttype 0x%x\n", ++ cBytes, type); ++ ++ if (cBytes > 0) { ++ switch (type) { ++ case MEM_NONPAGED: ++ /* If non-paged memory required, see note at top of file. */ ++ case MEM_PAGED: ++#ifndef MEM_CHECK ++ pMem = kmalloc(cBytes, ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL); ++ if (pMem) ++ memset(pMem, 0, cBytes); ++ ++#else ++ pMem = kmalloc(cBytes + sizeof(struct memInfo), ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL); ++ if (pMem) { ++ memset((void *)((u32)pMem + ++ sizeof(struct memInfo)), 0, cBytes); ++ pMem->size = cBytes; ++ pMem->caller = __builtin_return_address(0); ++ pMem->dwSignature = memInfoSign; ++ spin_lock(&mMan.lock); ++ MLST_PutTail(&mMan.lst, ++ (struct LST_ELEM *) pMem); ++ spin_unlock(&mMan.lock); ++ pMem = (void *)((u32)pMem + ++ sizeof(struct memInfo)); ++ } ++#endif ++ break; ++ case MEM_LARGEVIRTMEM: ++#ifndef MEM_CHECK ++ /* FIXME - Replace with 'vmalloc' after BP fix */ ++ pMem = __vmalloc(cBytes, ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL, PAGE_KERNEL); ++ if (pMem) ++ memset(pMem, 0, cBytes); ++ ++#else ++ /* FIXME - Replace with 'vmalloc' after BP fix */ ++ pMem = __vmalloc(cBytes + sizeof(struct memInfo), ++ (in_atomic()) ? GFP_ATOMIC : GFP_KERNEL, PAGE_KERNEL); ++ if (pMem) { ++ memset((void *)((u32)pMem + ++ sizeof(struct memInfo)), 0, cBytes); ++ pMem->size = cBytes; ++ pMem->caller = __builtin_return_address(0); ++ pMem->dwSignature = memInfoSign; ++ spin_lock(&mMan.lock); ++ MLST_PutTail(&mMan.lst, (struct LST_ELEM *) ++ pMem); ++ spin_unlock(&mMan.lock); ++ pMem = (void *)((u32)pMem + ++ sizeof(struct memInfo)); ++ } ++#endif ++ break; ++ default: ++ GT_1trace(MEM_debugMask, GT_6CLASS, ++ "MEM_Calloc: unexpected " ++ "MEM_POOLATTRS value 0x%x\n", type); ++ break; ++ } ++ } ++ ++ return pMem; ++} ++ ++/* ++ * ======== MEM_Exit ======== ++ * Purpose: ++ * Discontinue usage of the MEM module. ++ */ ++void MEM_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(MEM_debugMask, GT_5CLASS, "MEM_Exit: cRefs 0x%x\n", cRefs); ++ ++ cRefs--; ++#ifdef MEM_CHECK ++ if (cRefs == 0) ++ MEM_Check(); ++ ++#endif ++ MEM_ExtPhysPoolRelease(); ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== MEM_FlushCache ======== ++ * Purpose: ++ * Flush cache ++ */ ++void MEM_FlushCache(void *pMemBuf, u32 cBytes, s32 FlushType) ++{ ++ DBC_Require(cRefs > 0); ++ ++ switch (FlushType) { ++ /* invalidate only */ ++ case PROC_INVALIDATE_MEM: ++ dmac_inv_range(pMemBuf, pMemBuf + cBytes); ++ outer_inv_range(__pa((u32)pMemBuf), __pa((u32)pMemBuf + ++ cBytes)); ++ break; ++ /* writeback only */ ++ case PROC_WRITEBACK_MEM: ++ dmac_clean_range(pMemBuf, pMemBuf + cBytes); ++ outer_clean_range(__pa((u32)pMemBuf), __pa((u32)pMemBuf + ++ cBytes)); ++ break; ++ /* writeback and invalidate */ ++ case PROC_WRITEBACK_INVALIDATE_MEM: ++ dmac_flush_range(pMemBuf, pMemBuf + cBytes); ++ outer_flush_range(__pa((u32)pMemBuf), __pa((u32)pMemBuf + ++ cBytes)); ++ break; ++ default: ++ GT_1trace(MEM_debugMask, GT_6CLASS, "MEM_FlushCache: invalid " ++ "FlushMemType 0x%x\n", FlushType); ++ break; ++ } ++ ++} ++ ++ ++/* ++ * ======== MEM_Free ======== ++ * Purpose: ++ * Free the given block of system memory. ++ */ ++void MEM_Free(IN void *pMemBuf) ++{ ++#ifdef MEM_CHECK ++ struct memInfo *pMem = (void *)((u32)pMemBuf - sizeof(struct memInfo)); ++#endif ++ ++ DBC_Require(pMemBuf != NULL); ++ ++ GT_1trace(MEM_debugMask, GT_ENTER, "MEM_Free: pMemBufs 0x%x\n", ++ pMemBuf); ++ ++ if (pMemBuf) { ++#ifndef MEM_CHECK ++ kfree(pMemBuf); ++#else ++ if (pMem) { ++ if (pMem->dwSignature == memInfoSign) { ++ spin_lock(&mMan.lock); ++ MLST_RemoveElem(&mMan.lst, ++ (struct LST_ELEM *) pMem); ++ spin_unlock(&mMan.lock); ++ pMem->dwSignature = 0; ++ kfree(pMem); ++ } else { ++ GT_1trace(MEM_debugMask, GT_7CLASS, ++ "Invalid allocation or " ++ "Buffer underflow at %x\n", ++ (u32) pMem + sizeof(struct memInfo)); ++ } ++ } ++#endif ++ } ++} ++ ++/* ++ * ======== MEM_FreePhysMem ======== ++ * Purpose: ++ * Free the given block of physically contiguous memory. ++ */ ++void MEM_FreePhysMem(void *pVirtualAddress, u32 pPhysicalAddress, ++ u32 cBytes) ++{ ++ DBC_Require(cRefs > 0); ++ DBC_Require(pVirtualAddress != NULL); ++ ++ GT_1trace(MEM_debugMask, GT_ENTER, "MEM_FreePhysMem: pVirtualAddress " ++ "0x%x\n", pVirtualAddress); ++ ++ if (!extPhysMemPoolEnabled) ++ dma_free_coherent(NULL, cBytes, pVirtualAddress, ++ pPhysicalAddress); ++} ++ ++/* ++ * ======== MEM_Init ======== ++ * Purpose: ++ * Initialize MEM module private state. ++ */ ++bool MEM_Init(void) ++{ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ GT_create(&MEM_debugMask, "MM"); /* MM for MeM module */ ++ ++#ifdef MEM_CHECK ++ mMan.lst.head.next = &mMan.lst.head; ++ mMan.lst.head.prev = &mMan.lst.head; ++ mMan.lst.head.self = NULL; ++ spin_lock_init(&mMan.lock); ++#endif ++ ++ } ++ ++ cRefs++; ++ ++ GT_1trace(MEM_debugMask, GT_5CLASS, "MEM_Init: cRefs 0x%x\n", cRefs); ++ ++ DBC_Ensure(cRefs > 0); ++ ++ return true; ++} +diff --git a/drivers/dsp/bridge/services/ntfy.c b/drivers/dsp/bridge/services/ntfy.c +new file mode 100644 +index 0000000..2eff3eb +--- /dev/null ++++ b/drivers/dsp/bridge/services/ntfy.c +@@ -0,0 +1,329 @@ ++/* ++ * ntfy.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== ntfyce.c ======== ++ * Purpose: ++ * Manage lists of notification events. ++ * ++ * Public Functions: ++ * NTFY_Create ++ * NTFY_Delete ++ * NTFY_Exit ++ * NTFY_Init ++ * NTFY_Notify ++ * NTFY_Register ++ * ++ *! Revision History: ++ *! ================= ++ *! 06-Feb-2003 kc Removed DSP_POSTMESSAGE related code. ++ *! 05-Nov-2001 kc Updated DSP_HNOTIFICATION structure. ++ *! 10-May-2001 jeh Removed SERVICES module init/exit from NTFY_Init/Exit. ++ *! NTFY_Register() returns DSP_ENOTIMPL for all but ++ *! DSP_SIGNALEVENT. ++ *! 12-Oct-2000 jeh Use MEM_IsValidHandle(). ++ *! 07-Sep-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/ntfy.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define NTFY_SIGNATURE 0x5946544e /* "YFTN" */ ++ ++/* ++ * ======== NTFY_OBJECT ======== ++ */ ++struct NTFY_OBJECT { ++ u32 dwSignature; /* For object validation */ ++ struct LST_LIST *notifyList; /* List of NOTIFICATION objects */ ++ struct SYNC_CSOBJECT *hSync; /* For critical sections */ ++}; ++ ++/* ++ * ======== NOTIFICATION ======== ++ * This object will be created when a client registers for events. ++ */ ++struct NOTIFICATION { ++ struct LST_ELEM listElem; ++ u32 uEventMask; /* Events to be notified about */ ++ u32 uNotifyType; /* Type of notification to be sent */ ++ ++ /* ++ * We keep a copy of the event name to check if the event has ++ * already been registered. (SYNC also keeps a copy of the name). ++ */ ++ char *pstrName; /* Name of event */ ++ HANDLE hEvent; /* Handle for notification */ ++ struct SYNC_OBJECT *hSync; ++}; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask NTFY_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++/* ----------------------------------- Function Prototypes */ ++static void DeleteNotify(struct NOTIFICATION *pNotify); ++ ++/* ++ * ======== NTFY_Create ======== ++ * Purpose: ++ * Create an empty list of notifications. ++ */ ++DSP_STATUS NTFY_Create(struct NTFY_OBJECT **phNtfy) ++{ ++ struct NTFY_OBJECT *pNtfy; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(phNtfy != NULL); ++ ++ *phNtfy = NULL; ++ MEM_AllocObject(pNtfy, struct NTFY_OBJECT, NTFY_SIGNATURE); ++ ++ if (pNtfy) { ++ ++ status = SYNC_InitializeDPCCS(&pNtfy->hSync); ++ if (DSP_SUCCEEDED(status)) { ++ pNtfy->notifyList = LST_Create(); ++ if (pNtfy->notifyList == NULL) { ++ (void) SYNC_DeleteCS(pNtfy->hSync); ++ MEM_FreeObject(pNtfy); ++ status = DSP_EMEMORY; ++ } else { ++ *phNtfy = pNtfy; ++ } ++ } ++ } else { ++ status = DSP_EMEMORY; ++ } ++ ++ DBC_Ensure((DSP_FAILED(status) && *phNtfy == NULL) || ++ (DSP_SUCCEEDED(status) && MEM_IsValidHandle((*phNtfy), ++ NTFY_SIGNATURE))); ++ ++ return status; ++} ++ ++/* ++ * ======== NTFY_Delete ======== ++ * Purpose: ++ * Free resources allocated in NTFY_Create. ++ */ ++void NTFY_Delete(struct NTFY_OBJECT *hNtfy) ++{ ++ struct NOTIFICATION *pNotify; ++ ++ DBC_Require(MEM_IsValidHandle(hNtfy, NTFY_SIGNATURE)); ++ ++ /* Remove any elements remaining in list */ ++ if (hNtfy->notifyList) { ++ while ((pNotify = (struct NOTIFICATION *)LST_GetHead(hNtfy-> ++ notifyList))) { ++ DeleteNotify(pNotify); ++ } ++ DBC_Assert(LST_IsEmpty(hNtfy->notifyList)); ++ LST_Delete(hNtfy->notifyList); ++ } ++ if (hNtfy->hSync) ++ (void)SYNC_DeleteCS(hNtfy->hSync); ++ ++ MEM_FreeObject(hNtfy); ++} ++ ++/* ++ * ======== NTFY_Exit ======== ++ * Purpose: ++ * Discontinue usage of NTFY module. ++ */ ++void NTFY_Exit(void) ++{ ++ GT_0trace(NTFY_debugMask, GT_5CLASS, "Entered NTFY_Exit\n"); ++} ++ ++/* ++ * ======== NTFY_Init ======== ++ * Purpose: ++ * Initialize the NTFY module. ++ */ ++bool NTFY_Init(void) ++{ ++ GT_create(&NTFY_debugMask, "NY"); /* "NY" for NtfY */ ++ ++ GT_0trace(NTFY_debugMask, GT_5CLASS, "NTFY_Init()\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== NTFY_Notify ======== ++ * Purpose: ++ * Execute notify function (signal event) for every ++ * element in the notification list that is to be notified about the ++ * event specified in uEventMask. ++ */ ++void NTFY_Notify(struct NTFY_OBJECT *hNtfy, u32 uEventMask) ++{ ++ struct NOTIFICATION *pNotify; ++ ++ DBC_Require(MEM_IsValidHandle(hNtfy, NTFY_SIGNATURE)); ++ ++ /* ++ * Go through notifyList and notify all clients registered for ++ * uEventMask events. ++ */ ++ ++ (void) SYNC_EnterCS(hNtfy->hSync); ++ ++ pNotify = (struct NOTIFICATION *)LST_First(hNtfy->notifyList); ++ while (pNotify != NULL) { ++ if (pNotify->uEventMask & uEventMask) { ++ /* Notify */ ++ if (pNotify->uNotifyType == DSP_SIGNALEVENT) ++ (void)SYNC_SetEvent(pNotify->hSync); ++ ++ } ++ pNotify = (struct NOTIFICATION *)LST_Next(hNtfy->notifyList, ++ (struct LST_ELEM *)pNotify); ++ } ++ ++ (void) SYNC_LeaveCS(hNtfy->hSync); ++} ++ ++/* ++ * ======== NTFY_Register ======== ++ * Purpose: ++ * Add a notification element to the list. If the notification is already ++ * registered, and uEventMask != 0, the notification will get posted for ++ * events specified in the new event mask. If the notification is already ++ * registered and uEventMask == 0, the notification will be unregistered. ++ */ ++DSP_STATUS NTFY_Register(struct NTFY_OBJECT *hNtfy, ++ struct DSP_NOTIFICATION *hNotification, ++ u32 uEventMask, u32 uNotifyType) ++{ ++ struct NOTIFICATION *pNotify; ++ struct SYNC_ATTRS syncAttrs; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hNtfy, NTFY_SIGNATURE)); ++ ++ if (hNotification == NULL) ++ status = DSP_EHANDLE; ++ ++ /* Return DSP_ENOTIMPL if uNotifyType is not supported */ ++ if (DSP_SUCCEEDED(status)) { ++ if (!IsValidNotifyMask(uNotifyType)) ++ status = DSP_ENOTIMPL; ++ ++ } ++ ++ if (DSP_FAILED(status)) ++ return status; ++ ++ (void)SYNC_EnterCS(hNtfy->hSync); ++ ++ pNotify = (struct NOTIFICATION *)LST_First(hNtfy->notifyList); ++ while (pNotify != NULL) { ++ /* If there is more than one notification type, each ++ * type may require its own handler code. */ ++ ++ if (hNotification->handle == pNotify->hSync) { ++ /* found */ ++ break; ++ } ++ pNotify = (struct NOTIFICATION *)LST_Next(hNtfy->notifyList, ++ (struct LST_ELEM *)pNotify); ++ } ++ if (pNotify == NULL) { ++ /* Not registered */ ++ if (uEventMask == 0) { ++ status = DSP_EVALUE; ++ } else { ++ /* Allocate NOTIFICATION object, add to list */ ++ pNotify = MEM_Calloc(sizeof(struct NOTIFICATION), ++ MEM_PAGED); ++ if (pNotify == NULL) ++ status = DSP_EMEMORY; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ LST_InitElem((struct LST_ELEM *) pNotify); ++ /* If there is more than one notification type, each ++ * type may require its own handler code. */ ++ status = SYNC_OpenEvent(&pNotify->hSync, &syncAttrs); ++ hNotification->handle = pNotify->hSync; ++ ++ if (DSP_SUCCEEDED(status)) { ++ pNotify->uEventMask = uEventMask; ++ pNotify->uNotifyType = uNotifyType; ++ LST_PutTail(hNtfy->notifyList, ++ (struct LST_ELEM *)pNotify); ++ } else { ++ DeleteNotify(pNotify); ++ } ++ } ++ } else { ++ /* Found in list */ ++ if (uEventMask == 0) { ++ /* Remove from list and free */ ++ LST_RemoveElem(hNtfy->notifyList, ++ (struct LST_ELEM *)pNotify); ++ DeleteNotify(pNotify); ++ } else { ++ /* Update notification mask (type shouldn't change) */ ++ pNotify->uEventMask = uEventMask; ++ } ++ } ++ (void)SYNC_LeaveCS(hNtfy->hSync); ++ return status; ++} ++ ++/* ++ * ======== DeleteNotify ======== ++ * Purpose: ++ * Free the notification object. ++ */ ++static void DeleteNotify(struct NOTIFICATION *pNotify) ++{ ++ if (pNotify->hSync) ++ (void) SYNC_CloseEvent(pNotify->hSync); ++ ++ if (pNotify->pstrName) ++ MEM_Free(pNotify->pstrName); ++ ++ MEM_Free(pNotify); ++} ++ +diff --git a/drivers/dsp/bridge/services/reg.c b/drivers/dsp/bridge/services/reg.c +new file mode 100644 +index 0000000..0d85f41 +--- /dev/null ++++ b/drivers/dsp/bridge/services/reg.c +@@ -0,0 +1,196 @@ ++/* ++ * reg.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== regce.c ======== ++ * Purpose: ++ * Provide registry functions. ++ * ++ * Public Functions: ++ * REG_DeleteValue ++ * REG_EnumValue ++ * REG_Exit ++ * REG_GetValue ++ * REG_Init ++ * REG_SetValue ++ * ++ *! Revision History: ++ *! ================ ++ * ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/reg.h> ++#include <regsup.h> ++ ++#if GT_TRACE ++struct GT_Mask REG_debugMask = { NULL, NULL }; /* GT trace var. */ ++#endif ++ ++/* ++ * ======== REG_DeleteValue ======== ++ * Deletes a registry entry value. NOTE: A registry entry value is not the ++ * same as * a registry key. ++ */ ++DSP_STATUS REG_DeleteValue(OPTIONAL IN HANDLE *phKey, IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue) ++{ ++ DSP_STATUS status; ++ DBC_Require(pstrSubkey && pstrValue); ++ DBC_Require(phKey == NULL); ++ DBC_Require(strlen(pstrSubkey) < REG_MAXREGPATHLENGTH); ++ DBC_Require(strlen(pstrValue) < REG_MAXREGPATHLENGTH); ++ ++ GT_0trace(REG_debugMask, GT_ENTER, "REG_DeleteValue: entered\n"); ++ ++ /* Note that we don't use phKey */ ++ if (regsupDeleteValue(pstrSubkey, pstrValue) == DSP_SOK) ++ status = DSP_SOK; ++ else ++ status = DSP_EFAIL; ++ ++ return status; ++} ++ ++/* ++ * ======== REG_EnumValue ======== ++ * Enumerates a registry key and retrieve values stored under the key. ++ * We will assume the input pdwValueSize is smaller than ++ * REG_MAXREGPATHLENGTH for implementation purposes. ++ */ ++DSP_STATUS REG_EnumValue(IN HANDLE *phKey, IN u32 dwIndex, ++ IN CONST char *pstrKey, IN OUT char *pstrValue, ++ IN OUT u32 *pdwValueSize, IN OUT char *pstrData, ++ IN OUT u32 *pdwDataSize) ++{ ++ DSP_STATUS status; ++ ++ DBC_Require(pstrKey && pstrValue && pdwValueSize && pstrData && ++ pdwDataSize); ++ DBC_Require(*pdwValueSize <= REG_MAXREGPATHLENGTH); ++ DBC_Require(phKey == NULL); ++ DBC_Require(strlen(pstrKey) < REG_MAXREGPATHLENGTH); ++ ++ GT_0trace(REG_debugMask, GT_ENTER, "REG_EnumValue: entered\n"); ++ ++ status = regsupEnumValue(dwIndex, pstrKey, pstrValue, pdwValueSize, ++ pstrData, pdwDataSize); ++ ++ return status; ++} ++ ++/* ++ * ======== REG_Exit ======== ++ * Discontinue usage of the REG module. ++ */ ++void REG_Exit(void) ++{ ++ GT_0trace(REG_debugMask, GT_5CLASS, "REG_Exit\n"); ++ ++ regsupExit(); ++} ++ ++/* ++ * ======== REG_GetValue ======== ++ * Retrieve a value from the registry. ++ */ ++DSP_STATUS REG_GetValue(OPTIONAL IN HANDLE *phKey, IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue, OUT u8 *pbData, ++ IN OUT u32 *pdwDataSize) ++{ ++ DSP_STATUS status; ++ ++ DBC_Require(pstrSubkey && pstrValue && pbData); ++ DBC_Require(phKey == NULL); ++ DBC_Require(strlen(pstrSubkey) < REG_MAXREGPATHLENGTH); ++ DBC_Require(strlen(pstrValue) < REG_MAXREGPATHLENGTH); ++ ++ GT_0trace(REG_debugMask, GT_ENTER, "REG_GetValue: entered\n"); ++ ++ /* We need to use regsup calls... */ ++ /* ...for now we don't need the key handle or */ ++ /* the subkey, all we need is the value to lookup. */ ++ if (regsupGetValue((char *)pstrValue, pbData, pdwDataSize) == DSP_SOK) ++ status = DSP_SOK; ++ else ++ status = DSP_EFAIL; ++ ++ return status; ++} ++ ++/* ++ * ======== REG_Init ======== ++ * Initialize the REG module's private state. ++ */ ++bool REG_Init(void) ++{ ++ bool fInit; ++ ++ GT_create(®_debugMask, "RG"); /* RG for ReG */ ++ ++ fInit = regsupInit(); ++ ++ GT_0trace(REG_debugMask, GT_5CLASS, "REG_Init\n"); ++ ++ return fInit; ++} ++ ++/* ++ * ======== REG_SetValue ======== ++ * Set a value in the registry. ++ */ ++DSP_STATUS REG_SetValue(OPTIONAL IN HANDLE *phKey, IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue, IN CONST u32 dwType, ++ IN u8 *pbData, IN u32 dwDataSize) ++{ ++ DSP_STATUS status; ++ ++ DBC_Require(pstrValue && pbData); ++ DBC_Require(phKey == NULL); ++ DBC_Require(dwDataSize > 0); ++ DBC_Require(strlen(pstrValue) < REG_MAXREGPATHLENGTH); ++ ++ /* We need to use regsup calls... */ ++ /* ...for now we don't need the key handle or */ ++ /* the subkey, all we need is the value to lookup. */ ++ if (regsupSetValue((char *)pstrValue, pbData, dwDataSize) == DSP_SOK) ++ status = DSP_SOK; ++ else ++ status = DSP_EFAIL; ++ ++ return status; ++} ++ +diff --git a/drivers/dsp/bridge/services/regsup.c b/drivers/dsp/bridge/services/regsup.c +new file mode 100644 +index 0000000..5251b68 +--- /dev/null ++++ b/drivers/dsp/bridge/services/regsup.c +@@ -0,0 +1,368 @@ ++/* ++ * regsup.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== regsup.c ======== ++ * Purpose: ++ * Provide registry support functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 28-May-2002 map: Integrated PSI's dspimage update mechanism ++ *! 11-May-2002 gp: Turned PERF "on". ++ *! 21-May-2002 map: Fixed bug in SetValue - if resizing datasize, set ++ *! new size too ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/csl.h> ++ ++/* ----------------------------------- This */ ++#include <regsup.h> ++ ++struct RegValueStruct { ++ char name[BRIDGE_MAX_NAME_SIZE]; /* Name of a given value entry */ ++ u32 dataSize; /* Size of the data */ ++ void *pData; /* Pointer to the actual data */ ++}; ++ ++struct RegKeyStruct { ++ /*The current number of value entries this key has*/ ++ u32 numValueEntries; ++ /* Array of value entries */ ++ struct RegValueStruct values[BRIDGE_MAX_NUM_REG_ENTRIES]; ++}; ++ ++ ++/* Pointer to the registry support key */ ++static struct RegKeyStruct *pRegKey; ++ ++#if GT_TRACE ++extern struct GT_Mask REG_debugMask; /* GT trace var. */ ++/* ++ * ======== printS ======== ++ * Purpose: ++ * Displays printable characters in pBuf, if any. ++ */ ++static inline void printS(void *pBuf) ++{ ++ int pos = 0; ++ if (*(REG_debugMask).flags & (GT_2CLASS)) { ++ while (*(u8 *)((pBuf)+pos) >= ' ' && ++ *(u8 *)((pBuf)+pos) <= '~') { ++ GT_1trace(REG_debugMask, GT_2CLASS, "%c", ++ *(u8 *)((pBuf) + pos++)); ++ } ++ ++ GT_0trace(REG_debugMask, GT_2CLASS, "\n"); ++ } ++} ++#else ++#define printS(pBuf) ++#endif ++ ++/* ++ * ======== regsupInit ======== ++ * Purpose: ++ * Initialize the Registry Support module's private state. ++ */ ++bool regsupInit(void) ++{ ++ if (pRegKey != NULL) ++ return true; ++ ++ /* Need to allocate and setup our registry. */ ++ pRegKey = MEM_Calloc(sizeof(struct RegKeyStruct), MEM_NONPAGED); ++ if (pRegKey == NULL) ++ return false; ++ ++ return true; ++} ++ ++/* ++ * ======== regsupExit ======== ++ * Purpose: ++ * Release all registry support allocations. ++ */ ++void regsupExit(void) ++{ ++ u32 i; ++ ++ /* Make sure data has actually been allocated. */ ++ if (pRegKey == NULL) { ++ /* Nothing initialized.return! */ ++ return; ++ } ++ ++ GT_1trace(REG_debugMask, GT_2CLASS, "pRegKey->numValueEntries %d\n", ++ pRegKey->numValueEntries); ++ ++ /* Now go through each entry and free all resources. */ ++ for (i = 0; ((i < BRIDGE_MAX_NUM_REG_ENTRIES) && ++ (i < pRegKey->numValueEntries)); i++) { ++ if (pRegKey->values[i].name[0] != '\0') { ++ /* We have a valid entry.free it up! */ ++ if (pRegKey->values[i].pData != NULL) { ++ GT_3trace(REG_debugMask, GT_2CLASS, ++ "E %d\t %s DATA %x ", i, ++ pRegKey->values[i].name, ++ *(u32 *)pRegKey->values[i].pData); ++ printS((u8 *)(pRegKey->values[i].pData)); ++ MEM_Free(pRegKey->values[i].pData); ++ } ++ pRegKey->values[i].pData = NULL; ++ pRegKey->values[i].dataSize = 0; ++ pRegKey->values[i].name[0] = '\0'; ++ } ++ } ++ ++ /* Now that all of the resources are freed up, free the main one! */ ++ MEM_Free(pRegKey); ++ ++ /* Don't forget to NULL out the global entry! */ ++ pRegKey = NULL; ++} ++ ++/* ++ * ======== regsupGetValue ======== ++ * Purpose: ++ * Get the value of the entry having the given name. ++ */ ++DSP_STATUS regsupGetValue(char *valName, void *pBuf, u32 *dataSize) ++{ ++ DSP_STATUS retVal = DSP_EFAIL; ++ u32 i; ++ ++ /* Need to search through the entries looking for the right one. */ ++ for (i = 0; i < pRegKey->numValueEntries; i++) { ++ /* See if the name matches. */ ++ if (strncmp(pRegKey->values[i].name, valName, ++ BRIDGE_MAX_NAME_SIZE) == 0) { ++ ++ /* We have a match! Copy out the data. */ ++ memcpy(pBuf, pRegKey->values[i].pData, ++ pRegKey->values[i].dataSize); ++ ++ /* Get the size for the caller. */ ++ *dataSize = pRegKey->values[i].dataSize; ++ ++ /* Set our status to good and exit. */ ++ retVal = DSP_SOK; ++ break; ++ } ++ } ++ ++ if (DSP_SUCCEEDED(retVal)) { ++ GT_2trace(REG_debugMask, GT_2CLASS, "G %s DATA %x ", valName, ++ *(u32 *)pBuf); ++ printS((u8 *)pBuf); ++ } else { ++ GT_1trace(REG_debugMask, GT_3CLASS, "G %s FAILED\n", valName); ++ } ++ ++ return retVal; ++} ++ ++/* ++ * ======== regsupSetValue ======== ++ * Purpose: ++ * Sets the value of the entry having the given name. ++ */ ++DSP_STATUS regsupSetValue(char *valName, void *pBuf, u32 dataSize) ++{ ++ DSP_STATUS retVal = DSP_EFAIL; ++ u32 i; ++ ++ GT_2trace(REG_debugMask, GT_2CLASS, "S %s DATA %x ", valName, ++ *(u32 *)pBuf); ++ printS((u8 *)pBuf); ++ ++ /* Need to search through the entries looking for the right one. */ ++ for (i = 0; i < pRegKey->numValueEntries; i++) { ++ /* See if the name matches. */ ++ if (strncmp(pRegKey->values[i].name, valName, ++ BRIDGE_MAX_NAME_SIZE) == 0) { ++ /* Make sure the new data size is the same. */ ++ if (dataSize != pRegKey->values[i].dataSize) { ++ /* The caller needs a different data size! */ ++ MEM_Free(pRegKey->values[i].pData); ++ pRegKey->values[i].pData = MEM_Alloc(dataSize, ++ MEM_NONPAGED); ++ if (pRegKey->values[i].pData == NULL) ++ break; ++ ++ } ++ ++ /* We have a match! Copy out the data. */ ++ memcpy(pRegKey->values[i].pData, pBuf, dataSize); ++ ++ /* Reset datasize - overwrite if new or same */ ++ pRegKey->values[i].dataSize = dataSize; ++ ++ /* Set our status to good and exit. */ ++ retVal = DSP_SOK; ++ break; ++ } ++ } ++ ++ /* See if we found a match or if this is a new entry */ ++ if (i == pRegKey->numValueEntries) { ++ /* No match, need to make a new entry */ ++ /* First check to see if we can make any more entries. */ ++ if (pRegKey->numValueEntries < BRIDGE_MAX_NUM_REG_ENTRIES) { ++ strncpy(pRegKey->values[pRegKey->numValueEntries].name, ++ valName, BRIDGE_MAX_NAME_SIZE); ++ pRegKey->values[pRegKey->numValueEntries].pData = ++ MEM_Alloc(dataSize, MEM_NONPAGED); ++ if (pRegKey->values[pRegKey->numValueEntries].pData != ++ NULL) { ++ memcpy(pRegKey-> ++ values[pRegKey->numValueEntries].pData, ++ pBuf, dataSize); ++ pRegKey-> ++ values[pRegKey->numValueEntries].dataSize = ++ dataSize; ++ pRegKey->numValueEntries++; ++ retVal = DSP_SOK; ++ } ++ } else { ++ GT_0trace(REG_debugMask, GT_7CLASS, ++ "MAX NUM REG ENTRIES REACHED\n"); ++ } ++ } ++ ++ return retVal; ++} ++ ++/* ++ * ======== regsupEnumValue ======== ++ * Purpose: ++ * Returns registry "values" and their "data" under a (sub)key. ++ */ ++DSP_STATUS regsupEnumValue(IN u32 dwIndex, IN CONST char *pstrKey, ++ IN OUT char *pstrValue, IN OUT u32 *pdwValueSize, ++ IN OUT char *pstrData, IN OUT u32 *pdwDataSize) ++{ ++ DSP_STATUS retVal = REG_E_INVALIDSUBKEY; ++ u32 i; ++ u32 dwKeyLen; ++ u32 count = 0; ++ ++ DBC_Require(pstrKey); ++ dwKeyLen = strlen(pstrKey); ++ ++ /* Need to search through the entries looking for the right one. */ ++ for (i = 0; i < pRegKey->numValueEntries; i++) { ++ /* See if the name matches. */ ++ if ((strncmp(pRegKey->values[i].name, pstrKey, ++ dwKeyLen) == 0) && count++ == dwIndex) { ++ /* We have a match! Copy out the data. */ ++ memcpy(pstrData, pRegKey->values[i].pData, ++ pRegKey->values[i].dataSize); ++ /* Get the size for the caller. */ ++ *pdwDataSize = pRegKey->values[i].dataSize; ++ *pdwValueSize = strlen(&(pRegKey-> ++ values[i].name[dwKeyLen])); ++ strncpy(pstrValue, ++ &(pRegKey->values[i].name[dwKeyLen]), ++ *pdwValueSize + 1); ++ GT_3trace(REG_debugMask, GT_2CLASS, ++ "E Key %s, Value %s, Data %x ", ++ pstrKey, pstrValue, *(u32 *)pstrData); ++ printS((u8 *)pstrData); ++ /* Set our status to good and exit. */ ++ retVal = DSP_SOK; ++ break; ++ } ++ } ++ ++ if (count && DSP_FAILED(retVal)) ++ retVal = REG_E_NOMOREITEMS; ++ ++ return retVal; ++} ++ ++/* ++ * ======== regsupDeleteValue ======== ++ */ ++DSP_STATUS regsupDeleteValue(IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue) ++{ ++ DSP_STATUS retVal = DSP_EFAIL; ++ u32 i; ++ ++ for (i = 0; ((i < BRIDGE_MAX_NUM_REG_ENTRIES) && ++ (i < pRegKey->numValueEntries)); i++) { ++ /* See if the name matches... */ ++ if (strncmp(pRegKey->values[i].name, pstrValue, ++ BRIDGE_MAX_NAME_SIZE) == 0) { ++ /* We have a match! Delete this key. To delete a ++ * key, we free all resources associated with this ++ * key and, if we're not already the last entry in ++ * the array, we copy that entry into this deleted ++ * key. ++ */ ++ MEM_Free(pRegKey->values[i].pData); ++ if ((pRegKey->numValueEntries - 1) == i) { ++ /* we're deleting the last one */ ++ pRegKey->values[i].name[0] = '\0'; ++ pRegKey->values[i].dataSize = 0; ++ pRegKey->values[i].pData = NULL; ++ } else { ++ /* move the last one here */ ++ strncpy(pRegKey->values[i].name, pRegKey-> ++ values[pRegKey->numValueEntries - 1].name, ++ BRIDGE_MAX_NAME_SIZE); ++ pRegKey->values[i].dataSize = ++ pRegKey-> ++ values[pRegKey->numValueEntries-1].dataSize; ++ pRegKey->values[i].pData = ++ pRegKey-> ++ values[pRegKey->numValueEntries-1].pData; ++ /* don't have to do this, but for ++ * the paranoid... */ ++ pRegKey-> ++ values[pRegKey->numValueEntries-1].name[0] = ++ '\0'; ++ } ++ ++ /* another one bites the dust. */ ++ pRegKey->numValueEntries--; ++ ++ /* Set our status to good and exit... */ ++ retVal = DSP_SOK; ++ break; ++ } ++ } ++ return retVal; ++ ++} ++ +diff --git a/drivers/dsp/bridge/services/regsup.h b/drivers/dsp/bridge/services/regsup.h +new file mode 100644 +index 0000000..011be52 +--- /dev/null ++++ b/drivers/dsp/bridge/services/regsup.h +@@ -0,0 +1,58 @@ ++/* ++ * regsup.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== regsup.h ======== ++ * ++ *! Revision History ++ *! ================ ++ */ ++ ++#ifndef _REGSUP_H_ ++#define _REGSUP_H_ ++ ++#define BRIDGE_MAX_NAME_SIZE MAXREGPATHLENGTH ++#define BRIDGE_MAX_NUM_REG_ENTRIES 52 ++ ++/* Init function. MUST be called BEFORE any calls are */ ++/* made into this psuedo-registry!!! Returns TRUE/FALSE for SUCCESS/ERROR */ ++extern bool regsupInit(void); ++ ++/* Release all registry support allocations. */ ++extern void regsupExit(void); ++ ++/* ++ * ======== regsupDeleteValue ======== ++ */ ++extern DSP_STATUS regsupDeleteValue(IN CONST char *pstrSubkey, ++ IN CONST char *pstrValue); ++/* Get the value of the entry having the given name. Returns DSP_SOK */ ++/* if an entry was found and the value retrieved. Returns DSP_EFAIL ++ * otherwise.*/ ++extern DSP_STATUS regsupGetValue(char *valName, void *pBuf, u32 *dataSize); ++ ++/* Sets the value of the entry having the given name. Returns DSP_SOK */ ++/* if an entry was found and the value set. Returns DSP_EFAIL otherwise. */ ++extern DSP_STATUS regsupSetValue(char *valName, void *pBuf, u32 dataSize); ++ ++/* Returns registry "values" and their "data" under a (sub)key. */ ++extern DSP_STATUS regsupEnumValue(IN u32 dwIndex, IN CONST char *pstrKey, ++ IN OUT char *pstrValue, IN OUT u32 *pdwValueSize, ++ IN OUT char *pstrData, IN OUT u32 *pdwDataSize); ++ ++#endif ++ +diff --git a/drivers/dsp/bridge/services/services.c b/drivers/dsp/bridge/services/services.c +new file mode 100644 +index 0000000..346007e +--- /dev/null ++++ b/drivers/dsp/bridge/services/services.c +@@ -0,0 +1,193 @@ ++/* ++ * services.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== services.c ======== ++ * Purpose: ++ * Provide SERVICES loading. ++ * ++ * Public Functions: ++ * SERVICES_Exit ++ * SERVICES_Init ++ * ++ * ++ *! Revision History ++ *! ================ ++ *! 20-Nov-2000 rr: NTFY_Init/Exit added. ++ *! 06-Jul-2000 rr: PROC prefix changed to PRCS to accomodate RM. ++ *! 01-Feb-2000 kc: Created. ++ */ ++ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/dbg.h> ++#include <dspbridge/dpc.h> ++#include <dspbridge/kfile.h> ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/reg.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/clk.h> ++#include <dspbridge/util.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/services.h> ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask SERVICES_debugMask = { NULL, NULL }; /* GT trace var. */ ++#endif ++ ++static u32 cRefs; /* SERVICES module reference count */ ++ ++/* ++ * ======== SERVICES_Exit ======== ++ * Purpose: ++ * Discontinue usage of module; free resources when reference count ++ * reaches 0. ++ */ ++void SERVICES_Exit(void) ++{ ++ DBC_Require(cRefs > 0); ++ ++ GT_1trace(SERVICES_debugMask, GT_5CLASS, "SERVICES_Exit: cRefs 0x%x\n", ++ cRefs); ++ ++ cRefs--; ++ if (cRefs == 0) { ++ /* Uninitialize all SERVICES modules here */ ++ NTFY_Exit(); ++ UTIL_Exit(); ++ SYNC_Exit(); ++ CLK_Exit(); ++ REG_Exit(); ++ LST_Exit(); ++ KFILE_Exit(); ++ DPC_Exit(); ++ DBG_Exit(); ++ CSL_Exit(); ++ CFG_Exit(); ++ MEM_Exit(); ++ ++ GT_exit(); ++ } ++ ++ DBC_Ensure(cRefs >= 0); ++} ++ ++/* ++ * ======== SERVICES_Init ======== ++ * Purpose: ++ * Initializes SERVICES modules. ++ */ ++bool SERVICES_Init(void) ++{ ++ bool fInit = true; ++ bool fCFG, fCSL, fDBG, fDPC, fKFILE, fLST, fMEM; ++ bool fREG, fSYNC, fCLK, fUTIL, fNTFY; ++ ++ DBC_Require(cRefs >= 0); ++ ++ if (cRefs == 0) { ++ ++ GT_init(); ++ GT_create(&SERVICES_debugMask, "OS"); /* OS for OSal */ ++ ++ GT_0trace(SERVICES_debugMask, GT_ENTER, ++ "SERVICES_Init: entered\n"); ++ ++ /* Perform required initialization of SERVICES modules. */ ++ fMEM = MEM_Init(); ++ fREG = REG_Init(); ++ fCFG = CFG_Init(); ++ fCSL = CSL_Init(); ++ fDBG = DBG_Init(); ++ fDPC = DPC_Init(); ++ fKFILE = KFILE_Init(); ++ fLST = LST_Init(); ++ /* fREG = REG_Init(); */ ++ fSYNC = SYNC_Init(); ++ fCLK = CLK_Init(); ++ fUTIL = UTIL_Init(); ++ fNTFY = NTFY_Init(); ++ ++ fInit = fCFG && fCSL && fDBG && fDPC && fKFILE && ++ fLST && fMEM && fREG && fSYNC && fCLK && fUTIL; ++ ++ if (!fInit) { ++ if (fNTFY) ++ NTFY_Exit(); ++ ++ if (fUTIL) ++ UTIL_Exit(); ++ ++ if (fSYNC) ++ SYNC_Exit(); ++ ++ if (fCLK) ++ CLK_Exit(); ++ ++ if (fREG) ++ REG_Exit(); ++ ++ if (fLST) ++ LST_Exit(); ++ ++ if (fKFILE) ++ KFILE_Exit(); ++ ++ if (fDPC) ++ DPC_Exit(); ++ ++ if (fDBG) ++ DBG_Exit(); ++ ++ if (fCSL) ++ CSL_Exit(); ++ ++ if (fCFG) ++ CFG_Exit(); ++ ++ if (fMEM) ++ MEM_Exit(); ++ ++ } ++ } ++ ++ if (fInit) ++ cRefs++; ++ ++ GT_1trace(SERVICES_debugMask, GT_5CLASS, "SERVICES_Init: cRefs 0x%x\n", ++ cRefs); ++ ++ DBC_Ensure((fInit && (cRefs > 0)) || (!fInit && (cRefs >= 0))); ++ ++ return fInit; ++} ++ +diff --git a/drivers/dsp/bridge/services/sync.c b/drivers/dsp/bridge/services/sync.c +new file mode 100644 +index 0000000..7ab9347 +--- /dev/null ++++ b/drivers/dsp/bridge/services/sync.c +@@ -0,0 +1,602 @@ ++/* ++ * sync.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== sync.c ======== ++ * Purpose: ++ * Synchronization services. ++ * ++ * Public Functions: ++ * SYNC_CloseEvent ++ * SYNC_DeleteCS ++ * SYNC_EnterCS ++ * SYNC_Exit ++ * SYNC_Init ++ * SYNC_InitializeCS ++ * SYNC_LeaveCS ++ * SYNC_OpenEvent ++ * SYNC_ResetEvent ++ * SYNC_SetEvent ++ * SYNC_WaitOnEvent ++ * SYNC_WaitOnMultipleEvents ++ * ++ *! Revision History: ++ *! ================ ++ *! 05-Nov-2001 kc: Minor cosmetic changes. ++ *! 05-Oct-2000 jeh Added SYNC_WaitOnMultipleEvents(). ++ *! 10-Aug-2000 rr: SYNC_PostMessage added. ++ *! 10-Jul-2000 jeh Modified SYNC_OpenEvent() to handle NULL attrs. ++ *! 03-Feb-2000 rr: Module init/exit is handled by SERVICES Init/Exit. ++ *! GT Changes. ++ *! 01-Dec-1999 ag: Added optional named event creation in SYNC_OpenEvent(). ++ *! 22-Nov-1999 kc: Added changes from code review. ++ *! 22-Sep-1999 kc: Modified from sync95.c. ++ *! 05-Aug-1996 gp: Created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/mem.h> ++ ++/* ----------------------------------- This */ ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define SIGNATURE 0x434e5953 /* "SYNC" (in reverse) */ ++ ++enum wait_state { ++ wo_waiting, ++ wo_signalled ++} ; ++ ++enum sync_state { ++ so_reset, ++ so_signalled ++} ; ++ ++struct WAIT_OBJECT { ++ enum wait_state state; ++ struct SYNC_OBJECT *signalling_event; ++ struct semaphore sem; ++}; ++ ++/* Generic SYNC object: */ ++struct SYNC_OBJECT { ++ u32 dwSignature; /* Used for object validation. */ ++ enum sync_state state; ++ spinlock_t sync_lock; ++ struct WAIT_OBJECT *pWaitObj; ++}; ++ ++struct SYNC_DPCCSOBJECT { ++ u32 dwSignature; /* used for object validation */ ++ spinlock_t sync_dpccs_lock; ++ s32 count; ++} ; ++ ++/* ----------------------------------- Globals */ ++#if GT_TRACE ++static struct GT_Mask SYNC_debugMask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++static int test_and_set(volatile void *ptr, int val) ++{ ++ int ret = val; ++ asm volatile (" swp %0, %0, [%1]" : "+r" (ret) : "r"(ptr) : "memory"); ++ return ret; ++} ++ ++static void timeout_callback(unsigned long hWaitObj); ++ ++/* ++ * ======== SYNC_CloseEvent ======== ++ * Purpose: ++ * Close an existing SYNC event object. ++ */ ++DSP_STATUS SYNC_CloseEvent(struct SYNC_OBJECT *hEvent) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_OBJECT *pEvent = (struct SYNC_OBJECT *)hEvent; ++ ++ DBC_Require(pEvent != NULL && pEvent->pWaitObj == NULL); ++ ++ GT_1trace(SYNC_debugMask, GT_ENTER, "SYNC_CloseEvent: hEvent 0x%x\n", ++ hEvent); ++ ++ if (MEM_IsValidHandle(hEvent, SIGNATURE)) { ++ if (pEvent->pWaitObj) { ++ status = DSP_EFAIL; ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_CloseEvent: Wait object not NULL\n"); ++ } ++ MEM_FreeObject(pEvent); ++ ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_CloseEvent: invalid " ++ "hEvent handle 0x%x\n", hEvent); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_Exit ======== ++ * Purpose: ++ * Cleanup SYNC module. ++ */ ++void SYNC_Exit(void) ++{ ++ GT_0trace(SYNC_debugMask, GT_5CLASS, "SYNC_Exit\n"); ++} ++ ++/* ++ * ======== SYNC_Init ======== ++ * Purpose: ++ * Initialize SYNC module. ++ */ ++bool SYNC_Init(void) ++{ ++ GT_create(&SYNC_debugMask, "SY"); /* SY for SYnc */ ++ ++ GT_0trace(SYNC_debugMask, GT_5CLASS, "SYNC_Init\n"); ++ ++ return true; ++} ++ ++/* ++ * ======== SYNC_OpenEvent ======== ++ * Purpose: ++ * Open a new synchronization event object. ++ */ ++DSP_STATUS SYNC_OpenEvent(OUT struct SYNC_OBJECT **phEvent, ++ IN OPTIONAL struct SYNC_ATTRS *pAttrs) ++{ ++ struct SYNC_OBJECT *pEvent = NULL; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(phEvent != NULL); ++ ++ GT_2trace(SYNC_debugMask, GT_ENTER, ++ "SYNC_OpenEvent: phEvent 0x%x, pAttrs " ++ "0x%x\n", phEvent, pAttrs); ++ ++ /* Allocate memory for sync object */ ++ MEM_AllocObject(pEvent, struct SYNC_OBJECT, SIGNATURE); ++ if (pEvent != NULL) { ++ pEvent->state = so_reset; ++ pEvent->pWaitObj = NULL; ++ spin_lock_init(&pEvent->sync_lock); ++ } else { ++ status = DSP_EMEMORY; ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_OpenEvent: MEM_AllocObject failed\n"); ++ } ++ ++ *phEvent = pEvent; ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_ResetEvent ======== ++ * Purpose: ++ * Reset an event to non-signalled. ++ */ ++DSP_STATUS SYNC_ResetEvent(struct SYNC_OBJECT *hEvent) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_OBJECT *pEvent = (struct SYNC_OBJECT *)hEvent; ++ ++ GT_1trace(SYNC_debugMask, GT_ENTER, "SYNC_ResetEvent: hEvent 0x%x\n", ++ hEvent); ++ ++ if (MEM_IsValidHandle(hEvent, SIGNATURE)) { ++ pEvent->state = so_reset; ++ status = DSP_SOK; ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_ResetEvent: invalid hEvent " ++ "handle 0x%x\n", hEvent); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_SetEvent ======== ++ * Purpose: ++ * Set an event to signaled and unblock one waiting thread. ++ * ++ * This function is called from ISR, DPC and user context. Hence interrupts ++ * are disabled to ensure atomicity. ++ */ ++ ++DSP_STATUS SYNC_SetEvent(struct SYNC_OBJECT *hEvent) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_OBJECT *pEvent = (struct SYNC_OBJECT *)hEvent; ++ unsigned long flags; ++ ++ GT_1trace(SYNC_debugMask, GT_6CLASS, "SYNC_SetEvent: hEvent 0x%x\n", ++ hEvent); ++ ++ if (MEM_IsValidHandle(hEvent, SIGNATURE)) { ++ spin_lock_irqsave(&hEvent->sync_lock, flags); ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_SetEvent: pEvent->pWaitObj " ++ "= 0x%x \n", pEvent->pWaitObj); ++ if (pEvent->pWaitObj) ++ GT_1trace(SYNC_debugMask, GT_6CLASS, "SYNC_SetEvent: " ++ "pEvent->pWaitObj->state = 0x%x \n", ++ pEvent->pWaitObj->state); ++ if (pEvent->pWaitObj != NULL && ++ test_and_set(&pEvent->pWaitObj->state, ++ wo_signalled) == wo_waiting) { ++ ++ pEvent->state = so_reset; ++ pEvent->pWaitObj->signalling_event = pEvent; ++ up(&pEvent->pWaitObj->sem); ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_SetEvent: Unlock " ++ "Semaphore for hEvent 0x%x\n", hEvent); ++ } else { ++ pEvent->state = so_signalled; ++ } ++ spin_unlock_irqrestore(&hEvent->sync_lock, flags); ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_SetEvent: invalid hEvent " ++ "handle 0x%x\n", hEvent); ++ } ++ return status; ++} ++ ++/* ++ * ======== SYNC_WaitOnEvent ======== ++ * Purpose: ++ * Wait for an event to be signalled, up to the specified timeout. ++ * Note: dwTimeOut must be 0xffffffff to signal infinite wait. ++ */ ++DSP_STATUS SYNC_WaitOnEvent(struct SYNC_OBJECT *hEvent, u32 dwTimeout) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_OBJECT *pEvent = (struct SYNC_OBJECT *)hEvent; ++ u32 temp; ++ ++ GT_2trace(SYNC_debugMask, GT_6CLASS, "SYNC_WaitOnEvent: hEvent 0x%x\n, " ++ "dwTimeOut 0x%x", hEvent, dwTimeout); ++ if (MEM_IsValidHandle(hEvent, SIGNATURE)) { ++ status = SYNC_WaitOnMultipleEvents(&pEvent, 1, dwTimeout, ++ &temp); ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_WaitOnEvent: invalid hEvent" ++ "handle 0x%x\n", hEvent); ++ } ++ return status; ++} ++ ++/* ++ * ======== SYNC_WaitOnMultipleEvents ======== ++ * Purpose: ++ * Wait for any of an array of events to be signalled, up to the ++ * specified timeout. ++ */ ++DSP_STATUS SYNC_WaitOnMultipleEvents(struct SYNC_OBJECT **hSyncEvents, ++ u32 uCount, u32 dwTimeout, ++ OUT u32 *puIndex) ++{ ++ u32 i; ++ DSP_STATUS status = DSP_SOK; ++ u32 curr; ++ struct WAIT_OBJECT *Wp; ++ ++ DBC_Require(uCount > 0); ++ DBC_Require(hSyncEvents != NULL); ++ DBC_Require(puIndex != NULL); ++ ++ for (i = 0; i < uCount; i++) ++ DBC_Require(MEM_IsValidHandle(hSyncEvents[i], SIGNATURE)); ++ ++ GT_4trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_WaitOnMultipleEvents: hSyncEvents:" ++ "0x%x\tuCount: 0x%x" "\tdwTimeout: 0x%x\tpuIndex: 0x%x\n", ++ hSyncEvents, uCount, dwTimeout, puIndex); ++ ++ Wp = MEM_Calloc(sizeof(struct WAIT_OBJECT), MEM_NONPAGED); ++ if (Wp == NULL) ++ return DSP_EMEMORY; ++ ++ Wp->state = wo_waiting; ++ Wp->signalling_event = NULL; ++ init_MUTEX_LOCKED(&(Wp->sem)); ++ ++ for (curr = 0; curr < uCount; curr++) { ++ hSyncEvents[curr]->pWaitObj = Wp; ++ if (hSyncEvents[curr]->state == so_signalled) { ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "Detected signaled Event !!!\n"); ++ if (test_and_set(&(Wp->state), wo_signalled) == ++ wo_waiting) { ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "Setting Signal Event!!!\n"); ++ hSyncEvents[curr]->state = so_reset; ++ Wp->signalling_event = hSyncEvents[curr]; ++ } ++ curr++; /* Will try optimizing later */ ++ break; ++ } ++ } ++ ++ curr--; /* Will try optimizing later */ ++ if (Wp->state != wo_signalled && dwTimeout > 0) { ++ struct timer_list timeout; ++ if (dwTimeout != SYNC_INFINITE) { ++ init_timer(&timeout); ++ timeout.function = timeout_callback; ++ timeout.data = (unsigned long)Wp; ++ timeout.expires = jiffies + dwTimeout * HZ / 1000; ++ add_timer(&timeout); ++ } ++ if (down_interruptible(&(Wp->sem))) { ++ GT_0trace(SYNC_debugMask, GT_7CLASS, "SYNC: " ++ "WaitOnMultipleEvents Interrupted by signal\n"); ++ status = DSP_EFAIL; ++ } ++ if (dwTimeout != SYNC_INFINITE) { ++ if (in_interrupt()) { ++ if (!del_timer(&timeout)) { ++ GT_0trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC: Timer expired\n"); ++ } ++ } else { ++ if (!del_timer_sync(&timeout)) { ++ GT_0trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC: Timer expired\n"); ++ } ++ } ++ } ++ } ++ for (i = 0; i <= curr; i++) { ++ if (MEM_IsValidHandle(hSyncEvents[i], SIGNATURE)) { ++ /* Memory corruption here if hSyncEvents[i] is ++ * freed before following statememt. */ ++ hSyncEvents[i]->pWaitObj = NULL; ++ } ++ if (hSyncEvents[i] == Wp->signalling_event) ++ *puIndex = i; ++ ++ } ++ if (Wp->signalling_event == NULL && DSP_SUCCEEDED(status)) { ++ GT_0trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC:Signaling Event NULL!!!(:-\n"); ++ status = DSP_ETIMEOUT; ++ } ++ if (Wp) ++ MEM_Free(Wp); ++ return status; ++} ++ ++static void timeout_callback(unsigned long hWaitObj) ++{ ++ struct WAIT_OBJECT *pWaitObj = (struct WAIT_OBJECT *)hWaitObj; ++ if (test_and_set(&pWaitObj->state, wo_signalled) == wo_waiting) ++ up(&pWaitObj->sem); ++ ++} ++ ++/* ++ * ======== SYNC_DeleteCS ======== ++ */ ++DSP_STATUS SYNC_DeleteCS(struct SYNC_CSOBJECT *hCSObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_CSOBJECT *pCSObj = (struct SYNC_CSOBJECT *)hCSObj; ++ ++ GT_0trace(SYNC_debugMask, GT_ENTER, "SYNC_DeleteCS\n"); ++ ++ if (MEM_IsValidHandle(hCSObj, SIGNATURECS)) { ++ if (down_trylock(&pCSObj->sem) != 0) { ++ GT_1trace(SYNC_debugMask, GT_7CLASS, ++ "CS in use (locked) while " ++ "deleting! pCSObj=0x%X", pCSObj); ++ DBC_Assert(0); ++ } ++ MEM_FreeObject(hCSObj); ++ } else if (MEM_IsValidHandle(hCSObj, SIGNATUREDPCCS)) { ++ struct SYNC_DPCCSOBJECT *pDPCCSObj = ++ (struct SYNC_DPCCSOBJECT *)hCSObj; ++ if (pDPCCSObj->count != 1) { ++ GT_1trace(SYNC_debugMask, GT_7CLASS, ++ "DPC CS in use (locked) while " ++ "deleting! pCSObj=0x%X", pCSObj); ++ DBC_Assert(0); ++ } ++ MEM_FreeObject(pDPCCSObj); ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_DeleteCS: invalid hCSObj " ++ "handle 0x%x\n", hCSObj); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_EnterCS ======== ++ */ ++DSP_STATUS SYNC_EnterCS(struct SYNC_CSOBJECT *hCSObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_CSOBJECT *pCSObj = (struct SYNC_CSOBJECT *)hCSObj; ++ ++ GT_1trace(SYNC_debugMask, GT_ENTER, "SYNC_EnterCS: hCSObj %p\n", ++ hCSObj); ++ if (MEM_IsValidHandle(hCSObj, SIGNATURECS)) { ++ if (in_interrupt()) { ++ status = DSP_EFAIL; ++ GT_0trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC_EnterCS called from " ++ "ISR/DPC or with ISR/DPC disabled!"); ++ DBC_Assert(0); ++ } else if (down_interruptible(&pCSObj->sem)) { ++ GT_1trace(SYNC_debugMask, GT_7CLASS, ++ "CS interrupted by signal! " ++ "pCSObj=0x%X", pCSObj); ++ status = DSP_EFAIL; ++ } ++ } else if (MEM_IsValidHandle(hCSObj, SIGNATUREDPCCS)) { ++ struct SYNC_DPCCSOBJECT *pDPCCSObj = ++ (struct SYNC_DPCCSOBJECT *)hCSObj; ++ GT_0trace(SYNC_debugMask, GT_ENTER, "SYNC_EnterCS DPC\n"); ++ spin_lock_bh(&pDPCCSObj->sync_dpccs_lock); ++ pDPCCSObj->count--; ++ if (pDPCCSObj->count != 0) { ++ /* FATAL ERROR : Failed to acquire DPC CS */ ++ GT_2trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC_EnterCS DPCCS %x locked," ++ "count %d", pDPCCSObj, pDPCCSObj->count); ++ spin_unlock_bh(&pDPCCSObj->sync_dpccs_lock); ++ DBC_Assert(0); ++ } ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_EnterCS: invalid hCSObj " ++ "handle 0x%x\n", hCSObj); ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_InitializeCS ======== ++ */ ++DSP_STATUS SYNC_InitializeCS(OUT struct SYNC_CSOBJECT **phCSObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_CSOBJECT *pCSObj = NULL; ++ ++ GT_0trace(SYNC_debugMask, GT_ENTER, "SYNC_InitializeCS\n"); ++ ++ /* Allocate memory for sync CS object */ ++ MEM_AllocObject(pCSObj, struct SYNC_CSOBJECT, SIGNATURECS); ++ if (pCSObj != NULL) { ++ init_MUTEX(&pCSObj->sem); ++ } else { ++ status = DSP_EMEMORY; ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_InitializeCS: MEM_AllocObject" ++ "failed\n"); ++ } ++ /* return CS object */ ++ *phCSObj = pCSObj; ++ DBC_Assert(DSP_FAILED(status) || (pCSObj)); ++ return status; ++} ++ ++DSP_STATUS SYNC_InitializeDPCCS(OUT struct SYNC_CSOBJECT **phCSObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_DPCCSOBJECT *pCSObj = NULL; ++ ++ DBC_Require(phCSObj); ++ ++ GT_0trace(SYNC_debugMask, GT_ENTER, "SYNC_InitializeDPCCS\n"); ++ ++ if (phCSObj) { ++ /* Allocate memory for sync CS object */ ++ MEM_AllocObject(pCSObj, struct SYNC_DPCCSOBJECT, ++ SIGNATUREDPCCS); ++ if (pCSObj != NULL) { ++ pCSObj->count = 1; ++ spin_lock_init(&pCSObj->sync_dpccs_lock); ++ } else { ++ status = DSP_EMEMORY; ++ GT_0trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_InitializeDPCCS: " ++ "MEM_AllocObject failed\n"); ++ } ++ ++ /* return CS object */ ++ *phCSObj = (struct SYNC_CSOBJECT *)pCSObj; ++ } else { ++ status = DSP_EPOINTER; ++ } ++ ++ GT_1trace(SYNC_debugMask, GT_ENTER, "SYNC_InitializeDPCCS " ++ "pCSObj %p\n", pCSObj); ++ DBC_Assert(DSP_FAILED(status) || (pCSObj)); ++ ++ return status; ++} ++ ++/* ++ * ======== SYNC_LeaveCS ======== ++ */ ++DSP_STATUS SYNC_LeaveCS(struct SYNC_CSOBJECT *hCSObj) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct SYNC_CSOBJECT *pCSObj = (struct SYNC_CSOBJECT *)hCSObj; ++ ++ GT_1trace(SYNC_debugMask, GT_ENTER, "SYNC_LeaveCS: hCSObj %p\n", ++ hCSObj); ++ ++ if (MEM_IsValidHandle(hCSObj, SIGNATURECS)) { ++ up(&pCSObj->sem); ++ } else if (MEM_IsValidHandle(hCSObj, SIGNATUREDPCCS)) { ++ struct SYNC_DPCCSOBJECT *pDPCCSObj = ++ (struct SYNC_DPCCSOBJECT *)hCSObj; ++ pDPCCSObj->count++; ++ if (pDPCCSObj->count != 1) { ++ /* FATAL ERROR : Invalid DPC CS count */ ++ GT_2trace(SYNC_debugMask, GT_7CLASS, ++ "SYNC_LeaveCS DPCCS %x, " ++ "Invalid count %d", pDPCCSObj, ++ pDPCCSObj->count); ++ spin_unlock_bh(&pDPCCSObj->sync_dpccs_lock); ++ DBC_Assert(0); ++ spin_lock_bh(&pDPCCSObj->sync_dpccs_lock); ++ } ++ spin_unlock_bh(&pDPCCSObj->sync_dpccs_lock); ++ GT_0trace(SYNC_debugMask, GT_ENTER, "SYNC_LeaveCS DPC\n"); ++ } else { ++ status = DSP_EHANDLE; ++ GT_1trace(SYNC_debugMask, GT_6CLASS, ++ "SYNC_LeaveCS: invalid hCSObj " ++ "handle 0x%x\n", hCSObj); ++ } ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/wmd/_cmm.h b/drivers/dsp/bridge/wmd/_cmm.h +new file mode 100644 +index 0000000..801b000 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_cmm.h +@@ -0,0 +1,59 @@ ++/* ++ * _cmm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _cmm.h ======== ++ * Description: ++ * Private header file defining CMM manager objects and defines needed ++ * by IO manager to register shared memory regions when DSP base image ++ * is loaded(WMD_IO_OnLoaded). ++ * ++ * Public Functions: ++ * None. ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 24-Aug-2001 ag Created. ++ */ ++ ++#ifndef _CMM_ ++#define _CMM_ ++ ++/* ++ * These target side symbols define the beginning and ending addresses ++ * of the section of shared memory used for shared memory manager CMM. ++ * They are defined in the *cfg.cmd file by cdb code. ++ */ ++#define SHM0_SHARED_BASE_SYM "_SHM0_BEG" ++#define SHM0_SHARED_END_SYM "_SHM0_END" ++#define SHM0_SHARED_RESERVED_BASE_SYM "_SHM0_RSVDSTRT" ++ ++/* ++ * Shared Memory Region #0(SHMSEG0) is used in the following way: ++ * ++ * |(_SHM0_BEG) | (_SHM0_RSVDSTRT) | (_SHM0_END) ++ * V V V ++ * ------------------------------------------------------------ ++ * | DSP-side allocations | GPP-side allocations | ++ * ------------------------------------------------------------ ++ * ++ * ++ */ ++ ++#endif /* _CMM_ */ +diff --git a/drivers/dsp/bridge/wmd/_deh.h b/drivers/dsp/bridge/wmd/_deh.h +new file mode 100644 +index 0000000..df281ad +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_deh.h +@@ -0,0 +1,46 @@ ++/* ++ * _deh.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _deh.h ======== ++ * Description: ++ * Private header for DEH module. ++ * ++ *! Revision History: ++ *! ================ ++ *! 21-Sep-2001 kc: created. ++ */ ++ ++#ifndef _DEH_ ++#define _DEH_ ++ ++#include <dspbridge/dpc.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/wmd.h> ++ ++#define SIGNATURE 0x5f484544 /* "DEH_" backwards */ ++ ++/* DEH Manager: only one created per board: */ ++struct DEH_MGR { ++ u32 dwSignature; /* Used for object validation. */ ++ struct WMD_DEV_CONTEXT *hWmdContext; /* WMD device context. */ ++ struct NTFY_OBJECT *hNtfy; /* NTFY object */ ++ struct DPC_OBJECT *hMmuFaultDpc; /* DPC object handle. */ ++ struct DSP_ERRORINFO errInfo; /* DSP exception info. */ ++} ; ++ ++#endif /* _DEH_ */ +diff --git a/drivers/dsp/bridge/wmd/_msg_sm.h b/drivers/dsp/bridge/wmd/_msg_sm.h +new file mode 100644 +index 0000000..fa5e9ee +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_msg_sm.h +@@ -0,0 +1,158 @@ ++/* ++ * _msg_sm.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _msg_sm.h ======== ++ * Description: ++ * Private header file defining MSG manager objects and defines needed ++ * by IO manager. ++ * ++ * Public Functions: ++ * None. ++ * ++ * Notes: ++ * ++ *! Revision History: ++ *! ================ ++ *! 09-May-2001 jeh Code Review cleanup. ++ *! 08-Nov-2000 jeh Created. ++ */ ++ ++#ifndef _MSG_SM_ ++#define _MSG_SM_ ++ ++#include <dspbridge/list.h> ++#include <dspbridge/msgdefs.h> ++ ++/* ++ * These target side symbols define the beginning and ending addresses ++ * of the section of shared memory used for messages. They are ++ * defined in the *cfg.cmd file by cdb code. ++ */ ++#define MSG_SHARED_BUFFER_BASE_SYM "_MSG_BEG" ++#define MSG_SHARED_BUFFER_LIMIT_SYM "_MSG_END" ++ ++#ifndef _CHNL_WORDSIZE ++#define _CHNL_WORDSIZE 4 /* default _CHNL_WORDSIZE is 2 bytes/word */ ++#endif ++ ++/* ++ * ======== MSG ======== ++ * There is a control structure for messages to the DSP, and a control ++ * structure for messages from the DSP. The shared memory region for ++ * transferring messages is partitioned as follows: ++ * ++ * ---------------------------------------------------------- ++ * |Control | Messages from DSP | Control | Messages to DSP | ++ * ---------------------------------------------------------- ++ * ++ * MSG control structure for messages to the DSP is used in the following ++ * way: ++ * ++ * bufEmpty - This flag is set to FALSE by the GPP after it has output ++ * messages for the DSP. The DSP host driver sets it to ++ * TRUE after it has copied the messages. ++ * postSWI - Set to 1 by the GPP after it has written the messages, ++ * set the size, and set bufEmpty to FALSE. ++ * The DSP Host driver uses SWI_andn of the postSWI field ++ * when a host interrupt occurs. The host driver clears ++ * this after posting the SWI. ++ * size - Number of messages to be read by the DSP. ++ * ++ * For messages from the DSP: ++ * bufEmpty - This flag is set to FALSE by the DSP after it has output ++ * messages for the GPP. The DPC on the GPP sets it to ++ * TRUE after it has copied the messages. ++ * postSWI - Set to 1 the DPC on the GPP after copying the messages. ++ * size - Number of messages to be read by the GPP. ++ */ ++struct MSG { ++ u32 bufEmpty; /* to/from DSP buffer is empty */ ++ u32 postSWI; /* Set to "1" to post MSG SWI */ ++ u32 size; /* Number of messages to/from the DSP */ ++ u32 resvd; ++} ; ++ ++/* ++ * ======== MSG_MGR ======== ++ * The MSG_MGR maintains a list of all MSG_QUEUEs. Each NODE object can ++ * have MSG_QUEUE to hold all messages that come up from the corresponding ++ * node on the DSP. The MSG_MGR also has a shared queue of messages ++ * ready to go to the DSP. ++ */ ++struct MSG_MGR { ++ /* The first two fields must match those in msgobj.h */ ++ u32 dwSignature; ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD. */ ++ ++ struct IO_MGR *hIOMgr; /* IO manager */ ++ struct LST_LIST *queueList; /* List of MSG_QUEUEs */ ++ struct SYNC_CSOBJECT *hSyncCS; /* For critical sections */ ++ /* Signalled when MsgFrame is available */ ++ struct SYNC_OBJECT *hSyncEvent; ++ struct LST_LIST *msgFreeList; /* Free MsgFrames ready to be filled */ ++ struct LST_LIST *msgUsedList; /* MsgFrames ready to go to DSP */ ++ u32 uMsgsPending; /* # of queued messages to go to DSP */ ++ u32 uMaxMsgs; /* Max # of msgs that fit in buffer */ ++ MSG_ONEXIT onExit; /* called when RMS_EXIT is received */ ++} ; ++ ++/* ++ * ======== MSG_QUEUE ======== ++ * Each NODE has a MSG_QUEUE for receiving messages from the ++ * corresponding node on the DSP. The MSG_QUEUE object maintains a list ++ * of messages that have been sent to the host, but not yet read (MSG_Get), ++ * and a list of free frames that can be filled when new messages arrive ++ * from the DSP. ++ * The MSG_QUEUE's hSynEvent gets posted when a message is ready. ++ */ ++struct MSG_QUEUE { ++ struct LST_ELEM listElem; ++ u32 dwSignature; ++ struct MSG_MGR *hMsgMgr; ++ u32 uMaxMsgs; /* Node message depth */ ++ u32 dwId; /* Node environment pointer */ ++ struct LST_LIST *msgFreeList; /* Free MsgFrames ready to be filled */ ++ /* Filled MsgFramess waiting to be read */ ++ struct LST_LIST *msgUsedList; ++ HANDLE hArg; /* Handle passed to mgr onExit callback */ ++ struct SYNC_OBJECT *hSyncEvent; /* Signalled when message is ready */ ++ struct SYNC_OBJECT *hSyncDone; /* For synchronizing cleanup */ ++ struct SYNC_OBJECT *hSyncDoneAck; /* For synchronizing cleanup */ ++ struct NTFY_OBJECT *hNtfy; /* For notification of message ready */ ++ bool fDone; /* TRUE <==> deleting the object */ ++ u32 refCount; /* Number of pending MSG_get/put calls */ ++}; ++ ++/* ++ * ======== MSG_DSPMSG ======== ++ */ ++struct MSG_DSPMSG { ++ struct DSP_MSG msg; ++ u32 dwId; /* Identifies the node the message goes to */ ++} ; ++ ++/* ++ * ======== MSG_FRAME ======== ++ */ ++struct MSG_FRAME { ++ struct LST_ELEM listElem; ++ struct MSG_DSPMSG msgData; ++} ; ++ ++#endif /* _MSG_SM_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/_tiomap.h b/drivers/dsp/bridge/wmd/_tiomap.h +new file mode 100644 +index 0000000..815f695 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_tiomap.h +@@ -0,0 +1,384 @@ ++/* ++ * _tiomap.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== _tiomap.h ======== ++ * Description: ++ * Definitions and types private to this WMD. ++ * ++ */ ++ ++#ifndef _TIOMAP_ ++#define _TIOMAP_ ++ ++#include <dspbridge/devdefs.h> ++#include <hw_defs.h> ++#include <hw_mbox.h> ++#include <dspbridge/wmdioctl.h> /* for WMDIOCTL_EXTPROC defn */ ++#include <dspbridge/sync.h> ++#include <dspbridge/clk.h> ++ ++struct MAP_L4PERIPHERAL { ++ u32 physAddr; ++ u32 dspVirtAddr; ++} ; ++ ++#define ARM_MAILBOX_START 0xfffcf000 ++#define ARM_MAILBOX_LENGTH 0x800 ++ ++/* New Registers in OMAP3.1 */ ++ ++#define TESTBLOCK_ID_START 0xfffed400 ++#define TESTBLOCK_ID_LENGTH 0xff ++ ++/* ID Returned by OMAP1510 */ ++#define TBC_ID_VALUE 0xB47002F ++ ++#define SPACE_LENGTH 0x2000 ++#define API_CLKM_DPLL_DMA 0xfffec000 ++#define ARM_INTERRUPT_OFFSET 0xb00 ++ ++#define BIOS_24XX ++ ++#define L4_PERIPHERAL_NULL 0x0 ++#define DSPVA_PERIPHERAL_NULL 0x0 ++ ++#define MAX_LOCK_TLB_ENTRIES 15 ++ ++#define L4_PERIPHERAL_PRM 0x48306000 /*PRM L4 Peripheral */ ++#define DSPVA_PERIPHERAL_PRM 0x1181e000 ++#define L4_PERIPHERAL_SCM 0x48002000 /*SCM L4 Peripheral */ ++#define DSPVA_PERIPHERAL_SCM 0x1181f000 ++#define L4_PERIPHERAL_MMU 0x5D000000 /*MMU L4 Peripheral */ ++#define DSPVA_PERIPHERAL_MMU 0x11820000 ++#define L4_PERIPHERAL_CM 0x48004000 /* Core L4, Clock Management */ ++#define DSPVA_PERIPHERAL_CM 0x1181c000 ++#define L4_PERIPHERAL_PER 0x48005000 /* PER */ ++#define DSPVA_PERIPHERAL_PER 0x1181d000 ++ ++#define L4_PERIPHERAL_GPIO1 0x48310000 ++#define DSPVA_PERIPHERAL_GPIO1 0x11809000 ++#define L4_PERIPHERAL_GPIO2 0x49050000 ++#define DSPVA_PERIPHERAL_GPIO2 0x1180a000 ++#define L4_PERIPHERAL_GPIO3 0x49052000 ++#define DSPVA_PERIPHERAL_GPIO3 0x1180b000 ++#define L4_PERIPHERAL_GPIO4 0x49054000 ++#define DSPVA_PERIPHERAL_GPIO4 0x1180c000 ++#define L4_PERIPHERAL_GPIO5 0x49056000 ++#define DSPVA_PERIPHERAL_GPIO5 0x1180d000 ++ ++#define L4_PERIPHERAL_IVA2WDT 0x49030000 ++#define DSPVA_PERIPHERAL_IVA2WDT 0x1180e000 ++ ++#define L4_PERIPHERAL_DISPLAY 0x48050000 ++#define DSPVA_PERIPHERAL_DISPLAY 0x1180f000 ++ ++#define L4_PERIPHERAL_SSI 0x48058000 ++#define DSPVA_PERIPHERAL_SSI 0x11804000 ++#define L4_PERIPHERAL_GDD 0x48059000 ++#define DSPVA_PERIPHERAL_GDD 0x11805000 ++#define L4_PERIPHERAL_SS1 0x4805a000 ++#define DSPVA_PERIPHERAL_SS1 0x11806000 ++#define L4_PERIPHERAL_SS2 0x4805b000 ++#define DSPVA_PERIPHERAL_SS2 0x11807000 ++ ++#define L4_PERIPHERAL_CAMERA 0x480BC000 ++#define DSPVA_PERIPHERAL_CAMERA 0x11819000 ++ ++#define L4_PERIPHERAL_SDMA 0x48056000 ++#define DSPVA_PERIPHERAL_SDMA 0x11810000 /*0x1181d000 conflicts with PER */ ++ ++#define L4_PERIPHERAL_UART1 0x4806a000 ++#define DSPVA_PERIPHERAL_UART1 0x11811000 ++#define L4_PERIPHERAL_UART2 0x4806c000 ++#define DSPVA_PERIPHERAL_UART2 0x11812000 ++#define L4_PERIPHERAL_UART3 0x49020000 ++#define DSPVA_PERIPHERAL_UART3 0x11813000 ++ ++#define L4_PERIPHERAL_MCBSP1 0x48074000 ++#define DSPVA_PERIPHERAL_MCBSP1 0x11814000 ++#define L4_PERIPHERAL_MCBSP2 0x49022000 ++#define DSPVA_PERIPHERAL_MCBSP2 0x11815000 ++#define L4_PERIPHERAL_MCBSP3 0x49024000 ++#define DSPVA_PERIPHERAL_MCBSP3 0x11816000 ++#define L4_PERIPHERAL_MCBSP4 0x49026000 ++#define DSPVA_PERIPHERAL_MCBSP4 0x11817000 ++#define L4_PERIPHERAL_MCBSP5 0x48096000 ++#define DSPVA_PERIPHERAL_MCBSP5 0x11818000 ++ ++#define L4_PERIPHERAL_GPTIMER5 0x49038000 ++#define DSPVA_PERIPHERAL_GPTIMER5 0x11800000 ++#define L4_PERIPHERAL_GPTIMER6 0x4903a000 ++#define DSPVA_PERIPHERAL_GPTIMER6 0x11801000 ++#define L4_PERIPHERAL_GPTIMER7 0x4903c000 ++#define DSPVA_PERIPHERAL_GPTIMER7 0x11802000 ++#define L4_PERIPHERAL_GPTIMER8 0x4903e000 ++#define DSPVA_PERIPHERAL_GPTIMER8 0x11803000 ++ ++#define L4_PERIPHERAL_SPI1 0x48098000 ++#define DSPVA_PERIPHERAL_SPI1 0x1181a000 ++#define L4_PERIPHERAL_SPI2 0x4809a000 ++#define DSPVA_PERIPHERAL_SPI2 0x1181b000 ++ ++#define L4_PERIPHERAL_MBOX 0x48094000 ++#define DSPVA_PERIPHERAL_MBOX 0x11808000 ++ ++#define PM_GRPSEL_BASE 0x48307000 ++#define DSPVA_GRPSEL_BASE 0x11821000 ++ ++#define L4_PERIPHERAL_SIDETONE_MCBSP2 0x49028000 ++#define DSPVA_PERIPHERAL_SIDETONE_MCBSP2 0x11824000 ++#define L4_PERIPHERAL_SIDETONE_MCBSP3 0x4902a000 ++#define DSPVA_PERIPHERAL_SIDETONE_MCBSP3 0x11825000 ++ ++/* define a static array with L4 mappings */ ++static const struct MAP_L4PERIPHERAL L4PeripheralTable[] = { ++ {L4_PERIPHERAL_MBOX, DSPVA_PERIPHERAL_MBOX}, ++ {L4_PERIPHERAL_SCM, DSPVA_PERIPHERAL_SCM}, ++ {L4_PERIPHERAL_MMU, DSPVA_PERIPHERAL_MMU}, ++ {L4_PERIPHERAL_GPTIMER5, DSPVA_PERIPHERAL_GPTIMER5}, ++ {L4_PERIPHERAL_GPTIMER6, DSPVA_PERIPHERAL_GPTIMER6}, ++ {L4_PERIPHERAL_GPTIMER7, DSPVA_PERIPHERAL_GPTIMER7}, ++ {L4_PERIPHERAL_GPTIMER8, DSPVA_PERIPHERAL_GPTIMER8}, ++ {L4_PERIPHERAL_GPIO1, DSPVA_PERIPHERAL_GPIO1}, ++ {L4_PERIPHERAL_GPIO2, DSPVA_PERIPHERAL_GPIO2}, ++ {L4_PERIPHERAL_GPIO3, DSPVA_PERIPHERAL_GPIO3}, ++ {L4_PERIPHERAL_GPIO4, DSPVA_PERIPHERAL_GPIO4}, ++ {L4_PERIPHERAL_GPIO5, DSPVA_PERIPHERAL_GPIO5}, ++ {L4_PERIPHERAL_IVA2WDT, DSPVA_PERIPHERAL_IVA2WDT}, ++ {L4_PERIPHERAL_DISPLAY, DSPVA_PERIPHERAL_DISPLAY}, ++ {L4_PERIPHERAL_SSI, DSPVA_PERIPHERAL_SSI}, ++ {L4_PERIPHERAL_GDD, DSPVA_PERIPHERAL_GDD}, ++ {L4_PERIPHERAL_SS1, DSPVA_PERIPHERAL_SS1}, ++ {L4_PERIPHERAL_SS2, DSPVA_PERIPHERAL_SS2}, ++ {L4_PERIPHERAL_UART1, DSPVA_PERIPHERAL_UART1}, ++ {L4_PERIPHERAL_UART2, DSPVA_PERIPHERAL_UART2}, ++ {L4_PERIPHERAL_UART3, DSPVA_PERIPHERAL_UART3}, ++ {L4_PERIPHERAL_MCBSP1, DSPVA_PERIPHERAL_MCBSP1}, ++ {L4_PERIPHERAL_MCBSP2, DSPVA_PERIPHERAL_MCBSP2}, ++ {L4_PERIPHERAL_MCBSP3, DSPVA_PERIPHERAL_MCBSP3}, ++ {L4_PERIPHERAL_MCBSP4, DSPVA_PERIPHERAL_MCBSP4}, ++ {L4_PERIPHERAL_MCBSP5, DSPVA_PERIPHERAL_MCBSP5}, ++ {L4_PERIPHERAL_CAMERA, DSPVA_PERIPHERAL_CAMERA}, ++ {L4_PERIPHERAL_SPI1, DSPVA_PERIPHERAL_SPI1}, ++ {L4_PERIPHERAL_SPI2, DSPVA_PERIPHERAL_SPI2}, ++ {L4_PERIPHERAL_PRM, DSPVA_PERIPHERAL_PRM}, ++ {L4_PERIPHERAL_CM, DSPVA_PERIPHERAL_CM}, ++ {L4_PERIPHERAL_PER, DSPVA_PERIPHERAL_PER}, ++ {PM_GRPSEL_BASE, DSPVA_GRPSEL_BASE}, ++ {L4_PERIPHERAL_SIDETONE_MCBSP2, DSPVA_PERIPHERAL_SIDETONE_MCBSP2}, ++ {L4_PERIPHERAL_SIDETONE_MCBSP3, DSPVA_PERIPHERAL_SIDETONE_MCBSP3}, ++ {L4_PERIPHERAL_NULL, DSPVA_PERIPHERAL_NULL} ++}; ++ ++/* ++ * 15 10 0 ++ * --------------------------------- ++ * |0|0|1|0|0|0|c|c|c|i|i|i|i|i|i|i| ++ * --------------------------------- ++ * | (class) | (module specific) | ++ * ++ * where c -> Externel Clock Command: Clk & Autoidle Disable/Enable ++ * i -> External Clock ID Timers 5,6,7,8, McBSP1,2 and WDT3 ++ */ ++ ++/* MBX_PM_CLK_IDMASK: DSP External clock id mask. */ ++#define MBX_PM_CLK_IDMASK 0x7F ++ ++/* MBX_PM_CLK_CMDSHIFT: DSP External clock command shift. */ ++#define MBX_PM_CLK_CMDSHIFT 7 ++ ++/* MBX_PM_CLK_CMDMASK: DSP External clock command mask. */ ++#define MBX_PM_CLK_CMDMASK 7 ++ ++/* MBX_PM_MAX_RESOURCES: CORE 1 Clock resources. */ ++#define MBX_CORE1_RESOURCES 7 ++ ++/* MBX_PM_MAX_RESOURCES: CORE 2 Clock Resources. */ ++#define MBX_CORE2_RESOURCES 1 ++ ++/* MBX_PM_MAX_RESOURCES: TOTAL Clock Reosurces. */ ++#define MBX_PM_MAX_RESOURCES 11 ++ ++/* Power Management Commands */ ++enum BPWR_ExtClockCmd { ++ BPWR_DisableClock = 0, ++ BPWR_EnableClock, ++ BPWR_DisableAutoIdle, ++ BPWR_EnableAutoIdle ++} ; ++ ++/* OMAP242x specific resources */ ++enum BPWR_ExtClockId { ++ BPWR_GPTimer5 = 0x10, ++ BPWR_GPTimer6, ++ BPWR_GPTimer7, ++ BPWR_GPTimer8, ++ BPWR_WDTimer3, ++ BPWR_MCBSP1, ++ BPWR_MCBSP2, ++ BPWR_MCBSP3, ++ BPWR_MCBSP4, ++ BPWR_MCBSP5, ++ BPWR_SSI = 0x20 ++} ; ++ ++static const u32 BPWR_CLKID[] = { ++ (u32) BPWR_GPTimer5, ++ (u32) BPWR_GPTimer6, ++ (u32) BPWR_GPTimer7, ++ (u32) BPWR_GPTimer8, ++ (u32) BPWR_WDTimer3, ++ (u32) BPWR_MCBSP1, ++ (u32) BPWR_MCBSP2, ++ (u32) BPWR_MCBSP3, ++ (u32) BPWR_MCBSP4, ++ (u32) BPWR_MCBSP5, ++ (u32) BPWR_SSI ++}; ++ ++struct BPWR_Clk_t { ++ u32 clkId; ++ enum SERVICES_ClkId funClk; ++ enum SERVICES_ClkId intClk; ++} ; ++ ++static const struct BPWR_Clk_t BPWR_Clks[] = { ++ {(u32) BPWR_GPTimer5, SERVICESCLK_gpt5_fck, SERVICESCLK_gpt5_ick}, ++ {(u32) BPWR_GPTimer6, SERVICESCLK_gpt6_fck, SERVICESCLK_gpt6_ick}, ++ {(u32) BPWR_GPTimer7, SERVICESCLK_gpt7_fck, SERVICESCLK_gpt7_ick}, ++ {(u32) BPWR_GPTimer8, SERVICESCLK_gpt8_fck, SERVICESCLK_gpt8_ick}, ++ {(u32) BPWR_WDTimer3, SERVICESCLK_wdt3_fck, SERVICESCLK_wdt3_ick}, ++ {(u32) BPWR_MCBSP1, SERVICESCLK_mcbsp1_fck, SERVICESCLK_mcbsp1_ick}, ++ {(u32) BPWR_MCBSP2, SERVICESCLK_mcbsp2_fck, SERVICESCLK_mcbsp2_ick}, ++ {(u32) BPWR_MCBSP3, SERVICESCLK_mcbsp3_fck, SERVICESCLK_mcbsp3_ick}, ++ {(u32) BPWR_MCBSP4, SERVICESCLK_mcbsp4_fck, SERVICESCLK_mcbsp4_ick}, ++ {(u32) BPWR_MCBSP5, SERVICESCLK_mcbsp5_fck, SERVICESCLK_mcbsp5_ick}, ++ {(u32) BPWR_SSI, SERVICESCLK_ssi_fck, SERVICESCLK_ssi_ick} ++}; ++ ++/* Interrupt Register Offsets */ ++#define INTH_IT_REG_OFFSET 0x00 /* Interrupt register offset */ ++#define INTH_MASK_IT_REG_OFFSET 0x04 /* Mask Interrupt reg offset */ ++ ++#define DSP_MAILBOX1_INT 10 ++ ++/* ++ * INTH_InterruptKind_t ++ * Identify the kind of interrupt: either FIQ/IRQ ++ */ ++enum INTH_InterruptKind_t { ++ INTH_IRQ = 0, ++ INTH_FIQ = 1 ++} ; ++ ++enum INTH_SensitiveEdge_t { ++ FALLING_EDGE_SENSITIVE = 0, ++ LOW_LEVEL_SENSITIVE = 1 ++} ; ++ ++/* ++ * Bit definition of Interrupt Level Registers ++ */ ++ ++/* Mail Box defines */ ++#define MB_ARM2DSP1_REG_OFFSET 0x00 ++ ++#define MB_ARM2DSP1B_REG_OFFSET 0x04 ++ ++#define MB_DSP2ARM1B_REG_OFFSET 0x0C ++ ++#define MB_ARM2DSP1_FLAG_REG_OFFSET 0x18 ++ ++#define MB_ARM2DSP_FLAG 0x0001 ++ ++#define MBOX_ARM2DSP HW_MBOX_ID_0 ++#define MBOX_DSP2ARM HW_MBOX_ID_1 ++#define MBOX_ARM HW_MBOX_U0_ARM ++#define MBOX_DSP HW_MBOX_U1_DSP1 ++ ++#define ENABLE true ++#define DISABLE false ++ ++#define HIGH_LEVEL true ++#define LOW_LEVEL false ++ ++/* Macro's */ ++#define REG16(A) (*(REG_UWORD16 *)(A)) ++ ++#define ClearBit(reg, mask) (reg &= ~mask) ++#define SetBit(reg, mask) (reg |= mask) ++ ++#define SetGroupBits16(reg, position, width, value) \ ++ do {\ ++ reg &= ~((0xFFFF >> (16 - (width))) << (position)) ; \ ++ reg |= ((value & (0xFFFF >> (16 - (width)))) << (position)); \ ++ } while (0); ++ ++#define ClearBitIndex(reg, index) (reg &= ~(1 << (index))) ++ ++/* This mini driver's device context: */ ++struct WMD_DEV_CONTEXT { ++ struct DEV_OBJECT *hDevObject; /* Handle to WCD device object. */ ++ u32 dwDspBaseAddr; /* Arm's API to DSP virtual base addr */ ++ /* ++ * DSP External memory prog address as seen virtually by the OS on ++ * the host side. ++ */ ++ u32 dwDspExtBaseAddr; /* See the comment above */ ++ u32 dwAPIRegBase; /* API memory mapped registers */ ++ u32 dwDSPMmuBase; /* DSP MMU Mapped registers */ ++ u32 dwMailBoxBase; /* Mail box mapped registers */ ++ u32 dwAPIClkBase; /* CLK Registers */ ++ u32 dwDSPClkM2Base; /* DSP Clock Module m2 */ ++ u32 dwPublicRhea; /* Pub Rhea */ ++ u32 dwIntAddr; /* MB INTR reg */ ++ u32 dwTCEndianism; /* TC Endianism register */ ++ u32 dwTestBase; /* DSP MMU Mapped registers */ ++ u32 dwSelfLoop; /* Pointer to the selfloop */ ++ u32 dwDSPStartAdd; /* API Boot vector */ ++ u32 dwInternalSize; /* Internal memory size */ ++ ++ /* ++ * Processor specific info is set when prog loaded and read from DCD. ++ * [See WMD_BRD_Ctrl()] PROC info contains DSP-MMU TLB entries. ++ */ ++ /* DMMU TLB entries */ ++ struct WMDIOCTL_EXTPROC aTLBEntry[WMDIOCTL_NUMOFMMUTLB]; ++ u32 dwBrdState; /* Last known board state. */ ++ u32 ulIntMask; /* int mask */ ++ u16 ioBase; /* Board I/O base */ ++ u32 numTLBEntries; /* DSP MMU TLB entry counter */ ++ u32 fixedTLBEntries; /* Fixed DSPMMU TLB entry count */ ++ ++ /* TC Settings */ ++ bool tcWordSwapOn; /* Traffic Controller Word Swap */ ++ struct PgTableAttrs *pPtAttrs; ++ u32 uDspPerClks; ++} ; ++ ++ /* ++ * ======== WMD_TLB_DspVAToMpuPA ======== ++ * Given a DSP virtual address, traverse the page table and return ++ * a corresponding MPU physical address and size. ++ */ ++extern DSP_STATUS WMD_TLB_DspVAToMpuPA(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u32 ulVirtAddr, ++ OUT u32 *ulPhysAddr, ++ OUT u32 *sizeTlb); ++ ++#endif /* _TIOMAP_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/_tiomap_mmu.h b/drivers/dsp/bridge/wmd/_tiomap_mmu.h +new file mode 100644 +index 0000000..6b21047 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_tiomap_mmu.h +@@ -0,0 +1,53 @@ ++/* ++ * _tiomap_mmu.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _tiomap_mmu.h ======== ++ * Description: ++ * Definitions and types for the DSP MMU modules ++ * ++ *! Revision History ++ *! ================ ++ *! 19-Apr-2004 sb: Renamed HW types. Removed dspMmuTlbEntry ++ *! 05-Jan-2004 vp: Moved the file to a platform specific folder from common. ++ *! 21-Mar-2003 sb: Added macro definition TIHEL_LARGEPAGESIZE ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++#ifndef _TIOMAP_MMU_ ++#define _TIOMAP_MMU_ ++ ++#include "_tiomap.h" ++ ++/* ++ * ======== configureDspMmu ======== ++ * ++ * Make DSP MMu page table entries. ++ * Note: Not utilizing Coarse / Fine page tables. ++ * SECTION = 1MB, LARGE_PAGE = 64KB, SMALL_PAGE = 4KB, TINY_PAGE = 1KB. ++ * DSP Byte address 0x40_0000 is word addr 0x20_0000. ++ */ ++extern void configureDspMmu(struct WMD_DEV_CONTEXT *pDevContext, ++ u32 dataBasePhys, ++ u32 dspBaseVirt, ++ u32 sizeInBytes, ++ s32 nEntryStart, ++ enum HW_Endianism_t endianism, ++ enum HW_ElementSize_t elemSize, ++ enum HW_MMUMixedSize_t mixedSize); ++ ++#endif /* _TIOMAP_MMU_ */ +diff --git a/drivers/dsp/bridge/wmd/_tiomap_pwr.h b/drivers/dsp/bridge/wmd/_tiomap_pwr.h +new file mode 100644 +index 0000000..7ebd7b5 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_tiomap_pwr.h +@@ -0,0 +1,102 @@ ++/* ++ * _tiomap_pwr.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _tiomap_pwr.h ======== ++ * Description: ++ * Definitions and types for the DSP wake/sleep routines. ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++#ifndef _TIOMAP_PWR_ ++#define _TIOMAP_PWR_ ++ ++/* ++ * ======== WakeDSP ========= ++ * Wakes up the DSP from DeepSleep ++ */ ++extern DSP_STATUS WakeDSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs); ++ ++/* ++ * ======== SleepDSP ========= ++ * Places the DSP in DeepSleep. ++ */ ++extern DSP_STATUS SleepDSP(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u32 dwCmd, IN void *pArgs); ++/* ++ * ========InterruptDSP======== ++ * Sends an interrupt to DSP unconditionally. ++ */ ++extern void InterruptDSP(struct WMD_DEV_CONTEXT *pDevContext, IN u16 wMbVal); ++ ++/* ++ * ======== WakeDSP ========= ++ * Wakes up the DSP from DeepSleep ++ */ ++extern DSP_STATUS DSPPeripheralClkCtrl(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs); ++/* ++ * ======== handle_hibernation_fromDSP ======== ++ * Handle Hibernation requested from DSP ++ */ ++DSP_STATUS handle_hibernation_fromDSP(struct WMD_DEV_CONTEXT *pDevContext); ++/* ++ * ======== PostScale_DSP ======== ++ * Handle Post Scale notification to DSP ++ */ ++DSP_STATUS PostScale_DSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs); ++/* ++ * ======== PreScale_DSP ======== ++ * Handle Pre Scale notification to DSP ++ */ ++DSP_STATUS PreScale_DSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs); ++/* ++ * ======== handle_constraints_set ======== ++ * Handle constraints request from DSP ++ */ ++DSP_STATUS handle_constraints_set(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs); ++/* ++ * ======== DSP_PeripheralClocks_Disable ======== ++ * This function disables all the peripheral clocks that ++ * were enabled by DSP. Call this function only when ++ * DSP is entering Hibernation or when DSP is in ++ * Error state ++ */ ++DSP_STATUS DSP_PeripheralClocks_Disable(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs); ++ ++/* ++ * ======== DSP_PeripheralClocks_Enable ======== ++ * This function enables all the peripheral clocks that ++ * were requested by DSP. ++ */ ++DSP_STATUS DSP_PeripheralClocks_Enable(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs); ++ ++/* ++ * ======== DSPClkWakeupEventCtrl ======== ++ * This function sets the group selction bits for while ++ * enabling/disabling. ++ */ ++void DSPClkWakeupEventCtrl(u32 ClkId, bool enable); ++ ++#endif /* _TIOMAP_PWR_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/_tiomap_util.h b/drivers/dsp/bridge/wmd/_tiomap_util.h +new file mode 100644 +index 0000000..47e1e5d +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/_tiomap_util.h +@@ -0,0 +1,46 @@ ++/* ++ * _tiomap_util.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _tiomap_util.h ======== ++ * Description: ++ * Definitions and types for the utility routines. ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++#ifndef _TIOMAP_UTIL_ ++#define _TIOMAP_UTIL_ ++ ++/* Time out Values in uSeconds*/ ++#define TIHELEN_ACKTIMEOUT 10000 ++ ++/* Time delay for HOM->SAM transition. */ ++#define WAIT_SAM 1000000 /* in usec (1000 millisec) */ ++ ++/* ++ * ======== WaitForStart ======== ++ * Wait for the singal from DSP that it has started, or time out. ++ * The argument dwSyncAddr is set to 1 before releasing the DSP. ++ * If the DSP starts running, it will clear this location. ++ */ ++extern bool WaitForStart(struct WMD_DEV_CONTEXT *pDevContext, u32 dwSyncAddr); ++ ++#endif /* _TIOMAP_UTIL_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/chnl_sm.c b/drivers/dsp/bridge/wmd/chnl_sm.c +new file mode 100644 +index 0000000..e8ffb2f +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/chnl_sm.c +@@ -0,0 +1,1100 @@ ++/* ++ * chnl_sm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== chnl_sm.c ======== ++ * Description: ++ * Implements upper edge functions for WMD channel module. ++ * ++ * Public Functions: ++ * WMD_CHNL_AddIOReq ++ * WMD_CHNL_CancelIO ++ * WMD_CHNL_Close ++ * WMD_CHNL_Create ++ * WMD_CHNL_Destroy ++ * WMD_CHNL_FlushIO ++ * WMD_CHNL_GetInfo ++ * WMD_CHNL_GetIOC ++ * WMD_CHNL_GetMgrInfo ++ * WMD_CHNL_Idle ++ * WMD_CHNL_Open ++ * ++ * Notes: ++ * The lower edge functions must be implemented by the WMD writer, and ++ * are declared in chnl_sm.h. ++ * ++ * Care is taken in this code to prevent simulataneous access to channel ++ * queues from ++ * 1. Threads. ++ * 2. IO_DPC(), scheduled from the IO_ISR() as an event. ++ * ++ * This is done primarily by: ++ * - Semaphores. ++ * - state flags in the channel object; and ++ * - ensuring the IO_Dispatch() routine, which is called from both ++ * CHNL_AddIOReq() and the DPC(if implemented), is not re-entered. ++ * ++ * Channel Invariant: ++ * There is an important invariant condition which must be maintained per ++ * channel outside of WMD_CHNL_GetIOC() and IO_Dispatch(), violation of ++ * which may cause timeouts and/or failure offunction SYNC_WaitOnEvent. ++ * This invariant condition is: ++ * ++ * LST_Empty(pChnl->pIOCompletions) ==> pChnl->hSyncEvent is reset ++ * and ++ * !LST_Empty(pChnl->pIOCompletions) ==> pChnl->hSyncEvent is set. ++ * ++ *! Revision History: ++ *! ================ ++ *! 10-Feb-2004 sb: Consolidated the MAILBOX_IRQ macro at the top of the file. ++ *! 05-Jan-2004 vp: Updated for 2.6 kernel on 24xx platform. ++ *! 23-Apr-2003 sb: Fixed mailbox deadlock ++ *! 24-Feb-2003 vp: Code Review Updates. ++ *! 18-Oct-2002 vp: Ported to Linux platform ++ *! 29-Aug-2002 rr Changed the SYNC error code return to DSP error code return ++ * in WMD_CHNL_GetIOC. ++ *! 22-Jan-2002 ag Zero-copy support added. ++ *! CMM_CallocBuf() used for SM allocations. ++ *! 04-Feb-2001 ag DSP-DMA support added. ++ *! 22-Nov-2000 kc: Updated usage of PERF_RegisterStat. ++ *! 06-Nov-2000 jeh Move ISR_Install, DPC_Create from CHNL_Create to IO_Create. ++ *! 13-Oct-2000 jeh Added dwArg parameter to WMD_CHNL_AddIOReq(), added ++ *! WMD_CHNL_Idle and WMD_CHNL_RegisterNotify for DSPStream. ++ *! Remove #ifdef DEBUG from around channel cIOCs field. ++ *! 21-Sep-2000 rr: PreOMAP chnl class library acts like a IO class library. ++ *! 25-Sep-2000 ag: MEM_[Unmap]LinearAddress added for #ifdef CHNL_PREOMAP. ++ *! 07-Sep-2000 rr: Added new channel class for PreOMAP. ++ *! 11-Jul-2000 jeh Allow NULL user event in WMD_CHNL_Open(). ++ *! 06-Jul-2000 rr: Changed prefix PROC to PRCS for process module calls. ++ *! 20-Jan-2000 ag: Incorporated code review comments. ++ *! 05-Jan-2000 ag: Text format cleanup. ++ *! 07-Dec-1999 ag: Now setting ChnlMgr fSharedIRQ flag before ISR_Install(). ++ *! 01-Dec-1999 ag: WMD_CHNL_Open() now accepts named sync event. ++ *! 14-Nov-1999 ag: DPC_Schedule() uncommented. ++ *! 28-Oct-1999 ag: CHNL Attrs userEvent not supported. ++ *! SM addrs taken from COFF(IO) or host resource(SM). ++ *! 25-May-1999 jg: CHNL_IOCLASS boards now get their shared memory buffer ++ *! address and length from symbols defined in the currently ++ *! loaded COFF file. See _chn_sm.h. ++ *! 18-Jun-1997 gp: Moved waiting back to ring 0 to improve performance. ++ *! 22-Jan-1998 gp: Update User's pIOC struct in GetIOC at lower IRQL (NT). ++ *! 16-Jan-1998 gp: Commented out PERF stuff, since it is not all there in NT. ++ *! 13-Jan-1998 gp: Protect IOCTLs from IO_DPC by raising IRQL to DIRQL (NT). ++ *! 22-Oct-1997 gp: Call SYNC_OpenEvent in CHNL_Open, for NT support. ++ *! 18-Jun-1997 gp: Moved waiting back to ring 0 to improve performance. ++ *! 16-Jun-1997 gp: Added call into lower edge CHNL function to allow override ++ *! of the SHM window length reported by Windows CM. ++ *! 05-Jun-1997 gp: Removed unnecessary critical sections. ++ *! 18-Mar-1997 gp: Ensured CHNL_FlushIO on input leaves channel in READY state. ++ *! 06-Jan-1997 gp: ifdefed to support the IO variant of SHM channel class lib. ++ *! 21-Jan-1997 gp: CHNL_Close: set pChnl = NULL for DBC_Ensure(). ++ *! 14-Jan-1997 gp: Updated based on code review feedback. ++ *! 03-Jan-1997 gp: Added CHNL_E_WAITTIMEOUT error return code to CHNL_FlushIO() ++ *! 23-Oct-1996 gp: Tag channel with ring 0 process handle. ++ *! 13-Sep-1996 gp: Added performance statistics for channel. ++ *! 09-Sep-1996 gp: Added WMD_CHNL_GetMgrInfo(). ++ *! 04-Sep-1996 gp: Removed shared memory control struct offset: made zero. ++ *! 01-Aug-1996 gp: Implemented basic channel manager and channel create/delete. ++ *! 17-Jul-1996 gp: Started pseudo coding. ++ *! 11-Jul-1996 gp: Stubbed out. ++ */ ++ ++/* ----------------------------------- OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/cfg.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Mini-Driver */ ++#include <dspbridge/wmd.h> ++#include <dspbridge/wmdchnl.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/io_sm.h> ++ ++/* ----------------------------------- Define for This */ ++#define USERMODE_ADDR PAGE_OFFSET ++ ++#define MAILBOX_IRQ INT_MAIL_MPU_IRQ ++ ++/* ----------------------------------- Function Prototypes */ ++static struct LST_LIST *CreateChirpList(u32 uChirps); ++ ++static void FreeChirpList(struct LST_LIST *pList); ++ ++static struct CHNL_IRP *MakeNewChirp(void); ++ ++static DSP_STATUS SearchFreeChannel(struct CHNL_MGR *pChnlMgr, ++ OUT u32 *pdwChnl); ++ ++/* ++ * ======== WMD_CHNL_AddIOReq ======== ++ * Enqueue an I/O request for data transfer on a channel to the DSP. ++ * The direction (mode) is specified in the channel object. Note the DSP ++ * address is specified for channels opened in direct I/O mode. ++ */ ++DSP_STATUS WMD_CHNL_AddIOReq(struct CHNL_OBJECT *hChnl, void *pHostBuf, ++ u32 cBytes, u32 cBufSize, ++ OPTIONAL u32 dwDspAddr, u32 dwArg) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ struct CHNL_IRP *pChirp = NULL; ++ u32 dwState; ++ bool fIsEOS; ++ struct CHNL_MGR *pChnlMgr = pChnl->pChnlMgr; ++ u8 *pHostSysBuf = NULL; ++ bool fSchedDPC = false; ++ u16 wMbVal = 0; ++ ++ DBG_Trace(DBG_ENTER, ++ "> WMD_CHNL_AddIOReq pChnl %p CHNL_IsOutput %x uChnlType " ++ "%x Id %d\n", pChnl, CHNL_IsOutput(pChnl->uMode), ++ pChnl->uChnlType, pChnl->uId); ++ ++ fIsEOS = (cBytes == 0) ? true : false; ++ ++ if (pChnl->uChnlType == CHNL_PCPY && pChnl->uId > 1 && pHostBuf) { ++ if (!(pHostBuf < (void *)USERMODE_ADDR)) { ++ pHostSysBuf = pHostBuf; ++ goto func_cont; ++ } ++ /* if addr in user mode, then copy to kernel space */ ++ pHostSysBuf = MEM_Alloc(cBufSize, MEM_NONPAGED); ++ if (pHostSysBuf == NULL) { ++ status = DSP_EMEMORY; ++ DBG_Trace(DBG_LEVEL7, ++ "No memory to allocate kernel buffer\n"); ++ goto func_cont; ++ } ++ if (CHNL_IsOutput(pChnl->uMode)) { ++ status = copy_from_user(pHostSysBuf, pHostBuf, ++ cBufSize); ++ if (status) { ++ DBG_Trace(DBG_LEVEL7, ++ "Error copying user buffer to " ++ "kernel, %d bytes remaining.\n", ++ status); ++ MEM_Free(pHostSysBuf); ++ pHostSysBuf = NULL; ++ status = DSP_EPOINTER; ++ } ++ } ++ } ++func_cont: ++ /* Validate args: */ ++ if (pHostBuf == NULL) { ++ status = DSP_EPOINTER; ++ } else if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else if (fIsEOS && CHNL_IsInput(pChnl->uMode)) { ++ status = CHNL_E_NOEOS; ++ } else { ++ /* Check the channel state: only queue chirp if channel state ++ * allows */ ++ dwState = pChnl->dwState; ++ if (dwState != CHNL_STATEREADY) { ++ if (dwState & CHNL_STATECANCEL) { ++ status = CHNL_E_CANCELLED; ++ } else if ((dwState & CHNL_STATEEOS) ++ && CHNL_IsOutput(pChnl->uMode)) { ++ status = CHNL_E_EOS; ++ } else { ++ /* No other possible states left: */ ++ DBC_Assert(0); ++ } ++ } ++ } ++ /* Mailbox IRQ is disabled to avoid race condition with DMA/ZCPY ++ * channels. DPCCS is held to avoid race conditions with PCPY channels. ++ * If DPC is scheduled in process context (IO_Schedule) and any ++ * non-mailbox interrupt occurs, that DPC will run and break CS. Hence ++ * we disable ALL DPCs. We will try to disable ONLY IO DPC later. */ ++ SYNC_EnterCS(pChnlMgr->hCSObj); ++ disable_irq(MAILBOX_IRQ); ++ if (pChnl->uChnlType == CHNL_PCPY) { ++ /* This is a processor-copy channel. */ ++ if (DSP_SUCCEEDED(status) && CHNL_IsOutput(pChnl->uMode)) { ++ /* Check buffer size on output channels for fit. */ ++ if (cBytes > IO_BufSize(pChnl->pChnlMgr->hIOMgr)) ++ status = CHNL_E_BUFSIZE; ++ ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get a free chirp: */ ++ pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pFreeList); ++ if (pChirp == NULL) ++ status = CHNL_E_NOIORPS; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Enqueue the chirp on the chnl's IORequest queue: */ ++ pChirp->pHostUserBuf = pChirp->pHostSysBuf = pHostBuf; ++ if (pChnl->uChnlType == CHNL_PCPY && pChnl->uId > 1) ++ pChirp->pHostSysBuf = pHostSysBuf; ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Note: for dma chans dwDspAddr contains dsp address ++ * of SM buffer.*/ ++ DBC_Assert(pChnlMgr->uWordSize != 0); ++ /* DSP address */ ++ pChirp->uDspAddr = dwDspAddr / pChnlMgr->uWordSize; ++ pChirp->cBytes = cBytes; ++ pChirp->cBufSize = cBufSize; ++ /* Only valid for output channel */ ++ pChirp->dwArg = dwArg; ++ pChirp->status = (fIsEOS ? CHNL_IOCSTATEOS : ++ CHNL_IOCSTATCOMPLETE); ++ LST_PutTail(pChnl->pIORequests, (struct LST_ELEM *) ++ pChirp); ++ pChnl->cIOReqs++; ++ DBC_Assert(pChnl->cIOReqs <= pChnl->cChirps); ++ /* If end of stream, update the channel state to prevent ++ * more IOR's: */ ++ if (fIsEOS) ++ pChnl->dwState |= CHNL_STATEEOS; ++ ++ { ++ /* Legacy DSM Processor-Copy */ ++ DBC_Assert(pChnl->uChnlType == CHNL_PCPY); ++ /* Request IO from the DSP */ ++ IO_RequestChnl(pChnlMgr->hIOMgr, pChnl, ++ (CHNL_IsInput(pChnl->uMode) ? ++ IO_INPUT : IO_OUTPUT), &wMbVal); ++ fSchedDPC = true; ++ } ++ } ++ } ++ enable_irq(MAILBOX_IRQ); ++ SYNC_LeaveCS(pChnlMgr->hCSObj); ++ if (wMbVal != 0) ++ IO_IntrDSP2(pChnlMgr->hIOMgr, wMbVal); ++ ++ if (fSchedDPC == true) { ++ /* Schedule a DPC, to do the actual data transfer: */ ++ IO_Schedule(pChnlMgr->hIOMgr); ++ } ++ DBG_Trace(DBG_ENTER, "< WMD_CHNL_AddIOReq pChnl %p\n", pChnl); ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_CancelIO ======== ++ * Return all I/O requests to the client which have not yet been ++ * transferred. The channel's I/O completion object is ++ * signalled, and all the I/O requests are queued as IOC's, with the ++ * status field set to CHNL_IOCSTATCANCEL. ++ * This call is typically used in abort situations, and is a prelude to ++ * CHNL_Close(); ++ */ ++DSP_STATUS WMD_CHNL_CancelIO(struct CHNL_OBJECT *hChnl) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ u32 iChnl = -1; ++ CHNL_MODE uMode; ++ struct CHNL_IRP *pChirp; ++ struct CHNL_MGR *pChnlMgr = NULL; ++ ++ /* Check args: */ ++ if (MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ iChnl = pChnl->uId; ++ uMode = pChnl->uMode; ++ pChnlMgr = pChnl->pChnlMgr; ++ } else { ++ status = DSP_EHANDLE; ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ /* Mark this channel as cancelled, to prevent further IORequests or ++ * IORequests or dispatching. */ ++ SYNC_EnterCS(pChnlMgr->hCSObj); ++ pChnl->dwState |= CHNL_STATECANCEL; ++ if (LST_IsEmpty(pChnl->pIORequests)) ++ goto func_cont; ++ ++ if (pChnl->uChnlType == CHNL_PCPY) { ++ /* Indicate we have no more buffers available for transfer: */ ++ if (CHNL_IsInput(pChnl->uMode)) { ++ IO_CancelChnl(pChnlMgr->hIOMgr, iChnl); ++ } else { ++ /* Record that we no longer have output buffers ++ * available: */ ++ pChnlMgr->dwOutputMask &= ~(1 << iChnl); ++ } ++ } ++ /* Move all IOR's to IOC queue: */ ++ while (!LST_IsEmpty(pChnl->pIORequests)) { ++ pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pIORequests); ++ if (pChirp) { ++ pChirp->cBytes = 0; ++ pChirp->status |= CHNL_IOCSTATCANCEL; ++ LST_PutTail(pChnl->pIOCompletions, ++ (struct LST_ELEM *)pChirp); ++ pChnl->cIOCs++; ++ pChnl->cIOReqs--; ++ DBC_Assert(pChnl->cIOReqs >= 0); ++ } ++ } ++func_cont: ++ SYNC_LeaveCS(pChnlMgr->hCSObj); ++func_end: ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_Close ======== ++ * Purpose: ++ * Ensures all pending I/O on this channel is cancelled, discards all ++ * queued I/O completion notifications, then frees the resources allocated ++ * for this channel, and makes the corresponding logical channel id ++ * available for subsequent use. ++ */ ++DSP_STATUS WMD_CHNL_Close(struct CHNL_OBJECT *hChnl) ++{ ++ DSP_STATUS status; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ ++ /* Check args: */ ++ if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ goto func_cont; ++ } ++ { ++ /* Cancel IO: this ensures no further IO requests or ++ * notifications.*/ ++ status = WMD_CHNL_CancelIO(hChnl); ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) { ++ /* Assert I/O on this channel is now cancelled: Protects ++ * from IO_DPC. */ ++ DBC_Assert((pChnl->dwState & CHNL_STATECANCEL)); ++ /* Invalidate channel object: Protects from ++ * CHNL_GetIOCompletion(). */ ++ pChnl->dwSignature = 0x0000; ++ /* Free the slot in the channel manager: */ ++ pChnl->pChnlMgr->apChannel[pChnl->uId] = NULL; ++ pChnl->pChnlMgr->cOpenChannels -= 1; ++ if (pChnl->hNtfy) { ++ NTFY_Delete(pChnl->hNtfy); ++ pChnl->hNtfy = NULL; ++ } ++ /* Reset channel event: (NOTE: hUserEvent freed in user ++ * context.). */ ++ if (pChnl->hSyncEvent) { ++ SYNC_ResetEvent(pChnl->hSyncEvent); ++ SYNC_CloseEvent(pChnl->hSyncEvent); ++ pChnl->hSyncEvent = NULL; ++ } ++ /* Free I/O request and I/O completion queues: */ ++ if (pChnl->pIOCompletions) { ++ FreeChirpList(pChnl->pIOCompletions); ++ pChnl->pIOCompletions = NULL; ++ pChnl->cIOCs = 0; ++ } ++ if (pChnl->pIORequests) { ++ FreeChirpList(pChnl->pIORequests); ++ pChnl->pIORequests = NULL; ++ pChnl->cIOReqs = 0; ++ } ++ if (pChnl->pFreeList) { ++ FreeChirpList(pChnl->pFreeList); ++ pChnl->pFreeList = NULL; ++ } ++ /* Release channel object. */ ++ MEM_FreeObject(pChnl); ++ pChnl = NULL; ++ } ++ DBC_Ensure(DSP_FAILED(status) || ++ !MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)); ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_Create ======== ++ * Create a channel manager object, responsible for opening new channels ++ * and closing old ones for a given board. ++ */ ++DSP_STATUS WMD_CHNL_Create(OUT struct CHNL_MGR **phChnlMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CHNL_MGRATTRS *pMgrAttrs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_MGR *pChnlMgr = NULL; ++ s32 cChannels; ++#ifdef DEBUG ++ struct CHNL_MGR *hChnlMgr; ++#endif ++ /* Check DBC requirements: */ ++ DBC_Require(phChnlMgr != NULL); ++ DBC_Require(pMgrAttrs != NULL); ++ DBC_Require(pMgrAttrs->cChannels > 0); ++ DBC_Require(pMgrAttrs->cChannels <= CHNL_MAXCHANNELS); ++ DBC_Require(pMgrAttrs->uWordSize != 0); ++#ifdef DEBUG ++ /* This for the purposes of DBC_Require: */ ++ status = DEV_GetChnlMgr(hDevObject, &hChnlMgr); ++ DBC_Require(status != DSP_EHANDLE); ++ DBC_Require(hChnlMgr == NULL); ++#endif ++ if (DSP_SUCCEEDED(status)) { ++ /* Allocate channel manager object: */ ++ MEM_AllocObject(pChnlMgr, struct CHNL_MGR, CHNL_MGRSIGNATURE); ++ if (pChnlMgr) { ++ /* The cChannels attr must equal the # of supported ++ * chnls for each transport(# chnls for PCPY = DDMA = ++ * ZCPY): i.e. pMgrAttrs->cChannels = CHNL_MAXCHANNELS = ++ * DDMA_MAXDDMACHNLS = DDMA_MAXZCPYCHNLS. */ ++ DBC_Assert(pMgrAttrs->cChannels == CHNL_MAXCHANNELS); ++ cChannels = (CHNL_MAXCHANNELS + (CHNL_MAXCHANNELS * ++ CHNL_PCPY)); ++ /* Create array of channels: */ ++ pChnlMgr->apChannel = MEM_Calloc( ++ sizeof(struct CHNL_OBJECT *) * ++ cChannels, MEM_NONPAGED); ++ if (pChnlMgr->apChannel) { ++ /* Initialize CHNL_MGR object: */ ++ /* Shared memory driver. */ ++ pChnlMgr->dwType = CHNL_TYPESM; ++ pChnlMgr->uWordSize = pMgrAttrs->uWordSize; ++ /* total # chnls supported */ ++ pChnlMgr->cChannels = cChannels; ++ pChnlMgr->cOpenChannels = 0; ++ pChnlMgr->dwOutputMask = 0; ++ pChnlMgr->dwLastOutput = 0; ++ pChnlMgr->hDevObject = hDevObject; ++ if (DSP_SUCCEEDED(status)) { ++ status = SYNC_InitializeDPCCS ++ (&pChnlMgr->hCSObj); ++ } ++ } else { ++ status = DSP_EMEMORY; ++ } ++ } else { ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_FAILED(status)) { ++ WMD_CHNL_Destroy(pChnlMgr); ++ *phChnlMgr = NULL; ++ } else { ++ /* Return channel manager object to caller... */ ++ *phChnlMgr = pChnlMgr; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_Destroy ======== ++ * Purpose: ++ * Close all open channels, and destroy the channel manager. ++ */ ++DSP_STATUS WMD_CHNL_Destroy(struct CHNL_MGR *hChnlMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_MGR *pChnlMgr = hChnlMgr; ++ u32 iChnl; ++ ++ if (MEM_IsValidHandle(hChnlMgr, CHNL_MGRSIGNATURE)) { ++ /* Close all open channels: */ ++ for (iChnl = 0; iChnl < pChnlMgr->cChannels; iChnl++) { ++ if (DSP_SUCCEEDED ++ (WMD_CHNL_Close(pChnlMgr->apChannel[iChnl]))) { ++ DBC_Assert(pChnlMgr->apChannel[iChnl] == NULL); ++ } ++ } ++ /* release critical section */ ++ if (pChnlMgr->hCSObj) ++ SYNC_DeleteCS(pChnlMgr->hCSObj); ++ ++ /* Free channel manager object: */ ++ if (pChnlMgr->apChannel) ++ MEM_Free(pChnlMgr->apChannel); ++ ++ /* Set hChnlMgr to NULL in device object. */ ++ DEV_SetChnlMgr(pChnlMgr->hDevObject, NULL); ++ /* Free this Chnl Mgr object: */ ++ MEM_FreeObject(hChnlMgr); ++ } else { ++ status = DSP_EHANDLE; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_FlushIO ======== ++ * purpose: ++ * Flushes all the outstanding data requests on a channel. ++ */ ++DSP_STATUS WMD_CHNL_FlushIO(struct CHNL_OBJECT *hChnl, u32 dwTimeOut) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ CHNL_MODE uMode = -1; ++ struct CHNL_MGR *pChnlMgr; ++ struct CHNL_IOC chnlIOC; ++ /* Check args: */ ++ if (MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ if ((dwTimeOut == CHNL_IOCNOWAIT) ++ && CHNL_IsOutput(pChnl->uMode)) { ++ status = DSP_EINVALIDARG; ++ } else { ++ uMode = pChnl->uMode; ++ pChnlMgr = pChnl->pChnlMgr; ++ } ++ } else { ++ status = DSP_EHANDLE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Note: Currently, if another thread continues to add IO ++ * requests to this channel, this function will continue to ++ * flush all such queued IO requests. */ ++ if (CHNL_IsOutput(uMode) && (pChnl->uChnlType == CHNL_PCPY)) { ++ /* Wait for IO completions, up to the specified ++ * timeout: */ ++ while (!LST_IsEmpty(pChnl->pIORequests) && ++ DSP_SUCCEEDED(status)) { ++ status = WMD_CHNL_GetIOC(hChnl, dwTimeOut, ++ &chnlIOC); ++ if (DSP_FAILED(status)) ++ continue; ++ ++ if (chnlIOC.status & CHNL_IOCSTATTIMEOUT) ++ status = CHNL_E_WAITTIMEOUT; ++ ++ } ++ } else { ++ status = WMD_CHNL_CancelIO(hChnl); ++ /* Now, leave the channel in the ready state: */ ++ pChnl->dwState &= ~CHNL_STATECANCEL; ++ } ++ } ++ DBC_Ensure(DSP_FAILED(status) || LST_IsEmpty(pChnl->pIORequests)); ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_GetInfo ======== ++ * Purpose: ++ * Retrieve information related to a channel. ++ */ ++DSP_STATUS WMD_CHNL_GetInfo(struct CHNL_OBJECT *hChnl, ++ OUT struct CHNL_INFO *pInfo) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ if (pInfo != NULL) { ++ if (MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ /* Return the requested information: */ ++ pInfo->hChnlMgr = pChnl->pChnlMgr; ++ pInfo->hEvent = pChnl->hUserEvent; ++ pInfo->dwID = pChnl->uId; ++ pInfo->dwMode = pChnl->uMode; ++ pInfo->cPosition = pChnl->cBytesMoved; ++ pInfo->hProcess = pChnl->hProcess; ++ pInfo->hSyncEvent = pChnl->hSyncEvent; ++ pInfo->cIOCs = pChnl->cIOCs; ++ pInfo->cIOReqs = pChnl->cIOReqs; ++ pInfo->dwState = pChnl->dwState; ++ } else { ++ status = DSP_EHANDLE; ++ } ++ } else { ++ status = DSP_EPOINTER; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_GetIOC ======== ++ * Optionally wait for I/O completion on a channel. Dequeue an I/O ++ * completion record, which contains information about the completed ++ * I/O request. ++ * Note: Ensures Channel Invariant (see notes above). ++ */ ++DSP_STATUS WMD_CHNL_GetIOC(struct CHNL_OBJECT *hChnl, u32 dwTimeOut, ++ OUT struct CHNL_IOC *pIOC) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_OBJECT *pChnl = (struct CHNL_OBJECT *)hChnl; ++ struct CHNL_IRP *pChirp; ++ DSP_STATUS statSync; ++ bool fDequeueIOC = true; ++ struct CHNL_IOC ioc = { NULL, 0, 0, 0, 0 }; ++ u8 *pHostSysBuf = NULL; ++ ++ DBG_Trace(DBG_ENTER, "> WMD_CHNL_GetIOC pChnl %p CHNL_IsOutput %x " ++ "uChnlType %x\n", pChnl, CHNL_IsOutput(pChnl->uMode), ++ pChnl->uChnlType); ++ /* Check args: */ ++ if (pIOC == NULL) { ++ status = DSP_EPOINTER; ++ } else if (!MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else if (dwTimeOut == CHNL_IOCNOWAIT) { ++ if (LST_IsEmpty(pChnl->pIOCompletions)) ++ status = CHNL_E_NOIOC; ++ ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ ioc.status = CHNL_IOCSTATCOMPLETE; ++ if (dwTimeOut != CHNL_IOCNOWAIT && LST_IsEmpty(pChnl->pIOCompletions)) { ++ if (dwTimeOut == CHNL_IOCINFINITE) ++ dwTimeOut = SYNC_INFINITE; ++ ++ statSync = SYNC_WaitOnEvent(pChnl->hSyncEvent, dwTimeOut); ++ if (statSync == DSP_ETIMEOUT) { ++ /* No response from DSP */ ++ ioc.status |= CHNL_IOCSTATTIMEOUT; ++ fDequeueIOC = false; ++ } else if (statSync == DSP_EFAIL) { ++ /* This can occur when the user mode thread is ++ * aborted (^C), or when _VWIN32_WaitSingleObject() ++ * fails due to unkown causes. */ ++ /* Even though Wait failed, there may be something in ++ * the Q: */ ++ if (LST_IsEmpty(pChnl->pIOCompletions)) { ++ ioc.status |= CHNL_IOCSTATCANCEL; ++ fDequeueIOC = false; ++ } ++ } ++ } ++ /* See comment in AddIOReq */ ++ SYNC_EnterCS(pChnl->pChnlMgr->hCSObj); ++ disable_irq(MAILBOX_IRQ); ++ if (fDequeueIOC) { ++ /* Dequeue IOC and set pIOC; */ ++ DBC_Assert(!LST_IsEmpty(pChnl->pIOCompletions)); ++ pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pIOCompletions); ++ /* Update pIOC from channel state and chirp: */ ++ if (pChirp) { ++ pChnl->cIOCs--; ++ /* If this is a zero-copy channel, then set IOC's pBuf ++ * to the DSP's address. This DSP address will get ++ * translated to user's virtual addr later. */ ++ { ++ pHostSysBuf = pChirp->pHostSysBuf; ++ ioc.pBuf = pChirp->pHostUserBuf; ++ } ++ ioc.cBytes = pChirp->cBytes; ++ ioc.cBufSize = pChirp->cBufSize; ++ ioc.dwArg = pChirp->dwArg; ++ ioc.status |= pChirp->status; ++ /* Place the used chirp on the free list: */ ++ LST_PutTail(pChnl->pFreeList, (struct LST_ELEM *) ++ pChirp); ++ } else { ++ ioc.pBuf = NULL; ++ ioc.cBytes = 0; ++ } ++ } else { ++ ioc.pBuf = NULL; ++ ioc.cBytes = 0; ++ ioc.dwArg = 0; ++ ioc.cBufSize = 0; ++ } ++ /* Ensure invariant: If any IOC's are queued for this channel... */ ++ if (!LST_IsEmpty(pChnl->pIOCompletions)) { ++ /* Since DSPStream_Reclaim() does not take a timeout ++ * parameter, we pass the stream's timeout value to ++ * WMD_CHNL_GetIOC. We cannot determine whether or not ++ * we have waited in User mode. Since the stream's timeout ++ * value may be non-zero, we still have to set the event. ++ * Therefore, this optimization is taken out. ++ * ++ * if (dwTimeOut == CHNL_IOCNOWAIT) { ++ * ... ensure event is set.. ++ * SYNC_SetEvent(pChnl->hSyncEvent); ++ * } */ ++ SYNC_SetEvent(pChnl->hSyncEvent); ++ } else { ++ /* else, if list is empty, ensure event is reset. */ ++ SYNC_ResetEvent(pChnl->hSyncEvent); ++ } ++ enable_irq(MAILBOX_IRQ); ++ SYNC_LeaveCS(pChnl->pChnlMgr->hCSObj); ++ if (fDequeueIOC && (pChnl->uChnlType == CHNL_PCPY && pChnl->uId > 1)) { ++ if (!(ioc.pBuf < (void *) USERMODE_ADDR)) ++ goto func_cont; ++ ++ /* If the addr is in user mode, then copy it */ ++ if (!pHostSysBuf || !ioc.pBuf) { ++ status = DSP_EPOINTER; ++ DBG_Trace(DBG_LEVEL7, ++ "System buffer NULL in IO completion.\n"); ++ goto func_cont; ++ } ++ if (!CHNL_IsInput(pChnl->uMode)) ++ goto func_cont1; ++ ++ /*pHostUserBuf */ ++ status = copy_to_user(ioc.pBuf, pHostSysBuf, ioc.cBytes); ++#ifndef RES_CLEANUP_DISABLE ++ if (status) { ++ if (current->flags & PF_EXITING) { ++ DBG_Trace(DBG_LEVEL7, ++ "\n2current->flags == PF_EXITING, " ++ " current->flags;0x%x\n", ++ current->flags); ++ status = 0; ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "\n2current->flags != PF_EXITING, " ++ " current->flags;0x%x\n", ++ current->flags); ++ } ++ } ++#endif ++ if (status) { ++ DBG_Trace(DBG_LEVEL7, ++ "Error copying kernel buffer to user, %d" ++ " bytes remaining. in_interupt %d\n", ++ status, in_interrupt()); ++ status = DSP_EPOINTER; ++ } ++func_cont1: ++ MEM_Free(pHostSysBuf); ++ } ++func_cont: ++ /* Update User's IOC block: */ ++ *pIOC = ioc; ++func_end: ++ DBG_Trace(DBG_ENTER, "< WMD_CHNL_GetIOC pChnl %p\n", pChnl); ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_GetMgrInfo ======== ++ * Retrieve information related to the channel manager. ++ */ ++DSP_STATUS WMD_CHNL_GetMgrInfo(struct CHNL_MGR *hChnlMgr, u32 uChnlID, ++ OUT struct CHNL_MGRINFO *pMgrInfo) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_MGR *pChnlMgr = (struct CHNL_MGR *)hChnlMgr; ++ ++ if (pMgrInfo != NULL) { ++ if (uChnlID <= CHNL_MAXCHANNELS) { ++ if (MEM_IsValidHandle(hChnlMgr, CHNL_MGRSIGNATURE)) { ++ /* Return the requested information: */ ++ pMgrInfo->hChnl = pChnlMgr->apChannel[uChnlID]; ++ pMgrInfo->cOpenChannels = pChnlMgr-> ++ cOpenChannels; ++ pMgrInfo->dwType = pChnlMgr->dwType; ++ /* total # of chnls */ ++ pMgrInfo->cChannels = pChnlMgr->cChannels; ++ } else { ++ status = DSP_EHANDLE; ++ } ++ } else { ++ status = CHNL_E_BADCHANID; ++ } ++ } else { ++ status = DSP_EPOINTER; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_Idle ======== ++ * Idles a particular channel. ++ */ ++DSP_STATUS WMD_CHNL_Idle(struct CHNL_OBJECT *hChnl, u32 dwTimeOut, ++ bool fFlush) ++{ ++ CHNL_MODE uMode; ++ struct CHNL_MGR *pChnlMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hChnl, CHNL_SIGNATURE)); ++ ++ uMode = hChnl->uMode; ++ pChnlMgr = hChnl->pChnlMgr; ++ ++ if (CHNL_IsOutput(uMode) && !fFlush) { ++ /* Wait for IO completions, up to the specified timeout: */ ++ status = WMD_CHNL_FlushIO(hChnl, dwTimeOut); ++ } else { ++ status = WMD_CHNL_CancelIO(hChnl); ++ ++ /* Reset the byte count and put channel back in ready state. */ ++ hChnl->cBytesMoved = 0; ++ hChnl->dwState &= ~CHNL_STATECANCEL; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_Open ======== ++ * Open a new half-duplex channel to the DSP board. ++ */ ++DSP_STATUS WMD_CHNL_Open(OUT struct CHNL_OBJECT **phChnl, ++ struct CHNL_MGR *hChnlMgr, CHNL_MODE uMode, ++ u32 uChnlId, CONST IN struct CHNL_ATTRS *pAttrs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct CHNL_MGR *pChnlMgr = hChnlMgr; ++ struct CHNL_OBJECT *pChnl = NULL; ++ struct SYNC_ATTRS *pSyncAttrs = NULL; ++ struct SYNC_OBJECT *hSyncEvent = NULL; ++ /* Ensure DBC requirements: */ ++ DBC_Require(phChnl != NULL); ++ DBC_Require(pAttrs != NULL); ++ *phChnl = NULL; ++ /* Validate Args: */ ++ if (pAttrs->uIOReqs == 0) { ++ status = DSP_EINVALIDARG; ++ } else { ++ if (!MEM_IsValidHandle(hChnlMgr, CHNL_MGRSIGNATURE)) { ++ status = DSP_EHANDLE; ++ } else { ++ if (uChnlId != CHNL_PICKFREE) { ++ if (uChnlId >= pChnlMgr->cChannels) { ++ status = CHNL_E_BADCHANID; ++ } else if (pChnlMgr->apChannel[uChnlId] != ++ NULL) { ++ status = CHNL_E_CHANBUSY; ++ } ++ } else { ++ /* Check for free channel */ ++ status = SearchFreeChannel(pChnlMgr, &uChnlId); ++ } ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_end; ++ ++ DBC_Assert(uChnlId < pChnlMgr->cChannels); ++ /* Create channel object: */ ++ MEM_AllocObject(pChnl, struct CHNL_OBJECT, 0x0000); ++ if (!pChnl) { ++ status = DSP_EMEMORY; ++ goto func_cont; ++ } ++ /* Protect queues from IO_DPC: */ ++ pChnl->dwState = CHNL_STATECANCEL; ++ /* Allocate initial IOR and IOC queues: */ ++ pChnl->pFreeList = CreateChirpList(pAttrs->uIOReqs); ++ pChnl->pIORequests = CreateChirpList(0); ++ pChnl->pIOCompletions = CreateChirpList(0); ++ pChnl->cChirps = pAttrs->uIOReqs; ++ pChnl->cIOCs = 0; ++ pChnl->cIOReqs = 0; ++ status = SYNC_OpenEvent(&hSyncEvent, pSyncAttrs); ++ if (DSP_SUCCEEDED(status)) { ++ status = NTFY_Create(&pChnl->hNtfy); ++ if (DSP_FAILED(status)) { ++ /* The only failure that could have occurred */ ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ if (pChnl->pIOCompletions && pChnl->pIORequests && ++ pChnl->pFreeList) { ++ /* Initialize CHNL object fields: */ ++ pChnl->pChnlMgr = pChnlMgr; ++ pChnl->uId = uChnlId; ++ pChnl->uMode = uMode; ++ pChnl->hUserEvent = hSyncEvent; /* for Linux */ ++ pChnl->hSyncEvent = hSyncEvent; ++ /* get the process handle */ ++ pChnl->hProcess = current->pid; ++ pChnl->pCBArg = 0; ++ pChnl->cBytesMoved = 0; ++ /* Default to proc-copy */ ++ pChnl->uChnlType = CHNL_PCPY; ++ } else { ++ status = DSP_EMEMORY; ++ } ++ } else { ++ status = DSP_EINVALIDARG; ++ } ++ if (DSP_FAILED(status)) { ++ /* Free memory */ ++ if (pChnl->pIOCompletions) { ++ FreeChirpList(pChnl->pIOCompletions); ++ pChnl->pIOCompletions = NULL; ++ pChnl->cIOCs = 0; ++ } ++ if (pChnl->pIORequests) { ++ FreeChirpList(pChnl->pIORequests); ++ pChnl->pIORequests = NULL; ++ } ++ if (pChnl->pFreeList) { ++ FreeChirpList(pChnl->pFreeList); ++ pChnl->pFreeList = NULL; ++ } ++ if (hSyncEvent) { ++ SYNC_CloseEvent(hSyncEvent); ++ hSyncEvent = NULL; ++ } ++ if (pChnl->hNtfy) { ++ NTFY_Delete(pChnl->hNtfy); ++ pChnl->hNtfy = NULL; ++ } ++ MEM_FreeObject(pChnl); ++ } ++func_cont: ++ if (DSP_SUCCEEDED(status)) { ++ /* Insert channel object in channel manager: */ ++ pChnlMgr->apChannel[pChnl->uId] = pChnl; ++ SYNC_EnterCS(pChnlMgr->hCSObj); ++ pChnlMgr->cOpenChannels++; ++ SYNC_LeaveCS(pChnlMgr->hCSObj); ++ /* Return result... */ ++ pChnl->dwSignature = CHNL_SIGNATURE; ++ pChnl->dwState = CHNL_STATEREADY; ++ *phChnl = pChnl; ++ } ++func_end: ++ DBC_Ensure((DSP_SUCCEEDED(status) && ++ MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)) || ++ (*phChnl == NULL)); ++ return status; ++} ++ ++/* ++ * ======== WMD_CHNL_RegisterNotify ======== ++ * Registers for events on a particular channel. ++ */ ++DSP_STATUS WMD_CHNL_RegisterNotify(struct CHNL_OBJECT *hChnl, u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Assert(!(uEventMask & ~(DSP_STREAMDONE | DSP_STREAMIOCOMPLETION))); ++ ++ status = NTFY_Register(hChnl->hNtfy, hNotification, uEventMask, ++ uNotifyType); ++ ++ return status; ++} ++ ++/* ++ * ======== CreateChirpList ======== ++ * Purpose: ++ * Initialize a queue of channel I/O Request/Completion packets. ++ * Parameters: ++ * uChirps: Number of Chirps to allocate. ++ * Returns: ++ * Pointer to queue of IRPs, or NULL. ++ * Requires: ++ * Ensures: ++ */ ++static struct LST_LIST *CreateChirpList(u32 uChirps) ++{ ++ struct LST_LIST *pChirpList; ++ struct CHNL_IRP *pChirp; ++ u32 i; ++ ++ pChirpList = LST_Create(); ++ ++ if (pChirpList) { ++ /* Make N chirps and place on queue. */ ++ for (i = 0; (i < uChirps) && ((pChirp = MakeNewChirp()) != ++ NULL); i++) { ++ LST_PutTail(pChirpList, (struct LST_ELEM *)pChirp); ++ } ++ ++ /* If we couldn't allocate all chirps, free those allocated: */ ++ if (i != uChirps) { ++ FreeChirpList(pChirpList); ++ pChirpList = NULL; ++ } ++ } ++ ++ return pChirpList; ++} ++ ++/* ++ * ======== FreeChirpList ======== ++ * Purpose: ++ * Free the queue of Chirps. ++ */ ++static void FreeChirpList(struct LST_LIST *pChirpList) ++{ ++ DBC_Require(pChirpList != NULL); ++ ++ while (!LST_IsEmpty(pChirpList)) ++ MEM_Free(LST_GetHead(pChirpList)); ++ ++ LST_Delete(pChirpList); ++} ++ ++/* ++ * ======== MakeNewChirp ======== ++ * Allocate the memory for a new channel IRP. ++ */ ++static struct CHNL_IRP *MakeNewChirp(void) ++{ ++ struct CHNL_IRP *pChirp; ++ ++ pChirp = (struct CHNL_IRP *)MEM_Calloc( ++ sizeof(struct CHNL_IRP), MEM_NONPAGED); ++ if (pChirp != NULL) { ++ /* LST_InitElem only resets the list's member values. */ ++ LST_InitElem(&pChirp->link); ++ } ++ ++ return pChirp; ++} ++ ++/* ++ * ======== SearchFreeChannel ======== ++ * Search for a free channel slot in the array of channel pointers. ++ */ ++static DSP_STATUS SearchFreeChannel(struct CHNL_MGR *pChnlMgr, ++ OUT u32 *pdwChnl) ++{ ++ DSP_STATUS status = CHNL_E_OUTOFSTREAMS; ++ u32 i; ++ ++ DBC_Require(MEM_IsValidHandle(pChnlMgr, CHNL_MGRSIGNATURE)); ++ ++ for (i = 0; i < pChnlMgr->cChannels; i++) { ++ if (pChnlMgr->apChannel[i] == NULL) { ++ status = DSP_SOK; ++ *pdwChnl = i; ++ break; ++ } ++ } ++ ++ return status; ++} +diff --git a/drivers/dsp/bridge/wmd/io_sm.c b/drivers/dsp/bridge/wmd/io_sm.c +new file mode 100644 +index 0000000..325f1f1 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/io_sm.c +@@ -0,0 +1,2011 @@ ++/* ++ * io_sm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== io_sm.c ======== ++ * Description: ++ * IO dispatcher for a shared memory channel driver. ++ * ++ * Public Functions: ++ * WMD_IO_Create ++ * WMD_IO_Destroy ++ * WMD_IO_OnLoaded ++ * IO_AndSetValue ++ * IO_BufSize ++ * IO_CancelChnl ++ * IO_DPC ++ * IO_ISR ++ * IO_IVAISR ++ * IO_OrSetValue ++ * IO_ReadValue ++ * IO_ReadValueLong ++ * IO_RequestChnl ++ * IO_Schedule ++ * IO_WriteValue ++ * IO_WriteValueLong ++ * ++ * Channel Invariant: ++ * There is an important invariant condition which must be maintained per ++ * channel outside of WMD_CHNL_GetIOC() and IO_Dispatch(), violation of ++ * which may cause timeouts and/or failure of the WIN32_WaitSingleObject ++ * function (SYNC_WaitOnEvent). ++ * ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++#include <linux/workqueue.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/cfg.h> ++#include <dspbridge/dpc.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/sync.h> ++#include <dspbridge/reg.h> ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_mmu.h> ++ ++/* ----------------------------------- Mini Driver */ ++#include <dspbridge/wmddeh.h> ++#include <dspbridge/wmdio.h> ++#include <dspbridge/wmdioctl.h> ++#include <_tiomap.h> ++#include <tiomap_io.h> ++#include <_tiomap_pwr.h> ++#include <tiomap_io.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/cod.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/chnl_sm.h> ++#include <dspbridge/dbreg.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/rms_sh.h> ++#include <dspbridge/mgr.h> ++#include <dspbridge/drv.h> ++#include "_cmm.h" ++ ++/* ----------------------------------- This */ ++#include <dspbridge/io_sm.h> ++#include "_msg_sm.h" ++#include <dspbridge/gt.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define OUTPUTNOTREADY 0xffff ++#define NOTENABLED 0xffff /* channel(s) not enabled */ ++ ++#define EXTEND "_EXT_END" ++ ++#define SwapWord(x) (x) ++#define ulPageAlignSize 0x10000 /* Page Align Size */ ++ ++#define MAX_PM_REQS 32 ++ ++/* IO Manager: only one created per board: */ ++struct IO_MGR { ++ /* These four fields must be the first fields in a IO_MGR_ struct: */ ++ u32 dwSignature; /* Used for object validation */ ++ struct WMD_DEV_CONTEXT *hWmdContext; /* WMD device context */ ++ struct WMD_DRV_INTERFACE *pIntfFxns; /* Function interface to WMD */ ++ struct DEV_OBJECT *hDevObject; /* Device this board represents */ ++ ++ /* These fields initialized in WMD_IO_Create(): */ ++ struct CHNL_MGR *hChnlMgr; ++ struct SHM *pSharedMem; /* Shared Memory control */ ++ u8 *pInput; /* Address of input channel */ ++ u8 *pOutput; /* Address of output channel */ ++ struct MSG_MGR *hMsgMgr; /* Message manager */ ++ struct MSG *pMsgInputCtrl; /* Msg control for from DSP messages */ ++ struct MSG *pMsgOutputCtrl; /* Msg control for to DSP messages */ ++ u8 *pMsgInput; /* Address of input messages */ ++ u8 *pMsgOutput; /* Address of output messages */ ++ u32 uSMBufSize; /* Size of a shared memory I/O channel */ ++ bool fSharedIRQ; /* Is this IRQ shared? */ ++ struct DPC_OBJECT *hDPC; /* DPC object handle */ ++ struct SYNC_CSOBJECT *hCSObj; /* Critical section object handle */ ++ u32 uWordSize; /* Size in bytes of DSP word */ ++ u16 wIntrVal; /* interrupt value */ ++ /* private extnd proc info; mmu setup */ ++ struct MGR_PROCESSOREXTINFO extProcInfo; ++ struct CMM_OBJECT *hCmmMgr; /* Shared Mem Mngr */ ++ struct work_struct io_workq; /*workqueue */ ++ u32 dQuePowerMbxVal[MAX_PM_REQS]; ++ u32 iQuePowerHead; ++ u32 iQuePowerTail; ++#ifndef DSP_TRACEBUF_DISABLED ++ u32 ulTraceBufferBegin; /* Trace message start address */ ++ u32 ulTraceBufferEnd; /* Trace message end address */ ++ u32 ulTraceBufferCurrent; /* Trace message current address */ ++ u32 ulGPPReadPointer; /* GPP Read pointer to Trace buffer */ ++ u8 *pMsg; ++ u32 ulGppVa; ++ u32 ulDspVa; ++#endif ++} ; ++ ++/* ----------------------------------- Function Prototypes */ ++static void IO_DispatchChnl(IN struct IO_MGR *pIOMgr, ++ IN OUT struct CHNL_OBJECT *pChnl, u32 iMode); ++static void IO_DispatchMsg(IN struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr); ++static void IO_DispatchPM(struct work_struct *work); ++static void NotifyChnlComplete(struct CHNL_OBJECT *pChnl, ++ struct CHNL_IRP *pChirp); ++static void InputChnl(struct IO_MGR *pIOMgr, struct CHNL_OBJECT *pChnl, ++ u32 iMode); ++static void OutputChnl(struct IO_MGR *pIOMgr, struct CHNL_OBJECT *pChnl, ++ u32 iMode); ++static void InputMsg(struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr); ++static void OutputMsg(struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr); ++static u32 FindReadyOutput(struct CHNL_MGR *pChnlMgr, ++ struct CHNL_OBJECT *pChnl, u32 dwMask); ++static u32 ReadData(struct WMD_DEV_CONTEXT *hDevContext, void *pDest, ++ void *pSrc, u32 uSize); ++static u32 WriteData(struct WMD_DEV_CONTEXT *hDevContext, void *pDest, ++ void *pSrc, u32 uSize); ++static struct workqueue_struct *bridge_workqueue; ++#ifndef DSP_TRACEBUF_DISABLED ++void PrintDSPDebugTrace(struct IO_MGR *hIOMgr); ++#endif ++ ++/* Bus Addr (cached kernel)*/ ++static DSP_STATUS registerSHMSegs(struct IO_MGR *hIOMgr, ++ struct COD_MANAGER *hCodMan, ++ u32 dwGPPBasePA); ++ ++#ifdef CONFIG_BRIDGE_DVFS ++/* The maximum number of OPPs that are supported */ ++extern s32 dsp_max_opps; ++/* The Vdd1 opp table information */ ++extern u32 vdd1_dsp_freq[6][4] ; ++#endif ++ ++#if GT_TRACE ++static struct GT_Mask dsp_trace_mask = { NULL, NULL }; /* GT trace variable */ ++#endif ++ ++/* ++ * ======== WMD_IO_Create ======== ++ * Create an IO manager object. ++ */ ++DSP_STATUS WMD_IO_Create(OUT struct IO_MGR **phIOMgr, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct IO_ATTRS *pMgrAttrs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct IO_MGR *pIOMgr = NULL; ++ struct SHM *pSharedMem = NULL; ++ struct WMD_DEV_CONTEXT *hWmdContext = NULL; ++ struct CFG_HOSTRES hostRes; ++ struct CFG_DEVNODE *hDevNode; ++ struct CHNL_MGR *hChnlMgr; ++ static int ref_count; ++ u32 devType; ++ /* Check DBC requirements: */ ++ DBC_Require(phIOMgr != NULL); ++ DBC_Require(pMgrAttrs != NULL); ++ DBC_Require(pMgrAttrs->uWordSize != 0); ++ /* This for the purposes of DBC_Require: */ ++ status = DEV_GetChnlMgr(hDevObject, &hChnlMgr); ++ DBC_Require(status != DSP_EHANDLE); ++ DBC_Require(hChnlMgr != NULL); ++ DBC_Require(hChnlMgr->hIOMgr == NULL); ++ /* Message manager will be created when a file is loaded, since ++ * size of message buffer in shared memory is configurable in ++ * the base image. */ ++ DEV_GetWMDContext(hDevObject, &hWmdContext); ++ DBC_Assert(hWmdContext); ++ DEV_GetDevType(hDevObject, &devType); ++ /* DSP shared memory area will get set properly when ++ * a program is loaded. They are unknown until a COFF file is ++ * loaded. I chose the value -1 because it was less likely to be ++ * a valid address than 0. */ ++ pSharedMem = (struct SHM *) -1; ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ /* ++ * Create a Single Threaded Work Queue ++ */ ++ ++ if (ref_count == 0) ++ bridge_workqueue = create_workqueue("bridge_work-queue"); ++ ++ if (bridge_workqueue <= 0) ++ DBG_Trace(DBG_LEVEL1, "Workque Create" ++ " failed 0x%d \n", bridge_workqueue); ++ ++ ++ /* Allocate IO manager object: */ ++ MEM_AllocObject(pIOMgr, struct IO_MGR, IO_MGRSIGNATURE); ++ if (pIOMgr == NULL) { ++ status = DSP_EMEMORY; ++ goto func_cont; ++ } ++ /*Intializing Work Element*/ ++ if (ref_count == 0) { ++ INIT_WORK(&pIOMgr->io_workq, (void *)IO_DispatchPM); ++ ref_count = 1; ++ } else ++ PREPARE_WORK(&pIOMgr->io_workq, (void *)IO_DispatchPM); ++ ++ /* Initialize CHNL_MGR object: */ ++#ifndef DSP_TRACEBUF_DISABLED ++ pIOMgr->pMsg = NULL; ++#endif ++ pIOMgr->hChnlMgr = hChnlMgr; ++ pIOMgr->uWordSize = pMgrAttrs->uWordSize; ++ pIOMgr->pSharedMem = pSharedMem; ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_InitializeCS(&pIOMgr->hCSObj); ++ ++ if (devType == DSP_UNIT) { ++ /* Create a DPC object: */ ++ status = DPC_Create(&pIOMgr->hDPC, IO_DPC, (void *)pIOMgr); ++ if (DSP_SUCCEEDED(status)) ++ status = DEV_GetDevNode(hDevObject, &hDevNode); ++ ++ pIOMgr->iQuePowerHead = 0; ++ pIOMgr->iQuePowerTail = 0; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = CFG_GetHostResources((struct CFG_DEVNODE *) ++ DRV_GetFirstDevExtension() , &hostRes); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pIOMgr->hWmdContext = hWmdContext; ++ pIOMgr->fSharedIRQ = pMgrAttrs->fShared; ++ IO_DisableInterrupt(hWmdContext); ++ if (devType == DSP_UNIT) { ++ /* Plug the channel ISR:. */ ++ if ((request_irq(INT_MAIL_MPU_IRQ, IO_ISR, 0, ++ "DspBridge\tmailbox", (void *)pIOMgr)) == 0) ++ status = DSP_SOK; ++ else ++ status = DSP_EFAIL; ++ } ++ if (DSP_SUCCEEDED(status)) ++ DBG_Trace(DBG_LEVEL1, "ISR_IRQ Object 0x%x \n", ++ pIOMgr); ++ else ++ status = CHNL_E_ISR; ++ } else ++ status = CHNL_E_ISR; ++func_cont: ++ if (DSP_FAILED(status)) { ++ /* Cleanup: */ ++ WMD_IO_Destroy(pIOMgr); ++ *phIOMgr = NULL; ++ } else { ++ /* Return IO manager object to caller... */ ++ hChnlMgr->hIOMgr = pIOMgr; ++ *phIOMgr = pIOMgr; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_IO_Destroy ======== ++ * Purpose: ++ * Disable interrupts, destroy the IO manager. ++ */ ++DSP_STATUS WMD_IO_Destroy(struct IO_MGR *hIOMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *hWmdContext; ++ if (MEM_IsValidHandle(hIOMgr, IO_MGRSIGNATURE)) { ++ /* Unplug IRQ: */ ++ /* Disable interrupts from the board: */ ++ if (DSP_SUCCEEDED(DEV_GetWMDContext(hIOMgr->hDevObject, ++ &hWmdContext))) ++ DBC_Assert(hWmdContext); ++ (void)CHNLSM_DisableInterrupt(hWmdContext); ++ destroy_workqueue(bridge_workqueue); ++ /* Linux function to uninstall ISR */ ++ free_irq(INT_MAIL_MPU_IRQ, (void *)hIOMgr); ++ (void)DPC_Destroy(hIOMgr->hDPC); ++#ifndef DSP_TRACEBUF_DISABLED ++ if (hIOMgr->pMsg) ++ MEM_Free(hIOMgr->pMsg); ++#endif ++ SYNC_DeleteCS(hIOMgr->hCSObj); /* Leak Fix. */ ++ /* Free this IO manager object: */ ++ MEM_FreeObject(hIOMgr); ++ } else ++ status = DSP_EHANDLE; ++ ++ return status; ++} ++ ++/* ++ * ======== WMD_IO_OnLoaded ======== ++ * Purpose: ++ * Called when a new program is loaded to get shared memory buffer ++ * parameters from COFF file. ulSharedBufferBase and ulSharedBufferLimit ++ * are in DSP address units. ++ */ ++DSP_STATUS WMD_IO_OnLoaded(struct IO_MGR *hIOMgr) ++{ ++ struct COD_MANAGER *hCodMan; ++ struct CHNL_MGR *hChnlMgr; ++ struct MSG_MGR *hMsgMgr; ++ u32 ulShmBase; ++ u32 ulShmBaseOffset; ++ u32 ulShmLimit; ++ u32 ulShmLength = -1; ++ u32 ulMemLength = -1; ++ u32 ulMsgBase; ++ u32 ulMsgLimit; ++ u32 ulMsgLength = -1; ++ u32 ulExtEnd; ++ u32 ulGppPa = 0; ++ u32 ulGppVa = 0; ++ u32 ulDspVa = 0; ++ u32 ulSegSize = 0; ++ u32 ulPadSize = 0; ++ u32 i; ++ DSP_STATUS status = DSP_SOK; ++ u32 uNumProcs = 0; ++ s32 ndx = 0; ++ /* DSP MMU setup table */ ++ struct WMDIOCTL_EXTPROC aEProc[WMDIOCTL_NUMOFMMUTLB]; ++ struct CFG_HOSTRES hostRes; ++ u32 mapAttrs; ++ u32 ulShm0End; ++ u32 ulDynExtBase; ++ u32 ulSeg1Size = 0; ++ u32 paCurr = 0; ++ u32 vaCurr = 0; ++ u32 gppVaCurr = 0; ++ u32 numBytes = 0; ++ u32 allBits = 0; ++ u32 pgSize[] = { HW_PAGE_SIZE_16MB, HW_PAGE_SIZE_1MB, ++ HW_PAGE_SIZE_64KB, HW_PAGE_SIZE_4KB }; ++ ++ status = DEV_GetCodMgr(hIOMgr->hDevObject, &hCodMan); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ hChnlMgr = hIOMgr->hChnlMgr; ++ /* The message manager is destroyed when the board is stopped. */ ++ DEV_GetMsgMgr(hIOMgr->hDevObject, &hIOMgr->hMsgMgr); ++ hMsgMgr = hIOMgr->hMsgMgr; ++ DBC_Assert(MEM_IsValidHandle(hChnlMgr, CHNL_MGRSIGNATURE)); ++ DBC_Assert(MEM_IsValidHandle(hMsgMgr, MSGMGR_SIGNATURE)); ++ if (hIOMgr->pSharedMem) ++ hIOMgr->pSharedMem = NULL; ++ ++ /* Get start and length of channel part of shared memory */ ++ status = COD_GetSymValue(hCodMan, CHNL_SHARED_BUFFER_BASE_SYM, ++ &ulShmBase); ++ if (DSP_FAILED(status)) { ++ status = CHNL_E_NOMEMMAP; ++ goto func_cont1; ++ } ++ status = COD_GetSymValue(hCodMan, CHNL_SHARED_BUFFER_LIMIT_SYM, ++ &ulShmLimit); ++ if (DSP_FAILED(status)) { ++ status = CHNL_E_NOMEMMAP; ++ goto func_cont1; ++ } ++ if (ulShmLimit <= ulShmBase) { ++ status = CHNL_E_INVALIDMEMBASE; ++ } else { ++ /* get total length in bytes */ ++ ulShmLength = (ulShmLimit - ulShmBase + 1) * hIOMgr->uWordSize; ++ /* Calculate size of a PROCCOPY shared memory region */ ++ DBG_Trace(DBG_LEVEL7, ++ "**(proc)PROCCOPY SHMMEM SIZE: 0x%x bytes\n", ++ (ulShmLength - sizeof(struct SHM))); ++ } ++func_cont1: ++ if (DSP_SUCCEEDED(status)) { ++ /* Get start and length of message part of shared memory */ ++ status = COD_GetSymValue(hCodMan, MSG_SHARED_BUFFER_BASE_SYM, ++ &ulMsgBase); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, MSG_SHARED_BUFFER_LIMIT_SYM, ++ &ulMsgLimit); ++ if (DSP_SUCCEEDED(status)) { ++ if (ulMsgLimit <= ulMsgBase) { ++ status = CHNL_E_INVALIDMEMBASE; ++ } else { ++ /* Length (bytes) of messaging part of shared ++ * memory */ ++ ulMsgLength = (ulMsgLimit - ulMsgBase + 1) * ++ hIOMgr->uWordSize; ++ /* Total length (bytes) of shared memory: ++ * chnl + msg */ ++ ulMemLength = ulShmLength + ulMsgLength; ++ } ++ } else { ++ status = CHNL_E_NOMEMMAP; ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++#ifndef DSP_TRACEBUF_DISABLED ++ status = COD_GetSymValue(hCodMan, DSP_TRACESEC_END, &ulShm0End); ++ DBG_Trace(DBG_LEVEL7, "_BRIDGE_TRACE_END value = %x \n", ++ ulShm0End); ++#else ++ status = COD_GetSymValue(hCodMan, SHM0_SHARED_END_SYM, ++ &ulShm0End); ++ DBG_Trace(DBG_LEVEL7, "_SHM0_END = %x \n", ulShm0End); ++#endif ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, DYNEXTBASE, &ulDynExtBase); ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, EXTEND, &ulExtEnd); ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Get memory reserved in host resources */ ++ (void)MGR_EnumProcessorInfo(0, ++ (struct DSP_PROCESSORINFO *)&hIOMgr->extProcInfo, ++ sizeof(struct MGR_PROCESSOREXTINFO), &uNumProcs); ++ CFG_GetHostResources(( ++ struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &hostRes); ++ /* The first MMU TLB entry(TLB_0) in DCD is ShmBase. */ ++ ndx = 0; ++ ulGppPa = hostRes.dwMemPhys[1]; ++ ulGppVa = hostRes.dwMemBase[1]; ++ /* THIS IS THE VIRTUAL UNCACHED IOREMAPPED ADDRESS !!! */ ++ /* Why can't we directly take the DSPVA from the symbols? */ ++ ulDspVa = hIOMgr->extProcInfo.tyTlb[0].ulDspVirt; ++ ulSegSize = (ulShm0End - ulDspVa) * hIOMgr->uWordSize; ++ ulSeg1Size = (ulExtEnd - ulDynExtBase) * hIOMgr->uWordSize; ++ ulSeg1Size = (ulSeg1Size + 0xFFF) & (~0xFFFUL); /* 4K align*/ ++ ulSegSize = (ulSegSize + 0xFFFF) & (~0xFFFFUL); /* 64K align*/ ++ ulPadSize = ulPageAlignSize - ((ulGppPa + ulSeg1Size) % ++ ulPageAlignSize); ++ if (ulPadSize == ulPageAlignSize) ++ ulPadSize = 0x0; ++ ++ DBG_Trace(DBG_LEVEL7, "ulGppPa %x, ulGppVa %x, ulDspVa %x, " ++ "ulShm0End %x, ulDynExtBase %x, ulExtEnd %x, " ++ "ulSegSize %x ulSeg1Size %x \n", ulGppPa, ulGppVa, ++ ulDspVa, ulShm0End, ulDynExtBase, ulExtEnd, ulSegSize, ++ ulSeg1Size); ++ ++ if ((ulSegSize + ulSeg1Size + ulPadSize) > ++ hostRes.dwMemLength[1]) { ++ DBG_Trace(DBG_LEVEL7, "ulGppPa %x, ulGppVa %x, ulDspVa " ++ "%x, ulShm0End %x, ulDynExtBase %x, ulExtEnd " ++ "%x, ulSegSize %x, ulSeg1Size %x \n", ulGppPa, ++ ulGppVa, ulDspVa, ulShm0End, ulDynExtBase, ++ ulExtEnd, ulSegSize, ulSeg1Size); ++ DBG_Trace(DBG_LEVEL7, "Insufficient SHM Reserved 0x%x. " ++ "Required 0x%x\n", hostRes.dwMemLength[1], ++ ulSegSize + ulSeg1Size + ulPadSize); ++ status = DSP_EMEMORY; ++ } ++ } ++ if (DSP_FAILED(status)) ++ goto func_cont; ++ ++ paCurr = ulGppPa; ++ vaCurr = ulDynExtBase * hIOMgr->uWordSize; ++ gppVaCurr = ulGppVa; ++ numBytes = ulSeg1Size; ++ ++ /* ++ * Try to fit into TLB entries. If not possible, push them to page ++ * tables. It is quite possible that if sections are not on ++ * bigger page boundary, we may end up making several small pages. ++ * So, push them onto page tables, if that is the case. ++ */ ++ mapAttrs = 0x00000000; ++ mapAttrs = DSP_MAPLITTLEENDIAN; ++ mapAttrs |= DSP_MAPPHYSICALADDR; ++ mapAttrs |= DSP_MAPELEMSIZE32; ++ mapAttrs |= DSP_MAPDONOTLOCK; ++ ++ while (numBytes && DSP_SUCCEEDED(status)) { ++ /* To find the max. page size with which both PA & VA are ++ * aligned */ ++ allBits = paCurr | vaCurr; ++ DBG_Trace(DBG_LEVEL1, "allBits %x, paCurr %x, vaCurr %x, " ++ "numBytes %x\n", allBits, paCurr, vaCurr, numBytes); ++ for (i = 0; i < 4; i++) { ++ if ((numBytes >= pgSize[i]) && ((allBits & ++ (pgSize[i] - 1)) == 0)) { ++ status = hIOMgr->pIntfFxns->pfnBrdMemMap ++ (hIOMgr->hWmdContext, paCurr, vaCurr, ++ pgSize[i], mapAttrs); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ paCurr += pgSize[i]; ++ vaCurr += pgSize[i]; ++ gppVaCurr += pgSize[i]; ++ numBytes -= pgSize[i]; ++ /* Don't try smaller sizes. Hopefully we have ++ * reached an address aligned to a bigger page ++ * size*/ ++ break; ++ } ++ } ++ } ++ paCurr += ulPadSize; ++ vaCurr += ulPadSize; ++ gppVaCurr += ulPadSize; ++ ++ /* configure the TLB entries for the next cacheable segment */ ++ numBytes = ulSegSize; ++ vaCurr = ulDspVa * hIOMgr->uWordSize; ++ allBits = 0x0; ++ while (numBytes && DSP_SUCCEEDED(status)) { ++ /* To find the max. page size with which both PA & VA are ++ * aligned*/ ++ allBits = paCurr | vaCurr; ++ DBG_Trace(DBG_LEVEL1, "allBits for Seg1 %x, paCurr %x, " ++ "vaCurr %x, numBytes %x\n", allBits, paCurr, vaCurr, ++ numBytes); ++ for (i = 0; i < 4; i++) { ++ if (!(numBytes >= pgSize[i]) || ++ !((allBits & (pgSize[i]-1)) == 0)) ++ continue; ++ if (ndx < MAX_LOCK_TLB_ENTRIES) { ++ /* This is the physical address written to ++ * DSP MMU */ ++ aEProc[ndx].ulGppPa = paCurr; ++ /* THIS IS THE VIRTUAL UNCACHED IOREMAPPED ++ * ADDRESS!!! */ ++ aEProc[ndx].ulGppVa = gppVaCurr; ++ aEProc[ndx].ulDspVa = vaCurr / hIOMgr-> ++ uWordSize; ++ aEProc[ndx].ulSize = pgSize[i]; ++ aEProc[ndx].endianism = HW_LITTLE_ENDIAN; ++ aEProc[ndx].elemSize = HW_ELEM_SIZE_16BIT; ++ aEProc[ndx].mixedMode = HW_MMU_CPUES; ++ DBG_Trace(DBG_LEVEL1, "SHM MMU TLB entry PA %lx" ++ " VA %lx DSP_VA %lx Size %lx\n", ++ aEProc[ndx].ulGppPa, ++ aEProc[ndx].ulGppVa, ++ aEProc[ndx].ulDspVa * ++ hIOMgr->uWordSize, pgSize[i]); ++ ndx++; ++ } else { ++ status = hIOMgr->pIntfFxns->pfnBrdMemMap( ++ hIOMgr->hWmdContext, paCurr, vaCurr, pgSize[i], ++ mapAttrs); ++ DBG_Trace(DBG_LEVEL1, "SHM MMU PTE entry PA %lx" ++ " VA %lx DSP_VA %lx Size %lx\n", ++ aEProc[ndx].ulGppPa, ++ aEProc[ndx].ulGppVa, ++ aEProc[ndx].ulDspVa * ++ hIOMgr->uWordSize, pgSize[i]); ++ DBC_Assert(DSP_SUCCEEDED(status)); ++ } ++ paCurr += pgSize[i]; ++ vaCurr += pgSize[i]; ++ gppVaCurr += pgSize[i]; ++ numBytes -= pgSize[i]; ++ /* Don't try smaller sizes. Hopefully we have reached ++ an address aligned to a bigger page size*/ ++ break; ++ } ++ } ++ ++ /* Copy remaining entries from CDB. All entries are 1 MB and should not ++ * conflict with SHM entries on MPU or DSP side */ ++ for (i = 3; i < 7 && ndx < WMDIOCTL_NUMOFMMUTLB && ++ DSP_SUCCEEDED(status); i++) { ++ if (hIOMgr->extProcInfo.tyTlb[i].ulGppPhys == 0) ++ continue; ++ ++ if ((hIOMgr->extProcInfo.tyTlb[i].ulGppPhys > ulGppPa - 0x100000 ++ && hIOMgr->extProcInfo.tyTlb[i].ulGppPhys <= ++ ulGppPa + ulSegSize) ++ || (hIOMgr->extProcInfo.tyTlb[i].ulDspVirt > ulDspVa - ++ 0x100000 / hIOMgr->uWordSize && hIOMgr-> ++ extProcInfo.tyTlb[i].ulDspVirt ++ <= ulDspVa + ulSegSize / hIOMgr->uWordSize)) { ++ DBG_Trace(DBG_LEVEL7, "CDB MMU entry %d conflicts with " ++ "SHM.\n\tCDB: GppPa %x, DspVa %x.\n\tSHM: " ++ "GppPa %x, DspVa %x, Bytes %x.\n", i, ++ hIOMgr->extProcInfo.tyTlb[i].ulGppPhys, ++ hIOMgr->extProcInfo.tyTlb[i].ulDspVirt, ++ ulGppPa, ulDspVa, ulSegSize); ++ status = DSP_EFAIL; ++ } else { ++ if (ndx < MAX_LOCK_TLB_ENTRIES) { ++ aEProc[ndx].ulDspVa = hIOMgr->extProcInfo. ++ tyTlb[i].ulDspVirt; ++ aEProc[ndx].ulGppPa = hIOMgr->extProcInfo. ++ tyTlb[i].ulGppPhys; ++ aEProc[ndx].ulGppVa = 0; ++ /* Can't convert, so set to zero*/ ++ aEProc[ndx].ulSize = 0x100000; /* 1 MB*/ ++ DBG_Trace(DBG_LEVEL1, "SHM MMU entry PA %x " ++ "DSP_VA 0x%x\n", aEProc[ndx].ulGppPa, ++ aEProc[ndx].ulDspVa); ++ ndx++; ++ } else { ++ status = hIOMgr->pIntfFxns->pfnBrdMemMap ++ (hIOMgr->hWmdContext, ++ hIOMgr->extProcInfo.tyTlb[i].ulGppPhys, ++ hIOMgr->extProcInfo.tyTlb[i].ulDspVirt, ++ 0x100000, mapAttrs); ++ } ++ } ++ } ++ if (i < 7 && DSP_SUCCEEDED(status)) { ++ /* All CDB entries could not be made*/ ++ status = DSP_EFAIL; ++ } ++func_cont: ++ mapAttrs = 0x00000000; ++ mapAttrs = DSP_MAPLITTLEENDIAN; ++ mapAttrs |= DSP_MAPPHYSICALADDR; ++ mapAttrs |= DSP_MAPELEMSIZE32; ++ mapAttrs |= DSP_MAPDONOTLOCK; ++ ++ /* Map the L4 peripherals */ ++ i = 0; ++ while (L4PeripheralTable[i].physAddr && DSP_SUCCEEDED(status)) { ++ status = hIOMgr->pIntfFxns->pfnBrdMemMap ++ (hIOMgr->hWmdContext, L4PeripheralTable[i].physAddr, ++ L4PeripheralTable[i].dspVirtAddr, HW_PAGE_SIZE_4KB, ++ mapAttrs); ++ if (DSP_FAILED(status)) ++ break; ++ i++; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ for (i = ndx; i < WMDIOCTL_NUMOFMMUTLB; i++) { ++ aEProc[i].ulDspVa = 0; ++ aEProc[i].ulGppPa = 0; ++ aEProc[i].ulGppVa = 0; ++ aEProc[i].ulSize = 0; ++ } ++ /* Set the SHM physical address entry (grayed out in CDB file) ++ * to the virtual uncached ioremapped address of SHM reserved ++ * on MPU */ ++ hIOMgr->extProcInfo.tyTlb[0].ulGppPhys = (ulGppVa + ulSeg1Size + ++ ulPadSize); ++ DBG_Trace(DBG_LEVEL1, "*********extProcInfo *********%x \n", ++ hIOMgr->extProcInfo.tyTlb[0].ulGppPhys); ++ /* Need SHM Phys addr. IO supports only one DSP for now: ++ * uNumProcs=1 */ ++ if ((hIOMgr->extProcInfo.tyTlb[0].ulGppPhys == 0) || ++ (uNumProcs != 1)) { ++ status = CHNL_E_NOMEMMAP; ++ DBC_Assert(false); ++ } else { ++ DBC_Assert(aEProc[0].ulDspVa <= ulShmBase); ++ /* ulShmBase may not be at ulDspVa address */ ++ ulShmBaseOffset = (ulShmBase - aEProc[0].ulDspVa) * ++ hIOMgr->uWordSize; ++ /* WMD_BRD_Ctrl() will set dev context dsp-mmu info. In ++ * _BRD_Start() the MMU will be re-programed with MMU ++ * DSPVa-GPPPa pair info while DSP is in a known ++ * (reset) state. */ ++ DBC_Assert(hIOMgr->pIntfFxns != NULL); ++ DBC_Assert(hIOMgr->hWmdContext != NULL); ++ status = hIOMgr->pIntfFxns->pfnDevCntrl(hIOMgr-> ++ hWmdContext, WMDIOCTL_SETMMUCONFIG, aEProc); ++ ulShmBase = hIOMgr->extProcInfo.tyTlb[0].ulGppPhys; ++ DBG_Trace(DBG_LEVEL1, "extProcInfo.tyTlb[0].ulGppPhys " ++ "%x \n ", hIOMgr->extProcInfo.tyTlb[0]. ++ ulGppPhys); ++ ulShmBase += ulShmBaseOffset; ++ ulShmBase = (u32)MEM_LinearAddress((void *)ulShmBase, ++ ulMemLength); ++ DBC_Assert(ulShmBase != 0); ++ if (DSP_SUCCEEDED(status)) { ++ status = registerSHMSegs(hIOMgr, hCodMan, ++ aEProc[0].ulGppPa); ++ /* Register SM */ ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ hIOMgr->pSharedMem = (struct SHM *)ulShmBase; ++ hIOMgr->pInput = (u8 *)hIOMgr->pSharedMem + ++ sizeof(struct SHM); ++ hIOMgr->pOutput = hIOMgr->pInput + (ulShmLength - ++ sizeof(struct SHM))/2; ++ hIOMgr->uSMBufSize = hIOMgr->pOutput - hIOMgr->pInput; ++ DBG_Trace(DBG_LEVEL3, ++ "hIOMgr: pInput %p pOutput %p ulShmLength %x\n", ++ hIOMgr->pInput, hIOMgr->pOutput, ulShmLength); ++ DBG_Trace(DBG_LEVEL3, ++ "pSharedMem %p uSMBufSize %x sizeof(SHM) %x\n", ++ hIOMgr->pSharedMem, hIOMgr->uSMBufSize, ++ sizeof(struct SHM)); ++ /* Set up Shared memory addresses for messaging. */ ++ hIOMgr->pMsgInputCtrl = (struct MSG *)((u8 *) ++ hIOMgr->pSharedMem + ++ ulShmLength); ++ hIOMgr->pMsgInput = (u8 *)hIOMgr->pMsgInputCtrl + ++ sizeof(struct MSG); ++ hIOMgr->pMsgOutputCtrl = (struct MSG *)((u8 *)hIOMgr-> ++ pMsgInputCtrl + ulMsgLength / 2); ++ hIOMgr->pMsgOutput = (u8 *)hIOMgr->pMsgOutputCtrl + ++ sizeof(struct MSG); ++ hMsgMgr->uMaxMsgs = ((u8 *)hIOMgr->pMsgOutputCtrl - ++ hIOMgr->pMsgInput) / ++ sizeof(struct MSG_DSPMSG); ++ DBG_Trace(DBG_LEVEL7, "IO MGR SHM details : pSharedMem 0x%x, " ++ "pInput 0x%x, pOutput 0x%x, pMsgInputCtrl 0x%x, " ++ "pMsgInput 0x%x, pMsgOutputCtrl 0x%x, pMsgOutput " ++ "0x%x \n", (u8 *)hIOMgr->pSharedMem, ++ (u8 *)hIOMgr->pInput, (u8 *)hIOMgr->pOutput, ++ (u8 *)hIOMgr->pMsgInputCtrl, ++ (u8 *)hIOMgr->pMsgInput, ++ (u8 *)hIOMgr->pMsgOutputCtrl, ++ (u8 *)hIOMgr->pMsgOutput); ++ DBG_Trace(DBG_LEVEL7, "** (proc) MAX MSGS IN SHARED MEMORY: " ++ "0x%x\n", hMsgMgr->uMaxMsgs); ++ memset((void *) hIOMgr->pSharedMem, 0, sizeof(struct SHM)); ++ } ++#ifndef DSP_TRACEBUF_DISABLED ++ if (DSP_SUCCEEDED(status)) { ++ /* Get the start address of trace buffer */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, SYS_PUTCBEG, ++ &hIOMgr->ulTraceBufferBegin); ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ hIOMgr->ulGPPReadPointer = hIOMgr->ulTraceBufferBegin = ++ (ulGppVa + ulSeg1Size + ulPadSize) + ++ (hIOMgr->ulTraceBufferBegin - ulDspVa); ++ /* Get the end address of trace buffer */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, SYS_PUTCEND, ++ &hIOMgr->ulTraceBufferEnd); ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ hIOMgr->ulTraceBufferEnd = (ulGppVa + ulSeg1Size + ulPadSize) + ++ (hIOMgr->ulTraceBufferEnd - ulDspVa); ++ /* Get the current address of DSP write pointer */ ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMan, ++ BRIDGE_SYS_PUTC_current, ++ &hIOMgr->ulTraceBufferCurrent); ++ if (DSP_FAILED(status)) ++ status = CHNL_E_NOMEMMAP; ++ ++ } ++ hIOMgr->ulTraceBufferCurrent = (ulGppVa + ulSeg1Size + ++ ulPadSize) + (hIOMgr-> ++ ulTraceBufferCurrent - ulDspVa); ++ /* Calculate the size of trace buffer */ ++ if (hIOMgr->pMsg) ++ MEM_Free(hIOMgr->pMsg); ++ hIOMgr->pMsg = MEM_Alloc(((hIOMgr->ulTraceBufferEnd - ++ hIOMgr->ulTraceBufferBegin) * ++ hIOMgr->uWordSize) + 2, MEM_NONPAGED); ++ if (!hIOMgr->pMsg) ++ status = DSP_EMEMORY; ++ ++ DBG_Trace(DBG_LEVEL1, "** hIOMgr->pMsg: 0x%x\n", hIOMgr->pMsg); ++ hIOMgr->ulDspVa = ulDspVa; ++ hIOMgr->ulGppVa = (ulGppVa + ulSeg1Size + ulPadSize); ++ } ++#endif ++ IO_EnableInterrupt(hIOMgr->hWmdContext); ++ return status; ++} ++ ++/* ++ * ======== IO_BufSize ======== ++ * Size of shared memory I/O channel. ++ */ ++u32 IO_BufSize(struct IO_MGR *hIOMgr) ++{ ++ DBC_Require(MEM_IsValidHandle(hIOMgr, IO_MGRSIGNATURE)); ++ ++ return hIOMgr->uSMBufSize; ++} ++ ++/* ++ * ======== IO_CancelChnl ======== ++ * Cancel IO on a given PCPY channel. ++ */ ++void IO_CancelChnl(struct IO_MGR *hIOMgr, u32 ulChnl) ++{ ++ struct IO_MGR *pIOMgr = (struct IO_MGR *)hIOMgr; ++ struct SHM *sm; ++ ++ DBC_Require(MEM_IsValidHandle(hIOMgr, IO_MGRSIGNATURE)); ++ sm = hIOMgr->pSharedMem; ++ ++ /* Inform DSP that we have no more buffers on this channel: */ ++ IO_AndValue(pIOMgr->hWmdContext, struct SHM, sm, hostFreeMask, ++ (~(1 << ulChnl))); ++ ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, MBX_PCPY_CLASS); ++} ++ ++/* ++ * ======== IO_DispatchChnl ======== ++ * Proc-copy chanl dispatch. ++ */ ++static void IO_DispatchChnl(IN struct IO_MGR *pIOMgr, ++ IN OUT struct CHNL_OBJECT *pChnl, u32 iMode) ++{ ++ DBC_Require(MEM_IsValidHandle(pIOMgr, IO_MGRSIGNATURE)); ++ ++ DBG_Trace(DBG_LEVEL3, "Entering IO_DispatchChnl \n"); ++ ++ /* See if there is any data available for transfer: */ ++ DBC_Assert(iMode == IO_SERVICE); ++ ++ /* Any channel will do for this mode: */ ++ InputChnl(pIOMgr, pChnl, iMode); ++ OutputChnl(pIOMgr, pChnl, iMode); ++} ++ ++/* ++ * ======== IO_DispatchMsg ======== ++ * Performs I/O dispatch on message queues. ++ */ ++static void IO_DispatchMsg(IN struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr) ++{ ++ DBC_Require(MEM_IsValidHandle(pIOMgr, IO_MGRSIGNATURE)); ++ ++ DBG_Trace(DBG_LEVEL3, "Entering IO_DispatchMsg \n"); ++ ++ /* We are performing both input and output processing. */ ++ InputMsg(pIOMgr, hMsgMgr); ++ OutputMsg(pIOMgr, hMsgMgr); ++} ++ ++/* ++ * ======== IO_DispatchPM ======== ++ * Performs I/O dispatch on PM related messages from DSP ++ */ ++static void IO_DispatchPM(struct work_struct *work) ++{ ++ struct IO_MGR *pIOMgr = ++ container_of(work, struct IO_MGR, io_workq); ++ DSP_STATUS status; ++ u32 pArg[2]; ++ ++ /*DBC_Require(MEM_IsValidHandle(pIOMgr, IO_MGRSIGNATURE));*/ ++ ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM: Entering IO_DispatchPM : \n"); ++ ++ /* Perform Power message processing here */ ++ while (pIOMgr->iQuePowerHead != pIOMgr->iQuePowerTail) { ++ pArg[0] = *(u32 *)&(pIOMgr->dQuePowerMbxVal[pIOMgr-> ++ iQuePowerTail]); ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM - pArg[0] - 0x%x: \n", ++ pArg[0]); ++ /* Send the command to the WMD clk/pwr manager to handle */ ++ if (pArg[0] == MBX_PM_HIBERNATE_EN) { ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM : Hibernate " ++ "command\n"); ++ status = pIOMgr->pIntfFxns->pfnDevCntrl(pIOMgr-> ++ hWmdContext, WMDIOCTL_PWR_HIBERNATE, pArg); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM : " ++ "Hibernation command failed\n"); ++ } ++ } else if (pArg[0] == MBX_PM_OPP_REQ) { ++ pArg[1] = pIOMgr->pSharedMem->oppRequest.rqstOppPt; ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM : Value of OPP " ++ "value =0x%x \n", pArg[1]); ++ status = pIOMgr->pIntfFxns->pfnDevCntrl(pIOMgr-> ++ hWmdContext, WMDIOCTL_CONSTRAINT_REQUEST, ++ pArg); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM : Failed " ++ "to set constraint = 0x%x \n", ++ pArg[1]); ++ } ++ ++ } else { ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM - clock control - " ++ "value of msg = 0x%x: \n", pArg[0]); ++ status = pIOMgr->pIntfFxns->pfnDevCntrl(pIOMgr-> ++ hWmdContext, WMDIOCTL_CLK_CTRL, pArg); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, "IO_DispatchPM : Failed " ++ "to control the DSP clk = 0x%x \n", ++ *pArg); ++ } ++ } ++ /* increment the tail count here */ ++ pIOMgr->iQuePowerTail++; ++ if (pIOMgr->iQuePowerTail >= MAX_PM_REQS) ++ pIOMgr->iQuePowerTail = 0; ++ ++ } ++ ++} ++ ++/* ++ * ======== IO_DPC ======== ++ * Deferred procedure call for shared memory channel driver ISR. Carries ++ * out the dispatch of I/O as a non-preemptible event.It can only be ++ * pre-empted by an ISR. ++ */ ++void IO_DPC(IN OUT void *pRefData) ++{ ++ struct IO_MGR *pIOMgr = (struct IO_MGR *)pRefData; ++ struct CHNL_MGR *pChnlMgr; ++ struct MSG_MGR *pMsgMgr; ++ struct DEH_MGR *hDehMgr; ++ ++ DBC_Require(MEM_IsValidHandle(pIOMgr, IO_MGRSIGNATURE)); ++ pChnlMgr = pIOMgr->hChnlMgr; ++ DEV_GetMsgMgr(pIOMgr->hDevObject, &pMsgMgr); ++ DEV_GetDehMgr(pIOMgr->hDevObject, &hDehMgr); ++ DBC_Require(MEM_IsValidHandle(pChnlMgr, CHNL_MGRSIGNATURE)); ++ DBG_Trace(DBG_LEVEL7, "Entering IO_DPC(0x%x)\n", pRefData); ++ /* Check value of interrupt register to ensure it is a valid error */ ++ if ((pIOMgr->wIntrVal > DEH_BASE) && (pIOMgr->wIntrVal < DEH_LIMIT)) { ++ /* notify DSP/BIOS exception */ ++ if (hDehMgr) ++ WMD_DEH_Notify(hDehMgr, DSP_SYSERROR, pIOMgr->wIntrVal); ++ ++ } ++ IO_DispatchChnl(pIOMgr, NULL, IO_SERVICE); ++#ifdef CHNL_MESSAGES ++ if (pMsgMgr) { ++ DBC_Require(MEM_IsValidHandle(pMsgMgr, MSGMGR_SIGNATURE)); ++ IO_DispatchMsg(pIOMgr, pMsgMgr); ++ } ++#endif ++#ifndef DSP_TRACEBUF_DISABLED ++ if (pIOMgr->wIntrVal & MBX_DBG_CLASS) { ++ /* notify DSP Trace message */ ++ if (pIOMgr->wIntrVal & MBX_DBG_SYSPRINTF) ++ PrintDSPDebugTrace(pIOMgr); ++ } ++#endif ++ ++#ifndef DSP_TRACEBUF_DISABLED ++ PrintDSPDebugTrace(pIOMgr); ++#endif ++} ++ ++ ++/* ++ * ======== IO_ISR ======== ++ * Main interrupt handler for the shared memory IO manager. ++ * Calls the WMD's CHNL_ISR to determine if this interrupt is ours, then ++ * schedules a DPC to dispatch I/O. ++ */ ++irqreturn_t IO_ISR(int irq, IN void *pRefData) ++{ ++ struct IO_MGR *hIOMgr = (struct IO_MGR *)pRefData; ++ bool fSchedDPC; ++ DBC_Require(irq == INT_MAIL_MPU_IRQ); ++ DBC_Require(MEM_IsValidHandle(hIOMgr, IO_MGRSIGNATURE)); ++ DBG_Trace(DBG_LEVEL3, "Entering IO_ISR(0x%x)\n", pRefData); ++ ++ /* Call WMD's CHNLSM_ISR() to see if interrupt is ours, and process. */ ++ if (IO_CALLISR(hIOMgr->hWmdContext, &fSchedDPC, &hIOMgr->wIntrVal)) { ++ { ++ DBG_Trace(DBG_LEVEL3, "IO_ISR %x\n", hIOMgr->wIntrVal); ++ if (hIOMgr->wIntrVal & MBX_PM_CLASS) { ++ hIOMgr->dQuePowerMbxVal[hIOMgr->iQuePowerHead] = ++ hIOMgr->wIntrVal; ++ hIOMgr->iQuePowerHead++; ++ if (hIOMgr->iQuePowerHead >= MAX_PM_REQS) ++ hIOMgr->iQuePowerHead = 0; ++ ++ queue_work(bridge_workqueue, &hIOMgr->io_workq); ++ } ++ if (hIOMgr->wIntrVal == MBX_DEH_RESET) { ++ DBG_Trace(DBG_LEVEL6, "*** DSP RESET ***\n"); ++ hIOMgr->wIntrVal = 0; ++ } else if (fSchedDPC) { ++ /* PROC-COPY defer i/o */ ++ DPC_Schedule(hIOMgr->hDPC); ++ } ++ } ++ } else ++ /* Ensure that, if WMD didn't claim it, the IRQ is shared. */ ++ DBC_Ensure(hIOMgr->fSharedIRQ); ++ return IRQ_HANDLED; ++} ++ ++/* ++ * ======== IO_RequestChnl ======== ++ * Purpose: ++ * Request chanenel I/O from the DSP. Sets flags in shared memory, then ++ * interrupts the DSP. ++ */ ++void IO_RequestChnl(struct IO_MGR *pIOMgr, struct CHNL_OBJECT *pChnl, ++ u32 iMode, OUT u16 *pwMbVal) ++{ ++ struct CHNL_MGR *pChnlMgr; ++ struct SHM *sm; ++ DBC_Require(pChnl != NULL); ++ DBC_Require(pwMbVal != NULL); ++ pChnlMgr = pIOMgr->hChnlMgr; ++ sm = pIOMgr->pSharedMem; ++ if (iMode == IO_INPUT) { ++ /* Assertion fires if CHNL_AddIOReq() called on a stream ++ * which was cancelled, or attached to a dead board: */ ++ DBC_Assert((pChnl->dwState == CHNL_STATEREADY) || ++ (pChnl->dwState == CHNL_STATEEOS)); ++ /* Indicate to the DSP we have a buffer available for input: */ ++ IO_OrValue(pIOMgr->hWmdContext, struct SHM, sm, hostFreeMask, ++ (1 << pChnl->uId)); ++ *pwMbVal = MBX_PCPY_CLASS; ++ } else if (iMode == IO_OUTPUT) { ++ /* This assertion fails if CHNL_AddIOReq() was called on a ++ * stream which was cancelled, or attached to a dead board: */ ++ DBC_Assert((pChnl->dwState & ~CHNL_STATEEOS) == ++ CHNL_STATEREADY); ++ /* Record the fact that we have a buffer available for ++ * output: */ ++ pChnlMgr->dwOutputMask |= (1 << pChnl->uId); ++ } else { ++ DBC_Assert(iMode); /* Shouldn't get here. */ ++ } ++} ++ ++/* ++ * ======== IO_Schedule ======== ++ * Schedule DPC for IO. ++ */ ++void IO_Schedule(struct IO_MGR *pIOMgr) ++{ ++ DBC_Require(MEM_IsValidHandle(pIOMgr, IO_MGRSIGNATURE)); ++ ++ DPC_Schedule(pIOMgr->hDPC); ++} ++ ++/* ++ * ======== FindReadyOutput ======== ++ * Search for a host output channel which is ready to send. If this is ++ * called as a result of servicing the DPC, then implement a round ++ * robin search; otherwise, this was called by a client thread (via ++ * IO_Dispatch()), so just start searching from the current channel id. ++ */ ++static u32 FindReadyOutput(struct CHNL_MGR *pChnlMgr, ++ struct CHNL_OBJECT *pChnl, u32 dwMask) ++{ ++ u32 uRetval = OUTPUTNOTREADY; ++ u32 id, startId; ++ u32 shift; ++ ++ id = (pChnl != NULL ? pChnl->uId : (pChnlMgr->dwLastOutput + 1)); ++ id = ((id == CHNL_MAXCHANNELS) ? 0 : id); ++ DBC_Assert(id < CHNL_MAXCHANNELS); ++ if (dwMask) { ++ shift = (1 << id); ++ startId = id; ++ do { ++ if (dwMask & shift) { ++ uRetval = id; ++ if (pChnl == NULL) ++ pChnlMgr->dwLastOutput = id; ++ ++ break; ++ } ++ id = id + 1; ++ id = ((id == CHNL_MAXCHANNELS) ? 0 : id); ++ shift = (1 << id); ++ } while (id != startId); ++ } ++ DBC_Ensure((uRetval == OUTPUTNOTREADY) || (uRetval < CHNL_MAXCHANNELS)); ++ return uRetval; ++} ++ ++/* ++ * ======== InputChnl ======== ++ * Dispatch a buffer on an input channel. ++ */ ++static void InputChnl(struct IO_MGR *pIOMgr, struct CHNL_OBJECT *pChnl, ++ u32 iMode) ++{ ++ struct CHNL_MGR *pChnlMgr; ++ struct SHM *sm; ++ u32 chnlId; ++ u32 uBytes; ++ struct CHNL_IRP *pChirp = NULL; ++ u32 dwArg; ++ bool fClearChnl = false; ++ bool fNotifyClient = false; ++ ++ sm = pIOMgr->pSharedMem; ++ pChnlMgr = pIOMgr->hChnlMgr; ++ ++ DBG_Trace(DBG_LEVEL3, "> InputChnl\n"); ++ ++ /* Attempt to perform input.... */ ++ if (!IO_GetValue(pIOMgr->hWmdContext, struct SHM, sm, inputFull)) ++ goto func_end; ++ ++ uBytes = IO_GetValue(pIOMgr->hWmdContext, struct SHM, sm, inputSize) * ++ pChnlMgr->uWordSize; ++ chnlId = IO_GetValue(pIOMgr->hWmdContext, struct SHM, sm, inputId); ++ dwArg = IO_GetLong(pIOMgr->hWmdContext, struct SHM, sm, arg); ++ if (!(chnlId >= 0) || !(chnlId < CHNL_MAXCHANNELS)) { ++ /* Shouldn't be here: would indicate corrupted SHM. */ ++ DBC_Assert(chnlId); ++ goto func_end; ++ } ++ pChnl = pChnlMgr->apChannel[chnlId]; ++ if ((pChnl != NULL) && CHNL_IsInput(pChnl->uMode)) { ++ if ((pChnl->dwState & ~CHNL_STATEEOS) == CHNL_STATEREADY) { ++ if (!pChnl->pIORequests) ++ goto func_end; ++ /* Get the I/O request, and attempt a transfer: */ ++ pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl-> ++ pIORequests); ++ if (pChirp) { ++ pChnl->cIOReqs--; ++ DBC_Assert(pChnl->cIOReqs >= 0); ++ /* Ensure we don't overflow the client's ++ * buffer: */ ++ uBytes = min(uBytes, pChirp->cBytes); ++ /* Transfer buffer from DSP side: */ ++ uBytes = ReadData(pIOMgr->hWmdContext, ++ pChirp->pHostSysBuf, ++ pIOMgr->pInput, uBytes); ++ pChnl->cBytesMoved += uBytes; ++ pChirp->cBytes = uBytes; ++ pChirp->dwArg = dwArg; ++ pChirp->status = CHNL_IOCSTATCOMPLETE; ++ DBG_Trace(DBG_LEVEL7, "Input Chnl:status= 0x%x " ++ "\n", *((RMS_WORD *)(pChirp-> ++ pHostSysBuf))); ++ if (uBytes == 0) { ++ /* This assertion fails if the DSP ++ * sends EOS more than once on this ++ * channel: */ ++ DBC_Assert(!(pChnl->dwState & ++ CHNL_STATEEOS)); ++ /* Zero bytes indicates EOS. Update ++ * IOC status for this chirp, and also ++ * the channel state: */ ++ pChirp->status |= CHNL_IOCSTATEOS; ++ pChnl->dwState |= CHNL_STATEEOS; ++ /* Notify that end of stream has ++ * occurred */ ++ NTFY_Notify(pChnl->hNtfy, ++ DSP_STREAMDONE); ++ DBG_Trace(DBG_LEVEL7, "Input Chnl NTFY " ++ "chnl = 0x%x\n", pChnl); ++ } ++ /* Tell DSP if no more I/O buffers available: */ ++ if (!pChnl->pIORequests) ++ goto func_end; ++ if (LST_IsEmpty(pChnl->pIORequests)) { ++ IO_AndValue(pIOMgr->hWmdContext, ++ struct SHM, sm, hostFreeMask, ++ ~(1 << pChnl->uId)); ++ } ++ fClearChnl = true; ++ fNotifyClient = true; ++ } else { ++ /* Input full for this channel, but we have no ++ * buffers available. The channel must be ++ * "idling". Clear out the physical input ++ * channel. */ ++ fClearChnl = true; ++ } ++ } else { ++ /* Input channel cancelled: clear input channel. */ ++ fClearChnl = true; ++ } ++ } else { ++ /* DPC fired after host closed channel: clear input channel. */ ++ fClearChnl = true; ++ } ++ if (fClearChnl) { ++ /* Indicate to the DSP we have read the input: */ ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, inputFull, 0); ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, MBX_PCPY_CLASS); ++ } ++ if (fNotifyClient) { ++ /* Notify client with IO completion record: */ ++ NotifyChnlComplete(pChnl, pChirp); ++ } ++func_end: ++ DBG_Trace(DBG_LEVEL3, "< InputChnl\n"); ++} ++ ++/* ++ * ======== InputMsg ======== ++ * Copies messages from shared memory to the message queues. ++ */ ++static void InputMsg(struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr) ++{ ++ u32 uMsgs; ++ u32 i; ++ u8 *pMsgInput; ++ struct MSG_QUEUE *hMsgQueue; ++ struct MSG_FRAME *pMsg; ++ struct MSG_DSPMSG msg; ++ struct MSG *pCtrl; ++ u32 fInputEmpty; ++ u32 addr; ++ ++ pCtrl = pIOMgr->pMsgInputCtrl; ++ /* Get the number of input messages to be read. */ ++ fInputEmpty = IO_GetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ bufEmpty); ++ uMsgs = IO_GetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, size); ++ if (fInputEmpty || uMsgs >= hMsgMgr->uMaxMsgs) ++ return; ++ ++ pMsgInput = pIOMgr->pMsgInput; ++ for (i = 0; i < uMsgs; i++) { ++ /* Read the next message */ ++ addr = (u32)&(((struct MSG_DSPMSG *)pMsgInput)->msg.dwCmd); ++ msg.msg.dwCmd = ReadExt32BitDspData(pIOMgr->hWmdContext, addr); ++ addr = (u32)&(((struct MSG_DSPMSG *)pMsgInput)->msg.dwArg1); ++ msg.msg.dwArg1 = ReadExt32BitDspData(pIOMgr->hWmdContext, addr); ++ addr = (u32)&(((struct MSG_DSPMSG *)pMsgInput)->msg.dwArg2); ++ msg.msg.dwArg2 = ReadExt32BitDspData(pIOMgr->hWmdContext, addr); ++ addr = (u32)&(((struct MSG_DSPMSG *)pMsgInput)->dwId); ++ msg.dwId = ReadExt32BitDspData(pIOMgr->hWmdContext, addr); ++ pMsgInput += sizeof(struct MSG_DSPMSG); ++ if (!hMsgMgr->queueList) ++ goto func_end; ++ ++ /* Determine which queue to put the message in */ ++ hMsgQueue = (struct MSG_QUEUE *)LST_First(hMsgMgr->queueList); ++ DBG_Trace(DBG_LEVEL7, "InputMsg RECVD: dwCmd=0x%x dwArg1=0x%x " ++ "dwArg2=0x%x dwId=0x%x \n", msg.msg.dwCmd, ++ msg.msg.dwArg1, msg.msg.dwArg2, msg.dwId); ++ /* Interrupt may occur before shared memory and message ++ * input locations have been set up. If all nodes were ++ * cleaned up, hMsgMgr->uMaxMsgs should be 0. */ ++ if (hMsgQueue && uMsgs > hMsgMgr->uMaxMsgs) ++ goto func_end; ++ ++ while (hMsgQueue != NULL) { ++ if (msg.dwId == hMsgQueue->dwId) { ++ /* Found it */ ++ if (msg.msg.dwCmd == RMS_EXITACK) { ++ /* The exit message does not get ++ * queued */ ++ /* Call the node exit notification */ ++ /* Node handle */ /* status */ ++ (*hMsgMgr->onExit)((HANDLE)hMsgQueue-> ++ hArg, msg.msg.dwArg1); ++ } else { ++ /* Not an exit acknowledgement, queue ++ * the message */ ++ if (!hMsgQueue->msgFreeList) ++ goto func_end; ++ pMsg = (struct MSG_FRAME *)LST_GetHead ++ (hMsgQueue->msgFreeList); ++ if (hMsgQueue->msgUsedList && pMsg) { ++ pMsg->msgData = msg; ++ LST_PutTail(hMsgQueue-> ++ msgUsedList, ++ (struct LST_ELEM *)pMsg); ++ NTFY_Notify(hMsgQueue->hNtfy, ++ DSP_NODEMESSAGEREADY); ++ SYNC_SetEvent(hMsgQueue-> ++ hSyncEvent); ++ } else { ++ /* No free frame to copy the ++ * message into */ ++ DBG_Trace(DBG_LEVEL7, "NO FREE " ++ "MSG FRAMES, DISCARDING" ++ " MESSAGE\n"); ++ } ++ } ++ break; ++ } ++ ++ if (!hMsgMgr->queueList || !hMsgQueue) ++ goto func_end; ++ hMsgQueue = (struct MSG_QUEUE *)LST_Next(hMsgMgr-> ++ queueList, (struct LST_ELEM *)hMsgQueue); ++ } ++ } ++ /* Set the post SWI flag */ ++ if (uMsgs > 0) { ++ /* Tell the DSP we've read the messages */ ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, bufEmpty, ++ true); ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, postSWI, ++ true); ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, MBX_PCPY_CLASS); ++ } ++func_end: ++ return; ++ ++} ++ ++/* ++ * ======== NotifyChnlComplete ======== ++ * Purpose: ++ * Signal the channel event, notifying the client that I/O has completed. ++ */ ++static void NotifyChnlComplete(struct CHNL_OBJECT *pChnl, ++ struct CHNL_IRP *pChirp) ++{ ++ bool fSignalEvent; ++ ++ DBC_Require(MEM_IsValidHandle(pChnl, CHNL_SIGNATURE)); ++ DBC_Require(pChnl->hSyncEvent != NULL); ++ /* Note: we signal the channel event only if the queue of IO ++ * completions is empty. If it is not empty, the event is sure to be ++ * signalled by the only IO completion list consumer: ++ * WMD_CHNL_GetIOC(). */ ++ fSignalEvent = LST_IsEmpty(pChnl->pIOCompletions); ++ /* Enqueue the IO completion info for the client: */ ++ LST_PutTail(pChnl->pIOCompletions, (struct LST_ELEM *) pChirp); ++ pChnl->cIOCs++; ++ DBC_Assert(pChnl->cIOCs <= pChnl->cChirps); ++ /* Signal the channel event (if not already set) that IO is complete: */ ++ if (fSignalEvent) ++ SYNC_SetEvent(pChnl->hSyncEvent); ++ ++ /* Notify that IO is complete */ ++ NTFY_Notify(pChnl->hNtfy, DSP_STREAMIOCOMPLETION); ++} ++ ++/* ++ * ======== OutputChnl ======== ++ * Purpose: ++ * Dispatch a buffer on an output channel. ++ */ ++static void OutputChnl(struct IO_MGR *pIOMgr, struct CHNL_OBJECT *pChnl, ++ u32 iMode) ++{ ++ struct CHNL_MGR *pChnlMgr; ++ struct SHM *sm; ++ u32 chnlId; ++ struct CHNL_IRP *pChirp; ++ u32 dwDspFMask; ++ ++ pChnlMgr = pIOMgr->hChnlMgr; ++ sm = pIOMgr->pSharedMem; ++ DBG_Trace(DBG_LEVEL3, "> OutputChnl\n"); ++ /* Attempt to perform output: */ ++ if (IO_GetValue(pIOMgr->hWmdContext, struct SHM, sm, outputFull)) ++ goto func_end; ++ ++ if (pChnl && !((pChnl->dwState & ~CHNL_STATEEOS) == CHNL_STATEREADY)) ++ goto func_end; ++ ++ /* Look to see if both a PC and DSP output channel are ready: */ ++ dwDspFMask = IO_GetValue(pIOMgr->hWmdContext, struct SHM, sm, ++ dspFreeMask); ++ chnlId = FindReadyOutput(pChnlMgr, pChnl, (pChnlMgr->dwOutputMask & ++ dwDspFMask)); ++ if (chnlId == OUTPUTNOTREADY) ++ goto func_end; ++ ++ pChnl = pChnlMgr->apChannel[chnlId]; ++ if (!pChnl || !pChnl->pIORequests) { ++ /* Shouldn't get here: */ ++ goto func_end; ++ } ++ /* Get the I/O request, and attempt a transfer: */ ++ pChirp = (struct CHNL_IRP *)LST_GetHead(pChnl->pIORequests); ++ if (!pChirp) ++ goto func_end; ++ ++ pChnl->cIOReqs--; ++ if (pChnl->cIOReqs < 0 || !pChnl->pIORequests) ++ goto func_end; ++ ++ /* Record fact that no more I/O buffers available: */ ++ if (LST_IsEmpty(pChnl->pIORequests)) ++ pChnlMgr->dwOutputMask &= ~(1 << chnlId); ++ ++ /* Transfer buffer to DSP side: */ ++ pChirp->cBytes = WriteData(pIOMgr->hWmdContext, pIOMgr->pOutput, ++ pChirp->pHostSysBuf, min(pIOMgr->uSMBufSize, pChirp-> ++ cBytes)); ++ pChnl->cBytesMoved += pChirp->cBytes; ++ /* Write all 32 bits of arg */ ++ IO_SetLong(pIOMgr->hWmdContext, struct SHM, sm, arg, pChirp->dwArg); ++#if _CHNL_WORDSIZE == 2 ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, outputId, ++ (u16)chnlId); ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, outputSize, ++ (u16)(pChirp->cBytes + (pChnlMgr->uWordSize-1)) / ++ (u16)pChnlMgr->uWordSize); ++#else ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, outputId, chnlId); ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, outputSize, ++ (pChirp->cBytes + (pChnlMgr->uWordSize - 1)) / pChnlMgr-> ++ uWordSize); ++#endif ++ IO_SetValue(pIOMgr->hWmdContext, struct SHM, sm, outputFull, 1); ++ /* Indicate to the DSP we have written the output: */ ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, MBX_PCPY_CLASS); ++ /* Notify client with IO completion record (keep EOS) */ ++ pChirp->status &= CHNL_IOCSTATEOS; ++ NotifyChnlComplete(pChnl, pChirp); ++ /* Notify if stream is done. */ ++ if (pChirp->status & CHNL_IOCSTATEOS) ++ NTFY_Notify(pChnl->hNtfy, DSP_STREAMDONE); ++ ++func_end: ++ DBG_Trace(DBG_LEVEL3, "< OutputChnl\n"); ++} ++/* ++ * ======== OutputMsg ======== ++ * Copies messages from the message queues to the shared memory. ++ */ ++static void OutputMsg(struct IO_MGR *pIOMgr, struct MSG_MGR *hMsgMgr) ++{ ++ u32 uMsgs = 0; ++ u32 i; ++ u8 *pMsgOutput; ++ struct MSG_FRAME *pMsg; ++ struct MSG *pCtrl; ++ u32 fOutputEmpty; ++ u32 val; ++ u32 addr; ++ ++ pCtrl = pIOMgr->pMsgOutputCtrl; ++ ++ /* Check if output has been cleared */ ++ fOutputEmpty = IO_GetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ bufEmpty); ++ if (fOutputEmpty) { ++ uMsgs = (hMsgMgr->uMsgsPending > hMsgMgr->uMaxMsgs) ? ++ hMsgMgr->uMaxMsgs : hMsgMgr->uMsgsPending; ++ pMsgOutput = pIOMgr->pMsgOutput; ++ /* Copy uMsgs messages into shared memory */ ++ for (i = 0; i < uMsgs; i++) { ++ if (!hMsgMgr->msgUsedList) { ++ DBG_Trace(DBG_LEVEL3, "msgUsedList is NULL\n"); ++ pMsg = NULL; ++ goto func_end; ++ } else ++ pMsg = (struct MSG_FRAME *)LST_GetHead( ++ hMsgMgr->msgUsedList); ++ if (pMsg != NULL) { ++ val = (pMsg->msgData).dwId; ++ addr = (u32)&(((struct MSG_DSPMSG *) ++ pMsgOutput)->dwId); ++ WriteExt32BitDspData(pIOMgr->hWmdContext, addr, ++ val); ++ val = (pMsg->msgData).msg.dwCmd; ++ addr = (u32)&((((struct MSG_DSPMSG *) ++ pMsgOutput)->msg).dwCmd); ++ WriteExt32BitDspData(pIOMgr->hWmdContext, addr, ++ val); ++ val = (pMsg->msgData).msg.dwArg1; ++ addr = ++ (u32)&((((struct MSG_DSPMSG *) ++ pMsgOutput)->msg).dwArg1); ++ WriteExt32BitDspData(pIOMgr->hWmdContext, addr, ++ val); ++ val = (pMsg->msgData).msg.dwArg2; ++ addr = ++ (u32)&((((struct MSG_DSPMSG *) ++ pMsgOutput)->msg).dwArg2); ++ WriteExt32BitDspData(pIOMgr->hWmdContext, addr, ++ val); ++ pMsgOutput += sizeof(struct MSG_DSPMSG); ++ if (!hMsgMgr->msgFreeList) ++ goto func_end; ++ LST_PutTail(hMsgMgr->msgFreeList, ++ (struct LST_ELEM *) pMsg); ++ SYNC_SetEvent(hMsgMgr->hSyncEvent); ++ } else { ++ DBG_Trace(DBG_LEVEL3, "pMsg is NULL\n"); ++ } ++ } ++ ++ if (uMsgs > 0) { ++ hMsgMgr->uMsgsPending -= uMsgs; ++#if _CHNL_WORDSIZE == 2 ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ size, (u16)uMsgs); ++#else ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ size, uMsgs); ++#endif ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ bufEmpty, false); ++ /* Set the post SWI flag */ ++ IO_SetValue(pIOMgr->hWmdContext, struct MSG, pCtrl, ++ postSWI, true); ++ /* Tell the DSP we have written the output. */ ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, MBX_PCPY_CLASS); ++ } ++ } ++func_end: ++ return; ++ ++} ++ ++/* ++ * ======== registerSHMSegs ======== ++ * purpose: ++ * Registers GPP SM segment with CMM. ++ */ ++static DSP_STATUS registerSHMSegs(struct IO_MGR *hIOMgr, ++ struct COD_MANAGER *hCodMan, ++ u32 dwGPPBasePA) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 ulShm0_Base = 0; ++ u32 ulShm0_End = 0; ++ u32 ulShm0_RsrvdStart = 0; ++ u32 ulRsrvdSize = 0; ++ u32 ulGppPhys; ++ u32 ulDspVirt; ++ u32 ulShmSegId0 = 0; ++ u32 dwOffset, dwGPPBaseVA, ulDSPSize; ++ ++ /* Read address and size info for first SM region.*/ ++ /* Get start of 1st SM Heap region */ ++ status = COD_GetSymValue(hCodMan, SHM0_SHARED_BASE_SYM, &ulShm0_Base); ++ DBC_Assert(ulShm0_Base != 0); ++ /* Get end of 1st SM Heap region */ ++ if (DSP_SUCCEEDED(status)) { ++ /* Get start and length of message part of shared memory */ ++ status = COD_GetSymValue(hCodMan, SHM0_SHARED_END_SYM, ++ &ulShm0_End); ++ DBC_Assert(ulShm0_End != 0); ++ } ++ /* start of Gpp reserved region */ ++ if (DSP_SUCCEEDED(status)) { ++ /* Get start and length of message part of shared memory */ ++ status = COD_GetSymValue(hCodMan, SHM0_SHARED_RESERVED_BASE_SYM, ++ &ulShm0_RsrvdStart); ++ DBG_Trace(DBG_LEVEL1, "***ulShm0_RsrvdStart 0x%x \n", ++ ulShm0_RsrvdStart); ++ DBC_Assert(ulShm0_RsrvdStart != 0); ++ } ++ /* Register with CMM */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetCmmMgr(hIOMgr->hDevObject, &hIOMgr->hCmmMgr); ++ if (DSP_SUCCEEDED(status)) { ++ status = CMM_UnRegisterGPPSMSeg(hIOMgr->hCmmMgr, ++ CMM_ALLSEGMENTS); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, "ERROR - Unable to " ++ "Un-Register SM segments \n"); ++ } ++ } else { ++ DBG_Trace(DBG_LEVEL7, "ERROR - Unable to get CMM " ++ "Handle \n"); ++ } ++ } ++ /* Register new SM region(s) */ ++ if (DSP_SUCCEEDED(status) && (ulShm0_End - ulShm0_Base) > 0) { ++ /* calc size (bytes) of SM the GPP can alloc from */ ++ ulRsrvdSize = (ulShm0_End - ulShm0_RsrvdStart + 1) * hIOMgr-> ++ uWordSize; ++ DBC_Assert(ulRsrvdSize > 0); ++ /* calc size of SM DSP can alloc from */ ++ ulDSPSize = (ulShm0_RsrvdStart - ulShm0_Base) * hIOMgr-> ++ uWordSize; ++ DBC_Assert(ulDSPSize > 0); ++ /* First TLB entry reserved for Bridge SM use.*/ ++ ulGppPhys = hIOMgr->extProcInfo.tyTlb[0].ulGppPhys; ++ /* get size in bytes */ ++ ulDspVirt = hIOMgr->extProcInfo.tyTlb[0].ulDspVirt * hIOMgr-> ++ uWordSize; ++ /* Calc byte offset used to convert GPP phys <-> DSP byte ++ * address.*/ ++ if (dwGPPBasePA > ulDspVirt) ++ dwOffset = dwGPPBasePA - ulDspVirt; ++ else ++ dwOffset = ulDspVirt - dwGPPBasePA; ++ ++ DBC_Assert(ulShm0_RsrvdStart * hIOMgr->uWordSize >= ulDspVirt); ++ /* calc Gpp phys base of SM region */ ++ /* Linux - this is actually uncached kernel virtual address*/ ++ dwGPPBaseVA = ulGppPhys + ulShm0_RsrvdStart * hIOMgr->uWordSize ++ - ulDspVirt; ++ /* calc Gpp phys base of SM region */ ++ /* Linux - this is the physical address*/ ++ dwGPPBasePA = dwGPPBasePA + ulShm0_RsrvdStart * hIOMgr-> ++ uWordSize - ulDspVirt; ++ /* Register SM Segment 0.*/ ++ status = CMM_RegisterGPPSMSeg(hIOMgr->hCmmMgr, dwGPPBasePA, ++ ulRsrvdSize, dwOffset, (dwGPPBasePA > ulDspVirt) ? ++ CMM_ADDTODSPPA : CMM_SUBFROMDSPPA, ++ (u32)(ulShm0_Base * hIOMgr->uWordSize), ++ ulDSPSize, &ulShmSegId0, dwGPPBaseVA); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, "ERROR - Failed to register SM " ++ "Seg 0 \n"); ++ } ++ /* first SM region is segId = 1 */ ++ DBC_Assert(ulShmSegId0 == 1); ++ } ++ return status; ++} ++ ++/* ++ * ======== ReadData ======== ++ * Copies buffers from the shared memory to the host buffer. ++ */ ++static u32 ReadData(struct WMD_DEV_CONTEXT *hDevContext, void *pDest, ++ void *pSrc, u32 uSize) ++{ ++ memcpy(pDest, pSrc, uSize); ++ return uSize; ++} ++ ++/* ++ * ======== WriteData ======== ++ * Copies buffers from the host side buffer to the shared memory. ++ */ ++static u32 WriteData(struct WMD_DEV_CONTEXT *hDevContext, void *pDest, ++ void *pSrc, u32 uSize) ++{ ++ memcpy(pDest, pSrc, uSize); ++ return uSize; ++} ++ ++/* ZCPY IO routines. */ ++void IO_IntrDSP2(IN struct IO_MGR *pIOMgr, IN u16 wMbVal) ++{ ++ CHNLSM_InterruptDSP2(pIOMgr->hWmdContext, wMbVal); ++} ++ ++/* ++ * ======== IO_SHMcontrol ======== ++ * Sets the requested SHM setting. ++ */ ++DSP_STATUS IO_SHMsetting(IN struct IO_MGR *hIOMgr, IN enum SHM_DESCTYPE desc, ++ IN void *pArgs) ++{ ++#ifdef CONFIG_BRIDGE_DVFS ++ u32 i; ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++ ++ switch (desc) { ++ case SHM_CURROPP: ++ /* Update the shared memory with requested OPP information */ ++ if (pArgs != NULL) ++ hIOMgr->pSharedMem->oppTableStruct.currOppPt = ++ *(u32 *)pArgs; ++ else ++ return DSP_EFAIL; ++ break; ++ case SHM_OPPINFO: ++ /* Update the shared memory with the voltage, frequency, ++ min and max frequency values for an OPP */ ++ for (i = 0; i <= dsp_max_opps; i++) { ++ hIOMgr->pSharedMem->oppTableStruct.oppPoint[i].voltage = ++ vdd1_dsp_freq[i][0]; ++ DBG_Trace(DBG_LEVEL5, "OPP shared memory -voltage: " ++ "%d\n", hIOMgr->pSharedMem->oppTableStruct. ++ oppPoint[i].voltage); ++ hIOMgr->pSharedMem->oppTableStruct.oppPoint[i]. ++ frequency = vdd1_dsp_freq[i][1]; ++ DBG_Trace(DBG_LEVEL5, "OPP shared memory -frequency: " ++ "%d\n", hIOMgr->pSharedMem->oppTableStruct. ++ oppPoint[i].frequency); ++ hIOMgr->pSharedMem->oppTableStruct.oppPoint[i].minFreq = ++ vdd1_dsp_freq[i][2]; ++ DBG_Trace(DBG_LEVEL5, "OPP shared memory -min value: " ++ "%d\n", hIOMgr->pSharedMem->oppTableStruct. ++ oppPoint[i].minFreq); ++ hIOMgr->pSharedMem->oppTableStruct.oppPoint[i].maxFreq = ++ vdd1_dsp_freq[i][3]; ++ DBG_Trace(DBG_LEVEL5, "OPP shared memory -max value: " ++ "%d\n", hIOMgr->pSharedMem->oppTableStruct. ++ oppPoint[i].maxFreq); ++ } ++ hIOMgr->pSharedMem->oppTableStruct.numOppPts = dsp_max_opps; ++ DBG_Trace(DBG_LEVEL5, "OPP shared memory - max OPP number: " ++ "%d\n", hIOMgr->pSharedMem->oppTableStruct.numOppPts); ++ /* Update the current OPP number */ ++ if (pdata->dsp_get_opp) ++ i = (*pdata->dsp_get_opp)(); ++ hIOMgr->pSharedMem->oppTableStruct.currOppPt = i; ++ DBG_Trace(DBG_LEVEL7, "OPP value programmed to shared memory: " ++ "%d\n", i); ++ break; ++ case SHM_GETOPP: ++ /* Get the OPP that DSP has requested */ ++ *(u32 *)pArgs = hIOMgr->pSharedMem->oppRequest.rqstOppPt; ++ break; ++ default: ++ break; ++ ++ queue_work(bridge_workqueue, ++ &(hIOMgr->io_workq)); ++ } ++#endif ++ return DSP_SOK; ++} ++ ++/* ++ * ======== WMD_IO_GetProcLoad ======== ++ * Gets the Processor's Load information ++ */ ++DSP_STATUS WMD_IO_GetProcLoad(IN struct IO_MGR *hIOMgr, ++ OUT struct DSP_PROCLOADSTAT *pProcStat) ++{ ++ pProcStat->uCurrLoad = hIOMgr->pSharedMem->loadMonInfo.currDspLoad; ++ pProcStat->uPredictedLoad = hIOMgr->pSharedMem->loadMonInfo.predDspLoad; ++ pProcStat->uCurrDspFreq = hIOMgr->pSharedMem->loadMonInfo.currDspFreq; ++ pProcStat->uPredictedFreq = hIOMgr->pSharedMem->loadMonInfo.predDspFreq; ++ ++ DBG_Trace(DBG_LEVEL4, "Curr Load =%d, Pred Load = %d, Curr Freq = %d, " ++ "Pred Freq = %d\n", pProcStat->uCurrLoad, ++ pProcStat->uPredictedLoad, pProcStat->uCurrDspFreq, ++ pProcStat->uPredictedFreq); ++ return DSP_SOK; ++} ++ ++#ifndef DSP_TRACEBUF_DISABLED ++void PrintDSPDebugTrace(struct IO_MGR *hIOMgr) ++{ ++ u32 ulNewMessageLength = 0, ulGPPCurPointer; ++ ++ GT_0trace(dsp_trace_mask, GT_ENTER, "Entering PrintDSPDebugTrace\n"); ++ ++ while (true) { ++ /* Get the DSP current pointer */ ++ ulGPPCurPointer = *(u32 *) (hIOMgr->ulTraceBufferCurrent); ++ ulGPPCurPointer = hIOMgr->ulGppVa + (ulGPPCurPointer - ++ hIOMgr->ulDspVa); ++ ++ /* No new debug messages available yet */ ++ if (ulGPPCurPointer == hIOMgr->ulGPPReadPointer) ++ break; ++ ++ /* Continuous data */ ++ else if (ulGPPCurPointer > hIOMgr->ulGPPReadPointer) { ++ ulNewMessageLength = ulGPPCurPointer - hIOMgr-> ++ ulGPPReadPointer; ++ ++ memcpy(hIOMgr->pMsg, (char *)hIOMgr->ulGPPReadPointer, ++ ulNewMessageLength); ++ hIOMgr->pMsg[ulNewMessageLength] = '\0'; ++ /* Advance the GPP trace pointer to DSP current ++ * pointer */ ++ hIOMgr->ulGPPReadPointer += ulNewMessageLength; ++ /* Print the trace messages */ ++ GT_0trace(dsp_trace_mask, GT_1CLASS, hIOMgr->pMsg); ++ } ++ /* Handle trace buffer wraparound */ ++ else if (ulGPPCurPointer < hIOMgr->ulGPPReadPointer) { ++ memcpy(hIOMgr->pMsg, (char *)hIOMgr->ulGPPReadPointer, ++ hIOMgr->ulTraceBufferEnd - ++ hIOMgr->ulGPPReadPointer); ++ ulNewMessageLength = ulGPPCurPointer - ++ hIOMgr->ulTraceBufferBegin; ++ memcpy(&hIOMgr->pMsg[hIOMgr->ulTraceBufferEnd - ++ hIOMgr->ulGPPReadPointer], ++ (char *)hIOMgr->ulTraceBufferBegin, ++ ulNewMessageLength); ++ hIOMgr->pMsg[hIOMgr->ulTraceBufferEnd - ++ hIOMgr->ulGPPReadPointer + ++ ulNewMessageLength] = '\0'; ++ /* Advance the GPP trace pointer to DSP current ++ * pointer */ ++ hIOMgr->ulGPPReadPointer = hIOMgr->ulTraceBufferBegin + ++ ulNewMessageLength; ++ /* Print the trace messages */ ++ GT_0trace(dsp_trace_mask, GT_1CLASS, hIOMgr->pMsg); ++ } ++ } ++} ++#endif ++ ++/* ++ * ======== PackTraceBuffer ======== ++ * Removes extra nulls from the trace buffer returned from the DSP. ++ * Works even on buffers that already are packed (null removed); but has ++ * one bug in that case -- loses the last character (replaces with '\0'). ++ * Continues through conversion for full set of nBytes input characters. ++ * Parameters: ++ * lpBuf: Pointer to input/output buffer ++ * nBytes: Number of characters in the buffer ++ * ulNumWords: Number of DSP words in the buffer. Indicates potential ++ * number of extra carriage returns to generate. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Unable to allocate memory. ++ * Requires: ++ * lpBuf must be a fully allocated writable block of at least nBytes. ++ * There are no more than ulNumWords extra characters needed (the number of ++ * linefeeds minus the number of NULLS in the input buffer). ++ */ ++#if (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE ++static DSP_STATUS PackTraceBuffer(char *lpBuf, u32 nBytes, u32 ulNumWords) ++{ ++ DSP_STATUS status = DSP_SOK; ++ char *lpTmpBuf; ++ char *lpBufStart; ++ char *lpTmpStart; ++ u32 nCnt; ++ char thisChar; ++ ++ /* tmp workspace, 1 KB longer than input buf */ ++ lpTmpBuf = MEM_Calloc((nBytes + ulNumWords), MEM_PAGED); ++ if (lpTmpBuf == NULL) { ++ DBG_Trace(DBG_LEVEL7, "PackTrace buffer:OutofMemory \n"); ++ status = DSP_EMEMORY; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ lpBufStart = lpBuf; ++ lpTmpStart = lpTmpBuf; ++ for (nCnt = nBytes; nCnt > 0; nCnt--) { ++ thisChar = *lpBuf++; ++ switch (thisChar) { ++ case '\0': /* Skip null bytes */ ++ break; ++ case '\n': /* Convert \n to \r\n */ ++ /* NOTE: do not reverse order; Some OS */ ++ /* editors control doesn't understand "\n\r" */ ++ *lpTmpBuf++ = '\r'; ++ *lpTmpBuf++ = '\n'; ++ break; ++ default: /* Copy in the actual ascii byte */ ++ *lpTmpBuf++ = thisChar; ++ break; ++ } ++ } ++ *lpTmpBuf = '\0'; /* Make sure tmp buf is null terminated */ ++ /* Cut output down to input buf size */ ++ strncpy(lpBufStart, lpTmpStart, nBytes); ++ /*Make sure output is null terminated */ ++ lpBufStart[nBytes - 1] = '\0'; ++ MEM_Free(lpTmpStart); ++ } ++ ++ return status; ++} ++#endif /* (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE */ ++ ++/* ++ * ======== PrintDspTraceBuffer ======== ++ * Prints the trace buffer returned from the DSP (if DBG_Trace is enabled). ++ * Parameters: ++ * hDehMgr: Handle to DEH manager object ++ * number of extra carriage returns to generate. ++ * Returns: ++ * DSP_SOK: Success. ++ * DSP_EMEMORY: Unable to allocate memory. ++ * Requires: ++ * hDehMgr muse be valid. Checked in WMD_DEH_Notify. ++ */ ++DSP_STATUS PrintDspTraceBuffer(struct WMD_DEV_CONTEXT *hWmdContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++#if (defined(DEBUG) || defined(DDSP_DEBUG_PRODUCT)) && GT_TRACE ++ struct COD_MANAGER *hCodMgr; ++ u32 ulTraceEnd; ++ u32 ulTraceBegin; ++ u32 ulNumBytes = 0; ++ u32 ulNumWords = 0; ++ u32 ulWordSize = 2; ++ CONST u32 uMaxSize = 512; ++ char *pszBuf; ++ u16 *lpszBuf; ++ ++ struct WMD_DEV_CONTEXT *pWmdContext = (struct WMD_DEV_CONTEXT *) ++ hWmdContext; ++ struct WMD_DRV_INTERFACE *pIntfFxns; ++ struct DEV_OBJECT *pDevObject = (struct DEV_OBJECT *) ++ pWmdContext->hDevObject; ++ ++ status = DEV_GetCodMgr(pDevObject, &hCodMgr); ++ if (DSP_FAILED(status)) ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: Failed on DEV_GetCodMgr.\n"); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Look for SYS_PUTCBEG/SYS_PUTCEND: */ ++ status = COD_GetSymValue(hCodMgr, COD_TRACEBEG, &ulTraceBegin); ++ GT_1trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: ulTraceBegin Value 0x%x\n", ++ ulTraceBegin); ++ if (DSP_FAILED(status)) ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: Failed on " ++ "COD_GetSymValue.\n"); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ status = COD_GetSymValue(hCodMgr, COD_TRACEEND, &ulTraceEnd); ++ GT_1trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: ulTraceEnd Value 0x%x\n", ++ ulTraceEnd); ++ if (DSP_FAILED(status)) ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: Failed on " ++ "COD_GetSymValue.\n"); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ ulNumBytes = (ulTraceEnd - ulTraceBegin) * ulWordSize; ++ /* If the chip type is 55 then the addresses will be ++ * byte addresses; convert them to word addresses. */ ++ if (ulNumBytes > uMaxSize) ++ ulNumBytes = uMaxSize; ++ ++ /* make sure the data we request fits evenly */ ++ ulNumBytes = (ulNumBytes / ulWordSize) * ulWordSize; ++ GT_1trace(dsp_trace_mask, GT_2CLASS, "PrintDspTraceBuffer: " ++ "ulNumBytes 0x%x\n", ulNumBytes); ++ ulNumWords = ulNumBytes * ulWordSize; ++ GT_1trace(dsp_trace_mask, GT_2CLASS, "PrintDspTraceBuffer: " ++ "ulNumWords 0x%x\n", ulNumWords); ++ status = DEV_GetIntfFxns(pDevObject, &pIntfFxns); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ pszBuf = MEM_Calloc(uMaxSize, MEM_NONPAGED); ++ lpszBuf = MEM_Calloc(ulNumBytes * 2, MEM_NONPAGED); ++ if (pszBuf != NULL) { ++ /* Read bytes from the DSP trace buffer... */ ++ status = (*pIntfFxns->pfnBrdRead)(hWmdContext, ++ (u8 *)pszBuf, (u32)ulTraceBegin, ++ ulNumBytes, 0); ++ if (DSP_FAILED(status)) ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: " ++ "Failed to Read Trace Buffer.\n"); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Pack and do newline conversion */ ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: " ++ "before pack and unpack.\n"); ++ PackTraceBuffer(pszBuf, ulNumBytes, ulNumWords); ++ GT_1trace(dsp_trace_mask, GT_1CLASS, ++ "DSP Trace Buffer:\n%s\n", pszBuf); ++ } ++ MEM_Free(pszBuf); ++ MEM_Free(lpszBuf); ++ } else { ++ GT_0trace(dsp_trace_mask, GT_2CLASS, ++ "PrintDspTraceBuffer: Failed to " ++ "allocate trace buffer.\n"); ++ status = DSP_EMEMORY; ++ } ++ } ++#endif ++ return status; ++} ++ ++void IO_SM_init(void) ++{ ++ ++ GT_create(&dsp_trace_mask, "DT"); /* DSP Trace Mask */ ++ ++} +diff --git a/drivers/dsp/bridge/wmd/mmu_fault.c b/drivers/dsp/bridge/wmd/mmu_fault.c +new file mode 100644 +index 0000000..5585cdb +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/mmu_fault.c +@@ -0,0 +1,172 @@ ++/* ++ * mmu_fault.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== mmu_fault.c ======== ++ * Description: ++ * Implements DSP MMU fault handling functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 26-Dec-2004 hn: Support for IVA MMU exception. ++ *! 06-Mar-2003 sb: Print MMU fault address. Cosmetic changes. ++ *! 16-Feb-2003 vp: Fixed warning in MMU_FaultIsr ++ *! 05-Jan-2004 vp: Updated support for 24xx silicon ++ *! 19-Feb-2003 vp: Code review updates. ++ *! - Cosmetic changes. ++ *! 18-Oct-2002 sb: Ported to Linux platform. ++ *! 10-Sep-2001 kc: created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/host_os.h> ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/dpc.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/drv.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmddeh.h> ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_mmu.h> ++ ++/* ----------------------------------- This */ ++#include "_deh.h" ++#include <dspbridge/cfg.h> ++#include "_tiomap_mmu.h" ++#include "_tiomap.h" ++#include "mmu_fault.h" ++ ++static u32 dmmuEventMask; ++u32 faultAddr; ++ ++static bool MMU_CheckIfFault(struct WMD_DEV_CONTEXT *pDevContext); ++ ++/* ++ * ======== MMU_FaultDpc ======== ++ * Deferred procedure call to handle DSP MMU fault. ++ */ ++void MMU_FaultDpc(IN void *pRefData) ++{ ++ struct DEH_MGR *hDehMgr = (struct DEH_MGR *)pRefData; ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)hDehMgr; ++ ++ DBG_Trace(DBG_LEVEL1, "MMU_FaultDpc Enter: 0x%x\n", pRefData); ++ ++ if (pDehMgr) ++ WMD_DEH_Notify(hDehMgr, DSP_MMUFAULT, 0L); ++ ++ DBG_Trace(DBG_LEVEL1, "MMU_FaultDpc Exit: 0x%x\n", pRefData); ++} ++ ++/* ++ * ======== MMU_FaultIsr ======== ++ * ISR to be triggered by a DSP MMU fault interrupt. ++ */ ++irqreturn_t MMU_FaultIsr(int irq, IN void *pRefData) ++{ ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)pRefData; ++ struct WMD_DEV_CONTEXT *pDevContext; ++ struct CFG_HOSTRES resources; ++ DSP_STATUS status = DSP_SOK; ++ ++ ++ DBG_Trace(DBG_LEVEL1, "Entering DEH_DspMmuIsr: 0x%x\n", pRefData); ++ DBC_Require(irq == INT_DSP_MMU_IRQ); ++ DBC_Require(MEM_IsValidHandle(pDehMgr, SIGNATURE)); ++ ++ if (MEM_IsValidHandle(pDehMgr, SIGNATURE)) { ++ ++ pDevContext = (struct WMD_DEV_CONTEXT *)pDehMgr->hWmdContext; ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ if (DSP_FAILED(status)) ++ DBG_Trace(DBG_LEVEL7, ++ "**Failed to get Host Resources " ++ "in MMU ISR **\n"); ++ if (MMU_CheckIfFault(pDevContext)) { ++ printk(KERN_INFO "***** DSPMMU FAULT ***** IRQStatus " ++ "0x%x\n", dmmuEventMask); ++ printk(KERN_INFO "***** DSPMMU FAULT ***** faultAddr " ++ "0x%x\n", faultAddr); ++ /* Disable the MMU events, else once we clear it will ++ * start to raise INTs again */ ++ /* ++ * Schedule a DPC directly. In the future, it may be ++ * necessary to check if DSP MMU fault is intended for ++ * Bridge. ++ */ ++ DPC_Schedule(pDehMgr->hMmuFaultDpc); ++ /* Reset errInfo structure before use. */ ++ pDehMgr->errInfo.dwErrMask = DSP_MMUFAULT; ++ pDehMgr->errInfo.dwVal1 = faultAddr >> 16; ++ pDehMgr->errInfo.dwVal2 = faultAddr & 0xFFFF; ++ pDehMgr->errInfo.dwVal3 = 0L; ++ /* Disable the MMU events, else once we clear it will ++ * start to raise INTs again */ ++ HW_MMU_EventDisable(resources.dwDmmuBase, ++ HW_MMU_TRANSLATION_FAULT); ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "***** MMU FAULT ***** faultcode 0x%x\n", ++ dmmuEventMask); ++ HW_MMU_EventDisable(resources.dwDmmuBase, ++ HW_MMU_ALL_INTERRUPTS); ++ } ++ } ++ return IRQ_HANDLED; ++} ++ ++ ++/* ++ * ======== MMU_CheckIfFault ======== ++ * Check to see if MMU Fault is valid TLB miss from DSP ++ * Note: This function is called from an ISR ++ */ ++static bool MMU_CheckIfFault(struct WMD_DEV_CONTEXT *pDevContext) ++{ ++ ++ ++ bool retVal = false; ++ DSP_STATUS status = DSP_SOK; ++ HW_STATUS hwStatus; ++ struct CFG_HOSTRES resources; ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ DBG_Trace(DBG_LEVEL7, "**Failed to get Host Resources in " ++ "MMU_CheckIfFault **\n"); ++ ++ hwStatus = HW_MMU_EventStatus(resources.dwDmmuBase, &dmmuEventMask); ++ if (dmmuEventMask == HW_MMU_TRANSLATION_FAULT) { ++ HW_MMU_FaultAddrRead(resources.dwDmmuBase, &faultAddr); ++ DBG_Trace(DBG_LEVEL1, "WMD_DEH_Notify: DSP_MMUFAULT, fault " ++ "address = 0x%x\n", faultAddr); ++ retVal = true; ++ } ++ return retVal; ++} +diff --git a/drivers/dsp/bridge/wmd/mmu_fault.h b/drivers/dsp/bridge/wmd/mmu_fault.h +new file mode 100644 +index 0000000..be59333 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/mmu_fault.h +@@ -0,0 +1,45 @@ ++/* ++ * mmu_fault.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== mmu_fault.h ======== ++ * Description: ++ * Defines DSP MMU fault handling functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 26-Dec-2004 hn: IVA MMU handlers. ++ *! 10-Sep-2001 kc: created. ++ */ ++ ++#ifndef MMU_FAULT_ ++#define MMU_FAULT_ ++ ++/* ++ * ======== MMU_FaultDpc ======== ++ * Deferred procedure call to handle DSP MMU fault. ++ */ ++ void MMU_FaultDpc(IN void *pRefData); ++ ++/* ++ * ======== MMU_FaultIsr ======== ++ * ISR to be triggered by a DSP MMU fault interrupt. ++ */ ++irqreturn_t MMU_FaultIsr(int irq, IN void *pRefData); ++ ++#endif /* MMU_FAULT_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/msg_sm.c b/drivers/dsp/bridge/wmd/msg_sm.c +new file mode 100644 +index 0000000..b9b2bec +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/msg_sm.c +@@ -0,0 +1,643 @@ ++/* ++ * msg_sm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== msg_sm.c ======== ++ * Description: ++ * Implements upper edge functions for WMD message module. ++ * ++ * Public Functions: ++ * WMD_MSG_Create ++ * WMD_MSG_CreateQueue ++ * WMD_MSG_Delete ++ * WMD_MSG_DeleteQueue ++ * WMD_MSG_Get ++ * WMD_MSG_Put ++ * WMD_MSG_RegisterNotify ++ * WMD_MSG_SetQueueId ++ * ++ *! Revision History: ++ *! ================= ++ *! 24-Jul-2002 jeh Release critical section in WMD_MSG_Put() before ++ *! scheduling DPC. ++ *! 09-May-2001 jeh Free MSG queue NTFY object, remove unnecessary set/ ++ *! reset of events. ++ *! 10-Jan-2001 jeh Set/Reset message manager and message queue events ++ *! correctly. ++ *! 04-Dec-2000 jeh Bug fixes. ++ *! 12-Sep-2000 jeh Created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/list.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/sync.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++ ++/* ----------------------------------- Others */ ++#include <dspbridge/io_sm.h> ++ ++/* ----------------------------------- This */ ++#include <_msg_sm.h> ++#include <dspbridge/wmdmsg.h> ++ ++/* ----------------------------------- Defines, Data Structures, Typedefs */ ++#define MSGQ_SIGNATURE 0x5147534d /* "QGSM" */ ++ ++/* ----------------------------------- Function Prototypes */ ++static DSP_STATUS AddNewMsg(struct LST_LIST *msgList); ++static void DeleteMsgMgr(struct MSG_MGR *hMsgMgr); ++static void DeleteMsgQueue(struct MSG_QUEUE *hMsgQueue, u32 uNumToDSP); ++static void FreeMsgList(struct LST_LIST *msgList); ++ ++/* ++ * ======== WMD_MSG_Create ======== ++ * Create an object to manage message queues. Only one of these objects ++ * can exist per device object. ++ */ ++DSP_STATUS WMD_MSG_Create(OUT struct MSG_MGR **phMsgMgr, ++ struct DEV_OBJECT *hDevObject, MSG_ONEXIT msgCallback) ++{ ++ struct MSG_MGR *pMsgMgr; ++ struct IO_MGR *hIOMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(phMsgMgr != NULL); ++ DBC_Require(msgCallback != NULL); ++ DBC_Require(hDevObject != NULL); ++ DEV_GetIOMgr(hDevObject, &hIOMgr); ++ DBC_Assert(hIOMgr != NULL); ++ *phMsgMgr = NULL; ++ /* Allocate MSG manager object */ ++ MEM_AllocObject(pMsgMgr, struct MSG_MGR, MSGMGR_SIGNATURE); ++ ++ if (pMsgMgr) { ++ pMsgMgr->onExit = msgCallback; ++ pMsgMgr->hIOMgr = hIOMgr; ++ /* List of MSG_QUEUEs */ ++ pMsgMgr->queueList = LST_Create(); ++ /* Queues of message frames for messages to the DSP. Message ++ * frames will only be added to the free queue when a ++ * MSG_QUEUE object is created. */ ++ pMsgMgr->msgFreeList = LST_Create(); ++ pMsgMgr->msgUsedList = LST_Create(); ++ if (pMsgMgr->queueList == NULL || ++ pMsgMgr->msgFreeList == NULL || ++ pMsgMgr->msgUsedList == NULL) ++ status = DSP_EMEMORY; ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_InitializeDPCCS(&pMsgMgr->hSyncCS); ++ ++ /* Create an event to be used by WMD_MSG_Put() in waiting ++ * for an available free frame from the message manager. */ ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_OpenEvent(&pMsgMgr->hSyncEvent, NULL); ++ ++ if (DSP_SUCCEEDED(status)) ++ *phMsgMgr = pMsgMgr; ++ else ++ DeleteMsgMgr(pMsgMgr); ++ ++ } else { ++ status = DSP_EMEMORY; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_MSG_CreateQueue ======== ++ * Create a MSG_QUEUE for sending/receiving messages to/from a node ++ * on the DSP. ++ */ ++DSP_STATUS WMD_MSG_CreateQueue(struct MSG_MGR *hMsgMgr, ++ OUT struct MSG_QUEUE **phMsgQueue, ++ u32 dwId, u32 uMaxMsgs, HANDLE hArg) ++{ ++ u32 i; ++ u32 uNumAllocated = 0; ++ struct MSG_QUEUE *pMsgQ; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hMsgMgr, MSGMGR_SIGNATURE)); ++ DBC_Require(phMsgQueue != NULL); ++ ++ *phMsgQueue = NULL; ++ /* Allocate MSG_QUEUE object */ ++ MEM_AllocObject(pMsgQ, struct MSG_QUEUE, MSGQ_SIGNATURE); ++ if (!pMsgQ) { ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ LST_InitElem((struct LST_ELEM *) pMsgQ); ++ pMsgQ->uMaxMsgs = uMaxMsgs; ++ pMsgQ->hMsgMgr = hMsgMgr; ++ pMsgQ->hArg = hArg; /* Node handle */ ++ pMsgQ->dwId = dwId; /* Node env (not valid yet) */ ++ /* Queues of Message frames for messages from the DSP */ ++ pMsgQ->msgFreeList = LST_Create(); ++ pMsgQ->msgUsedList = LST_Create(); ++ if (pMsgQ->msgFreeList == NULL || pMsgQ->msgUsedList == NULL) ++ status = DSP_EMEMORY; ++ ++ /* Create event that will be signalled when a message from ++ * the DSP is available. */ ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_OpenEvent(&pMsgQ->hSyncEvent, NULL); ++ ++ /* Create a notification list for message ready notification. */ ++ if (DSP_SUCCEEDED(status)) ++ status = NTFY_Create(&pMsgQ->hNtfy); ++ ++ /* Create events that will be used to synchronize cleanup ++ * when the object is deleted. hSyncDone will be set to ++ * unblock threads in MSG_Put() or MSG_Get(). hSyncDoneAck ++ * will be set by the unblocked thread to signal that it ++ * is unblocked and will no longer reference the object. */ ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_OpenEvent(&pMsgQ->hSyncDone, NULL); ++ ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_OpenEvent(&pMsgQ->hSyncDoneAck, NULL); ++ ++ if (DSP_SUCCEEDED(status)) { ++ if (!hMsgMgr->msgFreeList) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ /* Enter critical section */ ++ (void)SYNC_EnterCS(hMsgMgr->hSyncCS); ++ /* Initialize message frames and put in appropriate queues */ ++ for (i = 0; i < uMaxMsgs && DSP_SUCCEEDED(status); i++) { ++ status = AddNewMsg(hMsgMgr->msgFreeList); ++ if (DSP_SUCCEEDED(status)) { ++ uNumAllocated++; ++ status = AddNewMsg(pMsgQ->msgFreeList); ++ } ++ } ++ if (DSP_FAILED(status)) { ++ /* Stay inside CS to prevent others from taking any ++ * of the newly allocated message frames. */ ++ DeleteMsgQueue(pMsgQ, uNumAllocated); ++ } else { ++ LST_PutTail(hMsgMgr->queueList, ++ (struct LST_ELEM *)pMsgQ); ++ *phMsgQueue = pMsgQ; ++ /* Signal that free frames are now available */ ++ if (!LST_IsEmpty(hMsgMgr->msgFreeList)) ++ SYNC_SetEvent(hMsgMgr->hSyncEvent); ++ ++ } ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ } else { ++ DeleteMsgQueue(pMsgQ, 0); ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== WMD_MSG_Delete ======== ++ * Delete a MSG manager allocated in WMD_MSG_Create(). ++ */ ++void WMD_MSG_Delete(struct MSG_MGR *hMsgMgr) ++{ ++ DBC_Require(MEM_IsValidHandle(hMsgMgr, MSGMGR_SIGNATURE)); ++ ++ DeleteMsgMgr(hMsgMgr); ++} ++ ++/* ++ * ======== WMD_MSG_DeleteQueue ======== ++ * Delete a MSG queue allocated in WMD_MSG_CreateQueue. ++ */ ++void WMD_MSG_DeleteQueue(struct MSG_QUEUE *hMsgQueue) ++{ ++ struct MSG_MGR *hMsgMgr = hMsgQueue->hMsgMgr; ++ u32 refCount; ++ ++ DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE)); ++ hMsgQueue->fDone = true; ++ /* Unblock all threads blocked in MSG_Get() or MSG_Put(). */ ++ refCount = hMsgQueue->refCount; ++ while (refCount) { ++ /* Unblock thread */ ++ SYNC_SetEvent(hMsgQueue->hSyncDone); ++ /* Wait for acknowledgement */ ++ SYNC_WaitOnEvent(hMsgQueue->hSyncDoneAck, SYNC_INFINITE); ++ refCount = hMsgQueue->refCount; ++ } ++ /* Remove message queue from hMsgMgr->queueList */ ++ (void)SYNC_EnterCS(hMsgMgr->hSyncCS); ++ LST_RemoveElem(hMsgMgr->queueList, (struct LST_ELEM *)hMsgQueue); ++ /* Free the message queue object */ ++ DeleteMsgQueue(hMsgQueue, hMsgQueue->uMaxMsgs); ++ if (!hMsgMgr->msgFreeList) ++ goto func_cont; ++ if (LST_IsEmpty(hMsgMgr->msgFreeList)) ++ SYNC_ResetEvent(hMsgMgr->hSyncEvent); ++func_cont: ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++} ++ ++/* ++ * ======== WMD_MSG_Get ======== ++ * Get a message from a MSG queue. ++ */ ++DSP_STATUS WMD_MSG_Get(struct MSG_QUEUE *hMsgQueue, ++ struct DSP_MSG *pMsg, u32 uTimeout) ++{ ++ struct MSG_FRAME *pMsgFrame; ++ struct MSG_MGR *hMsgMgr; ++ bool fGotMsg = false; ++ struct SYNC_OBJECT *hSyncs[2]; ++ u32 uIndex; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE)); ++ DBC_Require(pMsg != NULL); ++ ++ hMsgMgr = hMsgQueue->hMsgMgr; ++ if (!hMsgQueue->msgUsedList) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ ++ /* Enter critical section */ ++ (void)SYNC_EnterCS(hMsgMgr->hSyncCS); ++ /* If a message is already there, get it */ ++ if (!LST_IsEmpty(hMsgQueue->msgUsedList)) { ++ pMsgFrame = (struct MSG_FRAME *)LST_GetHead(hMsgQueue-> ++ msgUsedList); ++ if (pMsgFrame != NULL) { ++ *pMsg = pMsgFrame->msgData.msg; ++ LST_PutTail(hMsgQueue->msgFreeList, ++ (struct LST_ELEM *)pMsgFrame); ++ if (LST_IsEmpty(hMsgQueue->msgUsedList)) ++ SYNC_ResetEvent(hMsgQueue->hSyncEvent); ++ ++ fGotMsg = true; ++ } ++ } else { ++ if (hMsgQueue->fDone) ++ status = DSP_EFAIL; ++ else ++ hMsgQueue->refCount++; ++ ++ } ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ if (DSP_SUCCEEDED(status) && !fGotMsg) { ++ /* Wait til message is available, timeout, or done. We don't ++ * have to schedule the DPC, since the DSP will send messages ++ * when they are available. */ ++ hSyncs[0] = hMsgQueue->hSyncEvent; ++ hSyncs[1] = hMsgQueue->hSyncDone; ++ status = SYNC_WaitOnMultipleEvents(hSyncs, 2, uTimeout, ++ &uIndex); ++ /* Enter critical section */ ++ (void)SYNC_EnterCS(hMsgMgr->hSyncCS); ++ if (hMsgQueue->fDone) { ++ hMsgQueue->refCount--; ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ /* Signal that we're not going to access hMsgQueue ++ * anymore, so it can be deleted. */ ++ (void)SYNC_SetEvent(hMsgQueue->hSyncDoneAck); ++ status = DSP_EFAIL; ++ } else { ++ if (DSP_SUCCEEDED(status)) { ++ DBC_Assert(!LST_IsEmpty(hMsgQueue-> ++ msgUsedList)); ++ /* Get msg from used list */ ++ pMsgFrame = (struct MSG_FRAME *) ++ LST_GetHead(hMsgQueue->msgUsedList); ++ /* Copy message into pMsg and put frame on the ++ * free list */ ++ if (pMsgFrame != NULL) { ++ *pMsg = pMsgFrame->msgData.msg; ++ LST_PutTail(hMsgQueue->msgFreeList, ++ (struct LST_ELEM *)pMsgFrame); ++ } ++ } ++ hMsgQueue->refCount--; ++ /* Reset the event if there are still queued messages */ ++ if (!LST_IsEmpty(hMsgQueue->msgUsedList)) ++ SYNC_SetEvent(hMsgQueue->hSyncEvent); ++ ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== WMD_MSG_Put ======== ++ * Put a message onto a MSG queue. ++ */ ++DSP_STATUS WMD_MSG_Put(struct MSG_QUEUE *hMsgQueue, ++ IN CONST struct DSP_MSG *pMsg, u32 uTimeout) ++{ ++ struct MSG_FRAME *pMsgFrame; ++ struct MSG_MGR *hMsgMgr; ++ bool fPutMsg = false; ++ struct SYNC_OBJECT *hSyncs[2]; ++ u32 uIndex; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE)); ++ DBC_Require(pMsg != NULL); ++ ++ hMsgMgr = hMsgQueue->hMsgMgr; ++ ++ if (!hMsgMgr->msgFreeList) { ++ status = DSP_EHANDLE; ++ goto func_end; ++ } ++ ++ ++ (void) SYNC_EnterCS(hMsgMgr->hSyncCS); ++ ++ /* If a message frame is available, use it */ ++ if (!LST_IsEmpty(hMsgMgr->msgFreeList)) { ++ pMsgFrame = (struct MSG_FRAME *)LST_GetHead(hMsgMgr-> ++ msgFreeList); ++ if (pMsgFrame != NULL) { ++ pMsgFrame->msgData.msg = *pMsg; ++ pMsgFrame->msgData.dwId = hMsgQueue->dwId; ++ LST_PutTail(hMsgMgr->msgUsedList, (struct LST_ELEM *) ++ pMsgFrame); ++ hMsgMgr->uMsgsPending++; ++ fPutMsg = true; ++ } ++ if (LST_IsEmpty(hMsgMgr->msgFreeList)) ++ SYNC_ResetEvent(hMsgMgr->hSyncEvent); ++ ++ /* Release critical section before scheduling DPC */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ /* Schedule a DPC, to do the actual data transfer: */ ++ IO_Schedule(hMsgMgr->hIOMgr); ++ } else { ++ if (hMsgQueue->fDone) ++ status = DSP_EFAIL; ++ else ++ hMsgQueue->refCount++; ++ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ } ++ if (DSP_SUCCEEDED(status) && !fPutMsg) { ++ /* Wait til a free message frame is available, timeout, ++ * or done */ ++ hSyncs[0] = hMsgMgr->hSyncEvent; ++ hSyncs[1] = hMsgQueue->hSyncDone; ++ status = SYNC_WaitOnMultipleEvents(hSyncs, 2, uTimeout, ++ &uIndex); ++ /* Enter critical section */ ++ (void)SYNC_EnterCS(hMsgMgr->hSyncCS); ++ if (hMsgQueue->fDone) { ++ hMsgQueue->refCount--; ++ /* Exit critical section */ ++ (void)SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ /* Signal that we're not going to access hMsgQueue ++ * anymore, so it can be deleted. */ ++ (void)SYNC_SetEvent(hMsgQueue->hSyncDoneAck); ++ status = DSP_EFAIL; ++ } else { ++ if (DSP_SUCCEEDED(status)) { ++ if (LST_IsEmpty(hMsgMgr->msgFreeList)) { ++ status = DSP_EPOINTER; ++ goto func_cont; ++ } ++ /* Get msg from free list */ ++ pMsgFrame = (struct MSG_FRAME *) ++ LST_GetHead(hMsgMgr->msgFreeList); ++ /* Copy message into pMsg and put frame on the ++ * used list */ ++ if (pMsgFrame != NULL) { ++ pMsgFrame->msgData.msg = *pMsg; ++ pMsgFrame->msgData.dwId = ++ hMsgQueue->dwId; ++ LST_PutTail(hMsgMgr->msgUsedList, ++ (struct LST_ELEM *) ++ pMsgFrame); ++ hMsgMgr->uMsgsPending++; ++ /* Schedule a DPC, to do the actual ++ * data transfer: */ ++ IO_Schedule(hMsgMgr->hIOMgr); ++ } ++ } ++ hMsgQueue->refCount--; ++ /* Reset event if there are still frames available */ ++ if (!LST_IsEmpty(hMsgMgr->msgFreeList)) ++ SYNC_SetEvent(hMsgMgr->hSyncEvent); ++func_cont: ++ /* Exit critical section */ ++ (void) SYNC_LeaveCS(hMsgMgr->hSyncCS); ++ } ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== WMD_MSG_RegisterNotify ======== ++ */ ++DSP_STATUS WMD_MSG_RegisterNotify(struct MSG_QUEUE *hMsgQueue, u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification) ++{ ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE)); ++ DBC_Require(hNotification != NULL); ++ DBC_Require(uEventMask == DSP_NODEMESSAGEREADY || uEventMask == 0); ++ DBC_Require(uNotifyType == DSP_SIGNALEVENT); ++ ++ status = NTFY_Register(hMsgQueue->hNtfy, hNotification, uEventMask, ++ uNotifyType); ++ ++ if (status == DSP_EVALUE) { ++ /* Not registered. Ok, since we couldn't have known. Node ++ * notifications are split between node state change handled ++ * by NODE, and message ready handled by MSG. */ ++ status = DSP_SOK; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== WMD_MSG_SetQueueId ======== ++ */ ++void WMD_MSG_SetQueueId(struct MSG_QUEUE *hMsgQueue, u32 dwId) ++{ ++ DBC_Require(MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE)); ++ /* DBC_Require(dwId != 0); */ ++ ++ /* ++ * A message queue must be created when a node is allocated, ++ * so that NODE_RegisterNotify() can be called before the node ++ * is created. Since we don't know the node environment until the ++ * node is created, we need this function to set hMsgQueue->dwId ++ * to the node environment, after the node is created. ++ */ ++ hMsgQueue->dwId = dwId; ++} ++ ++/* ++ * ======== AddNewMsg ======== ++ * Must be called in message manager critical section. ++ */ ++static DSP_STATUS AddNewMsg(struct LST_LIST *msgList) ++{ ++ struct MSG_FRAME *pMsg; ++ DSP_STATUS status = DSP_SOK; ++ ++ pMsg = (struct MSG_FRAME *)MEM_Calloc(sizeof(struct MSG_FRAME), ++ MEM_PAGED); ++ if (pMsg != NULL) { ++ LST_InitElem((struct LST_ELEM *) pMsg); ++ LST_PutTail(msgList, (struct LST_ELEM *) pMsg); ++ } else { ++ status = DSP_EMEMORY; ++ } ++ ++ return status; ++} ++ ++/* ++ * ======== DeleteMsgMgr ======== ++ */ ++static void DeleteMsgMgr(struct MSG_MGR *hMsgMgr) ++{ ++ DBC_Require(MEM_IsValidHandle(hMsgMgr, MSGMGR_SIGNATURE)); ++ ++ if (hMsgMgr->queueList) { ++ if (LST_IsEmpty(hMsgMgr->queueList)) { ++ LST_Delete(hMsgMgr->queueList); ++ hMsgMgr->queueList = NULL; ++ } ++ } ++ ++ if (hMsgMgr->msgFreeList) { ++ FreeMsgList(hMsgMgr->msgFreeList); ++ hMsgMgr->msgFreeList = NULL; ++ } ++ ++ if (hMsgMgr->msgUsedList) { ++ FreeMsgList(hMsgMgr->msgUsedList); ++ hMsgMgr->msgUsedList = NULL; ++ } ++ ++ if (hMsgMgr->hSyncEvent) ++ SYNC_CloseEvent(hMsgMgr->hSyncEvent); ++ ++ if (hMsgMgr->hSyncCS) ++ SYNC_DeleteCS(hMsgMgr->hSyncCS); ++ ++ MEM_FreeObject(hMsgMgr); ++} ++ ++/* ++ * ======== DeleteMsgQueue ======== ++ */ ++static void DeleteMsgQueue(struct MSG_QUEUE *hMsgQueue, u32 uNumToDSP) ++{ ++ struct MSG_MGR *hMsgMgr; ++ struct MSG_FRAME *pMsg; ++ u32 i; ++ ++ if (!MEM_IsValidHandle(hMsgQueue, MSGQ_SIGNATURE) ++ || !hMsgQueue->hMsgMgr || !hMsgQueue->hMsgMgr->msgFreeList) ++ goto func_end; ++ hMsgMgr = hMsgQueue->hMsgMgr; ++ ++ ++ /* Pull off uNumToDSP message frames from Msg manager and free */ ++ for (i = 0; i < uNumToDSP; i++) { ++ ++ if (!LST_IsEmpty(hMsgMgr->msgFreeList)) { ++ pMsg = (struct MSG_FRAME *)LST_GetHead(hMsgMgr-> ++ msgFreeList); ++ MEM_Free(pMsg); ++ } else { ++ /* Cannot free all of the message frames */ ++ break; ++ } ++ } ++ ++ if (hMsgQueue->msgFreeList) { ++ FreeMsgList(hMsgQueue->msgFreeList); ++ hMsgQueue->msgFreeList = NULL; ++ } ++ ++ if (hMsgQueue->msgUsedList) { ++ FreeMsgList(hMsgQueue->msgUsedList); ++ hMsgQueue->msgUsedList = NULL; ++ } ++ ++ ++ if (hMsgQueue->hNtfy) ++ NTFY_Delete(hMsgQueue->hNtfy); ++ ++ if (hMsgQueue->hSyncEvent) ++ SYNC_CloseEvent(hMsgQueue->hSyncEvent); ++ ++ if (hMsgQueue->hSyncDone) ++ SYNC_CloseEvent(hMsgQueue->hSyncDone); ++ ++ if (hMsgQueue->hSyncDoneAck) ++ SYNC_CloseEvent(hMsgQueue->hSyncDoneAck); ++ ++ MEM_FreeObject(hMsgQueue); ++func_end: ++ return; ++ ++} ++ ++/* ++ * ======== FreeMsgList ======== ++ */ ++static void FreeMsgList(struct LST_LIST *msgList) ++{ ++ struct MSG_FRAME *pMsg; ++ ++ if (!msgList) ++ goto func_end; ++ ++ while ((pMsg = (struct MSG_FRAME *)LST_GetHead(msgList)) != NULL) ++ MEM_Free(pMsg); ++ ++ DBC_Assert(LST_IsEmpty(msgList)); ++ ++ LST_Delete(msgList); ++func_end: ++ return; ++} ++ +diff --git a/drivers/dsp/bridge/wmd/tiomap3430.c b/drivers/dsp/bridge/wmd/tiomap3430.c +new file mode 100644 +index 0000000..2ab585d +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/tiomap3430.c +@@ -0,0 +1,2149 @@ ++/* ++ * tiomap.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== tiomap.c ======== ++ * Processor Manager Driver for TI OMAP3430 EVM. ++ * ++ * Public Function: ++ * WMD_DRV_Entry ++ * ++ *! Revision History: ++ *! ================ ++ * 26-March-2008 HK and AL: Added WMD_DEV_WalkTbl funciton. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++#include <linux/mm.h> ++#include <linux/mmzone.h> ++#include <mach-omap2/prm.h> ++#include <mach-omap2/cm.h> ++#include <mach-omap2/prm-regbits-34xx.h> ++#include <mach-omap2/cm-regbits-34xx.h> ++#include <mach/control.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/util.h> ++#include <dspbridge/reg.h> ++#include <dspbridge/dbreg.h> ++#include <dspbridge/cfg.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/csl.h> ++#include <dspbridge/sync.h> ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_dspssC64P.h> ++#include <hw_prcm.h> ++#include <hw_mmu.h> ++#include <hw_mbox.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmd.h> ++#include <dspbridge/wmdchnl.h> ++#include <dspbridge/wmddeh.h> ++#include <dspbridge/wmdio.h> ++#include <dspbridge/wmdmsg.h> ++#include <dspbridge/pwr.h> ++#include <dspbridge/chnl_sm.h> ++#include <dspbridge/io_sm.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/wcd.h> ++#include <dspbridge/dmm.h> ++ ++/* ----------------------------------- Local */ ++#include "_tiomap.h" ++#include "_tiomap_pwr.h" ++#include "_tiomap_mmu.h" ++#include "_tiomap_util.h" ++#include "tiomap_io.h" ++ ++ ++/* Offset in shared mem to write to in order to synchronize start with DSP */ ++#define SHMSYNCOFFSET 4 /* GPP byte offset */ ++ ++#define BUFFERSIZE 1024 ++ ++#define MMU_SECTION_ADDR_MASK 0xFFF00000 ++#define MMU_SSECTION_ADDR_MASK 0xFF000000 ++#define MMU_LARGE_PAGE_MASK 0xFFFF0000 ++#define MMU_SMALL_PAGE_MASK 0xFFFFF000 ++#define PAGES_II_LVL_TABLE 512 ++#define phys_to_page(phys) pfn_to_page((phys) >> PAGE_SHIFT) ++ ++#define MMU_GFLUSH 0x60 ++ ++/* Forward Declarations: */ ++static DSP_STATUS WMD_BRD_Monitor(struct WMD_DEV_CONTEXT *pDevContext); ++static DSP_STATUS WMD_BRD_Read(struct WMD_DEV_CONTEXT *pDevContext, ++ OUT u8 *pbHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes, u32 ulMemType); ++static DSP_STATUS WMD_BRD_Start(struct WMD_DEV_CONTEXT *pDevContext, ++ u32 dwDSPAddr); ++static DSP_STATUS WMD_BRD_Status(struct WMD_DEV_CONTEXT *pDevContext, ++ OUT BRD_STATUS *pdwState); ++static DSP_STATUS WMD_BRD_Stop(struct WMD_DEV_CONTEXT *pDevContext); ++static DSP_STATUS WMD_BRD_Write(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u8 *pbHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes, u32 ulMemType); ++static DSP_STATUS WMD_BRD_SetState(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulBrdState); ++static DSP_STATUS WMD_BRD_MemCopy(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulDspDestAddr, u32 ulDspSrcAddr, ++ u32 ulNumBytes, u32 ulMemType); ++static DSP_STATUS WMD_BRD_MemWrite(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType); ++static DSP_STATUS WMD_BRD_MemMap(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulMpuAddr, u32 ulVirtAddr, u32 ulNumBytes, ++ u32 ulMapAttr); ++static DSP_STATUS WMD_BRD_MemUnMap(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulVirtAddr, u32 ulNumBytes); ++static DSP_STATUS WMD_DEV_Create(OUT struct WMD_DEV_CONTEXT **ppDevContext, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CFG_HOSTRES *pConfig, ++ IN CONST struct CFG_DSPRES *pDspConfig); ++static DSP_STATUS WMD_DEV_Ctrl(struct WMD_DEV_CONTEXT *pDevContext, u32 dwCmd, ++ IN OUT void *pArgs); ++static DSP_STATUS WMD_DEV_Destroy(struct WMD_DEV_CONTEXT *pDevContext); ++static u32 user_va2pa(struct mm_struct *mm, u32 address); ++static DSP_STATUS PteUpdate(struct WMD_DEV_CONTEXT *hDevContext, u32 pa, ++ u32 va, u32 size, ++ struct HW_MMUMapAttrs_t *mapAttrs); ++static DSP_STATUS PteSet(struct PgTableAttrs *pt, u32 pa, u32 va, ++ u32 size, struct HW_MMUMapAttrs_t *attrs); ++static DSP_STATUS MemMapVmalloc(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulMpuAddr, u32 ulVirtAddr, ++ u32 ulNumBytes, struct HW_MMUMapAttrs_t *hwAttrs); ++static DSP_STATUS run_IdleBoot(u32 prcm_base, u32 cm_base, ++ u32 sysctrl_base); ++void GetHWRegs(u32 prcm_base, u32 cm_base); ++ ++/* ----------------------------------- Globals */ ++ ++/* Attributes of L2 page tables for DSP MMU */ ++struct PageInfo { ++ u32 numEntries; /* Number of valid PTEs in the L2 PT */ ++} ; ++ ++/* Attributes used to manage the DSP MMU page tables */ ++struct PgTableAttrs { ++ struct SYNC_CSOBJECT *hCSObj; /* Critical section object handle */ ++ ++ u32 L1BasePa; /* Physical address of the L1 PT */ ++ u32 L1BaseVa; /* Virtual address of the L1 PT */ ++ u32 L1size; /* Size of the L1 PT */ ++ u32 L1TblAllocPa; ++ /* Physical address of Allocated mem for L1 table. May not be aligned */ ++ u32 L1TblAllocVa; ++ /* Virtual address of Allocated mem for L1 table. May not be aligned */ ++ u32 L1TblAllocSz; ++ /* Size of consistent memory allocated for L1 table. ++ * May not be aligned */ ++ ++ u32 L2BasePa; /* Physical address of the L2 PT */ ++ u32 L2BaseVa; /* Virtual address of the L2 PT */ ++ u32 L2size; /* Size of the L2 PT */ ++ u32 L2TblAllocPa; ++ /* Physical address of Allocated mem for L2 table. May not be aligned */ ++ u32 L2TblAllocVa; ++ /* Virtual address of Allocated mem for L2 table. May not be aligned */ ++ u32 L2TblAllocSz; ++ /* Size of consistent memory allocated for L2 table. ++ * May not be aligned */ ++ ++ u32 L2NumPages; /* Number of allocated L2 PT */ ++ struct PageInfo *pgInfo; /* Array [L2NumPages] of L2 PT info structs */ ++} ; ++ ++/* ++ * If dsp_debug is true, do not branch to the DSP entry point and wait for DSP ++ * to boot ++ */ ++extern s32 dsp_debug; ++ ++ ++/* ++ * This mini driver's function interface table. ++ */ ++static struct WMD_DRV_INTERFACE drvInterfaceFxns = { ++ WCD_MAJOR_VERSION, /* WCD ver. for which this mini driver is built. */ ++ WCD_MINOR_VERSION, ++ WMD_DEV_Create, ++ WMD_DEV_Destroy, ++ WMD_DEV_Ctrl, ++ WMD_BRD_Monitor, ++ WMD_BRD_Start, ++ WMD_BRD_Stop, ++ WMD_BRD_Status, ++ WMD_BRD_Read, ++ WMD_BRD_Write, ++ WMD_BRD_SetState, ++ WMD_BRD_MemCopy, ++ WMD_BRD_MemWrite, ++ WMD_BRD_MemMap, ++ WMD_BRD_MemUnMap, ++ /* The following CHNL functions are provided by chnl_io.lib: */ ++ WMD_CHNL_Create, ++ WMD_CHNL_Destroy, ++ WMD_CHNL_Open, ++ WMD_CHNL_Close, ++ WMD_CHNL_AddIOReq, ++ WMD_CHNL_GetIOC, ++ WMD_CHNL_CancelIO, ++ WMD_CHNL_FlushIO, ++ WMD_CHNL_GetInfo, ++ WMD_CHNL_GetMgrInfo, ++ WMD_CHNL_Idle, ++ WMD_CHNL_RegisterNotify, ++ /* The following DEH functions are provided by tihelen_ue_deh.c */ ++ WMD_DEH_Create, ++ WMD_DEH_Destroy, ++ WMD_DEH_Notify, ++ WMD_DEH_RegisterNotify, ++ WMD_DEH_GetInfo, ++ /* The following IO functions are provided by chnl_io.lib: */ ++ WMD_IO_Create, ++ WMD_IO_Destroy, ++ WMD_IO_OnLoaded, ++ WMD_IO_GetProcLoad, ++ /* The following MSG functions are provided by chnl_io.lib: */ ++ WMD_MSG_Create, ++ WMD_MSG_CreateQueue, ++ WMD_MSG_Delete, ++ WMD_MSG_DeleteQueue, ++ WMD_MSG_Get, ++ WMD_MSG_Put, ++ WMD_MSG_RegisterNotify, ++ WMD_MSG_SetQueueId, ++}; ++ ++static inline void tlb_flush_all(const u32 base) ++{ ++ __raw_writeb(__raw_readb(base + MMU_GFLUSH) | 1, base + MMU_GFLUSH); ++} ++ ++static inline void flush_all(struct WMD_DEV_CONTEXT *pDevContext) ++{ ++ struct CFG_HOSTRES resources; ++ u32 temp = 0; ++ ++ CFG_GetHostResources((struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ HW_PWRST_IVA2RegGet(resources.dwPrmBase, &temp); ++ ++ if ((temp & HW_PWR_STATE_ON) == HW_PWR_STATE_OFF || ++ (temp & HW_PWR_STATE_ON) == HW_PWR_STATE_RET) { ++ CLK_Enable(SERVICESCLK_iva2_ck); ++ WakeDSP(pDevContext, NULL); ++ tlb_flush_all(pDevContext->dwDSPMmuBase); ++ CLK_Disable(SERVICESCLK_iva2_ck); ++ } else ++ tlb_flush_all(pDevContext->dwDSPMmuBase); ++} ++ ++static void bad_page_dump(u32 pa, struct page *pg) ++{ ++ pr_emerg("DSPBRIDGE: MAP function: COUNT 0 FOR PA 0x%x\n", pa); ++ pr_emerg("Bad page state in process '%s'\n" ++ "page:%p flags:0x%0*lx mapping:%p mapcount:%d count:%d\n" ++ "Backtrace:\n", ++ current->comm, pg, (int)(2*sizeof(unsigned long)), ++ (unsigned long)pg->flags, pg->mapping, ++ page_mapcount(pg), page_count(pg)); ++ BUG(); ++} ++ ++/* ++ * ======== WMD_DRV_Entry ======== ++ * purpose: ++ * Mini Driver entry point. ++ */ ++void WMD_DRV_Entry(OUT struct WMD_DRV_INTERFACE **ppDrvInterface, ++ IN CONST char *pstrWMDFileName) ++{ ++ ++ DBC_Require(pstrWMDFileName != NULL); ++ DBG_Trace(DBG_ENTER, "In the WMD_DRV_Entry \n"); ++ ++ IO_SM_init(); /* Initialization of io_sm module */ ++ ++ if (strcmp(pstrWMDFileName, "UMA") == 0) ++ *ppDrvInterface = &drvInterfaceFxns; ++ else ++ DBG_Trace(DBG_LEVEL7, "WMD_DRV_Entry Unknown WMD file name"); ++ ++} ++ ++/* ++ * ======== WMD_BRD_Monitor ======== ++ * purpose: ++ * This WMD_BRD_Monitor puts DSP into a Loadable state. ++ * i.e Application can load and start the device. ++ * ++ * Preconditions: ++ * Device in 'OFF' state. ++ */ ++static DSP_STATUS WMD_BRD_Monitor(struct WMD_DEV_CONTEXT *hDevContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ struct CFG_HOSTRES resources; ++ u32 temp; ++ enum HW_PwrState_t pwrState; ++ ++ DBG_Trace(DBG_ENTER, "Board in the monitor state \n"); ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ goto error_return; ++ ++ GetHWRegs(resources.dwPrmBase, resources.dwCmBase); ++ HW_PWRST_IVA2RegGet(resources.dwPrmBase, &temp); ++ if ((temp & 0x03) != 0x03 || (temp & 0x03) != 0x02) { ++ /* IVA2 is not in ON state */ ++ /* Read and set PM_PWSTCTRL_IVA2 to ON */ ++ HW_PWR_IVA2PowerStateSet(resources.dwPrmBase, ++ HW_PWR_DOMAIN_DSP, ++ HW_PWR_STATE_ON); ++ /* Set the SW supervised state transition */ ++ HW_PWR_CLKCTRL_IVA2RegSet(resources.dwCmBase, ++ HW_SW_SUP_WAKEUP); ++ /* Wait until the state has moved to ON */ ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ /* Disable Automatic transition */ ++ HW_PWR_CLKCTRL_IVA2RegSet(resources.dwCmBase, HW_AUTOTRANS_DIS); ++ } ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Monitor - Middle ****** \n"); ++ GetHWRegs(resources.dwPrmBase, resources.dwCmBase); ++ status = run_IdleBoot(resources.dwPrmBase, resources.dwCmBase, ++ resources.dwSysCtrlBase); ++ if (DSP_SUCCEEDED(status)) { ++ /* set the device state to IDLE */ ++ pDevContext->dwBrdState = BRD_IDLE; ++ ++ } ++error_return: ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Monitor - End ****** \n"); ++ GetHWRegs(resources.dwPrmBase, resources.dwCmBase); ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_Read ======== ++ * purpose: ++ * Reads buffers for DSP memory. ++ */ ++static DSP_STATUS WMD_BRD_Read(struct WMD_DEV_CONTEXT *hDevContext, ++ OUT u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ u32 offset; ++ u32 dspBaseAddr = hDevContext->dwDspBaseAddr; ++ ++ DBG_Trace(DBG_ENTER, "WMD_BRD_Read, pDevContext: 0x%x\n\t\tpbHostBuf:" ++ " 0x%x\n\t\tdwDSPAddr: 0x%x\n\t\tulNumBytes: 0x%x\n\t\t" ++ "ulMemType: 0x%x\n", pDevContext, pbHostBuf, ++ dwDSPAddr, ulNumBytes, ulMemType); ++ if (dwDSPAddr < pDevContext->dwDSPStartAdd) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Read: DSP address < start address \n "); ++ status = DSP_EFAIL; ++ return status; ++ } ++ /* change here to account for the 3 bands of the DSP internal memory */ ++ if ((dwDSPAddr - pDevContext->dwDSPStartAdd) < ++ pDevContext->dwInternalSize) { ++ offset = dwDSPAddr - pDevContext->dwDSPStartAdd; ++ } else { ++ DBG_Trace(DBG_LEVEL1, ++ "**** Reading From external memory **** \n "); ++ status = ReadExtDspData(pDevContext, pbHostBuf, dwDSPAddr, ++ ulNumBytes, ulMemType); ++ return status; ++ } ++ /* copy the data from DSP memory, */ ++ memcpy(pbHostBuf, (void *)(dspBaseAddr + offset), ulNumBytes); ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_SetState ======== ++ * purpose: ++ * This routine updates the Board status. ++ */ ++static DSP_STATUS WMD_BRD_SetState(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulBrdState) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ ++ DBG_Trace(DBG_ENTER, "WMD_BRD_SetState: Board State: 0x%x \n", ++ ulBrdState); ++ pDevContext->dwBrdState = ulBrdState; ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_Start ======== ++ * purpose: ++ * Initializes DSP MMU and Starts DSP. ++ * ++ * Preconditions: ++ * a) DSP domain is 'ACTIVE'. ++ * b) DSP_RST1 is asserted. ++ * b) DSP_RST2 is released. ++ */ ++static DSP_STATUS WMD_BRD_Start(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 dwDSPAddr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ u32 dwSyncAddr = 0; ++ u32 ulShmBase; /* Gpp Phys SM base addr(byte) */ ++ u32 ulShmBaseVirt; /* Dsp Virt SM base addr */ ++ u32 ulTLBBaseVirt; /* Base of MMU TLB entry */ ++ u32 ulShmOffsetVirt; /* offset of ulShmBaseVirt from ulTLBBaseVirt */ ++ s32 iEntryNdx; ++ s32 itmpEntryNdx = 0; /* DSP-MMU TLB entry base address */ ++ struct CFG_HOSTRES resources; ++ u32 temp; ++ u32 ulDspClkRate; ++ u32 ulDspClkAddr; ++ u32 ulBiosGpTimer; ++ u32 uClkCmd; ++ struct IO_MGR *hIOMgr; ++ u32 ulLoadMonitorTimer; ++ u32 extClkId = 0; ++ u32 tmpIndex; ++ u32 clkIdIndex = MBX_PM_MAX_RESOURCES; ++ ++ DBG_Trace(DBG_ENTER, "Entering WMD_BRD_Start:\n hDevContext: 0x%x\n\t " ++ "dwDSPAddr: 0x%x\n", hDevContext, dwDSPAddr); ++ ++ /* The device context contains all the mmu setup info from when the ++ * last dsp base image was loaded. The first entry is always ++ * SHMMEM base. */ ++ /* Get SHM_BEG - convert to byte address */ ++ (void) DEV_GetSymbol(pDevContext->hDevObject, SHMBASENAME, ++ &ulShmBaseVirt); ++ ulShmBaseVirt *= DSPWORDSIZE; ++ DBC_Assert(ulShmBaseVirt != 0); ++ /* DSP Virtual address */ ++ ulTLBBaseVirt = pDevContext->aTLBEntry[0].ulDspVa; ++ DBC_Assert(ulTLBBaseVirt <= ulShmBaseVirt); ++ ulShmOffsetVirt = ulShmBaseVirt - (ulTLBBaseVirt * DSPWORDSIZE); ++ /* Kernel logical address */ ++ ulShmBase = pDevContext->aTLBEntry[0].ulGppVa + ulShmOffsetVirt; ++ ++ DBC_Assert(ulShmBase != 0); ++ /* 2nd wd is used as sync field */ ++ dwSyncAddr = ulShmBase + SHMSYNCOFFSET; ++ /* Write a signature into the SHM base + offset; this will ++ * get cleared when the DSP program starts. */ ++ if ((ulShmBaseVirt == 0) || (ulShmBase == 0)) { ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Start: Illegal SM base\n"); ++ status = DSP_EFAIL; ++ } else ++ *((volatile u32 *)dwSyncAddr) = 0xffffffff; ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ /* Assert RST1 i.e only the RST only for DSP megacell */ ++ /* HW_RST_Reset(resources.dwPrcmBase, HW_RST1_IVA2);*/ ++ if (DSP_SUCCEEDED(status)) { ++ HW_RST_Reset(resources.dwPrmBase, HW_RST1_IVA2); ++ if (dsp_debug) { ++ /* Set the bootmode to self loop */ ++ DBG_Trace(DBG_LEVEL7, ++ "Set boot mode to self loop" ++ " for IVA2 Device\n"); ++ HW_DSPSS_BootModeSet(resources.dwSysCtrlBase, ++ HW_DSPSYSC_SELFLOOPBOOT, dwDSPAddr); ++ } else { ++ /* Set the bootmode to '0' - direct boot */ ++ DBG_Trace(DBG_LEVEL7, ++ "Set boot mode to direct" ++ " boot for IVA2 Device \n"); ++ HW_DSPSS_BootModeSet(resources.dwSysCtrlBase, ++ HW_DSPSYSC_DIRECTBOOT, dwDSPAddr); ++ } ++ } ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Reset and Unreset the RST2, so that BOOTADDR is copied to ++ * IVA2 SYSC register */ ++ HW_RST_Reset(resources.dwPrmBase, HW_RST2_IVA2); ++ udelay(100); ++ HW_RST_UnReset(resources.dwPrmBase, HW_RST2_IVA2); ++ udelay(100); ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Start 0 ****** \n"); ++ GetHWRegs(resources.dwPrmBase, resources.dwCmBase); ++ /* Disbale the DSP MMU */ ++ HW_MMU_Disable(resources.dwDmmuBase); ++ /* Disable TWL */ ++ HW_MMU_TWLDisable(resources.dwDmmuBase); ++ ++ /* Only make TLB entry if both addresses are non-zero */ ++ for (iEntryNdx = 0; iEntryNdx < WMDIOCTL_NUMOFMMUTLB; ++ iEntryNdx++) { ++ if ((pDevContext->aTLBEntry[iEntryNdx].ulGppPa != 0) && ++ (pDevContext->aTLBEntry[iEntryNdx].ulDspVa != 0)) { ++ DBG_Trace(DBG_LEVEL4, "** (proc) MMU %d GppPa:" ++ " 0x%x DspVa 0x%x Size 0x%x\n", ++ itmpEntryNdx, ++ pDevContext->aTLBEntry[iEntryNdx].ulGppPa, ++ pDevContext->aTLBEntry[iEntryNdx].ulDspVa, ++ pDevContext->aTLBEntry[iEntryNdx].ulSize); ++ configureDspMmu(pDevContext, ++ pDevContext->aTLBEntry[iEntryNdx].ulGppPa, ++ pDevContext->aTLBEntry[iEntryNdx].ulDspVa * ++ DSPWORDSIZE, ++ pDevContext->aTLBEntry[iEntryNdx].ulSize, ++ itmpEntryNdx, ++ pDevContext->aTLBEntry[iEntryNdx].endianism, ++ pDevContext->aTLBEntry[iEntryNdx].elemSize, ++ pDevContext->aTLBEntry[iEntryNdx]. ++ mixedMode); ++ itmpEntryNdx++; ++ } ++ } /* end for */ ++ } ++ ++ /* Lock the above TLB entries and get the BIOS and load monitor timer ++ * information*/ ++ if (DSP_SUCCEEDED(status)) { ++ HW_MMU_NumLockedSet(resources.dwDmmuBase, itmpEntryNdx); ++ HW_MMU_VictimNumSet(resources.dwDmmuBase, itmpEntryNdx); ++ HW_MMU_TTBSet(resources.dwDmmuBase, ++ pDevContext->pPtAttrs->L1BasePa); ++ HW_MMU_TWLEnable(resources.dwDmmuBase); ++ /* Enable the SmartIdle and AutoIdle bit for MMU_SYSCONFIG */ ++ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwDmmuBase) + 0x10)); ++ temp = (temp & 0xFFFFFFEF) | 0x11; ++ *((REG_UWORD32 *) ((u32) (resources.dwDmmuBase) + 0x10)) = ++ (u32) temp; ++ ++ /* Let the DSP MMU run */ ++ HW_MMU_Enable(resources.dwDmmuBase); ++ ++ /* Enable the BIOS clock */ ++ (void)DEV_GetSymbol(pDevContext->hDevObject, ++ BRIDGEINIT_BIOSGPTIMER, ++ &ulBiosGpTimer); ++ DBG_Trace(DBG_LEVEL7, "BIOS GPTimer : 0x%x\n", ulBiosGpTimer); ++ (void)DEV_GetSymbol(pDevContext->hDevObject, ++ BRIDGEINIT_LOADMON_GPTIMER, ++ &ulLoadMonitorTimer); ++ DBG_Trace(DBG_LEVEL7, "Load Monitor Timer : 0x%x\n", ++ ulLoadMonitorTimer); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ if (ulLoadMonitorTimer != 0xFFFF) { ++ uClkCmd = (BPWR_DisableClock << MBX_PM_CLK_CMDSHIFT) | ++ ulLoadMonitorTimer; ++ DBG_Trace(DBG_LEVEL7, ++ "encoded LoadMonitor cmd for Disable: 0x%x\n", ++ uClkCmd); ++ DSPPeripheralClkCtrl(pDevContext, &uClkCmd); ++ ++ extClkId = uClkCmd & MBX_PM_CLK_IDMASK; ++ for (tmpIndex = 0; tmpIndex < MBX_PM_MAX_RESOURCES; ++ tmpIndex++) { ++ if (extClkId == BPWR_CLKID[tmpIndex]) { ++ clkIdIndex = tmpIndex; ++ break; ++ } ++ } ++ ++ if (clkIdIndex < MBX_PM_MAX_RESOURCES) ++ status = CLK_Set_32KHz( ++ BPWR_Clks[clkIdIndex].funClk); ++ else ++ status = DSP_EFAIL; ++ ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, " Error while setting" ++ "LM Timer to 32KHz\n"); ++ } ++ uClkCmd = (BPWR_EnableClock << MBX_PM_CLK_CMDSHIFT) | ++ ulLoadMonitorTimer; ++ DBG_Trace(DBG_LEVEL7, ++ "encoded LoadMonitor cmd for Enable : 0x%x\n", ++ uClkCmd); ++ DSPPeripheralClkCtrl(pDevContext, &uClkCmd); ++ ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "Not able to get the symbol for Load " ++ "Monitor Timer\n"); ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ if (ulBiosGpTimer != 0xFFFF) { ++ uClkCmd = (BPWR_DisableClock << MBX_PM_CLK_CMDSHIFT) | ++ ulBiosGpTimer; ++ DBG_Trace(DBG_LEVEL7, "encoded BIOS GPTimer cmd for" ++ "Disable: 0x%x\n", uClkCmd); ++ DSPPeripheralClkCtrl(pDevContext, &uClkCmd); ++ ++ extClkId = uClkCmd & MBX_PM_CLK_IDMASK; ++ ++ for (tmpIndex = 0; tmpIndex < MBX_PM_MAX_RESOURCES; ++ tmpIndex++) { ++ if (extClkId == BPWR_CLKID[tmpIndex]) { ++ clkIdIndex = tmpIndex; ++ break; ++ } ++ } ++ ++ if (clkIdIndex < MBX_PM_MAX_RESOURCES) ++ status = CLK_Set_32KHz( ++ BPWR_Clks[clkIdIndex].funClk); ++ else ++ status = DSP_EFAIL; ++ ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ " Error while setting BIOS Timer to 32KHz\n"); ++ } ++ ++ uClkCmd = (BPWR_EnableClock << MBX_PM_CLK_CMDSHIFT) | ++ ulBiosGpTimer; ++ DBG_Trace(DBG_LEVEL7, "encoded BIOS GPTimer cmd :" ++ "0x%x\n", uClkCmd); ++ DSPPeripheralClkCtrl(pDevContext, &uClkCmd); ++ ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "Not able to get the symbol for BIOS Timer\n"); ++ } ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Set the DSP clock rate */ ++ (void)DEV_GetSymbol(pDevContext->hDevObject, ++ "_BRIDGEINIT_DSP_FREQ", &ulDspClkAddr); ++ /*Set Autoidle Mode for IVA2 PLL */ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x34)); ++ temp = (temp & 0xFFFFFFFE) | 0x1; ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x34)) = ++ (u32) temp; ++ DBG_Trace(DBG_LEVEL5, "WMD_BRD_Start: _BRIDGE_DSP_FREQ Addr:" ++ "0x%x \n", ulDspClkAddr); ++ if ((unsigned int *)ulDspClkAddr != NULL) { ++ /* Get the clock rate */ ++ status = CLK_GetRate(SERVICESCLK_iva2_ck, ++ &ulDspClkRate); ++ DBG_Trace(DBG_LEVEL5, ++ "WMD_BRD_Start: DSP clock rate (KHZ): 0x%x \n", ++ ulDspClkRate); ++ (void)WMD_BRD_Write(pDevContext, (u8 *)&ulDspClkRate, ++ ulDspClkAddr, sizeof(u32), 0); ++ } ++/*PM_IVA2GRPSEL_PER = 0xC0;*/ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ temp = (temp & 0xFFFFFF30) | 0xC0; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) = ++ (u32) temp; ++ ++/*PM_MPUGRPSEL_PER &= 0xFFFFFF3F;*/ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ temp = (temp & 0xFFFFFF3F); ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) = ++ (u32) temp; ++/*CM_SLEEPDEP_PER |= 0x04;*/ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerBase) + 0x44)); ++ temp = (temp & 0xFFFFFFFB) | 0x04; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerBase) + 0x44)) = ++ (u32) temp; ++ ++/*CM_CLKSTCTRL_IVA2 = 0x00000003 -To Allow automatic transitions*/ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x48)); ++ temp = (temp & 0xFFFFFFFC) | 0x03; ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x48)) = ++ (u32) temp; ++ ++ ++ /* Enable Mailbox events and also drain any pending ++ * stale messages */ ++ (void)CHNLSM_EnableInterrupt(pDevContext); ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ HW_RSTCTRL_RegGet(resources.dwPrmBase, HW_RST1_IVA2, &temp); ++ DBG_Trace(DBG_LEVEL7, "BRD_Start: RM_RSTCTRL_DSP = 0x%x \n", ++ temp); ++ HW_RSTST_RegGet(resources.dwPrmBase, HW_RST1_IVA2, &temp); ++ DBG_Trace(DBG_LEVEL7, "BRD_Start0: RM_RSTST_DSP = 0x%x \n", ++ temp); ++ ++ /* Let DSP go */ ++ DBG_Trace(DBG_LEVEL7, "Unreset, WMD_BRD_Start\n"); ++ /* Enable DSP MMU Interrupts */ ++ HW_MMU_EventEnable(resources.dwDmmuBase, ++ HW_MMU_ALL_INTERRUPTS); ++ /* release the RST1, DSP starts executing now .. */ ++ HW_RST_UnReset(resources.dwPrmBase, HW_RST1_IVA2); ++ ++ HW_RSTST_RegGet(resources.dwPrmBase, HW_RST1_IVA2, &temp); ++ DBG_Trace(DBG_LEVEL7, "BRD_Start: RM_RSTST_DSP = 0x%x \n", ++ temp); ++ HW_RSTCTRL_RegGet(resources.dwPrmBase, HW_RST1_IVA2, &temp); ++ DBG_Trace(DBG_LEVEL5, "WMD_BRD_Start: CM_RSTCTRL_DSP: 0x%x \n", ++ temp); ++ DBG_Trace(DBG_LEVEL7, "Driver waiting for Sync @ 0x%x \n", ++ dwSyncAddr); ++ DBG_Trace(DBG_LEVEL7, "DSP c_int00 Address = 0x%x \n", ++ dwDSPAddr); ++ if (dsp_debug) ++ while (*((volatile u16 *)dwSyncAddr)) ++ ;; ++ } ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Wait for DSP to clear word in shared memory */ ++ /* Read the Location */ ++ if (!WaitForStart(pDevContext, dwSyncAddr)) { ++ status = WMD_E_TIMEOUT; ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Start Failed to Synchronize\n"); ++ } ++ status = DEV_GetIOMgr(pDevContext->hDevObject, &hIOMgr); ++ if (DSP_SUCCEEDED(status)) { ++ IO_SHMsetting(hIOMgr, SHM_OPPINFO, NULL); ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Start: OPP information initialzed\n"); ++ /* Write the synchronization bit to indicate the ++ * completion of OPP table update to DSP ++ */ ++ *((volatile u32 *)dwSyncAddr) = 0XCAFECAFE; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* update board state */ ++ pDevContext->dwBrdState = BRD_RUNNING; ++ /* (void)CHNLSM_EnableInterrupt(pDevContext);*/ ++ DBG_Trace(DBG_LEVEL7, "Device Started \n "); ++ } else { ++ pDevContext->dwBrdState = BRD_UNKNOWN; ++ DBG_Trace(DBG_LEVEL7, "Device not Started \n "); ++ } ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_Stop ======== ++ * purpose: ++ * Puts DSP in self loop. ++ * ++ * Preconditions : ++ * a) None ++ */ ++static DSP_STATUS WMD_BRD_Stop(struct WMD_DEV_CONTEXT *hDevContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ struct CFG_HOSTRES resources; ++ struct PgTableAttrs *pPtAttrs; ++ u32 dspPwrState; ++ DSP_STATUS clk_status; ++ ++ DBG_Trace(DBG_ENTER, "Entering WMD_BRD_Stop:\nhDevContext: 0x%x\n", ++ hDevContext); ++ ++ /* Disable the mail box interrupts */ ++ (void)CHNLSM_DisableInterrupt(pDevContext); ++ ++ if (pDevContext->dwBrdState == BRD_STOPPED) ++ return status; ++ ++ /* as per TRM, it is advised to first drive the IVA2 to 'Standby' mode, ++ * before turning off the clocks.. This is to ensure that there are no ++ * pending L3 or other transactons from IVA2 */ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Stop: Get Host resources failed \n"); ++ DBG_Trace(DBG_LEVEL1, "Device Stopp failed \n "); ++ return DSP_EFAIL; ++ } ++ ++ HW_PWRST_IVA2RegGet(resources.dwPrmBase, &dspPwrState); ++ if (dspPwrState != HW_PWR_STATE_OFF) { ++ ++ CHNLSM_InterruptDSP2(pDevContext, MBX_PM_DSPIDLE); ++ ++ mdelay(10); ++ ++ GetHWRegs(resources.dwPrmBase, resources.dwCmBase); ++ ++ run_IdleBoot(resources.dwPrmBase, resources.dwCmBase, ++ resources.dwSysCtrlBase); ++ ++ udelay(50); ++ ++ clk_status = CLK_Disable(SERVICESCLK_iva2_ck); ++ if (DSP_FAILED(clk_status)) { ++ DBG_Trace(DBG_LEVEL6, ++ "\n WMD_BRD_Stop: CLK_Disable failed " ++ "for iva2_fck\n"); ++ } ++ /* IVA2 is not in OFF state */ ++ /* Set PM_PWSTCTRL_IVA2 to OFF */ ++ HW_PWR_IVA2PowerStateSet(resources.dwPrmBase, ++ HW_PWR_DOMAIN_DSP, ++ HW_PWR_STATE_OFF); ++ /* Set the SW supervised state transition for Sleep */ ++ HW_PWR_CLKCTRL_IVA2RegSet(resources.dwCmBase, ++ HW_SW_SUP_SLEEP); ++ } else { ++ clk_status = CLK_Disable(SERVICESCLK_iva2_ck); ++ if (DSP_FAILED(clk_status)) { ++ DBG_Trace(DBG_LEVEL6, ++ "\n WMD_BRD_Stop: Else loop CLK_Disable failed" ++ " for iva2_fck\n"); ++ } ++ } ++ udelay(10); ++ /* Release the Ext Base virtual Address as the next DSP Program ++ * may have a different load address */ ++ if (pDevContext->dwDspExtBaseAddr) ++ pDevContext->dwDspExtBaseAddr = 0; ++ ++ pDevContext->dwBrdState = BRD_STOPPED; /* update board state */ ++ DBG_Trace(DBG_LEVEL1, "Device Stopped \n "); ++ /* This is a good place to clear the MMU page tables as well */ ++ if (pDevContext->pPtAttrs) { ++ pPtAttrs = pDevContext->pPtAttrs; ++ memset((u8 *) pPtAttrs->L1BaseVa, 0x00, pPtAttrs->L1size); ++ memset((u8 *) pPtAttrs->L2BaseVa, 0x00, pPtAttrs->L2size); ++ memset((u8 *) pPtAttrs->pgInfo, 0x00, ++ (pPtAttrs->L2NumPages * sizeof(struct PageInfo))); ++ } ++ ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Stop - End ****** \n"); ++ ++ return status; ++} ++ ++ ++/* ++ * ======== WMD_BRD_Delete ======== ++ * purpose: ++ * Puts DSP in Low power mode ++ * ++ * Preconditions : ++ * a) None ++ */ ++static DSP_STATUS WMD_BRD_Delete(struct WMD_DEV_CONTEXT *hDevContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ struct CFG_HOSTRES resources; ++ struct PgTableAttrs *pPtAttrs; ++ DSP_STATUS clk_status; ++ ++ DBG_Trace(DBG_ENTER, "Entering WMD_BRD_Delete:\nhDevContext: 0x%x\n", ++ hDevContext); ++ ++ /* Disable the mail box interrupts */ ++ (void) CHNLSM_DisableInterrupt(pDevContext); ++ ++ if (pDevContext->dwBrdState == BRD_STOPPED) ++ return status; ++ ++ /* as per TRM, it is advised to first drive ++ * the IVA2 to 'Standby' mode, before turning off the clocks.. This is ++ * to ensure that there are no pending L3 or other transactons from ++ * IVA2 */ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Stop: Get Host resources failed \n"); ++ DBG_Trace(DBG_LEVEL1, "Device Delete failed \n "); ++ return DSP_EFAIL; ++ } ++ status = SleepDSP(pDevContext, PWR_EMERGENCYDEEPSLEEP, NULL); ++ clk_status = CLK_Disable(SERVICESCLK_iva2_ck); ++ if (DSP_FAILED(clk_status)) { ++ DBG_Trace(DBG_LEVEL6, "\n WMD_BRD_Stop: CLK_Disable failed for" ++ " iva2_fck\n"); ++ } ++ /* Release the Ext Base virtual Address as the next DSP Program ++ * may have a different load address */ ++ if (pDevContext->dwDspExtBaseAddr) ++ pDevContext->dwDspExtBaseAddr = 0; ++ ++ pDevContext->dwBrdState = BRD_STOPPED; /* update board state */ ++ DBG_Trace(DBG_LEVEL1, "Device Stopped \n "); ++ /* This is a good place to clear the MMU page tables as well */ ++ if (pDevContext->pPtAttrs) { ++ pPtAttrs = pDevContext->pPtAttrs; ++ memset((u8 *)pPtAttrs->L1BaseVa, 0x00, pPtAttrs->L1size); ++ memset((u8 *)pPtAttrs->L2BaseVa, 0x00, pPtAttrs->L2size); ++ memset((u8 *)pPtAttrs->pgInfo, 0x00, ++ (pPtAttrs->L2NumPages * sizeof(struct PageInfo))); ++ } ++ DBG_Trace(DBG_LEVEL6, "WMD_BRD_Stop - End ****** \n"); ++ return status; ++} ++ ++ ++/* ++ * ======== WMD_BRD_Status ======== ++ * Returns the board status. ++ */ ++static DSP_STATUS WMD_BRD_Status(struct WMD_DEV_CONTEXT *hDevContext, ++ OUT BRD_STATUS *pdwState) ++{ ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ *pdwState = pDevContext->dwBrdState; ++ return DSP_SOK; ++} ++ ++/* ++ * ======== WMD_BRD_Write ======== ++ * Copies the buffers to DSP internal or external memory. ++ */ ++static DSP_STATUS WMD_BRD_Write(struct WMD_DEV_CONTEXT *hDevContext, ++ IN u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ ++ DBG_Trace(DBG_ENTER, "WMD_BRD_Write, pDevContext: 0x%x\n\t\t " ++ "pbHostBuf: 0x%x\n\t\tdwDSPAddr: 0x%x\n\t\tulNumBytes: " ++ "0x%x\n \t\t ulMemtype: 0x%x\n", pDevContext, pbHostBuf, ++ dwDSPAddr, ulNumBytes, ulMemType); ++ if (dwDSPAddr < pDevContext->dwDSPStartAdd) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_Write: DSP address < start address \n "); ++ status = DSP_EFAIL; ++ return status; ++ } ++ if ((dwDSPAddr - pDevContext->dwDSPStartAdd) < ++ pDevContext->dwInternalSize) { ++ status = WriteDspData(hDevContext, pbHostBuf, dwDSPAddr, ++ ulNumBytes, ulMemType); ++ } else { ++ status = WriteExtDspData(pDevContext, pbHostBuf, dwDSPAddr, ++ ulNumBytes, ulMemType, false); ++ } ++ ++ DBG_Trace(DBG_ENTER, "WMD_BRD_Write, memcopy : DspLogicAddr=0x%x \n", ++ pDevContext->dwDspBaseAddr); ++ return status; ++} ++ ++/* ++ * ======== WMD_DEV_Create ======== ++ * Creates a driver object. Puts DSP in self loop. ++ */ ++static DSP_STATUS WMD_DEV_Create(OUT struct WMD_DEV_CONTEXT **ppDevContext, ++ struct DEV_OBJECT *hDevObject, ++ IN CONST struct CFG_HOSTRES *pConfig, ++ IN CONST struct CFG_DSPRES *pDspConfig) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = NULL; ++ s32 iEntryNdx; ++ s32 tcWordSwap; ++ u32 tcWordSwapSize = sizeof(tcWordSwap); ++ struct CFG_HOSTRES resources; ++ struct PgTableAttrs *pPtAttrs; ++ u32 pg_tbl_pa; ++ u32 pg_tbl_va; ++ u32 align_size; ++ ++ DBG_Trace(DBG_ENTER, "WMD_DEV_Create, ppDevContext: 0x%x\n\t\t " ++ "hDevObject: 0x%x\n\t\tpConfig: 0x%x\n\t\tpDspConfig: 0x%x\n", ++ ppDevContext, hDevObject, pConfig, pDspConfig); ++ /* Allocate and initialize a data structure to contain the mini driver ++ * state, which becomes the context for later calls into this WMD. */ ++ pDevContext = MEM_Calloc(sizeof(struct WMD_DEV_CONTEXT), MEM_NONPAGED); ++ if (!pDevContext) { ++ DBG_Trace(DBG_ENTER, "Failed to allocate mem \n"); ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_ENTER, "Failed to get host resources \n"); ++ status = DSP_EMEMORY; ++ goto func_end; ++ } ++ ++ pDevContext->dwDSPStartAdd = (u32)OMAP_GEM_BASE; ++ pDevContext->dwSelfLoop = (u32)NULL; ++ pDevContext->uDspPerClks = 0; ++ pDevContext->dwInternalSize = OMAP_DSP_SIZE; ++ /* Clear dev context MMU table entries. ++ * These get set on WMD_BRD_IOCTL() call after program loaded. */ ++ for (iEntryNdx = 0; iEntryNdx < WMDIOCTL_NUMOFMMUTLB; iEntryNdx++) { ++ pDevContext->aTLBEntry[iEntryNdx].ulGppPa = ++ pDevContext->aTLBEntry[iEntryNdx].ulDspVa = 0; ++ } ++ pDevContext->numTLBEntries = 0; ++ pDevContext->dwDspBaseAddr = (u32)MEM_LinearAddress((void *) ++ (pConfig->dwMemBase[3]), pConfig->dwMemLength[3]); ++ if (!pDevContext->dwDspBaseAddr) { ++ status = DSP_EFAIL; ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_DEV_Create: failed to Map the API memory\n"); ++ } ++ pPtAttrs = MEM_Calloc(sizeof(struct PgTableAttrs), MEM_NONPAGED); ++ if (pPtAttrs != NULL) { ++ /* Assuming that we use only DSP's memory map ++ * until 0x4000:0000 , we would need only 1024 ++ * L1 enties i.e L1 size = 4K */ ++ pPtAttrs->L1size = 0x1000; ++ align_size = pPtAttrs->L1size; ++ /* Align sizes are expected to be power of 2 */ ++ /* we like to get aligned on L1 table size */ ++ pg_tbl_va = (u32)MEM_AllocPhysMem(pPtAttrs->L1size, ++ align_size, &pg_tbl_pa); ++ /* Check if the PA is aligned for us */ ++ if ((pg_tbl_pa) & (align_size-1)) { ++ /* PA not aligned to page table size , ++ * try with more allocation and align */ ++ MEM_FreePhysMem((void *)pg_tbl_va, pg_tbl_pa, pPtAttrs->L1size); ++ /* we like to get aligned on L1 table size */ ++ pg_tbl_va = (u32) MEM_AllocPhysMem((pPtAttrs->L1size)*2, ++ align_size, &pg_tbl_pa); ++ /* We should be able to get aligned table now */ ++ pPtAttrs->L1TblAllocPa = pg_tbl_pa; ++ pPtAttrs->L1TblAllocVa = pg_tbl_va; ++ pPtAttrs->L1TblAllocSz = pPtAttrs->L1size * 2; ++ /* Align the PA to the next 'align' boundary */ ++ pPtAttrs->L1BasePa = ((pg_tbl_pa) + (align_size-1)) & ++ (~(align_size-1)); ++ pPtAttrs->L1BaseVa = pg_tbl_va + (pPtAttrs->L1BasePa - ++ pg_tbl_pa); ++ } else { ++ /* We got aligned PA, cool */ ++ pPtAttrs->L1TblAllocPa = pg_tbl_pa; ++ pPtAttrs->L1TblAllocVa = pg_tbl_va; ++ pPtAttrs->L1TblAllocSz = pPtAttrs->L1size; ++ pPtAttrs->L1BasePa = pg_tbl_pa; ++ pPtAttrs->L1BaseVa = pg_tbl_va; ++ } ++ if (pPtAttrs->L1BaseVa) ++ memset((u8 *)pPtAttrs->L1BaseVa, 0x00, pPtAttrs->L1size); ++ ++ /* number of L2 page tables = DMM pool used + SHMMEM +EXTMEM + ++ * L4 pages */ ++ pPtAttrs->L2NumPages = ((DMMPOOLSIZE >> 20) + 6); ++ pPtAttrs->L2size = HW_MMU_COARSE_PAGE_SIZE * ++ pPtAttrs->L2NumPages; ++ align_size = 4; /* Make it u32 aligned */ ++ /* we like to get aligned on L1 table size */ ++ pg_tbl_va = (u32)MEM_AllocPhysMem(pPtAttrs->L2size, ++ align_size, &pg_tbl_pa); ++ pPtAttrs->L2TblAllocPa = pg_tbl_pa; ++ pPtAttrs->L2TblAllocVa = pg_tbl_va; ++ pPtAttrs->L2TblAllocSz = pPtAttrs->L2size; ++ pPtAttrs->L2BasePa = pg_tbl_pa; ++ pPtAttrs->L2BaseVa = pg_tbl_va; ++ ++ if (pPtAttrs->L2BaseVa) ++ memset((u8 *)pPtAttrs->L2BaseVa, 0x00, pPtAttrs->L2size); ++ ++ pPtAttrs->pgInfo = MEM_Calloc(pPtAttrs->L2NumPages * ++ sizeof(struct PageInfo), MEM_NONPAGED); ++ DBG_Trace(DBG_LEVEL1, "L1 pa %x, va %x, size %x\n L2 pa %x, va " ++ "%x, size %x\n", pPtAttrs->L1BasePa, ++ pPtAttrs->L1BaseVa, pPtAttrs->L1size, ++ pPtAttrs->L2BasePa, pPtAttrs->L2BaseVa, ++ pPtAttrs->L2size); ++ DBG_Trace(DBG_LEVEL1, "pPtAttrs %x L2 NumPages %x pgInfo %x\n", ++ pPtAttrs, pPtAttrs->L2NumPages, pPtAttrs->pgInfo); ++ } ++ if ((pPtAttrs != NULL) && (pPtAttrs->L1BaseVa != 0) && ++ (pPtAttrs->L2BaseVa != 0) && (pPtAttrs->pgInfo != NULL)) ++ pDevContext->pPtAttrs = pPtAttrs; ++ else ++ status = DSP_EMEMORY; ++ ++ if (DSP_SUCCEEDED(status)) ++ status = SYNC_InitializeCS(&pPtAttrs->hCSObj); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Set the Endianism Register */ /* Need to set this */ ++ /* Retrieve the TC u16 SWAP Option */ ++ status = REG_GetValue(NULL, CURRENTCONFIG, TCWORDSWAP, ++ (u8 *)&tcWordSwap, &tcWordSwapSize); ++ /* Save the value */ ++ pDevContext->tcWordSwapOn = tcWordSwap; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ /* Set the Clock Divisor for the DSP module */ ++ DBG_Trace(DBG_LEVEL7, "WMD_DEV_create:Reset mail box and " ++ "enable the clock \n"); ++ status = CLK_Enable(SERVICESCLK_mailbox_ick); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_DEV_create:Reset mail box and " ++ "enable the clock Fail\n"); ++ } ++ udelay(5); ++ /* 24xx-Linux MMU address is obtained from the host ++ * resources struct */ ++ pDevContext->dwDSPMmuBase = resources.dwDmmuBase; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pDevContext->hDevObject = hDevObject; ++ pDevContext->ulIntMask = 0; ++ /* Store current board state. */ ++ pDevContext->dwBrdState = BRD_STOPPED; ++ /* Return this ptr to our device state to the WCD for storage:*/ ++ *ppDevContext = pDevContext; ++ DBG_Trace(DBG_ENTER, "Device Created \n"); ++ } else { ++ if (pPtAttrs != NULL) { ++ if (pPtAttrs->hCSObj) ++ SYNC_DeleteCS(pPtAttrs->hCSObj); ++ ++ if (pPtAttrs->pgInfo) ++ MEM_Free(pPtAttrs->pgInfo); ++ ++ if (pPtAttrs->L2TblAllocVa) { ++ MEM_FreePhysMem((void *)pPtAttrs->L2TblAllocVa, ++ pPtAttrs->L2TblAllocPa, ++ pPtAttrs->L2TblAllocSz); ++ } ++ if (pPtAttrs->L1TblAllocVa) { ++ MEM_FreePhysMem((void *)pPtAttrs->L1TblAllocVa, ++ pPtAttrs->L1TblAllocPa, ++ pPtAttrs->L1TblAllocSz); ++ } ++ } ++ if (pPtAttrs) ++ MEM_Free(pPtAttrs); ++ ++ if (pDevContext) ++ MEM_Free(pDevContext); ++ ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_DEV_Create Error Device not created\n"); ++ } ++func_end: ++ return status; ++} ++ ++/* ++ * ======== WMD_DEV_Ctrl ======== ++ * Receives device specific commands. ++ */ ++static DSP_STATUS WMD_DEV_Ctrl(struct WMD_DEV_CONTEXT *pDevContext, u32 dwCmd, ++ IN OUT void *pArgs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMDIOCTL_EXTPROC *paExtProc = (struct WMDIOCTL_EXTPROC *)pArgs; ++ s32 ndx; ++ ++ DBG_Trace(DBG_ENTER, "WMD_DEV_Ctrl, pDevContext: 0x%x\n\t\t dwCmd: " ++ "0x%x\n\t\tpArgs: 0x%x\n", pDevContext, dwCmd, pArgs); ++ switch (dwCmd) { ++ case WMDIOCTL_CHNLREAD: ++ break; ++ case WMDIOCTL_CHNLWRITE: ++ break; ++ case WMDIOCTL_SETMMUCONFIG: ++ /* store away dsp-mmu setup values for later use */ ++ for (ndx = 0; ndx < WMDIOCTL_NUMOFMMUTLB; ndx++, paExtProc++) ++ pDevContext->aTLBEntry[ndx] = *paExtProc; ++ ++ break; ++ case WMDIOCTL_DEEPSLEEP: ++ case WMDIOCTL_EMERGENCYSLEEP: ++ /* Currently only DSP Idle is supported Need to update for ++ * later releases */ ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_DEEPSLEEP\n"); ++ status = SleepDSP(pDevContext, PWR_DEEPSLEEP, pArgs); ++ break; ++ case WMDIOCTL_WAKEUP: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_WAKEUP\n"); ++ status = WakeDSP(pDevContext, pArgs); ++ break; ++ case WMDIOCTL_CLK_CTRL: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_CLK_CTRL\n"); ++ status = DSP_SOK; ++ /* Looking For Baseport Fix for Clocks */ ++ status = DSPPeripheralClkCtrl(pDevContext, pArgs); ++ break; ++ case WMDIOCTL_PWR_HIBERNATE: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_PWR_HIBERNATE\n"); ++ status = handle_hibernation_fromDSP(pDevContext); ++ break; ++ case WMDIOCTL_PRESCALE_NOTIFY: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_PRESCALE_NOTIFY\n"); ++ status = PreScale_DSP(pDevContext, pArgs); ++ break; ++ case WMDIOCTL_POSTSCALE_NOTIFY: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_POSTSCALE_NOTIFY\n"); ++ status = PostScale_DSP(pDevContext, pArgs); ++ break; ++ case WMDIOCTL_CONSTRAINT_REQUEST: ++ DBG_Trace(DBG_LEVEL5, "WMDIOCTL_CONSTRAINT_REQUEST\n"); ++ status = handle_constraints_set(pDevContext, pArgs); ++ break; ++ default: ++ status = DSP_EFAIL; ++ DBG_Trace(DBG_LEVEL7, "Error in WMD_BRD_Ioctl \n"); ++ break; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_DEV_Destroy ======== ++ * Destroys the driver object. ++ */ ++static DSP_STATUS WMD_DEV_Destroy(struct WMD_DEV_CONTEXT *hDevContext) ++{ ++ struct PgTableAttrs *pPtAttrs; ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = (struct WMD_DEV_CONTEXT *) ++ hDevContext; ++ DBG_Trace(DBG_ENTER, "Entering WMD_DEV_Destroy:n hDevContext ::0x%x\n", ++ hDevContext); ++ /* first put the device to stop state */ ++ WMD_BRD_Delete(pDevContext); ++ if (pDevContext && pDevContext->pPtAttrs) { ++ pPtAttrs = pDevContext->pPtAttrs; ++ if (pPtAttrs->hCSObj) ++ SYNC_DeleteCS(pPtAttrs->hCSObj); ++ ++ if (pPtAttrs->pgInfo) ++ MEM_Free(pPtAttrs->pgInfo); ++ ++ if (pPtAttrs->L2TblAllocVa) { ++ MEM_FreePhysMem((void *)pPtAttrs->L2TblAllocVa, ++ pPtAttrs->L2TblAllocPa, pPtAttrs-> ++ L2TblAllocSz); ++ } ++ if (pPtAttrs->L1TblAllocVa) { ++ MEM_FreePhysMem((void *)pPtAttrs->L1TblAllocVa, ++ pPtAttrs->L1TblAllocPa, pPtAttrs-> ++ L1TblAllocSz); ++ } ++ if (pPtAttrs) ++ MEM_Free(pPtAttrs); ++ ++ } ++ /* Free the driver's device context: */ ++ MEM_Free((void *) hDevContext); ++ return status; ++} ++ ++static DSP_STATUS WMD_BRD_MemCopy(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulDspDestAddr, u32 ulDspSrcAddr, ++ u32 ulNumBytes, u32 ulMemType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 srcAddr = ulDspSrcAddr; ++ u32 destAddr = ulDspDestAddr; ++ u32 copyBytes = 0; ++ u32 totalBytes = ulNumBytes; ++ u8 hostBuf[BUFFERSIZE]; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ while ((totalBytes > 0) && DSP_SUCCEEDED(status)) { ++ copyBytes = totalBytes > BUFFERSIZE ? BUFFERSIZE : totalBytes; ++ /* Read from External memory */ ++ status = ReadExtDspData(hDevContext, hostBuf, srcAddr, ++ copyBytes, ulMemType); ++ if (DSP_SUCCEEDED(status)) { ++ if (destAddr < (pDevContext->dwDSPStartAdd + ++ pDevContext->dwInternalSize)) { ++ /* Write to Internal memory */ ++ status = WriteDspData(hDevContext, hostBuf, ++ destAddr, copyBytes, ulMemType); ++ } else { ++ /* Write to External memory */ ++ status = WriteExtDspData(hDevContext, hostBuf, ++ destAddr, copyBytes, ulMemType, false); ++ } ++ } ++ totalBytes -= copyBytes; ++ srcAddr += copyBytes; ++ destAddr += copyBytes; ++ } ++ return status; ++} ++ ++/* Mem Write does not halt the DSP to write unlike WMD_BRD_Write */ ++static DSP_STATUS WMD_BRD_MemWrite(struct WMD_DEV_CONTEXT *hDevContext, ++ IN u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ u32 ulRemainBytes = 0; ++ u32 ulBytes = 0; ++ ulRemainBytes = ulNumBytes; ++ while (ulRemainBytes > 0 && DSP_SUCCEEDED(status)) { ++ ulBytes = ++ ulRemainBytes > BUFFERSIZE ? BUFFERSIZE : ulRemainBytes; ++ if (dwDSPAddr < (pDevContext->dwDSPStartAdd + ++ pDevContext->dwInternalSize)) { ++ status = WriteDspData(hDevContext, pbHostBuf, dwDSPAddr, ++ ulBytes, ulMemType); ++ } else { ++ status = WriteExtDspData(hDevContext, pbHostBuf, ++ dwDSPAddr, ulBytes, ulMemType, true); ++ } ++ ulRemainBytes -= ulBytes; ++ dwDSPAddr += ulBytes; ++ pbHostBuf = pbHostBuf + ulBytes; ++ } ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_MemMap ======== ++ * This function maps MPU buffer to the DSP address space. It performs ++ * linear to physical address translation if required. It translates each ++ * page since linear addresses can be physically non-contiguous ++ * All address & size arguments are assumed to be page aligned (in proc.c) ++ * ++ * TODO: Disable MMU while updating the page tables (but that'll stall DSP) ++ */ ++static DSP_STATUS WMD_BRD_MemMap(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulMpuAddr, u32 ulVirtAddr, ++ u32 ulNumBytes, u32 ulMapAttr) ++{ ++ u32 attrs; ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ struct HW_MMUMapAttrs_t hwAttrs; ++ struct vm_area_struct *vma; ++ struct mm_struct *mm = current->mm; ++ u32 write = 0; ++ u32 numUsrPgs = 0; ++ struct page *mappedPage, *pg; ++ s32 pgNum; ++ u32 va = ulVirtAddr; ++ struct task_struct *curr_task = current; ++ u32 pgI = 0; ++ u32 mpuAddr, pa; ++ ++ DBG_Trace(DBG_ENTER, "> WMD_BRD_MemMap hDevContext %x, pa %x, va %x, " ++ "size %x, ulMapAttr %x\n", hDevContext, ulMpuAddr, ulVirtAddr, ++ ulNumBytes, ulMapAttr); ++ if (ulNumBytes == 0) ++ return DSP_EINVALIDARG; ++ ++ if (ulMapAttr != 0) { ++ attrs = ulMapAttr; ++ } else { ++ /* Assign default attributes */ ++ attrs = DSP_MAPVIRTUALADDR | DSP_MAPELEMSIZE16; ++ } ++ /* Take mapping properties */ ++ if (attrs & DSP_MAPBIGENDIAN) ++ hwAttrs.endianism = HW_BIG_ENDIAN; ++ else ++ hwAttrs.endianism = HW_LITTLE_ENDIAN; ++ ++ hwAttrs.mixedSize = (enum HW_MMUMixedSize_t) ++ ((attrs & DSP_MAPMIXEDELEMSIZE) >> 2); ++ /* Ignore elementSize if mixedSize is enabled */ ++ if (hwAttrs.mixedSize == 0) { ++ if (attrs & DSP_MAPELEMSIZE8) { ++ /* Size is 8 bit */ ++ hwAttrs.elementSize = HW_ELEM_SIZE_8BIT; ++ } else if (attrs & DSP_MAPELEMSIZE16) { ++ /* Size is 16 bit */ ++ hwAttrs.elementSize = HW_ELEM_SIZE_16BIT; ++ } else if (attrs & DSP_MAPELEMSIZE32) { ++ /* Size is 32 bit */ ++ hwAttrs.elementSize = HW_ELEM_SIZE_32BIT; ++ } else if (attrs & DSP_MAPELEMSIZE64) { ++ /* Size is 64 bit */ ++ hwAttrs.elementSize = HW_ELEM_SIZE_64BIT; ++ } else { ++ /* ++ * Mixedsize isn't enabled, so size can't be ++ * zero here ++ */ ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_MemMap: MMU element size is zero\n"); ++ return DSP_EINVALIDARG; ++ } ++ } ++ if (attrs & DSP_MAPDONOTLOCK) ++ hwAttrs.donotlockmpupage = 1; ++ else ++ hwAttrs.donotlockmpupage = 0; ++ ++ if (attrs & DSP_MAPVMALLOCADDR) { ++ return MemMapVmalloc(hDevContext, ulMpuAddr, ulVirtAddr, ++ ulNumBytes, &hwAttrs); ++ } ++ /* ++ * Do OS-specific user-va to pa translation. ++ * Combine physically contiguous regions to reduce TLBs. ++ * Pass the translated pa to PteUpdate. ++ */ ++ if ((attrs & DSP_MAPPHYSICALADDR)) { ++ status = PteUpdate(pDevContext, ulMpuAddr, ulVirtAddr, ++ ulNumBytes, &hwAttrs); ++ goto func_cont; ++ } ++ ++ /* ++ * Important Note: ulMpuAddr is mapped from user application process ++ * to current process - it must lie completely within the current ++ * virtual memory address space in order to be of use to us here! ++ */ ++ down_read(&mm->mmap_sem); ++ vma = find_vma(mm, ulMpuAddr); ++ if (vma) ++ DBG_Trace(DBG_LEVEL6, "VMAfor UserBuf: ulMpuAddr=%x, " ++ "ulNumBytes=%x, vm_start=%x vm_end=%x vm_flags=%x \n", ++ ulMpuAddr, ulNumBytes, vma->vm_start, ++ vma->vm_end, vma->vm_flags); ++ ++ /* ++ * It is observed that under some circumstances, the user buffer is ++ * spread across several VMAs. So loop through and check if the entire ++ * user buffer is covered ++ */ ++ while ((vma) && (ulMpuAddr + ulNumBytes > vma->vm_end)) { ++ /* jump to the next VMA region */ ++ vma = find_vma(mm, vma->vm_end + 1); ++ DBG_Trace(DBG_LEVEL6, "VMAfor UserBuf ulMpuAddr=%x, " ++ "ulNumBytes=%x, vm_start=%x vm_end=%x vm_flags=%x\n", ++ ulMpuAddr, ulNumBytes, vma->vm_start, ++ vma->vm_end, vma->vm_flags); ++ } ++ if (!vma) { ++ DBG_Trace(DBG_LEVEL7, "Failed to get the VMA region for " ++ "MPU Buffer !!! \n"); ++ status = DSP_EINVALIDARG; ++ up_read(&mm->mmap_sem); ++ goto func_cont; ++ } ++ ++ if (vma->vm_flags & VM_IO) { ++ numUsrPgs = ulNumBytes / PG_SIZE_4K; ++ mpuAddr = ulMpuAddr; ++ DBG_Trace(DBG_LEVEL4, "WMD_BRD_MemMap:numOfActualTabEntries=%d," ++ "ulNumBytes= %d\n", numUsrPgs, ulNumBytes); ++ /* Get the physical addresses for user buffer */ ++ for (pgI = 0; pgI < numUsrPgs; pgI++) { ++ pa = user_va2pa(mm, mpuAddr); ++ if (!pa) { ++ status = DSP_EFAIL; ++ pr_err("DSPBRIDGE: VM_IO mapping physical" ++ "address is invalid\n"); ++ break; ++ } ++ if (pfn_valid(__phys_to_pfn(pa))) { ++ pg = phys_to_page(pa); ++ get_page(pg); ++ if (page_count(pg) < 1) { ++ pr_err("Bad page in VM_IO buffer\n"); ++ bad_page_dump(pa, pg); ++ } ++ } ++ status = PteSet(pDevContext->pPtAttrs, pa, ++ va, HW_PAGE_SIZE_4KB, &hwAttrs); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_MemMap: FAILED IN VM_IO" ++ "PTESET \n"); ++ break; ++ } ++ va += HW_PAGE_SIZE_4KB; ++ mpuAddr += HW_PAGE_SIZE_4KB; ++ pa += HW_PAGE_SIZE_4KB; ++ } ++ } else { ++ numUsrPgs = ulNumBytes / PG_SIZE_4K; ++ if (vma->vm_flags & (VM_WRITE | VM_MAYWRITE)) ++ write = 1; ++ ++ for (pgI = 0; pgI < numUsrPgs; pgI++) { ++ pgNum = get_user_pages(curr_task, mm, ulMpuAddr, 1, ++ write, 1, &mappedPage, NULL); ++ if (pgNum > 0) { ++ if (page_count(mappedPage) < 1) { ++ pr_err("Bad page count after doing" ++ "get_user_pages on" ++ "user buffer\n"); ++ bad_page_dump(page_to_phys(mappedPage), ++ mappedPage); ++ } ++ status = PteSet(pDevContext->pPtAttrs, ++ page_to_phys(mappedPage), va, ++ HW_PAGE_SIZE_4KB, &hwAttrs); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "WMD_BRD_MemMap: FAILED IN PTESET \n"); ++ break; ++ } ++ va += HW_PAGE_SIZE_4KB; ++ ulMpuAddr += HW_PAGE_SIZE_4KB; ++ } else { ++ pr_err("DSPBRIDGE: get_user_pages FAILED," ++ "MPU addr = 0x%x," ++ "vma->vm_flags = 0x%lx," ++ "get_user_pages Err" ++ "Value = %d, Buffer" ++ "size=0x%x\n", ulMpuAddr, ++ vma->vm_flags, pgNum, ++ ulNumBytes); ++ status = DSP_EFAIL; ++ break; ++ } ++ } ++ } ++ up_read(&mm->mmap_sem); ++func_cont: ++ /* Don't propogate Linux or HW status to upper layers */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DSP_SOK; ++ } else { ++ DBG_Trace(DBG_LEVEL7, "< WMD_BRD_MemMap status %x\n", status); ++ /* ++ * Roll out the mapped pages incase it failed in middle of ++ * mapping ++ */ ++ if (pgI) { ++ WMD_BRD_MemUnMap(pDevContext, ulVirtAddr, ++ (pgI * PG_SIZE_4K)); ++ } ++ status = DSP_EFAIL; ++ } ++ /* ++ * In any case, flush the TLB ++ * This is called from here instead from PteUpdate to avoid unnecessary ++ * repetition while mapping non-contiguous physical regions of a virtual ++ * region ++ */ ++ flush_all(pDevContext); ++ DBG_Trace(DBG_ENTER, "< WMD_BRD_MemMap status %x\n", status); ++ return status; ++} ++ ++/* ++ * ======== WMD_BRD_MemUnMap ======== ++ * Invalidate the PTEs for the DSP VA block to be unmapped. ++ * ++ * PTEs of a mapped memory block are contiguous in any page table ++ * So, instead of looking up the PTE address for every 4K block, ++ * we clear consecutive PTEs until we unmap all the bytes ++ */ ++static DSP_STATUS WMD_BRD_MemUnMap(struct WMD_DEV_CONTEXT *hDevContext, ++ u32 ulVirtAddr, u32 ulNumBytes) ++{ ++ u32 L1BaseVa; ++ u32 L2BaseVa; ++ u32 L2BasePa; ++ u32 L2PageNum; ++ u32 pteVal; ++ u32 pteSize; ++ u32 pteCount; ++ u32 pteAddrL1; ++ u32 pteAddrL2 = 0; ++ u32 remBytes; ++ u32 remBytesL2; ++ u32 vaCurr; ++ struct page *pg = NULL; ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ struct PgTableAttrs *pt = pDevContext->pPtAttrs; ++ u32 pacount = 0; ++ u32 *pPhysAddrPageTbl = NULL; ++ u32 temp; ++ u32 patemp = 0; ++ u32 pAddr; ++ u32 numof4KPages = 0; ++ ++ DBG_Trace(DBG_ENTER, "> WMD_BRD_MemUnMap hDevContext %x, va %x, " ++ "NumBytes %x\n", hDevContext, ulVirtAddr, ulNumBytes); ++ pPhysAddrPageTbl = DMM_GetPhysicalAddrTable(); ++ vaCurr = ulVirtAddr; ++ remBytes = ulNumBytes; ++ remBytesL2 = 0; ++ L1BaseVa = pt->L1BaseVa; ++ pteAddrL1 = HW_MMU_PteAddrL1(L1BaseVa, vaCurr); ++ DBG_Trace(DBG_ENTER, "WMD_BRD_MemUnMap L1BaseVa %x, pteAddrL1 %x " ++ "vaCurr %x remBytes %x\n", L1BaseVa, pteAddrL1, ++ vaCurr, remBytes); ++ while (remBytes && (DSP_SUCCEEDED(status))) { ++ u32 vaCurrOrig = vaCurr; ++ /* Find whether the L1 PTE points to a valid L2 PT */ ++ pteAddrL1 = HW_MMU_PteAddrL1(L1BaseVa, vaCurr); ++ pteVal = *(u32 *)pteAddrL1; ++ pteSize = HW_MMU_PteSizeL1(pteVal); ++ if (pteSize == HW_MMU_COARSE_PAGE_SIZE) { ++ /* ++ * Get the L2 PA from the L1 PTE, and find ++ * corresponding L2 VA ++ */ ++ L2BasePa = HW_MMU_PteCoarseL1(pteVal); ++ L2BaseVa = L2BasePa - pt->L2BasePa + pt->L2BaseVa; ++ L2PageNum = (L2BasePa - pt->L2BasePa) / ++ HW_MMU_COARSE_PAGE_SIZE; ++ /* ++ * Find the L2 PTE address from which we will start ++ * clearing, the number of PTEs to be cleared on this ++ * page, and the size of VA space that needs to be ++ * cleared on this L2 page ++ */ ++ pteAddrL2 = HW_MMU_PteAddrL2(L2BaseVa, vaCurr); ++ pteCount = pteAddrL2 & (HW_MMU_COARSE_PAGE_SIZE - 1); ++ pteCount = (HW_MMU_COARSE_PAGE_SIZE - pteCount) / ++ sizeof(u32); ++ if (remBytes < (pteCount * PG_SIZE_4K)) ++ pteCount = remBytes / PG_SIZE_4K; ++ ++ remBytesL2 = pteCount * PG_SIZE_4K; ++ DBG_Trace(DBG_LEVEL1, "WMD_BRD_MemUnMap L2BasePa %x, " ++ "L2BaseVa %x pteAddrL2 %x, remBytesL2 %x\n", ++ L2BasePa, L2BaseVa, pteAddrL2, remBytesL2); ++ /* ++ * Unmap the VA space on this L2 PT. A quicker way ++ * would be to clear pteCount entries starting from ++ * pteAddrL2. However, below code checks that we don't ++ * clear invalid entries or less than 64KB for a 64KB ++ * entry. Similar checking is done for L1 PTEs too ++ * below ++ */ ++ while (remBytesL2 && (DSP_SUCCEEDED(status))) { ++ pteVal = *(u32 *)pteAddrL2; ++ pteSize = HW_MMU_PteSizeL2(pteVal); ++ /* vaCurr aligned to pteSize? */ ++ if ((pteSize != 0) && (remBytesL2 >= pteSize) && ++ !(vaCurr & (pteSize - 1))) { ++ /* Collect Physical addresses from VA */ ++ pAddr = (pteVal & ~(pteSize - 1)); ++ if (pteSize == HW_PAGE_SIZE_64KB) ++ numof4KPages = 16; ++ else ++ numof4KPages = 1; ++ temp = 0; ++ while (temp++ < numof4KPages) { ++ pPhysAddrPageTbl[pacount++] = ++ pAddr; ++ pAddr += HW_PAGE_SIZE_4KB; ++ } ++ if (HW_MMU_PteClear(pteAddrL2, ++ vaCurr, pteSize) == RET_OK) { ++ status = DSP_SOK; ++ remBytesL2 -= pteSize; ++ vaCurr += pteSize; ++ pteAddrL2 += (pteSize >> 12) * ++ sizeof(u32); ++ } else { ++ status = DSP_EFAIL; ++ goto EXIT_LOOP; ++ } ++ } else { ++ status = DSP_EFAIL; ++ } ++ } ++ SYNC_EnterCS(pt->hCSObj); ++ if (remBytesL2 == 0) { ++ pt->pgInfo[L2PageNum].numEntries -= pteCount; ++ if (pt->pgInfo[L2PageNum].numEntries == 0) { ++ /* ++ * Clear the L1 PTE pointing to the ++ * L2 PT ++ */ ++ if (RET_OK == HW_MMU_PteClear(L1BaseVa, ++ vaCurrOrig, HW_MMU_COARSE_PAGE_SIZE)) ++ status = DSP_SOK; ++ else { ++ status = DSP_EFAIL; ++ SYNC_LeaveCS(pt->hCSObj); ++ goto EXIT_LOOP; ++ } ++ } ++ remBytes -= pteCount * PG_SIZE_4K; ++ } else { ++ status = DSP_EFAIL; ++ } ++ DBG_Trace(DBG_LEVEL1, "WMD_BRD_MemUnMap L2PageNum %x, " ++ "numEntries %x, pteCount %x, status: 0x%x\n", ++ L2PageNum, pt->pgInfo[L2PageNum].numEntries, ++ pteCount, status); ++ SYNC_LeaveCS(pt->hCSObj); ++ } else ++ /* vaCurr aligned to pteSize? */ ++ /* pteSize = 1 MB or 16 MB */ ++ if ((pteSize != 0) && (remBytes >= pteSize) && ++ !(vaCurr & (pteSize - 1))) { ++ if (pteSize == HW_PAGE_SIZE_1MB) ++ numof4KPages = 256; ++ else ++ numof4KPages = 4096; ++ temp = 0; ++ /* Collect Physical addresses from VA */ ++ pAddr = (pteVal & ~(pteSize - 1)); ++ while (temp++ < numof4KPages) { ++ pPhysAddrPageTbl[pacount++] = pAddr; ++ pAddr += HW_PAGE_SIZE_4KB; ++ } ++ if (HW_MMU_PteClear(L1BaseVa, vaCurr, pteSize) ++ == RET_OK) { ++ status = DSP_SOK; ++ remBytes -= pteSize; ++ vaCurr += pteSize; ++ } else { ++ status = DSP_EFAIL; ++ goto EXIT_LOOP; ++ } ++ } else { ++ status = DSP_EFAIL; ++ } ++ } ++ /* ++ * It is better to flush the TLB here, so that any stale old entries ++ * get flushed ++ */ ++EXIT_LOOP: ++ flush_all(pDevContext); ++ for (temp = 0; temp < pacount; temp++) { ++ patemp = pPhysAddrPageTbl[temp]; ++ if (pfn_valid(__phys_to_pfn(patemp))) { ++ pg = phys_to_page(patemp); ++ if (page_count(pg) < 1) { ++ pr_info("DSPBRIDGE:UNMAP function: COUNT 0" ++ "FOR PA 0x%x, size = 0x%x\n", ++ patemp, ulNumBytes); ++ bad_page_dump(patemp, pg); ++ } ++ SetPageDirty(pg); ++ page_cache_release(pg); ++ } ++ } ++ DBG_Trace(DBG_LEVEL1, "WMD_BRD_MemUnMap vaCurr %x, pteAddrL1 %x " ++ "pteAddrL2 %x\n", vaCurr, pteAddrL1, pteAddrL2); ++ DBG_Trace(DBG_ENTER, "< WMD_BRD_MemUnMap status %x remBytes %x, " ++ "remBytesL2 %x\n", status, remBytes, remBytesL2); ++ return status; ++} ++ ++/* ++ * ======== user_va2pa ======== ++ * Purpose: ++ * This function walks through the Linux page tables to convert a userland ++ * virtual address to physical address ++ */ ++static u32 user_va2pa(struct mm_struct *mm, u32 address) ++{ ++ pgd_t *pgd; ++ pmd_t *pmd; ++ pte_t *ptep, pte; ++ ++ pgd = pgd_offset(mm, address); ++ if (!(pgd_none(*pgd) || pgd_bad(*pgd))) { ++ pmd = pmd_offset(pgd, address); ++ if (!(pmd_none(*pmd) || pmd_bad(*pmd))) { ++ ptep = pte_offset_map(pmd, address); ++ if (ptep) { ++ pte = *ptep; ++ if (pte_present(pte)) ++ return pte & PAGE_MASK; ++ } ++ } ++ } ++ ++ return 0; ++} ++ ++ ++/* ++ * ======== PteUpdate ======== ++ * This function calculates the optimum page-aligned addresses and sizes ++ * Caller must pass page-aligned values ++ */ ++static DSP_STATUS PteUpdate(struct WMD_DEV_CONTEXT *hDevContext, u32 pa, ++ u32 va, u32 size, ++ struct HW_MMUMapAttrs_t *mapAttrs) ++{ ++ u32 i; ++ u32 allBits; ++ u32 paCurr = pa; ++ u32 vaCurr = va; ++ u32 numBytes = size; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ DSP_STATUS status = DSP_SOK; ++ u32 pgSize[] = { HW_PAGE_SIZE_16MB, HW_PAGE_SIZE_1MB, ++ HW_PAGE_SIZE_64KB, HW_PAGE_SIZE_4KB }; ++ DBG_Trace(DBG_ENTER, "> PteUpdate hDevContext %x, pa %x, va %x, " ++ "size %x, mapAttrs %x\n", hDevContext, pa, va, size, mapAttrs); ++ while (numBytes && DSP_SUCCEEDED(status)) { ++ /* To find the max. page size with which both PA & VA are ++ * aligned */ ++ allBits = paCurr | vaCurr; ++ DBG_Trace(DBG_LEVEL1, "allBits %x, paCurr %x, vaCurr %x, " ++ "numBytes %x ", allBits, paCurr, vaCurr, numBytes); ++ for (i = 0; i < 4; i++) { ++ if ((numBytes >= pgSize[i]) && ((allBits & ++ (pgSize[i] - 1)) == 0)) { ++ DBG_Trace(DBG_LEVEL1, "pgSize %x\n", pgSize[i]); ++ status = PteSet(pDevContext->pPtAttrs, paCurr, ++ vaCurr, pgSize[i], mapAttrs); ++ paCurr += pgSize[i]; ++ vaCurr += pgSize[i]; ++ numBytes -= pgSize[i]; ++ /* Don't try smaller sizes. Hopefully we have ++ * reached an address aligned to a bigger page ++ * size */ ++ break; ++ } ++ } ++ } ++ DBG_Trace(DBG_ENTER, "< PteUpdate status %x numBytes %x\n", status, ++ numBytes); ++ return status; ++} ++ ++/* ++ * ======== PteSet ======== ++ * This function calculates PTE address (MPU virtual) to be updated ++ * It also manages the L2 page tables ++ */ ++static DSP_STATUS PteSet(struct PgTableAttrs *pt, u32 pa, u32 va, ++ u32 size, struct HW_MMUMapAttrs_t *attrs) ++{ ++ u32 i; ++ u32 pteVal; ++ u32 pteAddrL1; ++ u32 pteSize; ++ u32 pgTblVa; /* Base address of the PT that will be updated */ ++ u32 L1BaseVa; ++ /* Compiler warns that the next three variables might be used ++ * uninitialized in this function. Doesn't seem so. Working around, ++ * anyways. */ ++ u32 L2BaseVa = 0; ++ u32 L2BasePa = 0; ++ u32 L2PageNum = 0; ++ DSP_STATUS status = DSP_SOK; ++ DBG_Trace(DBG_ENTER, "> PteSet pPgTableAttrs %x, pa %x, va %x, " ++ "size %x, attrs %x\n", pt, pa, va, size, attrs); ++ L1BaseVa = pt->L1BaseVa; ++ pgTblVa = L1BaseVa; ++ if ((size == HW_PAGE_SIZE_64KB) || (size == HW_PAGE_SIZE_4KB)) { ++ /* Find whether the L1 PTE points to a valid L2 PT */ ++ pteAddrL1 = HW_MMU_PteAddrL1(L1BaseVa, va); ++ if (pteAddrL1 <= (pt->L1BaseVa + pt->L1size)) { ++ pteVal = *(u32 *)pteAddrL1; ++ pteSize = HW_MMU_PteSizeL1(pteVal); ++ } else { ++ return DSP_EFAIL; ++ } ++ SYNC_EnterCS(pt->hCSObj); ++ if (pteSize == HW_MMU_COARSE_PAGE_SIZE) { ++ /* Get the L2 PA from the L1 PTE, and find ++ * corresponding L2 VA */ ++ L2BasePa = HW_MMU_PteCoarseL1(pteVal); ++ L2BaseVa = L2BasePa - pt->L2BasePa + pt->L2BaseVa; ++ L2PageNum = (L2BasePa - pt->L2BasePa) / ++ HW_MMU_COARSE_PAGE_SIZE; ++ } else if (pteSize == 0) { ++ /* L1 PTE is invalid. Allocate a L2 PT and ++ * point the L1 PTE to it */ ++ /* Find a free L2 PT. */ ++ for (i = 0; (i < pt->L2NumPages) && ++ (pt->pgInfo[i].numEntries != 0); i++) ++ ;; ++ if (i < pt->L2NumPages) { ++ L2PageNum = i; ++ L2BasePa = pt->L2BasePa + (L2PageNum * ++ HW_MMU_COARSE_PAGE_SIZE); ++ L2BaseVa = pt->L2BaseVa + (L2PageNum * ++ HW_MMU_COARSE_PAGE_SIZE); ++ /* Endianness attributes are ignored for ++ * HW_MMU_COARSE_PAGE_SIZE */ ++ status = HW_MMU_PteSet(L1BaseVa, L2BasePa, va, ++ HW_MMU_COARSE_PAGE_SIZE, attrs); ++ } else { ++ status = DSP_EMEMORY; ++ } ++ } else { ++ /* Found valid L1 PTE of another size. ++ * Should not overwrite it. */ ++ status = DSP_EFAIL; ++ } ++ if (DSP_SUCCEEDED(status)) { ++ pgTblVa = L2BaseVa; ++ if (size == HW_PAGE_SIZE_64KB) ++ pt->pgInfo[L2PageNum].numEntries += 16; ++ else ++ pt->pgInfo[L2PageNum].numEntries++; ++ DBG_Trace(DBG_LEVEL1, "L2 BaseVa %x, BasePa %x, " ++ "PageNum %x numEntries %x\n", L2BaseVa, ++ L2BasePa, L2PageNum, ++ pt->pgInfo[L2PageNum].numEntries); ++ } ++ SYNC_LeaveCS(pt->hCSObj); ++ } ++ if (DSP_SUCCEEDED(status)) { ++ DBG_Trace(DBG_LEVEL1, "PTE pgTblVa %x, pa %x, va %x, size %x\n", ++ pgTblVa, pa, va, size); ++ DBG_Trace(DBG_LEVEL1, "PTE endianism %x, elementSize %x, " ++ "mixedSize %x\n", attrs->endianism, ++ attrs->elementSize, attrs->mixedSize); ++ status = HW_MMU_PteSet(pgTblVa, pa, va, size, attrs); ++ } ++ DBG_Trace(DBG_ENTER, "< PteSet status %x\n", status); ++ return status; ++} ++ ++/* Memory map kernel VA -- memory allocated with vmalloc */ ++static DSP_STATUS MemMapVmalloc(struct WMD_DEV_CONTEXT *pDevContext, ++ u32 ulMpuAddr, u32 ulVirtAddr, u32 ulNumBytes, ++ struct HW_MMUMapAttrs_t *hwAttrs) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct page *pPage[1]; ++ u32 i; ++ u32 paCurr; ++ u32 paNext; ++ u32 vaCurr; ++ u32 sizeCurr; ++ u32 numPages; ++ u32 pa; ++ u32 numOf4KPages; ++ u32 temp = 0; ++ ++ DBG_Trace(DBG_ENTER, "> MemMapVmalloc hDevContext %x, pa %x, va %x, " ++ "size %x\n", pDevContext, ulMpuAddr, ulVirtAddr, ulNumBytes); ++ ++ /* ++ * Do Kernel va to pa translation. ++ * Combine physically contiguous regions to reduce TLBs. ++ * Pass the translated pa to PteUpdate. ++ */ ++ numPages = ulNumBytes / PAGE_SIZE; /* PAGE_SIZE = OS page size */ ++ i = 0; ++ vaCurr = ulMpuAddr; ++ pPage[0] = vmalloc_to_page((void *)vaCurr); ++ paNext = page_to_phys(pPage[0]); ++ while (DSP_SUCCEEDED(status) && (i < numPages)) { ++ /* ++ * Reuse paNext from the previous iteraion to avoid ++ * an extra va2pa call ++ */ ++ paCurr = paNext; ++ sizeCurr = PAGE_SIZE; ++ /* ++ * If the next page is physically contiguous, ++ * map it with the current one by increasing ++ * the size of the region to be mapped ++ */ ++ while (++i < numPages) { ++ pPage[0] = vmalloc_to_page((void *)(vaCurr + sizeCurr)); ++ paNext = page_to_phys(pPage[0]); ++ DBG_Trace(DBG_LEVEL5, "Xlate Vmalloc VA=0x%x , " ++ "PA=0x%x \n", (vaCurr + sizeCurr), paNext); ++ if (paNext == (paCurr + sizeCurr)) ++ sizeCurr += PAGE_SIZE; ++ else ++ break; ++ ++ } ++ if (paNext == 0) { ++ status = DSP_EMEMORY; ++ break; ++ } ++ pa = paCurr; ++ numOf4KPages = sizeCurr / HW_PAGE_SIZE_4KB; ++ while (temp++ < numOf4KPages) { ++ get_page(phys_to_page(pa)); ++ pa += HW_PAGE_SIZE_4KB; ++ } ++ status = PteUpdate(pDevContext, paCurr, ulVirtAddr + ++ (vaCurr - ulMpuAddr), sizeCurr, hwAttrs); ++ vaCurr += sizeCurr; ++ } ++ /* Don't propogate Linux or HW status to upper layers */ ++ if (DSP_SUCCEEDED(status)) { ++ status = DSP_SOK; ++ DBG_Trace(DBG_LEVEL7, "< WMD_BRD_MemMap succeeded %x\n", ++ status); ++ } else { ++ DBG_Trace(DBG_LEVEL7, "< WMD_BRD_MemMap status %x\n", status); ++ status = DSP_EFAIL; ++ } ++ /* ++ * In any case, flush the TLB ++ * This is called from here instead from PteUpdate to avoid unnecessary ++ * repetition while mapping non-contiguous physical regions of a virtual ++ * region ++ */ ++ flush_all(pDevContext); ++ DBG_Trace(DBG_LEVEL7, "< WMD_BRD_MemMap at end status %x\n", status); ++ return status; ++} ++ ++static DSP_STATUS run_IdleBoot(u32 prm_base, u32 cm_base, ++ u32 sysctrl_base) ++{ ++ u32 temp; ++ DSP_STATUS status = DSP_SOK; ++ enum HW_PwrState_t pwrState; ++ ++ /* Read PM_PWSTST_IVA2 */ ++ HW_PWRST_IVA2RegGet(prm_base, &temp); ++ if ((temp & 0x03) != 0x03 || (temp & 0x03) != 0x02) { ++ /* IVA2 is not in ON state */ ++ /* Set PM_PWSTCTRL_IVA2 to ON */ ++ HW_PWR_IVA2PowerStateSet(prm_base, HW_PWR_DOMAIN_DSP, ++ HW_PWR_STATE_ON); ++ /* Set the SW supervised state transition */ ++ HW_PWR_CLKCTRL_IVA2RegSet(cm_base, HW_SW_SUP_WAKEUP); ++ /* Wait until the state has moved to ON */ ++ HW_PWR_IVA2StateGet(prm_base, HW_PWR_DOMAIN_DSP, &pwrState); ++ } ++ CLK_Disable(SERVICESCLK_iva2_ck); ++ udelay(10); ++ /* Assert IVA2-RST1 and IVA2-RST2 */ ++ *((REG_UWORD32 *)((u32)(prm_base) + 0x50)) = (u32)0x07; ++ udelay(30); ++ /* set the SYSC for Idle Boot */ ++ *((REG_UWORD32 *)((u32)(sysctrl_base) + 0x404)) = (u32)0x01; ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (cm_base) + 0x34)); ++ temp = (temp & 0xFFFFFFFE) | 0x1; ++ *((REG_UWORD32 *) ((u32) (cm_base) + 0x34)) = ++ (u32) temp; ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (cm_base) + 0x4)); ++ temp = (temp & 0xFFFFFC8) | 0x37; ++ *((REG_UWORD32 *) ((u32) (cm_base) + 0x4)) = ++ (u32) temp; ++ CLK_Enable(SERVICESCLK_iva2_ck); ++ udelay(20); ++ GetHWRegs(prm_base, cm_base); ++ /* Release Reset1 and Reset2 */ ++ *((REG_UWORD32 *)((u32)(prm_base) + 0x50)) = (u32)0x05; ++ udelay(20); ++ *((REG_UWORD32 *)((u32)(prm_base) + 0x50)) = (u32)0x04; ++ udelay(30); ++ return status; ++} ++ ++ ++void GetHWRegs(u32 prm_base, u32 cm_base) ++{ ++ u32 temp; ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0x00)); ++ DBG_Trace(DBG_LEVEL6, "CM_FCLKEN_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0x10)); ++ DBG_Trace(DBG_LEVEL6, "CM_ICLKEN1_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0x20)); ++ DBG_Trace(DBG_LEVEL6, "CM_IDLEST_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0x48)); ++ DBG_Trace(DBG_LEVEL6, "CM_CLKSTCTRL_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0x4c)); ++ DBG_Trace(DBG_LEVEL6, "CM_CLKSTST_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(prm_base) + 0x50)); ++ DBG_Trace(DBG_LEVEL6, "RM_RSTCTRL_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(prm_base) + 0x58)); ++ DBG_Trace(DBG_LEVEL6, "RM_RSTST_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(prm_base) + 0xE0)); ++ DBG_Trace(DBG_LEVEL6, "PM_PWSTCTRL_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(prm_base) + 0xE4)); ++ DBG_Trace(DBG_LEVEL6, "PM_PWSTST_IVA2 = 0x%x \n", temp); ++ temp = (u32)*((REG_UWORD32 *)((u32)(cm_base) + 0xA10)); ++ DBG_Trace(DBG_LEVEL6, "CM_ICLKEN1_CORE = 0x%x \n", temp); ++} ++ ++/* ++ * ======== configureDspMmu ======== ++ * Make DSP MMU page table entries. ++ */ ++void configureDspMmu(struct WMD_DEV_CONTEXT *pDevContext, u32 dataBasePhys, ++ u32 dspBaseVirt, u32 sizeInBytes, s32 nEntryStart, ++ enum HW_Endianism_t endianism, ++ enum HW_ElementSize_t elemSize, ++ enum HW_MMUMixedSize_t mixedSize) ++{ ++ struct CFG_HOSTRES resources; ++ struct HW_MMUMapAttrs_t mapAttrs = { endianism, elemSize, mixedSize }; ++ DSP_STATUS status = DSP_SOK; ++ ++ DBC_Require(sizeInBytes > 0); ++ DBG_Trace(DBG_LEVEL1, ++ "configureDspMmu entry %x pa %x, va %x, bytes %x ", ++ nEntryStart, dataBasePhys, dspBaseVirt, sizeInBytes); ++ ++ DBG_Trace(DBG_LEVEL1, "endianism %x, elemSize %x, mixedSize %x\n", ++ endianism, elemSize, mixedSize); ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ status = HW_MMU_TLBAdd(pDevContext->dwDSPMmuBase, dataBasePhys, ++ dspBaseVirt, sizeInBytes, nEntryStart, ++ &mapAttrs, HW_SET, HW_SET); ++} ++ ++/* ++ * ======== WaitForStart ======== ++ * Wait for the singal from DSP that it has started, or time out. ++ */ ++bool WaitForStart(struct WMD_DEV_CONTEXT *pDevContext, u32 dwSyncAddr) ++{ ++ u16 usCount = TIHELEN_ACKTIMEOUT; ++ ++ /* Wait for response from board */ ++ while (*((volatile u16 *)dwSyncAddr) && --usCount) ++ udelay(10); ++ ++ /* If timed out: return FALSE */ ++ if (!usCount) { ++ DBG_Trace(DBG_LEVEL7, "Timed out Waiting for DSP to Start\n"); ++ return FALSE; ++ } ++ return TRUE; ++} +diff --git a/drivers/dsp/bridge/wmd/tiomap3430_pwr.c b/drivers/dsp/bridge/wmd/tiomap3430_pwr.c +new file mode 100644 +index 0000000..cbf6925 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/tiomap3430_pwr.c +@@ -0,0 +1,731 @@ ++/* ++ * tiomap_pwr.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2007-2008 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++/* ++ * ======== _tiomap_pwr.c ======== ++ * Description: ++ * Implementation of DSP wake/sleep routines. ++ * ++ *! Revision History ++ *! ================ ++ *! 01-Nov-2007 HK: Added Off mode(Hibernation) support and DVFS support ++ *! 05-Jan-2004 vp: Moved the file to platform specific folder and commented the ++ *! code. ++ *! 27-Mar-2003 vp: Added support for DSP boot idle mode. ++ *! 06-Dec-2002 cring: Added Palm support. ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++#include <dspbridge/cfg.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/io_sm.h> ++#include <dspbridge/chnl_sm.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/util.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/brddefs.h> ++#include <dspbridge/dev.h> ++#include <dspbridge/iodefs.h> ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_dspssC64P.h> ++#include <hw_prcm.h> ++#include <hw_mmu.h> ++ ++#include <dspbridge/pwr_sh.h> ++ ++/* ----------------------------------- specific to this file */ ++#include "_tiomap.h" ++#include "_tiomap_pwr.h" ++#include "_tiomap_util.h" ++#include <mach-omap2/prm-regbits-34xx.h> ++#include <mach-omap2/cm-regbits-34xx.h> ++ ++#ifdef CONFIG_PM ++#include <mach/board-3430sdp.h> ++#endif ++extern struct MAILBOX_CONTEXT mboxsetting; ++static unsigned short enable_off_mode = 0; ++/* ++ * ======== handle_constraints_set ======== ++ * Sets new DSP constraint ++ */ ++DSP_STATUS handle_constraints_set(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs) ++{ ++#ifdef CONFIG_BRIDGE_DVFS ++ u32 *pConstraintVal; ++ DSP_STATUS status = DSP_SOK; ++ struct CFG_HOSTRES resources; ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ ++ pConstraintVal = (u32 *)(pArgs); ++ /* Read the target value requested by DSP */ ++ DBG_Trace(DBG_LEVEL7, "handle_constraints_set:" ++ "opp requested = 0x%x\n", (u32)*(pConstraintVal+1)); ++ status = HW_MBOX_saveSettings(resources.dwMboxBase); ++ ++ /* Set the new opp value */ ++ if (pdata->dsp_set_min_opp) ++ (*pdata->dsp_set_min_opp)((u32)*(pConstraintVal+1)); ++ return DSP_SOK; ++#endif /* #ifdef CONFIG_BRIDGE_DVFS */ ++ return DSP_SOK; ++} ++ ++/* ++ * ======== handle_hibernation_fromDSP ======== ++ * Handle Hibernation requested from DSP ++ */ ++DSP_STATUS handle_hibernation_fromDSP(struct WMD_DEV_CONTEXT *pDevContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++#ifdef CONFIG_PM ++ u16 usCount = TIHELEN_ACKTIMEOUT; ++ struct CFG_HOSTRES resources; ++ enum HW_PwrState_t pwrState; ++#ifdef CONFIG_BRIDGE_DVFS ++ u32 opplevel; ++ struct IO_MGR *hIOMgr; ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++#endif ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ return status; ++ ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ /* Wait for DSP to move into Off state, how much time should ++ * we wait? */ ++ while ((pwrState != HW_PWR_STATE_OFF) && --usCount) { ++ udelay(500); ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ } ++ if (usCount == 0) { ++ DBG_Trace(DBG_LEVEL7, "Timed out Waiting for DSP Off mode \n"); ++ status = WMD_E_TIMEOUT; ++ return status; ++ } else { ++ ++ /* Save mailbox settings */ ++ status = HW_MBOX_saveSettings(resources.dwMboxBase); ++ DBG_Trace(DBG_LEVEL6, "MailBoxSettings: SYSCONFIG = 0x%x\n", ++ mboxsetting.sysconfig); ++ DBG_Trace(DBG_LEVEL6, "MailBoxSettings: IRQENABLE0 = 0x%x\n", ++ mboxsetting.irqEnable0); ++ DBG_Trace(DBG_LEVEL6, "MailBoxSettings: IRQENABLE1 = 0x%x\n", ++ mboxsetting.irqEnable1); ++ /* Turn off DSP Peripheral clocks and DSP Load monitor timer */ ++ status = DSP_PeripheralClocks_Disable(pDevContext, NULL); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Update the Bridger Driver state */ ++ pDevContext->dwBrdState = BRD_DSP_HIBERNATION; ++#ifdef CONFIG_BRIDGE_DVFS ++ status = DEV_GetIOMgr(pDevContext->hDevObject, &hIOMgr); ++ if (DSP_FAILED(status)) ++ return status; ++ IO_SHMsetting(hIOMgr, SHM_GETOPP, &opplevel); ++ /* Set the OPP to low level before moving to OFF mode */ ++ if (opplevel != VDD1_OPP1) { ++ DBG_Trace(DBG_LEVEL5, ++ "Tiomap_pwr.c - DSP requested" ++ " OPP = %d, MPU requesting low" ++ " OPP %d instead\n", opplevel, ++ VDD1_OPP1); ++ if (pdata->dsp_set_min_opp) ++ (*pdata->dsp_set_min_opp)(VDD1_OPP1); ++ status = DSP_SOK; ++ } ++#endif /* CONFIG_BRIDGE_DVFS */ ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "handle_hibernation_fromDSP- FAILED\n"); ++ } ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== SleepDSP ======== ++ * Put DSP in low power consuming state. ++ */ ++DSP_STATUS SleepDSP(struct WMD_DEV_CONTEXT *pDevContext, IN u32 dwCmd, ++ IN void *pArgs) ++{ ++ DSP_STATUS status = DSP_SOK; ++#ifdef CONFIG_PM ++ struct CFG_HOSTRES resources; ++ u16 usCount = TIHELEN_ACKTIMEOUT; ++ enum HW_PwrState_t pwrState; ++ enum HW_PwrState_t targetPwrState; ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ return status; ++ DBG_Trace(DBG_LEVEL7, "SleepDSP- Enter function \n"); ++ ++ /* next, check if sleep code is valid... */ ++ if ((dwCmd != PWR_DEEPSLEEP) && (dwCmd != PWR_EMERGENCYDEEPSLEEP)) { ++ DBG_Trace(DBG_LEVEL7, "SleepDSP- Illegal sleep command\n"); ++ return DSP_EINVALIDARG; ++ } ++ switch (pDevContext->dwBrdState) { ++ case BRD_RUNNING: ++ status = HW_MBOX_saveSettings(resources.dwMboxBase); ++ if (enable_off_mode) { ++ CHNLSM_InterruptDSP2(pDevContext, ++ MBX_PM_DSPHIBERNATE); ++ DBG_Trace(DBG_LEVEL7, ++ "SleepDSP - Sent hibernate " ++ "command to DSP\n"); ++ targetPwrState = HW_PWR_STATE_OFF; ++ } else { ++ CHNLSM_InterruptDSP2(pDevContext, ++ MBX_PM_DSPRETENTION); ++ targetPwrState = HW_PWR_STATE_RET; ++ } ++ break; ++ case BRD_RETENTION: ++ status = HW_MBOX_saveSettings(resources.dwMboxBase); ++ if (enable_off_mode) { ++ CHNLSM_InterruptDSP2(pDevContext, ++ MBX_PM_DSPHIBERNATE); ++ targetPwrState = HW_PWR_STATE_OFF; ++ } else ++ return DSP_SOK; ++ break; ++ case BRD_HIBERNATION: ++ case BRD_DSP_HIBERNATION: ++ status = HW_MBOX_saveSettings(resources.dwMboxBase); ++ /* Already in Hibernation, so just return */ ++ DBG_Trace(DBG_LEVEL7, "SleepDSP- DSP already in " ++ "hibernation\n"); ++ return DSP_SOK; ++ case BRD_STOPPED: ++ DBG_Trace(DBG_LEVEL7, ++ "SleepDSP- Board in STOP state \n"); ++ return DSP_SALREADYASLEEP; ++ default: ++ DBG_Trace(DBG_LEVEL7, ++ "SleepDSP- Bridge in Illegal state\n"); ++ return DSP_EFAIL; ++ } ++ /* Get the PRCM DSP power domain status */ ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ /* Wait for DSP to move into Standby state, how much time ++ * should we wait?*/ ++ while ((pwrState != targetPwrState) && --usCount) { ++ udelay(500); ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ } ++ if (usCount == 0) { ++ DBG_Trace(DBG_LEVEL7, "SleepDSP: Timed out Waiting for DSP" ++ " STANDBY %x \n", pwrState); ++ return WMD_E_TIMEOUT; ++ } else { ++ DBG_Trace(DBG_LEVEL7, "SleepDSP: DSP STANDBY Pwr state %x \n", ++ pwrState); ++ /* Update the Bridger Driver state */ ++ if (enable_off_mode) ++ pDevContext->dwBrdState = BRD_HIBERNATION; ++ else ++ pDevContext->dwBrdState = BRD_RETENTION; ++ /* Turn off DSP Peripheral clocks */ ++ status = DSP_PeripheralClocks_Disable(pDevContext, NULL); ++ if (DSP_FAILED(status)) ++ DBG_Trace(DBG_LEVEL7, "SleepDSP- FAILED\n"); ++ } ++#endif ++ return status; ++} ++ ++ ++/* ++ * ======== WakeDSP ======== ++ * Wake up DSP from sleep. ++ */ ++DSP_STATUS WakeDSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs) ++{ ++ DSP_STATUS status = DSP_SOK; ++#ifdef CONFIG_PM ++ struct CFG_HOSTRES resources; ++ enum HW_PwrState_t pwrState; ++ u32 temp; ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ return status; ++ /* check the BRD/WMD state, if it is not 'SLEEP' then return failure */ ++ if (pDevContext->dwBrdState == BRD_RUNNING || ++ pDevContext->dwBrdState == BRD_STOPPED || ++ pDevContext->dwBrdState == BRD_DSP_HIBERNATION) { ++ /* The Device is in 'RET' or 'OFF' state and WMD state is not ++ * 'SLEEP', this means state inconsistency, so return */ ++ status = DSP_SOK; ++ return status; ++ } ++ /* Enable the DSP peripheral clocks and load monitor timer ++ * before waking the DSP */ ++ DBG_Trace(DBG_LEVEL6, "WakeDSP: enable DSP Peripheral Clks = 0x%x \n", ++ pDevContext->uDspPerClks); ++ status = DSP_PeripheralClocks_Enable(pDevContext, NULL); ++ ++ /* Enabling Dppll in lock mode */ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x34)); ++ temp = (temp & 0xFFFFFFFE) | 0x1; ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x34)) = ++ (u32) temp; ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x4)); ++ temp = (temp & 0xFFFFFC8) | 0x37; ++ ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x4)) = ++ (u32) temp; ++ ++ udelay(10); ++ if (DSP_SUCCEEDED(status)) { ++ /* Send a message to DSP to wake up */ ++ CHNLSM_InterruptDSP2(pDevContext, MBX_PM_DSPWAKEUP); ++ HW_PWR_IVA2StateGet(resources.dwPrmBase, HW_PWR_DOMAIN_DSP, ++ &pwrState); ++ DBG_Trace(DBG_LEVEL7, ++ "\nWakeDSP: Power State After sending Interrupt " ++ "to DSP %x\n", pwrState); ++ /* set the device state to RUNNIG */ ++ pDevContext->dwBrdState = BRD_RUNNING; ++ } else { ++ DBG_Trace(DBG_LEVEL6, "WakeDSP: FAILED\n"); ++ } ++#endif ++ return status; ++} ++ ++/* ++ * ======== DSPPeripheralClkCtrl ======== ++ * Enable/Disable the DSP peripheral clocks as needed.. ++ */ ++DSP_STATUS DSPPeripheralClkCtrl(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs) ++{ ++ u32 extClk = 0; ++ u32 extClkId = 0; ++ u32 extClkCmd = 0; ++ u32 clkIdIndex = MBX_PM_MAX_RESOURCES; ++ u32 tmpIndex; ++ u32 dspPerClksBefore; ++ DSP_STATUS status = DSP_SOK; ++ DSP_STATUS status1 = DSP_SOK; ++ ++ DBG_Trace(DBG_ENTER, "Entering DSPPeripheralClkCtrl \n"); ++ dspPerClksBefore = pDevContext->uDspPerClks; ++ DBG_Trace(DBG_ENTER, "DSPPeripheralClkCtrl : uDspPerClks = 0x%x \n", ++ dspPerClksBefore); ++ ++ extClk = (u32)*((u32 *)pArgs); ++ ++ DBG_Trace(DBG_LEVEL3, "DSPPeripheralClkCtrl : extClk+Cmd = 0x%x \n", ++ extClk); ++ ++ extClkId = extClk & MBX_PM_CLK_IDMASK; ++ ++ /* process the power message -- TODO, keep it in a separate function */ ++ for (tmpIndex = 0; tmpIndex < MBX_PM_MAX_RESOURCES; tmpIndex++) { ++ if (extClkId == BPWR_CLKID[tmpIndex]) { ++ clkIdIndex = tmpIndex; ++ break; ++ } ++ } ++ /* TODO -- Assert may be a too hard restriction here.. May be we should ++ * just return with failure when the CLK ID does not match */ ++ /* DBC_Assert(clkIdIndex < MBX_PM_MAX_RESOURCES);*/ ++ if (clkIdIndex == MBX_PM_MAX_RESOURCES) { ++ DBG_Trace(DBG_LEVEL7, ++ "DSPPeripheralClkCtrl : Could n't get clock Id for" ++ "clkid 0x%x \n", clkIdIndex); ++ /* return with a more meaningfull error code */ ++ return DSP_EFAIL; ++ } ++ extClkCmd = (extClk >> MBX_PM_CLK_CMDSHIFT) & MBX_PM_CLK_CMDMASK; ++ switch (extClkCmd) { ++ case BPWR_DisableClock: ++ /* Call BP to disable the needed clock */ ++ DBG_Trace(DBG_LEVEL3, ++ "DSPPeripheralClkCtrl : Disable CLK for \n"); ++ status1 = CLK_Disable(BPWR_Clks[clkIdIndex].intClk); ++ status = CLK_Disable(BPWR_Clks[clkIdIndex].funClk); ++ DSPClkWakeupEventCtrl(BPWR_Clks[clkIdIndex].clkId, false); ++ if ((DSP_SUCCEEDED(status)) && (DSP_SUCCEEDED(status1))) { ++ (pDevContext->uDspPerClks) &= ++ (~((u32) (1 << clkIdIndex))); ++ } else { ++ DBG_Trace(DBG_LEVEL7, "DSPPeripheralClkCtrl : Failed " ++ "to disable clk\n"); ++ } ++ break; ++ case BPWR_EnableClock: ++ DBG_Trace(DBG_LEVEL3, ++ "DSPPeripheralClkCtrl : Enable CLK for \n"); ++ status1 = CLK_Enable(BPWR_Clks[clkIdIndex].intClk); ++ status = CLK_Enable(BPWR_Clks[clkIdIndex].funClk); ++ DSPClkWakeupEventCtrl(BPWR_Clks[clkIdIndex].clkId, true); ++ if ((DSP_SUCCEEDED(status)) && (DSP_SUCCEEDED(status1))) { ++ (pDevContext->uDspPerClks) |= (1 << clkIdIndex); ++ } else { ++ DBG_Trace(DBG_LEVEL7, ++ "DSPPeripheralClkCtrl:Failed to Enable clk\n"); ++ } ++ break; ++ default: ++ DBG_Trace(DBG_LEVEL3, ++ "DSPPeripheralClkCtrl : Unsupported CMD \n"); ++ /* unsupported cmd */ ++ /* TODO -- provide support for AUTOIDLE Enable/Disable ++ * commands */ ++ } ++ return status; ++} ++ ++/* ++ * ========PreScale_DSP======== ++ * Sends prescale notification to DSP ++ * ++ */ ++DSP_STATUS PreScale_DSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs) ++{ ++#ifdef CONFIG_BRIDGE_DVFS ++ u32 level; ++ u32 voltage_domain; ++ ++ voltage_domain = *((u32 *)pArgs); ++ level = *((u32 *)pArgs + 1); ++ ++ DBG_Trace(DBG_LEVEL7, "PreScale_DSP: voltage_domain = %x, level = " ++ "0x%x\n", voltage_domain, level); ++ if ((pDevContext->dwBrdState == BRD_HIBERNATION) || ++ (pDevContext->dwBrdState == BRD_RETENTION) || ++ (pDevContext->dwBrdState == BRD_DSP_HIBERNATION)) { ++ DBG_Trace(DBG_LEVEL7, "PreScale_DSP: IVA in sleep. " ++ "No notification to DSP\n"); ++ return DSP_SOK; ++ } else if ((pDevContext->dwBrdState == BRD_RUNNING)) { ++ /* Send a prenotificatio to DSP */ ++ DBG_Trace(DBG_LEVEL7, ++ "PreScale_DSP: Sent notification to DSP\n"); ++ CHNLSM_InterruptDSP2(pDevContext, MBX_PM_SETPOINT_PRENOTIFY); ++ return DSP_SOK; ++ } else { ++ DBG_Trace(DBG_LEVEL7, "PreScale_DSP: Failed - DSP BRD" ++ " state in wrong state"); ++ return DSP_EFAIL; ++ } ++#endif /* #ifdef CONFIG_BRIDGE_DVFS */ ++ return DSP_SOK; ++} ++ ++/* ++ * ========PostScale_DSP======== ++ * Sends postscale notification to DSP ++ * ++ */ ++DSP_STATUS PostScale_DSP(struct WMD_DEV_CONTEXT *pDevContext, IN void *pArgs) ++{ ++#ifdef CONFIG_BRIDGE_DVFS ++ u32 level; ++ u32 voltage_domain; ++ struct IO_MGR *hIOMgr; ++ DSP_STATUS status = DSP_SOK; ++ ++ status = DEV_GetIOMgr(pDevContext->hDevObject, &hIOMgr); ++ ++ voltage_domain = *((u32 *)pArgs); ++ level = *((u32 *)pArgs + 1); ++ DBG_Trace(DBG_LEVEL7, ++ "PostScale_DSP: voltage_domain = %x, level = 0x%x\n", ++ voltage_domain, level); ++ if ((pDevContext->dwBrdState == BRD_HIBERNATION) || ++ (pDevContext->dwBrdState == BRD_RETENTION) || ++ (pDevContext->dwBrdState == BRD_DSP_HIBERNATION)) { ++ /* Update the OPP value in shared memory */ ++ IO_SHMsetting(hIOMgr, SHM_CURROPP, &level); ++ DBG_Trace(DBG_LEVEL7, ++ "PostScale_DSP: IVA in sleep. Wrote to shared " ++ "memory \n"); ++ return DSP_SOK; ++ } else if ((pDevContext->dwBrdState == BRD_RUNNING)) { ++ /* Update the OPP value in shared memory */ ++ IO_SHMsetting(hIOMgr, SHM_CURROPP, &level); ++ /* Send a post notification to DSP */ ++ CHNLSM_InterruptDSP2(pDevContext, MBX_PM_SETPOINT_POSTNOTIFY); ++ DBG_Trace(DBG_LEVEL7, ++ "PostScale_DSP: Wrote to shared memory Sent post" ++ " notification to DSP\n"); ++ return DSP_SOK; ++ } else { ++ DBG_Trace(DBG_LEVEL7, "PostScale_DSP: Failed - DSP BRD state " ++ "in wrong state"); ++ return DSP_EFAIL; ++ } ++#endif /* #ifdef CONFIG_BRIDGE_DVFS */ ++ return DSP_SOK; ++} ++ ++/* ++ * ========DSP_PeripheralClocks_Disable======== ++ * Disables all the peripheral clocks that were requested by DSP ++ */ ++DSP_STATUS DSP_PeripheralClocks_Disable(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs) ++{ ++ ++ u32 clkIdx; ++ DSP_STATUS status = DSP_SOK; ++ ++ for (clkIdx = 0; clkIdx < MBX_PM_MAX_RESOURCES; clkIdx++) { ++ if (((pDevContext->uDspPerClks) >> clkIdx) & 0x01) { ++ /* Disables the interface clock of the peripheral */ ++ status = CLK_Disable(BPWR_Clks[clkIdx].intClk); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "Failed to Enable the DSP Peripheral" ++ "Clk 0x%x \n", BPWR_Clks[clkIdx]); ++ } ++ /* Disables the functional clock of the periphearl */ ++ status = CLK_Disable(BPWR_Clks[clkIdx].funClk); ++ if (DSP_FAILED(status)) { ++ DBG_Trace(DBG_LEVEL7, ++ "Failed to Enable the DSP Peripheral" ++ "Clk 0x%x \n", BPWR_Clks[clkIdx]); ++ } ++ } ++ } ++ return status; ++} ++ ++/* ++ * ========DSP_PeripheralClocks_Enable======== ++ * Enables all the peripheral clocks that were requested by DSP ++ */ ++DSP_STATUS DSP_PeripheralClocks_Enable(struct WMD_DEV_CONTEXT *pDevContext, ++ IN void *pArgs) ++{ ++ u32 clkIdx; ++ DSP_STATUS int_clk_status = DSP_EFAIL, fun_clk_status = DSP_EFAIL; ++ ++ for (clkIdx = 0; clkIdx < MBX_PM_MAX_RESOURCES; clkIdx++) { ++ if (((pDevContext->uDspPerClks) >> clkIdx) & 0x01) { ++ /* Enable the interface clock of the peripheral */ ++ int_clk_status = CLK_Enable(BPWR_Clks[clkIdx].intClk); ++ /* Enable the functional clock of the periphearl */ ++ fun_clk_status = CLK_Enable(BPWR_Clks[clkIdx].funClk); ++ } ++ } ++ if ((int_clk_status | fun_clk_status) != DSP_SOK) ++ return DSP_EFAIL; ++ return DSP_SOK; ++} ++ ++void DSPClkWakeupEventCtrl(u32 ClkId, bool enable) ++{ ++ struct CFG_HOSTRES resources; ++ DSP_STATUS status = DSP_SOK; ++ u32 iva2_grpsel; ++ u32 mpu_grpsel; ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ if (DSP_FAILED(status)) ++ return; ++ ++ switch (ClkId) { ++ case BPWR_GPTimer5: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_GPT5; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_GPT5; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_GPT5; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_GPT5; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_GPTimer6: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_GPT6; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_GPT6; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_GPT6; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_GPT6; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_GPTimer7: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_GPT7; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_GPT7; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_GPT7; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_GPT7; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_GPTimer8: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_GPT8; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_GPT8; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_GPT8; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_GPT8; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_MCBSP1: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCorePmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCorePmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_MCBSP1; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_MCBSP1; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_MCBSP1; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_MCBSP1; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwCorePmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwCorePmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_MCBSP2: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_MCBSP2; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_MCBSP2; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_MCBSP2; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_MCBSP2; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_MCBSP3: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_MCBSP3; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_MCBSP3; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_MCBSP3; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_MCBSP3; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_MCBSP4: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwPerPmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_MCBSP4; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_MCBSP4; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_MCBSP4; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_MCBSP4; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwPerPmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ case BPWR_MCBSP5: ++ iva2_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCorePmBase) + 0xA8)); ++ mpu_grpsel = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCorePmBase) + 0xA4)); ++ if (enable) { ++ iva2_grpsel |= OMAP3430_GRPSEL_MCBSP5; ++ mpu_grpsel &= ~OMAP3430_GRPSEL_MCBSP5; ++ } else { ++ mpu_grpsel |= OMAP3430_GRPSEL_MCBSP5; ++ iva2_grpsel &= ~OMAP3430_GRPSEL_MCBSP5; ++ } ++ *((REG_UWORD32 *) ((u32) (resources.dwCorePmBase) + 0xA8)) ++ = iva2_grpsel; ++ *((REG_UWORD32 *) ((u32) (resources.dwCorePmBase) + 0xA4)) ++ = mpu_grpsel; ++ break; ++ } ++} +diff --git a/drivers/dsp/bridge/wmd/tiomap_io.c b/drivers/dsp/bridge/wmd/tiomap_io.c +new file mode 100644 +index 0000000..6121e8f +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/tiomap_io.c +@@ -0,0 +1,427 @@ ++/* ++ * tiomap_io.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _tiomap_io.c ======== ++ * Description: ++ * Implementation for the io read/write routines. ++ * ++ *! Revision History ++ *! ================ ++ *! 16-Feb-2004 vp: Fixed warning in WriteDspData function. ++ *! 16-Apr-2003 vp: Added support for TC word swap ++ *! 26-Feb-2003 vp: Fixed issue with EXT_BEG and EXT_END address. ++ *! 24-Feb-2003 vp: Ported to Linux platform ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/drv.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/mem.h> ++#include <dspbridge/util.h> ++#include <dspbridge/cfg.h> ++ ++/* ----------------------------------- specific to this file */ ++#include "_tiomap.h" ++#include "_tiomap_pwr.h" ++#include "tiomap_io.h" ++ ++static u32 ulExtBase; ++static u32 ulExtEnd; ++ ++static u32 ulShm0End; ++static u32 ulDynExtBase; ++static u32 ulTraceSecBeg; ++static u32 ulTraceSecEnd; ++static u32 ulShmBaseVirt; ++ ++bool bSymbolsReloaded = true; ++ ++/* ++ * ======== ReadExtDspData ======== ++ * Copies DSP external memory buffers to the host side buffers. ++ */ ++DSP_STATUS ReadExtDspData(struct WMD_DEV_CONTEXT *hDevContext, ++ OUT u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct WMD_DEV_CONTEXT *pDevContext = hDevContext; ++ u32 offset; ++ u32 ulTLBBaseVirt = 0; ++ u32 ulShmOffsetVirt = 0; ++ u32 dwExtProgVirtMem; ++ u32 dwBaseAddr = pDevContext->dwDspExtBaseAddr; ++ bool bTraceRead = false; ++ ++ DBG_Trace(DBG_ENTER, "ReadExtDspData," ++ "hDevContext: 0x%x\n\t\tpbHostBuf: 0x%x" ++ "\n\t\tdwDSPAddr: 0x%x\n\t\tulNumBytes: 0x%x\n\t\t" ++ "ulMemType: 0x%x\n", pDevContext, pbHostBuf, dwDSPAddr, ++ ulNumBytes, ulMemType); ++ ++ if (!ulShmBaseVirt) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ SHMBASENAME, &ulShmBaseVirt); ++ } ++ DBC_Assert(ulShmBaseVirt != 0); ++ ++ /* Check if it is a read of Trace section */ ++ if (!ulTraceSecBeg) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ DSP_TRACESEC_BEG, &ulTraceSecBeg); ++ } ++ DBC_Assert(ulTraceSecBeg != 0); ++ ++ if (DSP_SUCCEEDED(status) && !ulTraceSecEnd) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ DSP_TRACESEC_END, &ulTraceSecEnd); ++ } ++ DBC_Assert(ulTraceSecEnd != 0); ++ ++ if (DSP_SUCCEEDED(status)) { ++ if ((dwDSPAddr <= ulTraceSecEnd) && ++ (dwDSPAddr >= ulTraceSecBeg)) { ++ DBG_Trace(DBG_LEVEL5, "Reading from DSP Trace" ++ "section 0x%x \n", dwDSPAddr); ++ bTraceRead = true; ++ } ++ } ++ ++ /* If reading from TRACE, force remap/unmap */ ++ if ((bTraceRead) && dwBaseAddr) { ++ dwBaseAddr = 0; ++ pDevContext->dwDspExtBaseAddr = 0; ++ } ++ ++ if (!dwBaseAddr) { ++ /* Initialize ulExtBase and ulExtEnd */ ++ ulExtBase = 0; ++ ulExtEnd = 0; ++ ++ /* Get DYNEXT_BEG, EXT_BEG and EXT_END.*/ ++ if (DSP_SUCCEEDED(status) && !ulDynExtBase) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ DYNEXTBASE, &ulDynExtBase); ++ } ++ DBC_Assert(ulDynExtBase != 0); ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ EXTBASE, &ulExtBase); ++ } ++ DBC_Assert(ulExtBase != 0); ++ ++ if (DSP_SUCCEEDED(status)) { ++ status = DEV_GetSymbol(pDevContext->hDevObject, ++ EXTEND, &ulExtEnd); ++ } ++ DBC_Assert(ulExtEnd != 0); ++ ++ /* Trace buffer is right after the SHM SEG0, ++ * so set the base address to SHMBASE */ ++ if (bTraceRead) { ++ ulExtBase = ulShmBaseVirt; ++ ulExtEnd = ulTraceSecEnd; ++ } ++ ++ DBC_Assert(ulExtEnd != 0); ++ DBC_Assert(ulExtEnd > ulExtBase); ++ ++ if (ulExtEnd < ulExtBase) ++ status = DSP_EFAIL; ++ ++ if (DSP_SUCCEEDED(status)) { ++ ulTLBBaseVirt = ++ pDevContext->aTLBEntry[0].ulDspVa * DSPWORDSIZE; ++ DBC_Assert(ulTLBBaseVirt <= ulShmBaseVirt); ++ dwExtProgVirtMem = pDevContext->aTLBEntry[0].ulGppVa; ++ ++ if (bTraceRead) { ++ DBG_Trace(DBG_LEVEL7, "ReadExtDspData: " ++ "GPP VA pointing to SHMMEMBASE 0x%x \n", ++ dwExtProgVirtMem); ++ } else { ++ ulShmOffsetVirt = ulShmBaseVirt - ulTLBBaseVirt; ++ ulShmOffsetVirt += PG_ALIGN_HIGH(ulExtEnd - ++ ulDynExtBase + 1, ++ HW_PAGE_SIZE_64KB); ++ dwExtProgVirtMem -= ulShmOffsetVirt; ++ dwExtProgVirtMem += (ulExtBase - ulDynExtBase); ++ DBG_Trace(DBG_LEVEL7, "ReadExtDspData: " ++ "GPP VA pointing to EXTMEMBASE 0x%x \n", ++ dwExtProgVirtMem); ++ pDevContext->dwDspExtBaseAddr = ++ dwExtProgVirtMem; ++ ++ /* This dwDspExtBaseAddr will get cleared only when the board is ++ * stopped. */ ++ if (!pDevContext->dwDspExtBaseAddr) { ++ status = DSP_EFAIL; ++ DBG_Trace(DBG_LEVEL7, "ReadExtDspData: " ++ "failed to Map the program memory\n"); ++ } ++ } ++ ++ dwBaseAddr = dwExtProgVirtMem; ++ } ++ } ++ ++ if (!dwBaseAddr || !ulExtBase || !ulExtEnd) { ++ DBG_Trace(DBG_LEVEL7, ++ "Symbols missing for Ext Prog reading \n"); ++ status = DSP_EFAIL; ++ } ++ ++ offset = dwDSPAddr - ulExtBase; ++ ++ if (DSP_SUCCEEDED(status)) ++ memcpy(pbHostBuf, (u8 *)dwBaseAddr+offset, ulNumBytes); ++ ++ return status; ++} ++/* ++ * ======== WriteDspData ======== ++ * purpose: ++ * Copies buffers to the DSP internal/external memory. ++ */ ++DSP_STATUS WriteDspData(struct WMD_DEV_CONTEXT *hDevContext, IN u8 *pbHostBuf, ++ u32 dwDSPAddr, u32 ulNumBytes, u32 ulMemType) ++{ ++ u32 offset; ++ u32 dwBaseAddr = hDevContext->dwDspBaseAddr; ++ struct CFG_HOSTRES resources; ++ DSP_STATUS status; ++ u32 base1, base2, base3; ++ base1 = OMAP_DSP_MEM1_SIZE; ++ base2 = OMAP_DSP_MEM2_BASE - OMAP_DSP_MEM1_BASE; ++ base3 = OMAP_DSP_MEM3_BASE - OMAP_DSP_MEM1_BASE; ++ DBG_Trace(DBG_ENTER, "Entered WriteDspData \n"); ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ ++ offset = dwDSPAddr - hDevContext->dwDSPStartAdd; ++ if (offset < base1) { ++ dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[2], ++ resources.dwMemLength[2]); ++ } else if (offset > base1 && offset < base2+OMAP_DSP_MEM2_SIZE) { ++ dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[3], ++ resources.dwMemLength[3]); ++ offset = offset - base2; ++ } else if (offset >= base2+OMAP_DSP_MEM2_SIZE && ++ offset < base3 + OMAP_DSP_MEM3_SIZE) { ++ dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[4], ++ resources.dwMemLength[4]); ++ offset = offset - base3; ++ } else{ ++ status = DSP_EFAIL; ++ return status; ++ } ++ if (ulNumBytes) ++ memcpy((u8 *) (dwBaseAddr+offset), pbHostBuf, ulNumBytes); ++ else ++ *((u32 *) pbHostBuf) = dwBaseAddr+offset; ++ ++ return status; ++} ++ ++/* ++ * ======== WriteExtDspData ======== ++ * purpose: ++ * Copies buffers to the external memory. ++ * ++ */ ++DSP_STATUS WriteExtDspData(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u8 *pbHostBuf, u32 dwDSPAddr, u32 ulNumBytes, ++ u32 ulMemType, bool bDynamicLoad) ++{ ++ u32 dwBaseAddr = pDevContext->dwDspExtBaseAddr; ++ u32 dwOffset = 0; ++ u8 bTempByte1, bTempByte2; ++ u8 remainByte[4]; ++ s32 i; ++ DSP_STATUS retVal = DSP_SOK; ++ u32 dwExtProgVirtMem; ++ u32 ulTLBBaseVirt = 0; ++ u32 ulShmOffsetVirt = 0; ++ struct CFG_HOSTRES hostRes; ++ bool bTraceLoad = false; ++ bTempByte1 = 0x0; ++ bTempByte2 = 0x0; ++ ++ DBG_Trace(DBG_ENTER, "Entered WriteExtDspData dwDSPAddr 0x%x " ++ "ulNumBytes 0x%x \n", dwDSPAddr, ulNumBytes); ++ if (bSymbolsReloaded) { ++ /* Check if it is a load to Trace section */ ++ retVal = DEV_GetSymbol(pDevContext->hDevObject, ++ DSP_TRACESEC_BEG, &ulTraceSecBeg); ++ if (DSP_SUCCEEDED(retVal)) ++ retVal = DEV_GetSymbol(pDevContext->hDevObject, ++ DSP_TRACESEC_END, &ulTraceSecEnd); ++ } ++ if (DSP_SUCCEEDED(retVal)) { ++ if ((dwDSPAddr <= ulTraceSecEnd) && ++ (dwDSPAddr >= ulTraceSecBeg)) { ++ DBG_Trace(DBG_LEVEL5, "Writing to DSP Trace " ++ "section 0x%x \n", dwDSPAddr); ++ bTraceLoad = true; ++ } ++ } ++ ++ /* If dynamic, force remap/unmap */ ++ if ((bDynamicLoad || bTraceLoad) && dwBaseAddr) { ++ dwBaseAddr = 0; ++ MEM_UnmapLinearAddress((void *)pDevContext->dwDspExtBaseAddr); ++ pDevContext->dwDspExtBaseAddr = 0x0; ++ } ++ if (!dwBaseAddr) { ++ if (bSymbolsReloaded) ++ /* Get SHM_BEG EXT_BEG and EXT_END. */ ++ retVal = DEV_GetSymbol(pDevContext->hDevObject, ++ SHMBASENAME, &ulShmBaseVirt); ++ DBC_Assert(ulShmBaseVirt != 0); ++ if (bDynamicLoad) { ++ if (DSP_SUCCEEDED(retVal)) { ++ if (bSymbolsReloaded) ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, DYNEXTBASE, ++ &ulExtBase); ++ } ++ DBC_Assert(ulExtBase != 0); ++ if (DSP_SUCCEEDED(retVal)) { ++ /* DR OMAPS00013235 : DLModules array may be ++ * in EXTMEM. It is expected that DYNEXTMEM and ++ * EXTMEM are contiguous, so checking for the ++ * upper bound at EXTEND should be Ok. */ ++ if (bSymbolsReloaded) ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, EXTEND, &ulExtEnd); ++ } ++ } else { ++ if (bSymbolsReloaded) { ++ if (DSP_SUCCEEDED(retVal)) ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, EXTBASE, ++ &ulExtBase); ++ DBC_Assert(ulExtBase != 0); ++ if (DSP_SUCCEEDED(retVal)) ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, EXTEND, &ulExtEnd); ++ } ++ } ++ /* Trace buffer it right after the SHM SEG0, so set the ++ * base address to SHMBASE */ ++ if (bTraceLoad) ++ ulExtBase = ulShmBaseVirt; ++ ++ DBC_Assert(ulExtEnd != 0); ++ DBC_Assert(ulExtEnd > ulExtBase); ++ if (ulExtEnd < ulExtBase) ++ retVal = DSP_EFAIL; ++ ++ if (DSP_SUCCEEDED(retVal)) { ++ ulTLBBaseVirt = pDevContext->aTLBEntry[0].ulDspVa * ++ DSPWORDSIZE; ++ DBC_Assert(ulTLBBaseVirt <= ulShmBaseVirt); ++ ++ if (bSymbolsReloaded) { ++ if (DSP_SUCCEEDED(retVal)) { ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, DSP_TRACESEC_END, ++ &ulShm0End); ++ } ++ if (DSP_SUCCEEDED(retVal)) { ++ retVal = DEV_GetSymbol(pDevContext-> ++ hDevObject, DYNEXTBASE, ++ &ulDynExtBase); ++ } ++ } ++ ulShmOffsetVirt = ulShmBaseVirt - ulTLBBaseVirt; ++ if (bTraceLoad) { ++ dwExtProgVirtMem = pDevContext->aTLBEntry[0]. ++ ulGppVa; ++ } else { ++ CFG_GetHostResources( ++ (struct CFG_DEVNODE *) ++ DRV_GetFirstDevExtension(), &hostRes); ++ dwExtProgVirtMem = hostRes.dwMemBase[1]; ++ dwExtProgVirtMem += (ulExtBase - ulDynExtBase); ++ } ++ DBG_Trace(DBG_LEVEL7, "WriteExtDspData: GPP VA " ++ "pointing to EXTMEMBASE 0x%x \n", ++ dwExtProgVirtMem); ++ ++ pDevContext->dwDspExtBaseAddr = ++ (u32)MEM_LinearAddress((void *) ++ TO_VIRTUAL_UNCACHED(dwExtProgVirtMem), ulExtEnd ++ - ulExtBase); ++ dwBaseAddr += pDevContext->dwDspExtBaseAddr; ++ /* This dwDspExtBaseAddr will get cleared only when ++ * the board is stopped. */ ++ if (!pDevContext->dwDspExtBaseAddr) { ++ retVal = DSP_EFAIL; ++ DBG_Trace(DBG_LEVEL7, "WriteExtDspData: failed " ++ "to Map the program memory\n"); ++ } ++ } ++ } ++ if (!dwBaseAddr || !ulExtBase || !ulExtEnd) { ++ DBG_Trace(DBG_LEVEL7, "Symbols missing for Ext Prog loading\n"); ++ retVal = DSP_EFAIL; ++ } ++ if (DSP_SUCCEEDED(retVal)) { ++ for (i = 0; i < 4; i++) ++ remainByte[i] = 0x0; ++ ++ dwOffset = dwDSPAddr - ulExtBase; ++ /* Also make sure the dwDSPAddr is < ulExtEnd */ ++ if (dwDSPAddr > ulExtEnd || dwOffset > dwDSPAddr) { ++ DBG_Trace(DBG_LEVEL7, "We can not load at this address " ++ "dwDSPAddr=0x%x, ulExt/DynBase=0x%x, " ++ "ulExtEnd=0x%x\n", dwDSPAddr, ulExtBase, ++ ulExtEnd); ++ retVal = DSP_EFAIL; ++ } ++ } ++ if (DSP_SUCCEEDED(retVal)) { ++ if (ulNumBytes) ++ memcpy((u8 *) dwBaseAddr + dwOffset, pbHostBuf, ++ ulNumBytes); ++ else ++ *((u32 *) pbHostBuf) = dwBaseAddr+dwOffset; ++ } ++ /* Unmap here to force remap for other Ext loads */ ++ if ((bDynamicLoad || bTraceLoad) && pDevContext->dwDspExtBaseAddr) { ++ MEM_UnmapLinearAddress((void *) pDevContext->dwDspExtBaseAddr); ++ pDevContext->dwDspExtBaseAddr = 0x0; ++ } ++ bSymbolsReloaded = false; ++ return retVal; ++} ++ +diff --git a/drivers/dsp/bridge/wmd/tiomap_io.h b/drivers/dsp/bridge/wmd/tiomap_io.h +new file mode 100644 +index 0000000..84a7553 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/tiomap_io.h +@@ -0,0 +1,112 @@ ++/* ++ * tiomap_io.h ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== _tiomap_io.h ======== ++ * Description: ++ * Definitions, types and function prototypes for the io ++ * (r/w external mem). ++ * ++ *! Revision History ++ *! ================ ++ *! 08-Oct-2002 rr: Created. ++ */ ++ ++#ifndef _TIOMAP_IO_ ++#define _TIOMAP_IO_ ++ ++/* ++ * Symbol that defines beginning of shared memory. ++ * For OMAP (Helen) this is the DSP Virtual base address of SDRAM. ++ * This will be used to program DSP MMU to map DSP Virt to GPP phys. ++ * (see dspMmuTlbEntry()). ++ */ ++#define SHMBASENAME "SHM_BEG" ++#define EXTBASE "EXT_BEG" ++#define EXTEND "_EXT_END" ++#define DYNEXTBASE "_DYNEXT_BEG" ++#define DYNEXTEND "_DYNEXT_END" ++#define IVAEXTMEMBASE "_IVAEXTMEM_BEG" ++#define IVAEXTMEMEND "_IVAEXTMEM_END" ++ ++ ++#define DSP_TRACESEC_BEG "_BRIDGE_TRACE_BEG" ++#define DSP_TRACESEC_END "_BRIDGE_TRACE_END" ++ ++#define SYS_PUTCBEG "_SYS_PUTCBEG" ++#define SYS_PUTCEND "_SYS_PUTCEND" ++#define BRIDGE_SYS_PUTC_current "_BRIDGE_SYS_PUTC_current" ++ ++ ++#define WORDSWAP_ENABLE 0x3 /* Enable word swap */ ++ ++/* ++ * ======== ReadExtDspData ======== ++ * Reads it from DSP External memory. The external memory for the DSP ++ * is configured by the combination of DSP MMU and SHM Memory manager in the CDB ++ */ ++extern DSP_STATUS ReadExtDspData(struct WMD_DEV_CONTEXT *pDevContext, ++ OUT u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType); ++ ++/* ++ * ======== WriteDspData ======== ++ */ ++extern DSP_STATUS WriteDspData(struct WMD_DEV_CONTEXT *pDevContext, ++ OUT u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType); ++ ++/* ++ * ======== WriteExtDspData ======== ++ * Writes to the DSP External memory for external program. ++ * The ext mem for progra is configured by the combination of DSP MMU and ++ * SHM Memory manager in the CDB ++ */ ++extern DSP_STATUS WriteExtDspData(struct WMD_DEV_CONTEXT *pDevContext, ++ IN u8 *pbHostBuf, u32 dwDSPAddr, ++ u32 ulNumBytes, u32 ulMemType, ++ bool bDynamicLoad); ++ ++/* ++ * ======== WriteExt32BitDspData ======== ++ * Writes 32 bit data to the external memory ++ */ ++extern inline void WriteExt32BitDspData(IN const ++ struct WMD_DEV_CONTEXT *pDevContext, IN u32 dwDSPAddr, ++ IN u32 val) ++{ ++ *(u32 *)dwDSPAddr = ((pDevContext->tcWordSwapOn) ? (((val << 16) & ++ 0xFFFF0000) | ((val >> 16) & 0x0000FFFF)) : val); ++} ++ ++/* ++ * ======== ReadExt32BitDspData ======== ++ * Reads 32 bit data from the external memory ++ */ ++extern inline u32 ReadExt32BitDspData(IN const struct WMD_DEV_CONTEXT ++ *pDevContext, IN u32 dwDSPAddr) ++{ ++ u32 retVal; ++ retVal = *(u32 *)dwDSPAddr; ++ ++ retVal = ((pDevContext->tcWordSwapOn) ? (((retVal << 16) ++ & 0xFFFF0000) | ((retVal >> 16) & 0x0000FFFF)) : retVal); ++ return retVal; ++} ++ ++#endif /* _TIOMAP_IO_ */ ++ +diff --git a/drivers/dsp/bridge/wmd/tiomap_sm.c b/drivers/dsp/bridge/wmd/tiomap_sm.c +new file mode 100644 +index 0000000..a6d5d62 +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/tiomap_sm.c +@@ -0,0 +1,195 @@ ++/* ++ * tiomap_sm.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++#include <dspbridge/cfg.h> ++#include <dspbridge/drv.h> ++#include <dspbridge/dev.h> ++ ++#include <dspbridge/dbg.h> ++ ++#include "_tiomap.h" ++#include "_tiomap_pwr.h" ++ ++#define MAILBOX_FIFOSTATUS(m) (0x80 + 4 * (m)) ++ ++static inline unsigned int fifo_full(void __iomem *mbox_base, int mbox_id) ++{ ++ return __raw_readl(mbox_base + MAILBOX_FIFOSTATUS(mbox_id)) & 0x1; ++} ++ ++DSP_STATUS CHNLSM_EnableInterrupt(struct WMD_DEV_CONTEXT *pDevContext) ++{ ++ DSP_STATUS status = DSP_SOK; ++ u32 numMbxMsg; ++ u32 mbxValue; ++ struct CFG_HOSTRES resources; ++ u32 devType; ++ struct IO_MGR *hIOMgr; ++ ++ DBG_Trace(DBG_ENTER, "CHNLSM_EnableInterrupt(0x%x)\n", pDevContext); ++ ++ /* Read the messages in the mailbox until the message queue is empty */ ++ ++ CFG_GetHostResources((struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ DEV_GetDevType(pDevContext->hDevObject, &devType); ++ status = DEV_GetIOMgr(pDevContext->hDevObject, &hIOMgr); ++ if (devType == DSP_UNIT) { ++ HW_MBOX_NumMsgGet(resources.dwMboxBase, ++ MBOX_DSP2ARM, &numMbxMsg); ++ while (numMbxMsg != 0) { ++ HW_MBOX_MsgRead(resources.dwMboxBase, ++ MBOX_DSP2ARM, ++ &mbxValue); ++ numMbxMsg--; ++ } ++ /* clear the DSP mailbox as well...*/ ++ HW_MBOX_NumMsgGet(resources.dwMboxBase, ++ MBOX_ARM2DSP, &numMbxMsg); ++ while (numMbxMsg != 0) { ++ HW_MBOX_MsgRead(resources.dwMboxBase, ++ MBOX_ARM2DSP, &mbxValue); ++ numMbxMsg--; ++ udelay(10); ++ ++ HW_MBOX_EventAck(resources.dwMboxBase, MBOX_ARM2DSP, ++ HW_MBOX_U1_DSP1, ++ HW_MBOX_INT_NEW_MSG); ++ } ++ /* Enable the new message events on this IRQ line */ ++ HW_MBOX_EventEnable(resources.dwMboxBase, ++ MBOX_DSP2ARM, ++ MBOX_ARM, ++ HW_MBOX_INT_NEW_MSG); ++ } ++ ++ return status; ++} ++ ++DSP_STATUS CHNLSM_DisableInterrupt(struct WMD_DEV_CONTEXT *pDevContext) ++{ ++ struct CFG_HOSTRES resources; ++ ++ DBG_Trace(DBG_ENTER, "CHNLSM_DisableInterrupt(0x%x)\n", pDevContext); ++ ++ CFG_GetHostResources((struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ HW_MBOX_EventDisable(resources.dwMboxBase, MBOX_DSP2ARM, ++ MBOX_ARM, HW_MBOX_INT_NEW_MSG); ++ return DSP_SOK; ++} ++ ++DSP_STATUS CHNLSM_InterruptDSP2(struct WMD_DEV_CONTEXT *pDevContext, ++ u16 wMbVal) ++{ ++#ifdef CONFIG_BRIDGE_DVFS ++ struct dspbridge_platform_data *pdata = ++ omap_dspbridge_dev->dev.platform_data; ++ u32 opplevel = 0; ++#endif ++ struct CFG_HOSTRES resources; ++ DSP_STATUS status = DSP_SOK; ++ unsigned long timeout; ++ u32 temp; ++ ++ status = CFG_GetHostResources((struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ if (DSP_FAILED(status)) ++ return DSP_EFAIL; ++#ifdef CONFIG_BRIDGE_DVFS ++ if (pDevContext->dwBrdState == BRD_DSP_HIBERNATION || ++ pDevContext->dwBrdState == BRD_HIBERNATION) { ++ if (pdata->dsp_get_opp) ++ opplevel = (*pdata->dsp_get_opp)(); ++ if (opplevel == 1) { ++ if (pdata->dsp_set_min_opp) ++ (*pdata->dsp_set_min_opp)(opplevel+1); ++ } ++ } ++#endif ++ ++ if (pDevContext->dwBrdState == BRD_DSP_HIBERNATION || ++ pDevContext->dwBrdState == BRD_HIBERNATION) { ++ /* Restore mailbox settings */ ++ /* Restart the peripheral clocks that were disabled only ++ * in DSP initiated Hibernation case.*/ ++ if (pDevContext->dwBrdState == BRD_DSP_HIBERNATION) { ++ DSP_PeripheralClocks_Enable(pDevContext, NULL); ++ /* Enabling Dpll in lock mode*/ ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x34)); ++ temp = (temp & 0xFFFFFFFE) | 0x1; ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x34)) = ++ (u32) temp; ++ temp = (u32) *((REG_UWORD32 *) ++ ((u32) (resources.dwCmBase) + 0x4)); ++ temp = (temp & 0xFFFFFC8) | 0x37; ++ ++ *((REG_UWORD32 *) ((u32) (resources.dwCmBase) + 0x4)) = ++ (u32) temp; ++ } ++ HW_MBOX_restoreSettings(resources.dwMboxBase); ++ ++ /* Access MMU SYS CONFIG register to generate a short wakeup */ ++ temp = (u32) *((REG_UWORD32 *) ((u32) ++ (resources.dwDmmuBase) + 0x10)); ++ ++ pDevContext->dwBrdState = BRD_RUNNING; ++ } ++ timeout = jiffies + msecs_to_jiffies(1); ++ while (fifo_full((void __iomem *) resources.dwMboxBase, 0)) { ++ if (time_after(jiffies, timeout)) { ++ printk(KERN_ERR "dspbridge: timed out waiting for mailbox\n"); ++ return WMD_E_TIMEOUT; ++ } ++ } ++ DBG_Trace(DBG_LEVEL3, "writing %x to Mailbox\n", ++ wMbVal); ++ ++ HW_MBOX_MsgWrite(resources.dwMboxBase, MBOX_ARM2DSP, ++ wMbVal); ++ return DSP_SOK; ++} ++ ++bool CHNLSM_ISR(struct WMD_DEV_CONTEXT *pDevContext, bool *pfSchedDPC, ++ u16 *pwIntrVal) ++{ ++ struct CFG_HOSTRES resources; ++ u32 numMbxMsg; ++ u32 mbxValue; ++ ++ DBG_Trace(DBG_ENTER, "CHNLSM_ISR(0x%x)\n", pDevContext); ++ ++ CFG_GetHostResources((struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources); ++ ++ HW_MBOX_NumMsgGet(resources.dwMboxBase, MBOX_DSP2ARM, &numMbxMsg); ++ ++ if (numMbxMsg > 0) { ++ HW_MBOX_MsgRead(resources.dwMboxBase, MBOX_DSP2ARM, &mbxValue); ++ ++ HW_MBOX_EventAck(resources.dwMboxBase, MBOX_DSP2ARM, ++ HW_MBOX_U0_ARM, HW_MBOX_INT_NEW_MSG); ++ ++ DBG_Trace(DBG_LEVEL3, "Read %x from Mailbox\n", mbxValue); ++ *pwIntrVal = (u16) mbxValue; ++ } ++ /* Set *pfSchedDPC to true; */ ++ *pfSchedDPC = true; ++ return true; ++} +diff --git a/drivers/dsp/bridge/wmd/ue_deh.c b/drivers/dsp/bridge/wmd/ue_deh.c +new file mode 100644 +index 0000000..d5551cb +--- /dev/null ++++ b/drivers/dsp/bridge/wmd/ue_deh.c +@@ -0,0 +1,329 @@ ++/* ++ * ue_deh.c ++ * ++ * DSP-BIOS Bridge driver support functions for TI OMAP processors. ++ * ++ * Copyright (C) 2005-2006 Texas Instruments, Inc. ++ * ++ * This package is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ++ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ++ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ++ */ ++ ++ ++/* ++ * ======== ue_deh.c ======== ++ * Description: ++ * Implements upper edge DSP exception handling (DEH) functions. ++ * ++ *! Revision History: ++ *! ================ ++ *! 03-Jan-2005 hn: Support for IVA DEH. ++ *! 05-Jan-2004 vp: Updated for the 24xx HW library. ++ *! 19-Feb-2003 vp: Code review updates. ++ *! - Cosmetic changes. ++ *! 18-Oct-2002 sb: Ported to Linux platform. ++ *! 10-Dec-2001 kc: Updated DSP error reporting in DEBUG mode. ++ *! 10-Sep-2001 kc: created. ++ */ ++ ++/* ----------------------------------- Host OS */ ++#include <dspbridge/host_os.h> ++ ++/* ----------------------------------- DSP/BIOS Bridge */ ++#include <dspbridge/std.h> ++#include <dspbridge/dbdefs.h> ++#include <dspbridge/errbase.h> ++ ++/* ----------------------------------- Trace & Debug */ ++#include <dspbridge/dbc.h> ++#include <dspbridge/dbg.h> ++ ++/* ----------------------------------- OS Adaptation Layer */ ++#include <dspbridge/csl.h> ++#include <dspbridge/cfg.h> ++#include <dspbridge/dpc.h> ++#include <dspbridge/mem.h> ++#include <dspbridge/ntfy.h> ++#include <dspbridge/drv.h> ++ ++/* ----------------------------------- Link Driver */ ++#include <dspbridge/wmddeh.h> ++ ++/* ----------------------------------- Platform Manager */ ++#include <dspbridge/dev.h> ++#include <dspbridge/wcd.h> ++ ++/* ------------------------------------ Hardware Abstraction Layer */ ++#include <hw_defs.h> ++#include <hw_mmu.h> ++ ++/* ----------------------------------- This */ ++#include "mmu_fault.h" ++#include "_tiomap.h" ++#include "_deh.h" ++#include "_tiomap_mmu.h" ++#include "_tiomap_pwr.h" ++#include <dspbridge/io_sm.h> ++ ++static struct HW_MMUMapAttrs_t mapAttrs = { HW_LITTLE_ENDIAN, ++ HW_ELEM_SIZE_16BIT, ++ HW_MMU_CPUES} ; ++#define VirtToPhys(x) ((x) - PAGE_OFFSET + PHYS_OFFSET) ++/* ++ * ======== WMD_DEH_Create ======== ++ * Creates DEH manager object. ++ */ ++DSP_STATUS WMD_DEH_Create(OUT struct DEH_MGR **phDehMgr, ++ struct DEV_OBJECT *hDevObject) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEH_MGR *pDehMgr = NULL; ++ struct CFG_HOSTRES cfgHostRes; ++ struct CFG_DEVNODE *hDevNode; ++ struct WMD_DEV_CONTEXT *hWmdContext = NULL; ++ ++ DBG_Trace(DBG_LEVEL1, "Entering DEH_Create: 0x%x\n", phDehMgr); ++ /* Message manager will be created when a file is loaded, since ++ * size of message buffer in shared memory is configurable in ++ * the base image. */ ++ /* Get WMD context info. */ ++ DEV_GetWMDContext(hDevObject, &hWmdContext); ++ DBC_Assert(hWmdContext); ++ /* Allocate IO manager object: */ ++ MEM_AllocObject(pDehMgr, struct DEH_MGR, SIGNATURE); ++ if (pDehMgr == NULL) { ++ status = DSP_EMEMORY; ++ } else { ++ /* Create an NTFY object to manage notifications */ ++ if (DSP_SUCCEEDED(status)) ++ status = NTFY_Create(&pDehMgr->hNtfy); ++ ++ /* Create a DPC object. */ ++ status = DPC_Create(&pDehMgr->hMmuFaultDpc, MMU_FaultDpc, ++ (void *)pDehMgr); ++ if (DSP_SUCCEEDED(status)) ++ status = DEV_GetDevNode(hDevObject, &hDevNode); ++ ++ if (DSP_SUCCEEDED(status)) ++ status = CFG_GetHostResources(hDevNode, &cfgHostRes); ++ ++ if (DSP_SUCCEEDED(status)) { ++ /* Fill in context structure */ ++ pDehMgr->hWmdContext = hWmdContext; ++ pDehMgr->errInfo.dwErrMask = 0L; ++ pDehMgr->errInfo.dwVal1 = 0L; ++ pDehMgr->errInfo.dwVal2 = 0L; ++ pDehMgr->errInfo.dwVal3 = 0L; ++ /* Install ISR function for DSP MMU fault */ ++ if ((request_irq(INT_DSP_MMU_IRQ, MMU_FaultIsr, 0, ++ "DspBridge\tiommu fault", (void *)pDehMgr)) == 0) ++ status = DSP_SOK; ++ else ++ status = DSP_EFAIL; ++ } ++ } ++ if (DSP_FAILED(status)) { ++ /* If create failed, cleanup */ ++ WMD_DEH_Destroy((struct DEH_MGR *)pDehMgr); ++ *phDehMgr = NULL; ++ } else { ++ *phDehMgr = (struct DEH_MGR *)pDehMgr; ++ DBG_Trace(DBG_LEVEL1, "ISR_IRQ Object 0x%x \n", ++ pDehMgr); ++ } ++ DBG_Trace(DBG_LEVEL1, "Exiting DEH_Create.\n"); ++ return status; ++} ++ ++/* ++ * ======== WMD_DEH_Destroy ======== ++ * Destroys DEH manager object. ++ */ ++DSP_STATUS WMD_DEH_Destroy(struct DEH_MGR *hDehMgr) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)hDehMgr; ++ ++ DBG_Trace(DBG_LEVEL1, "Entering DEH_Destroy: 0x%x\n", pDehMgr); ++ if (MEM_IsValidHandle(pDehMgr, SIGNATURE)) { ++ /* If notification object exists, delete it */ ++ if (pDehMgr->hNtfy) ++ (void)NTFY_Delete(pDehMgr->hNtfy); ++ /* Disable DSP MMU fault */ ++ free_irq(INT_DSP_MMU_IRQ, pDehMgr); ++ (void)DPC_Destroy(pDehMgr->hMmuFaultDpc); ++ /* Deallocate the DEH manager object */ ++ MEM_FreeObject(pDehMgr); ++ } ++ DBG_Trace(DBG_LEVEL1, "Exiting DEH_Destroy.\n"); ++ return status; ++} ++ ++/* ++ * ======== WMD_DEH_RegisterNotify ======== ++ * Registers for DEH notifications. ++ */ ++DSP_STATUS WMD_DEH_RegisterNotify(struct DEH_MGR *hDehMgr, u32 uEventMask, ++ u32 uNotifyType, ++ struct DSP_NOTIFICATION *hNotification) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)hDehMgr; ++ ++ DBG_Trace(DBG_LEVEL1, "Entering WMD_DEH_RegisterNotify: 0x%x\n", ++ pDehMgr); ++ ++ if (MEM_IsValidHandle(pDehMgr, SIGNATURE)) { ++ status = NTFY_Register(pDehMgr->hNtfy, hNotification, ++ uEventMask, uNotifyType); ++ } ++ DBG_Trace(DBG_LEVEL1, "Exiting WMD_DEH_RegisterNotify.\n"); ++ return status; ++} ++ ++ ++/* ++ * ======== WMD_DEH_Notify ======== ++ * DEH error notification function. Informs user about the error. ++ */ ++void WMD_DEH_Notify(struct DEH_MGR *hDehMgr, u32 ulEventMask, ++ u32 dwErrInfo) ++{ ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)hDehMgr; ++ struct WMD_DEV_CONTEXT *pDevContext; ++ DSP_STATUS status = DSP_SOK; ++ u32 memPhysical = 0; ++ u32 HW_MMU_MAX_TLB_COUNT = 31; ++ u32 extern faultAddr; ++ struct CFG_HOSTRES resources; ++ u32 dummyVaAddr; ++ HW_STATUS hwStatus; ++ ++ status = CFG_GetHostResources( ++ (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), ++ &resources); ++ if (DSP_FAILED(status)) ++ DBG_Trace(DBG_LEVEL7, ++ "**Failed to get Host Resources in MMU ISR **\n"); ++ ++ DBG_Trace(DBG_LEVEL1, "Entering WMD_DEH_Notify: 0x%x, 0x%x\n", pDehMgr, ++ ulEventMask); ++ if (MEM_IsValidHandle(pDehMgr, SIGNATURE)) { ++ printk(KERN_INFO "WMD_DEH_Notify: ********** DEVICE EXCEPTION " ++ "**********\n"); ++ pDevContext = (struct WMD_DEV_CONTEXT *)pDehMgr->hWmdContext; ++ ++ switch (ulEventMask) { ++ case DSP_SYSERROR: ++ /* reset errInfo structure before use */ ++ pDehMgr->errInfo.dwErrMask = DSP_SYSERROR; ++ pDehMgr->errInfo.dwVal1 = 0L; ++ pDehMgr->errInfo.dwVal2 = 0L; ++ pDehMgr->errInfo.dwVal3 = 0L; ++ pDehMgr->errInfo.dwVal1 = dwErrInfo; ++ printk(KERN_ERR "WMD_DEH_Notify: DSP_SYSERROR, errInfo " ++ "= 0x%x\n", dwErrInfo); ++ break; ++ case DSP_MMUFAULT: ++ /* MMU fault routine should have set err info ++ * structure */ ++ pDehMgr->errInfo.dwErrMask = DSP_MMUFAULT; ++ printk(KERN_INFO "WMD_DEH_Notify: DSP_MMUFAULT," ++ "errInfo = 0x%x\n", dwErrInfo); ++ printk(KERN_INFO "WMD_DEH_Notify: DSP_MMUFAULT, High " ++ "Address = 0x%x\n", ++ (unsigned int)pDehMgr->errInfo.dwVal1); ++ printk(KERN_INFO "WMD_DEH_Notify: DSP_MMUFAULT, Low " ++ "Address = 0x%x\n", ++ (unsigned int)pDehMgr->errInfo.dwVal2); ++ printk(KERN_INFO "WMD_DEH_Notify: DSP_MMUFAULT, fault " ++ "address = 0x%x\n", (unsigned int)faultAddr); ++ dummyVaAddr = (u32)MEM_Calloc(sizeof(char) * 0x1000, ++ MEM_PAGED); ++ memPhysical = (u32)MEM_Calloc(sizeof(char) * 0x1000, ++ MEM_PAGED); ++ dummyVaAddr = PG_ALIGN_LOW((u32)dummyVaAddr, ++ PG_SIZE_4K); ++ memPhysical = VirtToPhys(dummyVaAddr); ++ DBG_Trace(DBG_LEVEL6, "WMD_DEH_Notify: DSP_MMUFAULT, " ++ "mem Physical= 0x%x\n", memPhysical); ++ pDevContext = (struct WMD_DEV_CONTEXT *) ++ pDehMgr->hWmdContext; ++ /* Reset the dynamic mmu index to fixed count if it ++ * exceeds 31. So that the dynmmuindex is always ++ * between the range of standard/fixed entries ++ * and 31. */ ++ if (pDevContext->numTLBEntries > ++ HW_MMU_MAX_TLB_COUNT) { ++ pDevContext->numTLBEntries = pDevContext-> ++ fixedTLBEntries; ++ } ++ DBG_Trace(DBG_LEVEL6, "Adding TLB Entry %d: VA: 0x%x, " ++ "PA: 0x%x\n", pDevContext-> ++ numTLBEntries, faultAddr, memPhysical); ++ if (DSP_SUCCEEDED(status)) { ++ hwStatus = HW_MMU_TLBAdd(resources.dwDmmuBase, ++ memPhysical, faultAddr, ++ HW_PAGE_SIZE_4KB, 1, &mapAttrs, ++ HW_SET, HW_SET); ++ } ++ /* send an interrupt to DSP */ ++ HW_MBOX_MsgWrite(resources.dwMboxBase, MBOX_ARM2DSP, ++ MBX_DEH_CLASS | MBX_DEH_EMMU); ++ /* Clear MMU interrupt */ ++ HW_MMU_EventAck(resources.dwDmmuBase, ++ HW_MMU_TRANSLATION_FAULT); ++ break; ++ default: ++ DBG_Trace(DBG_LEVEL6, ++ "WMD_DEH_Notify: Unknown Error, errInfo = " ++ "0x%x\n", dwErrInfo); ++ break; ++ } ++ /* Set the Board state as ERROR */ ++ pDevContext->dwBrdState = BRD_ERROR; ++ /* Disable all the clocks that were enabled by DSP */ ++ (void)DSP_PeripheralClocks_Disable(pDevContext, NULL); ++ /* Call DSP Trace Buffer */ ++ PrintDspTraceBuffer(hDehMgr->hWmdContext); ++ ++ /* Signal DSP error/exception event. */ ++ NTFY_Notify(pDehMgr->hNtfy, ulEventMask); ++ } ++ DBG_Trace(DBG_LEVEL1, "Exiting WMD_DEH_Notify\n"); ++ ++} ++ ++/* ++ * ======== WMD_DEH_GetInfo ======== ++ * Retrieves error information. ++ */ ++DSP_STATUS WMD_DEH_GetInfo(struct DEH_MGR *hDehMgr, ++ struct DSP_ERRORINFO *pErrInfo) ++{ ++ DSP_STATUS status = DSP_SOK; ++ struct DEH_MGR *pDehMgr = (struct DEH_MGR *)hDehMgr; ++ ++ DBC_Require(pDehMgr); ++ DBC_Require(pErrInfo); ++ ++ DBG_Trace(DBG_LEVEL1, "Entering WMD_DEH_GetInfo: 0x%x\n", hDehMgr); ++ ++ if (MEM_IsValidHandle(pDehMgr, SIGNATURE)) { ++ /* Copy DEH error info structure to PROC error info ++ * structure. */ ++ pErrInfo->dwErrMask = pDehMgr->errInfo.dwErrMask; ++ pErrInfo->dwVal1 = pDehMgr->errInfo.dwVal1; ++ pErrInfo->dwVal2 = pDehMgr->errInfo.dwVal2; ++ pErrInfo->dwVal3 = pDehMgr->errInfo.dwVal3; ++ } ++ ++ DBG_Trace(DBG_LEVEL1, "Exiting WMD_DEH_GetInfo\n"); ++ ++ return status; ++} +-- +1.5.6.3 + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-blank-rotate-accessible-by-user.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-blank-rotate-accessible-by-user.patch new file mode 100644 index 0000000000..d75f15d00a --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-blank-rotate-accessible-by-user.patch @@ -0,0 +1,20 @@ +--- a/drivers/video/fbsysfs.c 2009-07-17 12:23:16.000000000 -0700 ++++ b/drivers/video/fbsysfs.c 2009-07-17 12:24:32.000000000 -0700 +@@ -489,7 +489,7 @@ + * fbdev to use configfs instead of sysfs */ + static struct device_attribute device_attrs[] = { + __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp), +- __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank), ++ __ATTR(blank, S_IRUGO|S_IWUGO, show_blank, store_blank), + __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console), + __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor), + __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode), +@@ -498,7 +498,7 @@ + __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual), + __ATTR(name, S_IRUGO, show_name, NULL), + __ATTR(stride, S_IRUGO, show_stride, NULL), +- __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate), ++ __ATTR(rotate, S_IRUGO|S_IWUGO, show_rotate, store_rotate), + __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate), + #ifdef CONFIG_FB_BACKLIGHT + __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve), diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-export-status.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-export-status.patch new file mode 100644 index 0000000000..eaa78e28c7 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-export-status.patch @@ -0,0 +1,44 @@ +From c78da49092fd206943f77aa9ebc3fa2c1301ac5a Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Thu, 23 Apr 2009 18:19:32 -0700 +Subject: [PATCH] DSS2: Export display status to sysfs + +It is useful to know from userspace if the display has been turned off, +e.g. to toggle display power from userspace. + +Signed-off-by: Tim Yamin <plasm@roo.me.uk> +--- + drivers/video/omap2/omapfb/omapfb-sysfs.c | 10 ++++++++++ + 1 files changed, 10 insertions(+), 0 deletions(-) + +diff --git a/drivers/video/omap2/omapfb/omapfb-sysfs.c b/drivers/video/omap2/omapfb/omapfb-sysfs.c +index 2c88718..28438fb 100644 +--- a/drivers/video/omap2/omapfb/omapfb-sysfs.c ++++ b/drivers/video/omap2/omapfb/omapfb-sysfs.c +@@ -326,6 +326,15 @@ static ssize_t show_virt(struct device *dev, + return snprintf(buf, PAGE_SIZE, "%p\n", ofbi->region.vaddr); + } + ++static ssize_t show_display_state(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ struct fb_info *fbi = dev_get_drvdata(dev); ++ struct omap_display *display = fb2display(fbi); ++ ++ return snprintf(buf, PAGE_SIZE, "%d\n", display->state); ++} ++ + static struct device_attribute omapfb_attrs[] = { + __ATTR(rotate_type, S_IRUGO, show_rotate_type, NULL), + __ATTR(mirror, S_IRUGO | S_IWUSR, show_mirror, store_mirror), +@@ -333,6 +342,7 @@ static struct device_attribute omapfb_attrs[] = { + __ATTR(overlays, S_IRUGO | S_IWUSR, show_overlays, store_overlays), + __ATTR(phys_addr, S_IRUGO, show_phys, NULL), + __ATTR(virt_addr, S_IRUGO, show_virt, NULL), ++ __ATTR(display_state, S_IRUGO, show_display_state, NULL), + }; + + int omapfb_create_sysfs(struct omapfb2_device *fbdev) +-- +1.5.6.3 + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-XY-coordinates-when-rotating.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-XY-coordinates-when-rotating.patch new file mode 100644 index 0000000000..98a82c8a35 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-XY-coordinates-when-rotating.patch @@ -0,0 +1,177 @@ +From a9cc890ffea21fa492678b1755a263120cbddf0e Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Mon, 20 Apr 2009 20:29:11 -0700 +Subject: [PATCH] DSS2: OMAPFB: Translate X/Y coordinates for the video planes when rotating. + +When rotating the video planes, translate the X/Y coordinates such that +a [0,0] from userspace always maps to the correct upper left corner of +the display. This patch assumes that you rotate plane 0 before rotating +plane 1. Patch also corrects the scaling parameters so that the video is +displayed in the correct orientation (vertically, instead of horizontally) +when rotating by 90 / 270 degrees. + +Signed-off-by: Tim Yamin <plasm@roo.me.uk> +--- + drivers/video/omap2/dss/dispc.c | 16 ++++++++++++---- + drivers/video/omap2/dss/overlay.c | 6 ++++++ + drivers/video/omap2/omapfb/omapfb-ioctl.c | 28 ++++++++++++++++++++++++++++ + 3 files changed, 46 insertions(+), 4 deletions(-) + +diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c +index 7e551c2..bece91d 100644 +--- a/drivers/video/omap2/dss/dispc.c ++++ b/drivers/video/omap2/dss/dispc.c +@@ -1580,10 +1580,18 @@ static int _dispc_setup_plane(enum omap_plane plane, + _dispc_set_pic_size(plane, width, height); + + if (plane != OMAP_DSS_GFX) { +- _dispc_set_scaling(plane, width, height, +- out_width, out_height, +- ilace, five_taps, fieldmode); +- _dispc_set_vid_size(plane, out_width, out_height); ++ if (rotation == 1 || rotation == 3) { ++ _dispc_set_scaling(plane, width, height, ++ out_height, out_width, ++ ilace, five_taps, fieldmode); ++ _dispc_set_vid_size(plane, out_height, out_width); ++ } else { ++ _dispc_set_scaling(plane, width, height, ++ out_width, out_height, ++ ilace, five_taps, fieldmode); ++ _dispc_set_vid_size(plane, out_width, out_height); ++ } ++ + _dispc_set_vid_color_conv(plane, cconv); + } + +diff --git a/drivers/video/omap2/dss/overlay.c b/drivers/video/omap2/dss/overlay.c +index c047206..a1a02b5 100644 +--- a/drivers/video/omap2/dss/overlay.c ++++ b/drivers/video/omap2/dss/overlay.c +@@ -344,6 +344,20 @@ + outh = info->out_height; + } + ++ if ((ovl->supported_modes & info->color_mode) == 0) { ++ DSSERR("overlay doesn't support mode %d\n", info->color_mode); ++ return -EINVAL; ++ } ++ ++ if (ovl->id != OMAP_DSS_GFX && (info->rotation == 1 || ++ info->rotation == 3)) { ++ if(outw > dh || outh > dw) ++ return -EINVAL; ++ ++ /* If coordinates are invalid, they will be clipped later... */ ++ return 0; ++ } ++ + if (dw < info->pos_x + outw) { + DSSDBG("check_overlay failed 1: %d < %d + %d\n", + dw, info->pos_x, outw); +@@ -356,11 +370,6 @@ + return -EINVAL; + } + +- if ((ovl->supported_modes & info->color_mode) == 0) { +- DSSERR("overlay doesn't support mode %d\n", info->color_mode); +- return -EINVAL; +- } +- + return 0; + } + +diff --git a/drivers/video/omap2/dss/manager.c b/drivers/video/omap2/dss/manager.c +index 79d8916..b548f62 100644 +--- a/drivers/video/omap2/dss/manager.c ++++ b/drivers/video/omap2/dss/manager.c +@@ -400,7 +400,7 @@ + struct omap_overlay *ovl; + bool ilace = 0; + int outw, outh; +- int r; ++ int r, pos_x = 0, pos_y = 0; + int num_planes_enabled = 0; + + DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name); +@@ -451,11 +451,51 @@ + else + outh = ovl->info.out_height; + ++ if (ovl->id != OMAP_DSS_GFX && ovl->info.rotation != 0) { ++ /* We need to rotate pos_x and pos_y with respect ++ to OMAP_DSS_GFX */ ++ ++ u16 dw, dh; ++ display->get_resolution(display, &dw, &dh); ++ ++ DSSDBG("plane pos was: (%d, %d), %dx%d, scr: %dx%d \n", ovl->info.pos_x, ++ ovl->info.pos_y, outw, outh, dw, dh); ++ ++ switch (ovl->info.rotation) { ++ case 1: ++ pos_y = ovl->info.pos_x; ++ pos_x = dw - ovl->info.pos_y - outh; ++ break; ++ case 2: ++ pos_x = dw - ovl->info.pos_x - outw; ++ pos_y = dh - ovl->info.pos_y - outh; ++ break; ++ case 3: ++ pos_x = ovl->info.pos_y; ++ pos_y = dh - ovl->info.pos_x - outw; ++ break; ++ } ++ ++ /* Check sanity */ ++ if (ovl->info.rotation != 2) { ++ if (dw < pos_x + outh) ++ pos_x = pos_y = 0; ++ else if (dh < pos_y + outw) ++ pos_x = pos_y = 0; ++ } else if ( (dw < ovl->info.pos_x + outw) || (dh < ovl->info.pos_y + outh) ) ++ pos_x = pos_y = 0; ++ ++ DSSDBG("pos_x is %d, pos_y is %d\n", pos_x, pos_y); ++ } else { ++ pos_x = ovl->info.pos_x; ++ pos_y = ovl->info.pos_y; ++ } ++ + r = dispc_setup_plane(ovl->id, ovl->manager->id, + ovl->info.paddr, + ovl->info.screen_width, +- ovl->info.pos_x, +- ovl->info.pos_y, ++ pos_x, ++ pos_y, + ovl->info.width, + ovl->info.height, + outw, +diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c +index 79d8916..b548f62 100644 +--- a/drivers/video/omap2/omapfb/omapfb-main.c ++++ b/drivers/video/omap2/omapfb/omapfb-main.c +@@ -484,22 +484,7 @@ + + if (var->rotate != fbi->var.rotate) { + DBG("rotation changing\n"); +- + ofbi->rotation = var->rotate; +- +- if (abs(var->rotate - fbi->var.rotate) != 2) { +- int tmp; +- DBG("rotate changing 90/270 degrees. " +- "swapping x/y res\n"); +- +- tmp = var->yres; +- var->yres = var->xres; +- var->xres = tmp; +- +- tmp = var->yres_virtual; +- var->yres_virtual = var->xres_virtual; +- var->xres_virtual = tmp; +- } + } + + xres_min = OMAPFB_PLANE_XRES_MIN; diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-scaling-when-rotating.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-scaling-when-rotating.patch new file mode 100644 index 0000000000..7cb8a7d9bf --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/dss2-fix-scaling-when-rotating.patch @@ -0,0 +1,52 @@ +From 19a31ba4e8408ce80a4dbb96af489304c5e8128f Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Fri, 22 May 2009 18:58:33 -0700 +Subject: [PATCH] Fix scaling checks when rotation is 90 or 270 degrees. + +--- + drivers/video/omap2/dss/dispc.c | 25 +++++++++++++++++++------ + 1 files changed, 19 insertions(+), 6 deletions(-) + +diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c +index 088d353..77ca81b 100644 +--- a/drivers/video/omap2/dss/dispc.c ++++ b/drivers/video/omap2/dss/dispc.c +@@ -1508,16 +1508,29 @@ static int _dispc_setup_plane(enum omap_plane plane, + } + } else { + /* video plane */ +- ++ u8 error = 0; + unsigned long fclk = 0; + +- if (out_width < width / maxdownscale || +- out_width > width * 8) +- return -EINVAL; ++ if(rotation == 1 || rotation == 3) ++ { ++ if (out_width < height / maxdownscale || out_width > height * 8) ++ error = 1; ++ ++ if (out_height < width / maxdownscale || out_height > width * 8) ++ error = 1; ++ } else { ++ if (out_width < width / maxdownscale || out_width > width * 8) ++ error = 1; + +- if (out_height < height / maxdownscale || +- out_height > height * 8) ++ if (out_height < height / maxdownscale || out_height > height * 8) ++ error = 1; ++ } ++ ++ if(error != 0) ++ { ++ printk("DSS: Unable to down/up scale video plane\n"); + return -EINVAL; ++ } + + switch (color_mode) { + case OMAP_DSS_COLOR_RGB16: +-- +1.5.6.3 + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/ehci.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/ehci.patch new file mode 100644 index 0000000000..5a8c84471b --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/ehci.patch @@ -0,0 +1,131 @@ +Index: git/arch/arm/mach-omap2/board-omap3beagle.c +=================================================================== +--- git.orig/arch/arm/mach-omap2/board-omap3beagle.c ++++ git/arch/arm/mach-omap2/board-omap3beagle.c +@@ -154,6 +154,7 @@ static int beagle_twl_gpio_setup(struct + * power switch and overcurrent detect + */ + ++#if 0 /* TODO: This needs to be modified to not rely on u-boot */ + gpio_request(gpio + 1, "EHCI_nOC"); + gpio_direction_input(gpio + 1); + +@@ -163,7 +164,7 @@ static int beagle_twl_gpio_setup(struct + + /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */ + gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1; +- ++#endif + return 0; + } + +Index: git/arch/arm/mach-omap2/usb-ehci.c +=================================================================== +--- git.orig/arch/arm/mach-omap2/usb-ehci.c ++++ git/arch/arm/mach-omap2/usb-ehci.c +@@ -147,9 +147,11 @@ static void setup_ehci_io_mux(void) + + void __init usb_ehci_init(void) + { ++#if 0 /* TODO: Setup Pin IO MUX for EHCI - moved this temporarily to U-boot */ + /* Setup Pin IO MUX for EHCI */ + if (cpu_is_omap34xx()) + setup_ehci_io_mux(); ++#endif + + if (platform_device_register(&ehci_device) < 0) { + printk(KERN_ERR "Unable to register HS-USB (EHCI) device\n"); +Index: git/drivers/usb/host/ehci-omap.c +=================================================================== +--- git.orig/drivers/usb/host/ehci-omap.c ++++ git/drivers/usb/host/ehci-omap.c +@@ -48,16 +48,25 @@ + * to get the PHY state machine in working state + */ + #define EXTERNAL_PHY_RESET ++#ifdef CONFIG_MACH_OMAP3_BEAGLE ++#define EXT_PHY_RESET_GPIO_PORT2 (147) ++#else + #define EXT_PHY_RESET_GPIO_PORT1 (57) + #define EXT_PHY_RESET_GPIO_PORT2 (61) ++#endif + #define EXT_PHY_RESET_DELAY (10) + ++#define PHY_STP_PULLUP_ENABLE (0x10) ++#define PHY_STP_PULLUP_DISABLE (0x90) ++ + /* ISSUE2: + * USBHOST supports External charge pump PHYs only + * Use the VBUS from Port1 to power VBUS of Port2 externally + * So use Port2 as the working ULPI port + */ ++#ifndef CONFIG_MACH_OMAP3_BEAGLE + #define VBUS_INTERNAL_CHARGEPUMP_HACK ++#endif + + #endif /* CONFIG_OMAP_EHCI_PHY_MODE */ + +@@ -225,14 +234,43 @@ static int omap_start_ehc(struct platfor + + #ifdef EXTERNAL_PHY_RESET + /* Refer: ISSUE1 */ ++#ifndef CONFIG_MACH_OMAP3_BEAGLE + gpio_request(EXT_PHY_RESET_GPIO_PORT1, "USB1 PHY reset"); + gpio_direction_output(EXT_PHY_RESET_GPIO_PORT1, 0); ++#endif + gpio_request(EXT_PHY_RESET_GPIO_PORT2, "USB2 PHY reset"); + gpio_direction_output(EXT_PHY_RESET_GPIO_PORT2, 0); ++ gpio_set_value(EXT_PHY_RESET_GPIO_PORT2, 0); + /* Hold the PHY in RESET for enough time till DIR is high */ + udelay(EXT_PHY_RESET_DELAY); + #endif + ++ /* ++ * The PHY register 0x7 - Interface Control register is ++ * configured to disable the integrated STP pull-up resistor ++ * used for interface protection. ++ * ++ * May not need to be here. ++ */ ++ omap_writel((0x7 << EHCI_INSNREG05_ULPI_REGADD_SHIFT) |/* interface reg */ ++ (2 << EHCI_INSNREG05_ULPI_OPSEL_SHIFT) |/* Write */ ++ (1 << EHCI_INSNREG05_ULPI_PORTSEL_SHIFT) |/* Port1 */ ++ (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT) |/* Start */ ++ (PHY_STP_PULLUP_DISABLE), ++ EHCI_INSNREG05_ULPI); ++ ++ while (!(omap_readl(EHCI_INSNREG05_ULPI) & (1<<EHCI_INSNREG05_ULPI_CONTROL_SHIFT))); ++ ++ /* Force PHY to HS */ ++ omap_writel((0x4 << EHCI_INSNREG05_ULPI_REGADD_SHIFT) |/* function ctrl */ ++ (2 << EHCI_INSNREG05_ULPI_OPSEL_SHIFT) |/* Write */ ++ (1 << EHCI_INSNREG05_ULPI_PORTSEL_SHIFT) |/* Port1 */ ++ (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT) |/* Start */ ++ (0x40), ++ EHCI_INSNREG05_ULPI); ++ ++ while (!(omap_readl(EHCI_INSNREG05_ULPI) & (1<<EHCI_INSNREG05_ULPI_CONTROL_SHIFT))); ++ + /* Configure TLL for 60Mhz clk for ULPI */ + ehci_clocks->usbtll_fck_clk = clk_get(&dev->dev, USBHOST_TLL_FCLK); + if (IS_ERR(ehci_clocks->usbtll_fck_clk)) +@@ -307,7 +345,9 @@ static int omap_start_ehc(struct platfor + * Hold the PHY in RESET for enough time till PHY is settled and ready + */ + udelay(EXT_PHY_RESET_DELAY); ++#ifndef CONFIG_MACH_OMAP3_BEAGLE + gpio_set_value(EXT_PHY_RESET_GPIO_PORT1, 1); ++#endif + gpio_set_value(EXT_PHY_RESET_GPIO_PORT2, 1); + #endif + +@@ -393,7 +433,9 @@ static void omap_stop_ehc(struct platfor + + + #ifdef EXTERNAL_PHY_RESET ++#ifndef CONFIG_MACH_OMAP3_BEAGLE + gpio_free(EXT_PHY_RESET_GPIO_PORT1); ++#endif + gpio_free(EXT_PHY_RESET_GPIO_PORT2); + #endif + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/logo_linux_clut224.ppm b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/logo_linux_clut224.ppm new file mode 100644 index 0000000000..76b746bf91 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/logo_linux_clut224.ppm @@ -0,0 +1,773 @@ +P3 +171 35 +255 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 +85 85 85 255 255 255 255 255 255 255 255 255 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 204 204 204 255 255 255 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 170 170 170 204 204 204 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 187 187 187 0 0 0 0 0 0 +85 85 85 255 255 255 255 255 255 255 255 255 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 204 204 204 255 255 255 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +119 119 119 0 0 0 0 0 0 34 34 34 221 221 221 255 255 255 68 68 68 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +119 119 119 0 0 0 0 0 0 0 0 0 136 136 136 255 255 255 119 119 119 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 136 136 136 238 238 238 255 255 255 255 255 255 +187 187 187 85 85 85 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 187 187 187 +255 255 255 255 255 255 255 255 255 187 187 187 85 85 85 0 0 0 0 0 0 0 0 0 +0 0 0 17 17 17 153 153 153 255 255 255 255 255 255 255 255 255 238 238 238 255 255 255 +85 85 85 0 0 0 0 0 0 0 0 0 85 85 85 187 187 187 255 255 255 255 255 255 +238 238 238 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 102 102 102 +255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 187 187 187 255 255 255 +255 255 255 255 255 255 68 68 68 0 0 0 119 119 119 187 187 187 255 255 255 255 255 255 +255 255 255 187 187 187 85 85 85 0 0 0 0 0 0 0 0 0 0 0 0 204 204 204 +255 255 255 255 255 255 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 153 153 153 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +119 119 119 0 0 0 0 0 0 85 85 85 238 238 238 255 255 255 51 51 51 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 17 17 17 204 204 204 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 51 51 51 0 0 0 0 0 0 +0 0 0 221 221 221 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +119 119 119 0 0 0 0 0 0 119 119 119 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 204 204 204 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 102 102 102 +255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 187 187 187 255 255 255 +255 255 255 255 255 255 68 68 68 0 0 0 204 204 204 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 51 51 51 0 0 0 0 0 0 0 0 0 204 204 204 +255 255 255 255 255 255 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 153 153 153 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 153 153 153 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 153 153 153 255 255 255 170 170 170 17 17 17 0 0 0 0 0 0 +102 102 102 221 221 221 238 238 238 17 17 17 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 102 102 102 0 0 0 0 0 0 +34 34 34 255 255 255 238 238 238 17 17 17 0 0 0 0 0 0 136 136 136 255 255 255 +85 85 85 0 0 0 34 34 34 255 255 255 221 221 221 102 102 102 0 0 0 0 0 0 +17 17 17 170 170 170 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +119 119 119 255 255 255 119 119 119 68 68 68 255 255 255 221 221 221 0 0 0 187 187 187 +255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 204 204 204 255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 85 85 85 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +255 255 255 255 255 255 255 255 255 221 221 221 119 119 119 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 238 238 238 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 102 102 102 0 0 0 0 0 0 51 51 51 170 170 170 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 +0 0 0 170 170 170 255 255 255 255 255 255 255 255 255 187 187 187 136 136 136 51 51 51 +0 0 0 0 0 0 119 119 119 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 221 221 221 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +68 68 68 255 255 255 187 187 187 153 153 153 255 255 255 255 255 255 85 85 85 238 238 238 +255 255 255 34 34 34 0 0 0 0 0 0 51 51 51 170 170 170 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 85 85 85 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 238 238 238 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 68 68 68 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 +0 0 0 0 0 0 51 51 51 136 136 136 136 136 136 136 136 136 255 255 255 255 255 255 +102 102 102 0 0 0 119 119 119 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 238 238 238 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 238 238 238 221 221 221 238 238 238 255 255 255 255 255 255 204 204 204 255 255 255 +221 221 221 0 0 0 0 0 0 68 68 68 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 85 85 85 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 +119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 17 17 17 0 0 0 0 0 0 +0 0 0 0 0 0 170 170 170 255 255 255 153 153 153 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 170 170 170 255 255 255 136 136 136 +0 0 0 0 0 0 51 51 51 204 204 204 255 255 255 119 119 119 0 0 0 0 0 0 +102 102 102 255 255 255 153 153 153 0 0 0 0 0 0 0 0 0 102 102 102 255 255 255 +204 204 204 0 0 0 51 51 51 255 255 255 204 204 204 85 85 85 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 204 204 204 255 255 255 255 255 255 170 170 170 221 221 221 255 255 255 255 255 255 +153 153 153 0 0 0 0 0 0 170 170 170 255 255 255 136 136 136 0 0 0 0 0 0 +51 51 51 204 204 204 255 255 255 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 85 85 85 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 238 238 238 255 255 255 51 51 51 0 0 0 0 0 0 +119 119 119 238 238 238 119 119 119 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 17 17 17 +238 238 238 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +85 85 85 0 0 0 17 17 17 221 221 221 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 102 102 102 0 0 0 136 136 136 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 204 204 204 0 0 0 +136 136 136 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +136 136 136 0 0 0 0 0 0 119 119 119 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 221 221 221 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 153 153 153 255 255 255 255 255 255 85 85 85 119 119 119 255 255 255 255 255 255 +102 102 102 0 0 0 0 0 0 136 136 136 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 204 204 204 0 0 0 136 136 136 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 204 204 204 0 0 0 +0 0 0 0 0 0 0 0 0 170 170 170 255 255 255 255 255 255 255 255 255 255 255 255 +255 255 255 255 255 255 136 136 136 0 0 0 0 0 0 0 0 0 17 17 17 221 221 221 +255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 68 68 68 255 255 255 238 238 238 34 34 34 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 68 68 68 255 255 255 238 238 238 34 34 34 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 204 204 204 255 255 255 255 255 255 +255 255 255 255 255 255 255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 17 17 17 +238 238 238 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 +85 85 85 0 0 0 0 0 0 17 17 17 136 136 136 255 255 255 255 255 255 255 255 255 +255 255 255 187 187 187 136 136 136 17 17 17 0 0 0 0 0 0 119 119 119 255 255 255 +255 255 255 255 255 255 136 136 136 187 187 187 255 255 255 255 255 255 204 204 204 0 0 0 +102 102 102 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 204 204 204 119 119 119 +0 0 0 0 0 0 0 0 0 0 0 0 102 102 102 187 187 187 255 255 255 255 255 255 +255 255 255 255 255 255 136 136 136 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 102 102 102 255 255 255 221 221 221 0 0 0 17 17 17 238 238 238 255 255 255 +34 34 34 0 0 0 0 0 0 0 0 0 119 119 119 255 255 255 255 255 255 255 255 255 +136 136 136 187 187 187 255 255 255 255 255 255 204 204 204 0 0 0 136 136 136 255 255 255 +255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 204 204 204 0 0 0 +0 0 0 0 0 0 0 0 0 17 17 17 170 170 170 255 255 255 255 255 255 255 255 255 +153 153 153 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 17 17 17 221 221 221 +255 255 255 102 102 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 68 68 68 255 255 255 238 238 238 34 34 34 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 68 68 68 255 255 255 238 238 238 34 34 34 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/memory-move-malloc-end.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/memory-move-malloc-end.patch new file mode 100644 index 0000000000..9000642104 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/memory-move-malloc-end.patch @@ -0,0 +1,9 @@ +--- git/arch/arm/plat-omap/include/mach/vmalloc.h 2009-06-09 15:14:54.000000000 -0700 ++++ git/arch/arm/plat-omap/include/mach/vmalloc.h 2009-06-09 15:06:35.000000000 -0700 +@@ -17,5 +17,5 @@ + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +-#define VMALLOC_END (PAGE_OFFSET + 0x18000000) ++#define VMALLOC_END (PAGE_OFFSET + 0x28000000) + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight-accessible-by-user.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight-accessible-by-user.patch new file mode 100644 index 0000000000..14e0934468 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight-accessible-by-user.patch @@ -0,0 +1,11 @@ +--- a/drivers/video/backlight/backlight.c 2009-07-17 12:20:05.000000000 -0700 ++++ b/drivers/video/backlight/backlight.c 2009-07-17 12:20:46.000000000 -0700 +@@ -205,7 +205,7 @@ + + static struct device_attribute bl_device_attributes[] = { + __ATTR(bl_power, 0644, backlight_show_power, backlight_store_power), +- __ATTR(brightness, 0644, backlight_show_brightness, ++ __ATTR(brightness, 0666, backlight_show_brightness, + backlight_store_brightness), + __ATTR(actual_brightness, 0444, backlight_show_actual_brightness, + NULL), diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight.patch new file mode 100644 index 0000000000..65b551f1de --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/screen-backlight.patch @@ -0,0 +1,10 @@ +--- a/arch/arm/mach-omap2/Kconfig ++++ b/arch/arm/mach-omap2/Kconfig +@@ -128,6 +128,7 @@ config MACH_OMAP3EVM + config MACH_OMAP3_BEAGLE + bool "OMAP3 BEAGLE board" + depends on ARCH_OMAP3 && ARCH_OMAP34XX ++ select BACKLIGHT_CLASS_DEVICE + + config MACH_OVERO + bool "Gumstix Overo board" diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/sound-headphone-detection.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/sound-headphone-detection.patch new file mode 100644 index 0000000000..ef8b3626bc --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/sound-headphone-detection.patch @@ -0,0 +1,93 @@ +From db8f1eba9154789c45c6a92413bbbd94f5d9c7f5 Mon Sep 17 00:00:00 2001 +From: Tim Yamin <plasm@roo.me.uk> +Date: Wed, 29 Apr 2009 17:30:25 -0700 +Subject: [PATCH] Touch Book: turn on/off the class D amplifier depending on whether the + headphones are plugged into the jack or not. + +Signed-off-by: Tim Yamin <plasm@roo.me.uk> +--- + sound/soc/omap/omap3beagle.c | 33 +++++++++++++++++++++++++++++++++ + 1 files changed, 33 insertions(+), 0 deletions(-) + +diff --git a/sound/soc/omap/omap3beagle.c b/sound/soc/omap/omap3beagle.c +index fd24a4a..1236638 100644 +--- a/sound/soc/omap/omap3beagle.c ++++ b/sound/soc/omap/omap3beagle.c +@@ -20,7 +20,10 @@ + */ + + #include <linux/clk.h> ++#include <linux/irq.h> ++#include <linux/interrupt.h> + #include <linux/platform_device.h> ++ + #include <sound/core.h> + #include <sound/pcm.h> + #include <sound/soc.h> +@@ -35,6 +38,9 @@ + #include "omap-pcm.h" + #include "../codecs/twl4030.h" + ++#define TB_HEADPHONE_GPIO 56 ++#define TB_HEADPHONE_IRQ OMAP_GPIO_IRQ(TB_HEADPHONE_GPIO) ++ + static int omap3beagle_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) + { +@@ -103,6 +109,33 @@ static struct snd_soc_device omap3beagle_snd_devdata = { + + static struct platform_device *omap3beagle_snd_device; + ++static void jack_work_func(struct work_struct *wq) ++{ ++ struct snd_soc_device *socdev = platform_get_drvdata(omap3beagle_snd_device); ++ struct snd_soc_codec *codec = socdev->codec; ++ ++ snd_soc_dapm_sync(codec); ++} ++DECLARE_WORK(jack_work, jack_work_func); ++ ++static irqreturn_t touchbook_headphone_event(int irq, void *snd) ++{ ++ int status = gpio_get_value(TB_HEADPHONE_GPIO); ++ struct snd_soc_device *socdev = platform_get_drvdata(omap3beagle_snd_device); ++ struct snd_soc_codec *codec = socdev->codec; ++ ++ if(status) { ++ snd_soc_dapm_disable_pin(codec, "HFL"); ++ snd_soc_dapm_disable_pin(codec, "HFR"); ++ } else { ++ snd_soc_dapm_enable_pin(codec, "HFL"); ++ snd_soc_dapm_enable_pin(codec, "HFR"); ++ } ++ ++ schedule_work(&jack_work); ++ return IRQ_HANDLED; ++} ++ + static int __init omap3beagle_soc_init(void) + { + int ret; +@@ -123,10 +156,22 @@ static int __init omap3beagle_soc_init(void) + omap3beagle_snd_devdata.dev = &omap3beagle_snd_device->dev; + *(unsigned int *)omap3beagle_dai.cpu_dai->private_data = 1; /* McBSP2 */ + ++ /* Touch Book -- headphone jack sensor */ ++ omap_set_gpio_debounce(TB_HEADPHONE_GPIO, 1); ++ omap_set_gpio_debounce_time(TB_HEADPHONE_GPIO, 0xff); ++ ++ ret = request_irq(TB_HEADPHONE_IRQ, touchbook_headphone_event, IRQF_TRIGGER_RISING | ++ IRQF_TRIGGER_FALLING, "touchbook_headphone", omap3beagle_snd_device); ++ if (ret < 0) ++ goto err1; ++ + ret = platform_device_add(omap3beagle_snd_device); + if (ret) + goto err1; + ++ /* Detect headphone status */ ++ touchbook_headphone_event(0, omap3beagle_snd_device); ++ + return 0; + + err1: diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/tincantools-puppy.diff b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/tincantools-puppy.diff new file mode 100644 index 0000000000..c7856731e5 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/tincantools-puppy.diff @@ -0,0 +1,66 @@ +--- /tmp/board-omap3beagle.c 2009-07-01 01:06:44.000000000 +0200 ++++ git/arch/arm/mach-omap2/board-omap3beagle.c 2009-07-01 01:06:50.000000000 +0200 +@@ -125,6 +125,13 @@ + .wires = 8, + .gpio_wp = 29, + }, ++ { ++ .mmc = 2, ++ .wires = 4, ++ .gpio_wp = 141, ++ .gpio_cd = 162, ++ .transceiver = true, ++ }, + {} /* Terminator */ + }; + +@@ -132,6 +139,11 @@ + .supply = "vmmc", + }; + ++static struct regulator_consumer_supply beagle_vmmc2_supply = { ++ .supply = "vmmc", ++}; ++ ++ + static struct regulator_consumer_supply beagle_vsim_supply = { + .supply = "vmmc_aux", + }; +@@ -148,6 +160,7 @@ + + /* link regulators to MMC adapters */ + beagle_vmmc1_supply.dev = mmc[0].dev; ++ beagle_vmmc2_supply.dev = mmc[1].dev; + beagle_vsim_supply.dev = mmc[0].dev; + + /* REVISIT: need ehci-omap hooks for external VBUS +@@ -209,6 +222,21 @@ + .consumer_supplies = &beagle_vmmc1_supply, + }; + ++/* VMMC2 for MMC2 pins CMD, CLK, DAT0..DAT3 (max 100 mA) */ ++static struct regulator_init_data beagle_vmmc2 = { ++ .constraints = { ++ .min_uV = 2700000, ++ .max_uV = 3150000, ++ .valid_modes_mask = REGULATOR_MODE_NORMAL ++ | REGULATOR_MODE_STANDBY, ++ .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE ++ | REGULATOR_CHANGE_MODE ++ | REGULATOR_CHANGE_STATUS, ++ }, ++ .num_consumer_supplies = 1, ++ .consumer_supplies = &beagle_vmmc2_supply, ++}; ++ + /* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */ + static struct regulator_init_data beagle_vsim = { + .constraints = { +@@ -284,6 +312,7 @@ + .gpio = &beagle_gpio_data, + .power = &beagle_power_data, + .vmmc1 = &beagle_vmmc1, ++ .vmmc2 = &beagle_vmmc2, + .vsim = &beagle_vsim, + .vdac = &beagle_vdac, + .vpll2 = &beagle_vpll2, diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-export-settings.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-export-settings.patch new file mode 100644 index 0000000000..f8353afee5 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-export-settings.patch @@ -0,0 +1,87 @@ +diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c +index 7c3897f..0c62ace 100644 +--- a/drivers/input/touchscreen/ads7846.c ++++ b/drivers/input/touchscreen/ads7846.c +@@ -491,9 +491,82 @@ static ssize_t ads7846_disable_store(struct device *dev, + + static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store); + ++static ssize_t show_debounce_max(struct device *dev, struct device_attribute *attr, char *buf) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", ts->debounce_max); ++} ++ ++static ssize_t show_debounce_tol(struct device *dev, struct device_attribute *attr, char *buf) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", ts->debounce_tol); ++} ++ ++static ssize_t show_debounce_rep(struct device *dev, struct device_attribute *attr, char *buf) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", ts->debounce_rep); ++} ++ ++static ssize_t show_x_plate_ohms(struct device *dev, struct device_attribute *attr, char *buf) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", ts->x_plate_ohms); ++} ++ ++static ssize_t write_debounce_max(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ unsigned long i; ++ ++ if (strict_strtoul(buf, 10, &i)) ++ return -EINVAL; ++ ++ ts->debounce_max = i; ++ return count; ++} ++ ++static ssize_t write_debounce_tol(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ unsigned long i; ++ ++ if (strict_strtoul(buf, 10, &i)) ++ return -EINVAL; ++ ++ ts->debounce_tol = i; ++ return count; ++} ++ ++static ssize_t write_debounce_rep(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ unsigned long i; ++ ++ if (strict_strtoul(buf, 10, &i)) ++ return -EINVAL; ++ ++ ts->debounce_rep = i; ++ return count; ++} ++ ++static ssize_t write_x_plate_ohms(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ unsigned long i; ++ ++ if (strict_strtoul(buf, 10, &i)) ++ return -EINVAL; ++ ++ ts->x_plate_ohms = i; ++ return count; ++} ++ ++static DEVICE_ATTR(debounce_max, S_IRUGO | S_IWUGO, show_debounce_max, write_debounce_max); ++static DEVICE_ATTR(debounce_tol, S_IRUGO | S_IWUGO, show_debounce_tol, write_debounce_tol); ++static DEVICE_ATTR(debounce_rep, S_IRUGO | S_IWUGO, show_debounce_rep, write_debounce_rep); ++static DEVICE_ATTR(x_plate_ohms, S_IRUGO | S_IWUGO, show_x_plate_ohms, write_x_plate_ohms); ++ + static struct attribute *ads784x_attributes[] = { + &dev_attr_pen_down.attr, + &dev_attr_disable.attr, ++ &dev_attr_debounce_max.attr, ++ &dev_attr_debounce_tol.attr, ++ &dev_attr_debounce_rep.attr, ++ &dev_attr_x_plate_ohms.attr, + NULL, + }; + diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-rotation-support.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-rotation-support.patch new file mode 100644 index 0000000000..6196716f23 --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/touchscreen-ads7846-rotation-support.patch @@ -0,0 +1,108 @@ +diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c +index 0c62ace..8f6e83c 100644 +--- a/drivers/input/touchscreen/ads7846.c ++++ b/drivers/input/touchscreen/ads7846.c +@@ -127,6 +127,7 @@ struct ads7846 { + void (*filter_cleanup)(void *data); + int (*get_pendown_state)(void); + int gpio_pendown; ++ int rotate; + }; + + /* leave chip selected when we're done, for quicker re-select? */ +@@ -511,6 +512,11 @@ static ssize_t show_x_plate_ohms(struct device *dev, struct device_attribute *at + return sprintf(buf, "%u\n", ts->x_plate_ohms); + } + ++static ssize_t show_rotate(struct device *dev, struct device_attribute *attr, char *buf) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ return sprintf(buf, "%u\n", ts->rotate); ++} ++ + static ssize_t write_debounce_max(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { + struct ads7846 *ts = dev_get_drvdata(dev); + unsigned long i; +@@ -555,10 +561,22 @@ static ssize_t write_x_plate_ohms(struct device *dev, struct device_attribute *a + return count; + } + ++static ssize_t write_rotate(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { ++ struct ads7846 *ts = dev_get_drvdata(dev); ++ unsigned long i = 0; ++ ++ if (strict_strtoul(buf, 10, &i) || i > 3) ++ return -EINVAL; ++ ++ ts->rotate = i; ++ return count; ++} ++ + static DEVICE_ATTR(debounce_max, S_IRUGO | S_IWUGO, show_debounce_max, write_debounce_max); + static DEVICE_ATTR(debounce_tol, S_IRUGO | S_IWUGO, show_debounce_tol, write_debounce_tol); + static DEVICE_ATTR(debounce_rep, S_IRUGO | S_IWUGO, show_debounce_rep, write_debounce_rep); + static DEVICE_ATTR(x_plate_ohms, S_IRUGO | S_IWUGO, show_x_plate_ohms, write_x_plate_ohms); ++static DEVICE_ATTR(rotate, S_IRUGO | S_IWUGO, show_rotate, write_rotate); + + static struct attribute *ads784x_attributes[] = { + &dev_attr_pen_down.attr, +@@ -567,6 +585,7 @@ static struct attribute *ads784x_attributes[] = { + &dev_attr_debounce_tol.attr, + &dev_attr_debounce_rep.attr, + &dev_attr_x_plate_ohms.attr, ++ &dev_attr_rotate.attr, + NULL, + }; + +@@ -596,6 +615,8 @@ static void ads7846_rx(void *ads) + { + struct ads7846 *ts = ads; + struct ads7846_packet *packet = ts->packet; ++ struct ads7846_platform_data *pdata = ts->spi->dev.platform_data; ++ + unsigned Rt; + u16 x, y, z1, z2; + +@@ -657,6 +678,7 @@ static void ads7846_rx(void *ads) + * timer by reading the pen signal state (it's a GPIO _and_ IRQ). + */ + if (Rt) { ++ int t; + struct input_dev *input = ts->input; + + if (!ts->pendown) { +@@ -666,6 +688,27 @@ static void ads7846_rx(void *ads) + dev_dbg(&ts->spi->dev, "DOWN\n"); + #endif + } ++ ++ switch(ts->rotate) ++ { ++ case 0: ++ x = pdata->x_max - x + pdata->x_min; ++ y = pdata->y_max - y + pdata->y_min; ++ break; ++ case 1: ++ t = x; ++ x = pdata->x_max - (((y - pdata->y_min) * (pdata->x_max - pdata->x_min)) / (pdata->y_max - pdata->y_min)); ++ y = pdata->y_min + (((t - pdata->x_min) * (pdata->y_max - pdata->y_min)) / (pdata->x_max - pdata->x_min)); ++ break; ++ case 2: ++ break; ++ case 3: ++ t = x; ++ x = pdata->x_min + (((y - pdata->y_min) * (pdata->x_max - pdata->x_min)) / (pdata->y_max - pdata->y_min)); ++ y = pdata->y_max - (((t - pdata->x_min) * (pdata->y_max - pdata->y_min)) / (pdata->x_max - pdata->x_min)); ++ break; ++ } ++ + input_report_abs(input, ABS_X, x); + input_report_abs(input, ABS_Y, y); + input_report_abs(input, ABS_PRESSURE, Rt); +@@ -980,6 +1023,7 @@ static int __devinit ads7846_probe(struct spi_device *spi) + + dev_set_drvdata(&spi->dev, ts); + ++ ts->rotate = 0; + ts->packet = packet; + ts->spi = spi; + ts->input = input_dev; diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-lower-current-consumption-upon-insertion.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-lower-current-consumption-upon-insertion.patch new file mode 100644 index 0000000000..e2df6cf83d --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-lower-current-consumption-upon-insertion.patch @@ -0,0 +1,30 @@ +--- a/drivers/usb/core/hub.c 2009-07-28 08:47:00.000000000 -0700 ++++ b/drivers/usb/core/hub.c 2009-07-28 08:32:20.000000000 -0700 +@@ -22,6 +22,7 @@ + #include <linux/kthread.h> + #include <linux/mutex.h> + #include <linux/freezer.h> ++#include <linux/gpio.h> + + #include <asm/uaccess.h> + #include <asm/byteorder.h> +@@ -3129,9 +3130,18 @@ + USB_PORT_FEAT_C_RESET); + } + +- if (connect_change) ++ if (connect_change) { ++ if(portstatus & USB_PORT_STAT_CONNECTION) { ++ gpio_set_value(176,0); ++ mdelay(25); ++ } + hub_port_connect_change(hub, i, + portstatus, portchange); ++ if(portstatus & USB_PORT_STAT_CONNECTION) { ++ mdelay(75); ++ gpio_set_value(176,1); ++ } ++ } + } /* end for i */ + + /* deal with hub status changes */ diff --git a/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-otg-pc-connection.patch b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-otg-pc-connection.patch new file mode 100644 index 0000000000..2bcfbdcc2f --- /dev/null +++ b/recipes/linux/linux-omap-pm-2.6.29/omap3-touchbook/usb-otg-pc-connection.patch @@ -0,0 +1,36 @@ +--- git/drivers/usb/gadget/file_storage.c 2009-06-07 12:18:05.000000000 -0700 ++++ git/drivers/usb/gadget/file_storage.c 2009-06-07 12:08:36.000000000 -0700 +@@ -283,8 +283,8 @@ + * + * DO NOT REUSE THESE IDs with any other driver!! Ever!! + * Instead: allocate your own, using normal USB-IF procedures. */ +-#define DRIVER_VENDOR_ID 0x0525 // NetChip +-#define DRIVER_PRODUCT_ID 0xa4a5 // Linux-USB File-backed Storage Gadget ++#define DRIVER_VENDOR_ID 0xa110 // Always Innovating, Inc. ++#define DRIVER_PRODUCT_ID 0x0001 // Tablet product + + + /* +@@ -2025,9 +2025,9 @@ + { + u8 *buf = (u8 *) bh->buf; + +- static char vendor_id[] = "Linux "; ++ static char vendor_id[] = "AI, Inc."; + static char product_disk_id[] = "File-Stor Gadget"; +- static char product_cdrom_id[] = "File-CD Gadget "; ++ static char product_cdrom_id[] = "Touch Book "; + + if (!fsg->curlun) { // Unsupported LUNs are okay + fsg->bad_lun_okay = 1; +@@ -3671,8 +3671,8 @@ + } + if (num_sectors < min_sectors) { + LINFO(curlun, "file too small: %s\n", filename); +- rc = -ETOOSMALL; +- goto out; ++// rc = -ETOOSMALL; ++// goto out; + } + + get_file(filp); |