summaryrefslogtreecommitdiffstats
path: root/package/lqtapi/src
diff options
context:
space:
mode:
Diffstat (limited to 'package/lqtapi/src')
-rw-r--r--package/lqtapi/src/Makefile1
-rw-r--r--package/lqtapi/src/include/linux/tapi/tapi-event.h37
-rw-r--r--package/lqtapi/src/include/linux/tapi/tapi-ioctl.h20
-rw-r--r--package/lqtapi/src/include/linux/tapi/tapi.h231
-rw-r--r--package/lqtapi/src/mps/Makefile8
-rw-r--r--package/lqtapi/src/mps/mps-core.c238
-rw-r--r--package/lqtapi/src/mps/mps-fifo.c102
-rw-r--r--package/lqtapi/src/mps/mps-irq.c157
-rw-r--r--package/lqtapi/src/mps/mps-irq.h18
-rw-r--r--package/lqtapi/src/mps/mps-msg.c19
-rw-r--r--package/lqtapi/src/mps/mps-msg.h87
-rw-r--r--package/lqtapi/src/mps/mps.h85
-rw-r--r--package/lqtapi/src/mps/vmmc-alm.c129
-rw-r--r--package/lqtapi/src/mps/vmmc-alm.h42
-rw-r--r--package/lqtapi/src/mps/vmmc-cmds.h98
-rw-r--r--package/lqtapi/src/mps/vmmc-coder.c221
-rw-r--r--package/lqtapi/src/mps/vmmc-coder.h14
-rw-r--r--package/lqtapi/src/mps/vmmc-core.c646
-rw-r--r--package/lqtapi/src/mps/vmmc-link.c52
-rw-r--r--package/lqtapi/src/mps/vmmc-link.h10
-rw-r--r--package/lqtapi/src/mps/vmmc-module.c130
-rw-r--r--package/lqtapi/src/mps/vmmc-module.h64
-rw-r--r--package/lqtapi/src/mps/vmmc-port.c48
-rw-r--r--package/lqtapi/src/mps/vmmc-port.h22
-rw-r--r--package/lqtapi/src/mps/vmmc-sig.h19
-rw-r--r--package/lqtapi/src/mps/vmmc-signal.c69
-rw-r--r--package/lqtapi/src/mps/vmmc-stream.c73
-rw-r--r--package/lqtapi/src/mps/vmmc-stream.h10
-rw-r--r--package/lqtapi/src/mps/vmmc.c90
-rw-r--r--package/lqtapi/src/mps/vmmc.h68
-rw-r--r--package/lqtapi/src/tapi/Makefile7
-rw-r--r--package/lqtapi/src/tapi/tapi-control.c193
-rw-r--r--package/lqtapi/src/tapi/tapi-core.c250
-rw-r--r--package/lqtapi/src/tapi/tapi-input.c99
-rw-r--r--package/lqtapi/src/tapi/tapi-nl.c62
-rw-r--r--package/lqtapi/src/tapi/tapi-port.c82
-rw-r--r--package/lqtapi/src/tapi/tapi-stream.c201
-rw-r--r--package/lqtapi/src/tapi/tapi-sysfs-port.c107
38 files changed, 3809 insertions, 0 deletions
diff --git a/package/lqtapi/src/Makefile b/package/lqtapi/src/Makefile
new file mode 100644
index 000000000..852accb6a
--- /dev/null
+++ b/package/lqtapi/src/Makefile
@@ -0,0 +1 @@
+obj-m = tapi/ mps/
diff --git a/package/lqtapi/src/include/linux/tapi/tapi-event.h b/package/lqtapi/src/include/linux/tapi/tapi-event.h
new file mode 100644
index 000000000..925c71369
--- /dev/null
+++ b/package/lqtapi/src/include/linux/tapi/tapi-event.h
@@ -0,0 +1,37 @@
+#ifndef __LINUX_TAPI_TAPI_EVENT_H__
+#define __LINUX_TAPI_TAPI_EVENT_H__
+
+
+struct tapi_device;
+struct tapi_port;
+
+struct tapi_hook_event {
+ bool on;
+};
+
+struct tapi_dtmf_event {
+ unsigned char code;
+};
+
+enum tapi_event_type {
+ TAPI_EVENT_TYPE_HOOK,
+ TAPI_EVENT_TYPE_DTMF,
+};
+
+struct tapi_event {
+ struct timeval time;
+ enum tapi_event_type type;
+ unsigned int port;
+ union {
+ struct tapi_hook_event hook;
+ struct tapi_dtmf_event dtmf;
+ };
+};
+
+void tapi_report_event(struct tapi_device *tdev, struct tapi_event *event);
+void tapi_report_hook_event(struct tapi_device *tdev, struct tapi_port *port,
+ bool on);
+void tapi_report_dtmf_event(struct tapi_device *tdev, struct tapi_port *port,
+ unsigned char code);
+
+#endif
diff --git a/package/lqtapi/src/include/linux/tapi/tapi-ioctl.h b/package/lqtapi/src/include/linux/tapi/tapi-ioctl.h
new file mode 100644
index 000000000..c43fac1e7
--- /dev/null
+++ b/package/lqtapi/src/include/linux/tapi/tapi-ioctl.h
@@ -0,0 +1,20 @@
+
+#include <linux/ioctl.h>
+
+#define TAPI_MAGIC 't'
+#define TAPI_IOCTL(x) _IO(TAPI_MAGIC, (x))
+
+#define TAPI_CONTROL_IOCTL_LINK_ALLOC TAPI_IOCTL(0)
+#define TAPI_CONTROL_IOCTL_LINK_FREE TAPI_IOCTL(1)
+#define TAPI_CONTROL_IOCTL_LINK_ENABLE TAPI_IOCTL(2)
+#define TAPI_CONTROL_IOCTL_LINK_DISABLE TAPI_IOCTL(3)
+
+#define TAPI_CONTROL_IOCTL_SYNC TAPI_IOCTL(4)
+
+#define TAPI_PORT_IOCTL_GET_ENDPOINT TAPI_IOCTL(5)
+#define TAPI_PORT_IOCTL_SET_RING TAPI_IOCTL(6)
+
+#define TAPI_STREAM_IOCTL_GET_ENDPOINT TAPI_IOCTL(7)
+#define TAPI_STREAM_IOCTL_CONFIGURE TAPI_IOCTL(8)
+#define TAPI_STREAM_IOCTL_START TAPI_IOCTL(9)
+#define TAPI_STREAM_IOCTL_STOP TAPI_IOCTL(10)
diff --git a/package/lqtapi/src/include/linux/tapi/tapi.h b/package/lqtapi/src/include/linux/tapi/tapi.h
new file mode 100644
index 000000000..410655d4c
--- /dev/null
+++ b/package/lqtapi/src/include/linux/tapi/tapi.h
@@ -0,0 +1,231 @@
+#ifndef __LINUX_TAPI_H__
+#define __LINUX_TAPI_H__
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/mutex.h>
+
+#include <linux/input.h>
+
+#include <asm/atomic.h>
+#include <linux/list.h>
+
+#include <linux/cdev.h>
+
+#include <linux/skbuff.h>
+#include <linux/wait.h>
+
+#include <linux/tapi/tapi-event.h>
+
+struct tapi_device;
+
+struct tapi_char_device {
+ struct tapi_device *tdev;
+ struct device dev;
+ struct cdev cdev;
+};
+
+static inline struct tapi_char_device *cdev_to_tapi_char_device(struct cdev *cdev)
+{
+ return container_of(cdev, struct tapi_char_device, cdev);
+}
+
+int tapi_char_device_register(struct tapi_device *tdev,
+ struct tapi_char_device *tchrdev, const struct file_operations *fops);
+
+
+struct tapi_endpoint {
+ unsigned int id;
+ void *data;
+};
+
+static inline void tapi_endpoint_set_data(struct tapi_endpoint *ep, void *data)
+{
+ ep->data = data;
+}
+
+static inline void *tapi_endpoint_get_data(struct tapi_endpoint *ep)
+{
+ return ep->data;
+}
+
+struct tapi_port {
+ unsigned int id;
+ struct tapi_endpoint ep;
+ struct input_dev *input;
+ struct tapi_char_device chrdev;
+};
+
+struct tapi_stream {
+ unsigned int id;
+ struct list_head head;
+ struct tapi_endpoint ep;
+
+ struct sk_buff_head recv_queue;
+ wait_queue_head_t recv_wait;
+ struct sk_buff_head send_queue;
+};
+
+struct tapi_link {
+ unsigned int id;
+ struct list_head head;
+};
+
+enum tapi_codec {
+ TAPI_CODEC_L16,
+};
+
+struct tapi_stream_config {
+ enum tapi_codec codec;
+ unsigned int buffer_size;
+};
+
+struct tapi_ops {
+ int (*send_dtmf_events)(struct tapi_device *, struct tapi_port *port,
+ struct tapi_dtmf_event *, size_t num_events, unsigned int dealy);
+ int (*send_dtmf_event)(struct tapi_device *, struct tapi_port *port,
+ struct tapi_dtmf_event *);
+ int (*ring)(struct tapi_device *, struct tapi_port *port, bool ring);
+
+ struct tapi_stream *(*stream_alloc)(struct tapi_device *);
+ void (*stream_free)(struct tapi_device *, struct tapi_stream *);
+ int (*stream_configure)(struct tapi_device *, struct tapi_stream *,
+ struct tapi_stream_config *);
+ int (*stream_start)(struct tapi_device *, struct tapi_stream *);
+ int (*stream_stop)(struct tapi_device *, struct tapi_stream *);
+ int (*stream_send)(struct tapi_device *, struct tapi_stream *,
+ struct sk_buff *);
+
+ struct tapi_link *(*link_alloc)(struct tapi_device *,
+ struct tapi_endpoint *ep1, struct tapi_endpoint *ep2);
+ void (*link_free)(struct tapi_device *, struct tapi_link *);
+ int (*link_enable)(struct tapi_device *, struct tapi_link *);
+ int (*link_disable)(struct tapi_device *, struct tapi_link *);
+
+ int (*sync)(struct tapi_device *);
+};
+
+int tapi_stream_recv(struct tapi_device *, struct tapi_stream *, struct sk_buff *);
+
+struct tapi_device {
+ unsigned int id;
+
+ const struct tapi_ops *ops;
+ unsigned int num_ports;
+
+ struct device dev;
+
+ struct mutex lock;
+
+ struct tapi_port *ports;
+ struct list_head streams;
+ struct list_head links;
+ atomic_t stream_id;
+ atomic_t link_id;
+
+ struct tapi_char_device stream_dev;
+ struct tapi_char_device control_dev;
+};
+
+static inline struct tapi_device *dev_to_tapi(struct device *dev)
+{
+ return container_of(dev, struct tapi_device, dev);
+}
+
+static inline struct tapi_stream *tapi_stream_from_id(struct tapi_device *tdev,
+ unsigned int id)
+{
+ struct tapi_stream *stream;
+
+ mutex_lock(&tdev->lock);
+
+ list_for_each_entry(stream, &tdev->streams, head) {
+ if (stream->id == id)
+ goto out;
+ }
+ stream = NULL;
+
+out:
+ mutex_unlock(&tdev->lock);
+ return stream;
+}
+
+struct tapi_link *tapi_link_alloc(struct tapi_device *, struct tapi_endpoint *,
+ struct tapi_endpoint *);
+void tapi_link_free(struct tapi_device *, struct tapi_link *);
+
+struct tapi_stream *tapi_stream_alloc(struct tapi_device *tdev);
+void tapi_stream_free(struct tapi_device *tdev, struct tapi_stream *stream);
+
+static inline int tapi_sync(struct tapi_device *tdev)
+{
+ if (!tdev->ops || !tdev->ops->sync)
+ return 0;
+
+ return tdev->ops->sync(tdev);
+}
+
+static inline int tapi_link_enable(struct tapi_device *tdev,
+ struct tapi_link *link)
+{
+ if (!tdev->ops || !tdev->ops->link_enable)
+ return 0;
+
+ return tdev->ops->link_enable(tdev, link);
+}
+
+static inline int tapi_link_disable(struct tapi_device *tdev,
+ struct tapi_link *link)
+{
+ if (!tdev->ops || !tdev->ops->link_disable)
+ return 0;
+
+ return tdev->ops->link_disable(tdev, link);
+}
+
+static inline int tapi_port_send_dtmf(struct tapi_device *tdev,
+ struct tapi_port *port, struct tapi_dtmf_event *dtmf)
+{
+ if (!tdev->ops || !tdev->ops->send_dtmf_event)
+ return -ENOSYS;
+
+ return tdev->ops->send_dtmf_event(tdev, port, dtmf);
+}
+
+static inline int tapi_port_set_ring(struct tapi_device *tdev,
+ struct tapi_port *port, bool ring)
+{
+ if (!tdev->ops || !tdev->ops->ring)
+ return -ENOSYS;
+
+ return tdev->ops->ring(tdev, port, ring);
+}
+
+static inline int tapi_stream_start(struct tapi_device *tdev,
+struct tapi_stream *stream)
+{
+ if (!tdev->ops || !tdev->ops->stream_start)
+ return -ENOSYS;
+
+ return tdev->ops->stream_start(tdev, stream);
+}
+
+static inline int tapi_stream_stop(struct tapi_device *tdev,
+struct tapi_stream *stream)
+{
+ if (!tdev->ops || !tdev->ops->stream_stop)
+ return -ENOSYS;
+
+ return tdev->ops->stream_stop(tdev, stream);
+}
+
+int tapi_device_register(struct tapi_device *tdev, const char *name,
+ struct device *parent);
+void tapi_device_unregister(struct tapi_device *tdev);
+
+struct tapi_sysfs_port;
+
+struct tapi_sysfs_port *tapi_port_alloc(struct tapi_device *tdev, unsigned int id);
+void tapi_port_delete(struct tapi_sysfs_port *);
+
+#endif
diff --git a/package/lqtapi/src/mps/Makefile b/package/lqtapi/src/mps/Makefile
new file mode 100644
index 000000000..201bccc28
--- /dev/null
+++ b/package/lqtapi/src/mps/Makefile
@@ -0,0 +1,8 @@
+
+
+mps-objs := mps-core.o mps-irq.o mps-fifo.o
+obj-m += mps.o
+
+vmmc-objs := vmmc-core.o vmmc-alm.o vmmc-module.o vmmc-link.o vmmc-port.o \
+ vmmc-signal.o vmmc-stream.o vmmc-coder.o
+obj-m += vmmc.o
diff --git a/package/lqtapi/src/mps/mps-core.c b/package/lqtapi/src/mps/mps-core.c
new file mode 100644
index 000000000..27f1c63eb
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-core.c
@@ -0,0 +1,238 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <ifxmips.h>
+#include <ifxmips_cgu.h>
+
+#include <ifxmips_prom.h>
+#include <ifxmips_irq.h>
+
+#include "mps.h"
+
+extern int mps_irq_init(struct mps *mps);
+extern void mps_irq_exit(struct mps *mps);
+
+#define MPS_CPU0_BOOT_RVEC 0x1c0
+#define MPS_CPU0_BOOT_NVEC 0x1c4
+#define MPS_CPU0_BOOT_EVEC 0x1c8
+#define MPS_CPU0_CP0_STATUS 0x1cc
+#define MPS_CPU0_CP0_EEPC 0x1d0
+#define MPS_CPU0_CP0_EPC 0x1d4
+#define MPS_CPU0_BOOT_SIZE 0x1d8
+#define MPS_CPU0_CFG_STAT 0x1dc
+#define MPS_CPU1_BOOT_RVEC 0x1e0
+#define MPS_CPU1_BOOT_NVEC 0x1e4
+#define MPS_CPU1_BOOT_EVEC 0x1e8
+#define MPS_CPU1_CP0_STATUS 0x1ec
+#define MPS_CPU1_CP0_EEPC 0x1f0
+#define MPS_CPU1_CP0_EPC 0x1f4
+#define MPS_CPU1_BOOT_SIZE 0x1f8
+#define MPS_CPU1_CFG_STAT 0x1fc
+
+static void mps_reset(void)
+{
+ ifxmips_w32(ifxmips_r32(IFXMIPS_RCU_RST) | IFXMIPS_RCU_RST_CPU1,
+ IFXMIPS_RCU_RST);
+ smp_wmb();
+}
+
+static void mps_release(void)
+{
+ uint32_t val;
+ val = ifxmips_r32(IFXMIPS_RCU_RST);
+ val |= 0x20000000;
+ val &= ~IFXMIPS_RCU_RST_CPU1;
+ ifxmips_w32(val, IFXMIPS_RCU_RST);
+ smp_wmb();
+}
+
+void mps_load_firmware(struct mps *mps, const void *data, size_t size,
+ enum mps_boot_config config)
+{
+ uint32_t cfg = 0;
+ uint32_t fw_size = size;
+
+ if (config == MPS_BOOT_LEGACY) {
+ cfg = 0x00020000;
+ fw_size -= sizeof(uint32_t);
+ } else {
+ if(config == MPS_BOOT_ENCRYPTED) {
+ cfg = __raw_readl(mps->mbox_base + MPS_CPU1_CFG_STAT);
+ cfg |= 0x00700000;
+ } else {
+ printk("PANIC!\n");
+ }
+ }
+
+ mps_reset();
+
+ memcpy_toio(mps->cp1_base, data, size);
+
+ __raw_writel(cfg, mps->mbox_base + MPS_CPU1_CFG_STAT);
+ __raw_writel(fw_size, mps->mbox_base + MPS_CPU1_BOOT_SIZE);
+ __raw_writel((uint32_t)mps->cp1_base, mps->mbox_base + MPS_CPU1_BOOT_RVEC);
+
+ mps_release();
+}
+EXPORT_SYMBOL_GPL(mps_load_firmware);
+
+void mps_configure_fifo(struct mps *mps, struct mps_fifo *fifo,
+ const struct mps_fifo_config *config)
+{
+ mps_fifo_init(fifo, mps->mbox_base + config->base,
+ mps->mbox_base + config->head_addr,
+ mps->mbox_base + config->tail_addr,
+ config->size);
+
+ __raw_writel(config->size, mps->mbox_base + config->size_addr);
+ __raw_writel(mps->mbox_res->start + config->base,
+ mps->mbox_base + config->base_addr);
+}
+EXPORT_SYMBOL_GPL(mps_configure_fifo);
+
+void mps_configure_mailbox(struct mps *mps, struct mps_mailbox *mbox,
+ const struct mps_fifo_config *upstream_config,
+ const struct mps_fifo_config *downstream_config)
+{
+ mps_configure_fifo(mps, &mbox->upstream, upstream_config);
+ mps_configure_fifo(mps, &mbox->downstream, downstream_config);
+}
+EXPORT_SYMBOL_GPL(mps_configure_mailbox);
+
+static int __devinit mps_probe(struct platform_device *pdev)
+{
+ int ret;
+ struct mps *mps;
+ struct resource *res;
+
+ mps = kzalloc(sizeof(*mps), GFP_KERNEL);
+
+ if (!mps)
+ return -ENOMEM;
+
+ mps->dev = &pdev->dev;
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mem");
+ if (!res) {
+ dev_err(&pdev->dev, "Failed to get mem resource");
+ ret = -ENOENT;
+ goto err_free;
+ }
+
+ res = request_mem_region(res->start, resource_size(res),
+ dev_name(&pdev->dev));
+
+ if (!res) {
+ dev_err(&pdev->dev, "Failed to request mem resource");
+ ret = -EBUSY;
+ goto err_free;
+ }
+
+ mps->base = ioremap_nocache(res->start, resource_size(res));
+
+ if (!mps->base) {
+ dev_err(&pdev->dev, "Failed to ioremap mem region\n");
+ ret = -EBUSY;
+ goto err_release_mem_region;
+ }
+
+ mps->res = res;
+
+
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mailbox");
+ if (!res) {
+ dev_err(&pdev->dev, "Failed to get mailbox mem region\n");
+ ret = -ENOENT;
+ goto err_free;
+ }
+
+ res = request_mem_region(res->start, resource_size(res),
+ dev_name(&pdev->dev));
+
+ if (!res) {
+ dev_err(&pdev->dev, "Failed to request mailbox mem region\n");
+ ret = -EBUSY;
+ goto err_free;
+ }
+
+ mps->mbox_base = ioremap_nocache(res->start, resource_size(res));
+
+ if (!mps->mbox_base) {
+ dev_err(&pdev->dev, "Failed to ioremap mailbox mem region\n");
+ ret = -EBUSY;
+ goto err_release_mem_region;
+ }
+
+ mps->mbox_res = res;
+
+ mps->cp1_base = ioremap_nocache((unsigned int)pdev->dev.platform_data, 1 << 20);
+
+ if (!mps->cp1_base) {
+ dev_err(&pdev->dev, "Failed to ioremap cp1 address\n");
+ ret = -EBUSY;
+ goto err_release_mem_region;
+ }
+
+ mps->irq_ad0 = INT_NUM_IM4_IRL18;
+ mps->irq_ad1 = INT_NUM_IM4_IRL19;
+ mps->irq_base = 160;
+
+ ret = mps_irq_init(mps);
+ if (ret < 0)
+ goto err_iounmap;
+
+ platform_set_drvdata(pdev, mps);
+
+ return 0;
+
+err_iounmap:
+ iounmap(mps->mbox_base);
+err_release_mem_region:
+ release_mem_region(res->start, resource_size(res));
+err_free:
+ kfree(mps);
+
+ return ret;
+}
+
+static int __devexit mps_remove(struct platform_device *pdev)
+{
+ struct mps *mps = platform_get_drvdata(pdev);
+
+ mps_irq_exit(mps);
+
+ iounmap(mps->mbox_base);
+ release_mem_region(mps->mbox_res->start, resource_size(mps->mbox_res));
+ iounmap(mps->base);
+ release_mem_region(mps->res->start, resource_size(mps->res));
+
+ kfree(mps);
+ return 0;
+}
+
+static struct platform_driver mps_driver = {
+ .probe = mps_probe,
+ .remove = __devexit_p(mps_remove),
+ .driver = {
+ .name = "mps",
+ .owner = THIS_MODULE
+ },
+};
+
+static int __init mps_init(void)
+{
+ return platform_driver_register(&mps_driver);
+}
+module_init(mps_init);
+
+static void __exit mps_exit(void)
+{
+ platform_driver_unregister(&mps_driver);
+}
+module_exit(mps_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
diff --git a/package/lqtapi/src/mps/mps-fifo.c b/package/lqtapi/src/mps/mps-fifo.c
new file mode 100644
index 000000000..9d88a4547
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-fifo.c
@@ -0,0 +1,102 @@
+#include <linux/io.h>
+
+#include "mps.h"
+
+void mps_fifo_init(struct mps_fifo *fifo, void __iomem *base,
+ void __iomem *head_addr, void __iomem *tail_addr, uint32_t size)
+{
+ fifo->base = base;
+ fifo->head_addr = head_addr;
+ fifo->tail_addr = tail_addr;
+ fifo->size = size;
+ mps_fifo_reset(fifo);
+}
+
+void mps_fifo_in(struct mps_fifo *fifo, const uint32_t *from, size_t len)
+{
+ uint32_t head = __raw_readl(fifo->head_addr);
+ void __iomem *base = fifo->base + head;
+ size_t i = 0;
+ size_t byte_len = len * 4;
+
+ if (head < byte_len) {
+ for(; i <= head / 4; ++i) {
+ __raw_writel(from[i], base);
+ base -= 4;
+ }
+
+ base += fifo->size;
+ head += fifo->size;
+ }
+
+ for(; i < len; ++i) {
+ __raw_writel(from[i], base);
+ base -= 4;
+ }
+
+ head -= byte_len;
+ __raw_writel(head, fifo->head_addr);
+
+}
+EXPORT_SYMBOL_GPL(mps_fifo_in);
+
+void mps_fifo_out(struct mps_fifo *fifo, uint32_t *to, size_t len)
+{
+ uint32_t tail = __raw_readl(fifo->tail_addr);
+ void __iomem *base = fifo->base + tail;
+ size_t i = 0;
+ size_t byte_len = len * 4;
+
+ if (tail < byte_len) {
+ for(; i <= tail / 4; ++i) {
+ to[i] = __raw_readl(base);
+ base -= 4;
+ }
+
+ base += fifo->size;
+ tail += fifo->size;
+ }
+
+ for(; i < len; ++i) {
+ to[i] = __raw_readl(base);
+ base -= 4;
+ }
+
+ tail -= byte_len;
+ __raw_writel(tail, fifo->tail_addr);
+}
+EXPORT_SYMBOL_GPL(mps_fifo_out);
+
+uint32_t mps_fifo_peek(struct mps_fifo *fifo)
+{
+ uint32_t tail = __raw_readl(fifo->tail_addr);
+ void __iomem *base = fifo->base + tail;
+ return __raw_readl(base);
+}
+
+void mps_fifo_reset(struct mps_fifo *fifo)
+{
+ void __iomem *base = fifo->base + fifo->size - 4;
+ size_t i;
+
+ __raw_writel(fifo->size - 4, fifo->head_addr);
+ __raw_writel(fifo->size - 4, fifo->tail_addr);
+
+ for(i = 0; i < 16; ++i) {
+ __raw_writel(0x0, base);
+ base -= 4;
+ }
+}
+
+size_t mps_fifo_len(struct mps_fifo *fifo)
+{
+ uint32_t head = __raw_readl(fifo->head_addr);
+ uint32_t tail = __raw_readl(fifo->tail_addr);
+
+ if (tail < head)
+ return head - tail;
+ else
+ return fifo->size - (tail - head);
+}
+EXPORT_SYMBOL_GPL(mps_fifo_len);
+
diff --git a/package/lqtapi/src/mps/mps-irq.c b/package/lqtapi/src/mps/mps-irq.c
new file mode 100644
index 000000000..8da0c00c7
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-irq.c
@@ -0,0 +1,157 @@
+#include <linux/interrupt.h>
+#include <linux/kernel_stat.h>
+#include <ifxmips_irq.h>
+
+#include "mps.h"
+#include "mps-irq.h"
+
+#define MPS_REG_AD0_IRQ_BASE 0x40
+#define MPS_REG_AD1_IRQ_BASE 0x44
+
+#define MPS_REG_AD_IRQ_STATUS 0x00
+#define MPS_REG_AD_IRQ_SET 0x08
+#define MPS_REG_AD_IRQ_CLEAR 0x10
+#define MPS_REG_AD_IRQ_ENABLE 0x18
+
+struct mps_irq_desc
+{
+ void __iomem *base;
+ unsigned int irq_base;
+};
+
+static inline unsigned int mps_irq_bit(struct mps_irq_desc *mps_desc, int irq)
+{
+ return BIT(irq - mps_desc->irq_base);
+}
+
+static void mps_irq_ack(unsigned int irq)
+{
+ struct mps_irq_desc *mps_desc = get_irq_chip_data(irq);
+
+ __raw_writel(mps_irq_bit(mps_desc, irq),
+ mps_desc->base + MPS_REG_AD_IRQ_CLEAR);
+}
+
+static void mps_irq_mask(unsigned int irq)
+{
+ struct mps_irq_desc *mps_desc = get_irq_chip_data(irq);
+ uint32_t mask;
+
+ mask = __raw_readl(mps_desc->base + MPS_REG_AD_IRQ_ENABLE);
+ mask &= ~mps_irq_bit(mps_desc, irq);
+ __raw_writel(mask, mps_desc->base + MPS_REG_AD_IRQ_ENABLE);
+}
+
+static void mps_irq_unmask(unsigned int irq)
+{
+ struct mps_irq_desc *mps_desc = get_irq_chip_data(irq);
+ uint32_t mask;
+
+ mask = __raw_readl(mps_desc->base + MPS_REG_AD_IRQ_ENABLE);
+ mask |= mps_irq_bit(mps_desc, irq) | 0xffff;
+ __raw_writel(mask, mps_desc->base + MPS_REG_AD_IRQ_ENABLE);
+}
+
+static struct irq_chip mps_irq_chip = {
+ .name = "mps",
+ .ack = mps_irq_ack,
+ .mask = mps_irq_mask,
+ .unmask = mps_irq_unmask,
+};
+
+static void mps_irq_demux_handler(unsigned int irq, struct irq_desc *desc)
+{
+ struct mps_irq_desc *mps_desc = get_irq_data(irq);
+ uint32_t val;
+ int mps_irq;
+
+ desc->chip->mask(irq);
+
+ val = __raw_readl(mps_desc->base + MPS_REG_AD_IRQ_STATUS);
+ mps_irq = ffs(val);
+
+/* printk("irq: %d %x\n", mps_irq, val);*/
+
+ if (mps_irq > 16)
+ printk("PANIC!\n");
+
+ if (mps_irq)
+ generic_handle_irq(mps_irq + mps_desc->irq_base - 1);
+
+ desc->chip->ack(irq);
+ desc->chip->unmask(irq);
+}
+
+#if 0
+
+static const uint32_t ring_msg[] = {
+0x01010004, 0x00030000,
+};
+
+static irqreturn_t mps_irq_ad0(int irq, void *devid)
+{
+ struct mps *mps = devid;
+ uint32_t val;
+
+ val = __raw_readl(mps->base + MPS_REG_AD0_IRQ_STATUS);
+ printk("WOHO ein IRQ: %x\n", val);
+ __raw_writel(val, mps->base + MPS_REG_AD0_IRQ_CLEAR);
+
+ if (val & BIT(MPS_IRQ_DOWNLOAD_DONE))
+ complete(&mps->init_completion);
+
+ if (val & BIT(MPS_IRQ_EVENT))
+ mps_fifo_in(&mps->mbox_cmd.downstream, ring_msg, ARRAY_SIZE(ring_msg));
+
+ return IRQ_HANDLED;
+}
+#endif
+
+#define MPS_NUM_AD_IRQS 32
+
+struct mps_irq_desc mps_irq_descs[2];
+
+int mps_irq_init(struct mps *mps)
+{
+ int ret = 0;
+ int irq;
+
+ mps_irq_descs[0].base = mps->base + MPS_REG_AD0_IRQ_BASE;
+ mps_irq_descs[0].irq_base = mps->irq_base;
+ mps_irq_descs[1].base = mps->base + MPS_REG_AD1_IRQ_BASE;
+ mps_irq_descs[1].irq_base = mps->irq_base + 16;
+
+
+ set_irq_data(mps->irq_ad0, &mps_irq_descs[0]);
+ set_irq_chained_handler(mps->irq_ad0, mps_irq_demux_handler);
+ set_irq_data(mps->irq_ad1, &mps_irq_descs[1]);
+ set_irq_chained_handler(mps->irq_ad1, mps_irq_demux_handler);
+
+/*
+ ret = request_irq(mps->irq_ad0, mps_irq_demux_handler, IRQF_DISABLED,
+ "mps ad0", &mps_irq_descs[0]);
+ ret = request_irq(mps->irq_ad1, mps_irq_demux_handler, IRQF_DISABLED,
+ "mps ad0", &mps_irq_descs[1]);
+*/
+ for (irq = 0; irq < MPS_NUM_AD_IRQS; ++irq) {
+ set_irq_chip_data(irq + mps->irq_base, &mps_irq_descs[irq / 16]);
+ set_irq_chip_and_handler(irq + mps->irq_base, &mps_irq_chip, handle_level_irq);
+ }
+
+
+/*
+ res = request_irq(INT_NUM_IM4_IRL18, mps_irq_ad0, IRQF_DISABLED,
+ "mps ad0", mps);
+
+ irqs = BIT(MPS_IRQ_CMD_UPSTREAM) | BIT(MPS_IRQ_DATA_UPSTREAM)
+ | BIT(MPS_IRQ_DOWNLOAD_DONE) | BIT(MPS_IRQ_EVENT) | BIT(MPS_IRQ_CMD_ERROR);
+
+ __raw_writel(irqs, mps->base + MPS_REG_AD0_IRQ_ENA);
+*/
+ return ret;
+}
+
+void mps_irq_exit(struct mps *mps)
+{
+ free_irq(INT_NUM_IM4_IRL18, mps);
+}
diff --git a/package/lqtapi/src/mps/mps-irq.h b/package/lqtapi/src/mps/mps-irq.h
new file mode 100644
index 000000000..c343ace3f
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-irq.h
@@ -0,0 +1,18 @@
+
+#define MPS_IRQ_BASE 160
+#define MPS_IRQ(x) (MPS_IRQ_BASE + (x))
+#define MPS_IRQ_CMD_UPSTREAM MPS_IRQ(0)
+#define MPS_IRQ_DATA_UPSTREAM MPS_IRQ(1)
+#define MPS_IRQ_CMD_DOWNSTREAM MPS_IRQ(2)
+#define MPS_IRQ_DATA_DOWNSTREAM MPS_IRQ(3)
+#define MPS_IRQ_RCV_OVERFLOW MPS_IRQ(4)
+#define MPS_IRQ_EVENT MPS_IRQ(5)
+#define MPS_IRQ_EVENT_OVERFLOW MPS_IRQ(6)
+#define MPS_IRQ_CMD_ERROR MPS_IRQ(8)
+#define MPS_IRQ_PCM_CRASH MPS_IRQ(9)
+#define MPS_IRQ_DATA_ERROR MPS_IRQ(10)
+#define MPS_IRQ_MIPS_OL MPS_IRQ(11)
+#define MPS_IRQ_WATCHDOG_FAIL MPS_IRQ(14)
+#define MPS_IRQ_DOWNLOAD_DONE MPS_IRQ(15)
+
+
diff --git a/package/lqtapi/src/mps/mps-msg.c b/package/lqtapi/src/mps/mps-msg.c
new file mode 100644
index 000000000..7fc0b7a99
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-msg.c
@@ -0,0 +1,19 @@
+
+
+int mps_message_send(struct mps_fifo *fifo, struct mps_message *msg)
+{
+}
+
+int mps_message_recv(struct mps_fifo *fifo, struct mps_message *msg)
+{
+ mps_fifo_out(fifo, &msg->header, sizeof(msg->header));
+ mps_fifo_out(fifo, &msg->data, mps_message_size(msg));
+}
+
+struct mps_message *msg mps_message_recv_alloc(struct mps_fifo *fifo)
+{
+ struct mps_message *msg;
+
+ mps_fifo_out(fifo, &msg->header, sizeof(msg->header));
+ mps_fifo_out(fifo, &msg->data, mps_message_size(msg));
+}
diff --git a/package/lqtapi/src/mps/mps-msg.h b/package/lqtapi/src/mps/mps-msg.h
new file mode 100644
index 000000000..8d672fbf5
--- /dev/null
+++ b/package/lqtapi/src/mps/mps-msg.h
@@ -0,0 +1,87 @@
+#ifndef __MPS_MSG_H__
+#define __MPS_MSG_H__
+
+#include <linux/slab.h>
+
+struct mps_message {
+ uint32_t header;
+ uint32_t data[0];
+};
+
+#define MPS_MSG_HEADER(_rw, _sc, _bc, _cmd, _chan, _mode, _ecmd, _length) \
+ (((_rw) << 31) | ((_sc) << 30) | ((_bc) << 29) | ((_cmd) << 24) | \
+ ((_chan) << 16) | ((_mode) << 13) | ((_ecmd) << 8) | (_length))
+
+#define MPS_MSG_INIT(_msg, _rw, _sc, _bc, _cmd, _chan, _mode, _ecmd, _length) \
+ do { \
+ (_msg)->header = MPS_MSG_HEADER(_rw, _sc, _bc, _cmd, _chan, _mode, \
+ _ecmd, _length); \
+ } while(0)
+
+
+static inline void mps_msg_init(struct mps_message *msg, uint32_t rw, uint32_t sc,
+ uint32_t bc, uint32_t cmd, uint32_t chan, uint32_t mode, uint32_t ecmd,
+ uint32_t length)
+{
+ msg->header = MPS_MSG_HEADER(rw, sc, bc, cmd, chan, mode, ecmd, length);
+}
+
+#define DECLARE_MESSAGE(_name, _size) struct mps_message _name; \
+ uint32_t __mps_msg_data_ ## __FUNCTION__ ## __LINE__[_size]
+
+static inline struct mps_message *mps_message_alloc(size_t size)
+{
+ return kmalloc(sizeof(struct mps_message) + size * sizeof(uint32_t), GFP_KERNEL);
+}
+
+static inline size_t mps_message_size(const struct mps_message *msg)
+{
+ return msg->header & 0xff;
+}
+
+enum {
+ MPS_MSG_WRITE = 0,
+ MPS_MSG_READ = 1,
+};
+
+enum {
+ MPS_CMD_ALI = 1,
+ MPS_CMD_DECT = 3,
+ MPS_CMD_SDD = 4,
+ MPS_CMD_EOP = 6,
+};
+
+#define MOD_PCM 0
+#define MOD_SDD 0
+#define MOD_ALI 1
+#define MOD_SIGNALING 2
+#define MOD_CODER 3
+#define MOD_RESOURCE 6
+#define MOD_SYSTEM 7
+#define ECMD_SYS_VER 6
+#define SYS_CAP_ECMD 7
+#define ECMD_CIDS_DATA 9
+#define ECMD_DCCTL_DEBUG 0x0a
+
+#define ALI_CHAN_CMD 6
+#define ALI_CHAN_ECMD 1
+
+#define MPS_MSG_HEADER_W(_sc, _bc, _cmd, _chan, _mode, _ecmd, _length) \
+ MPS_MSG_HEADER(MPS_MSG_WRITE, _sc, _bc, _cmd, _chan, _mode, _ecmd, _length)
+
+#define MPS_MSG_HEADER_R(_sc, _bc, _cmd, _chan, _mode, _ecmd, _length) \
+ MPS_MSG_HEADER(MPS_MSG_READ, _sc, _bc, _cmd, _chan, _mode, _ecmd, _length)
+
+#define MPS_MSG_CMD_EOP(_mode, _ecmd, _length) \
+ MPS_MSG_HEADER_R(0, 0, MPS_CMD_EOP, 0, _mode, _ecmd, _length)
+
+#define MPS_MSG_CMD_EOP_SYSTEM(_ecmd, _length) \
+ MPS_MSG_CMD_EOP(MOD_SYSTEM, _ecmd, _length)
+
+#define MPS_CMD_GET_VERSION \
+ MPS_MSG_CMD_EOP_SYSTEM(ECMD_SYS_VER, 4)
+
+#define MPS_CMD_ALI(_chan) \
+ MPS_MSG_HEADER_W(0, 0, ALI_CHAN_CMD, _chan, MOD_ALI, ALI_CHAN_ECMD, 12)
+
+#endif
diff --git a/package/lqtapi/src/mps/mps.h b/package/lqtapi/src/mps/mps.h
new file mode 100644
index 000000000..e759e5698
--- /dev/null
+++ b/package/lqtapi/src/mps/mps.h
@@ -0,0 +1,85 @@
+#ifndef __MPS_H__
+#define __MPS_H__
+
+#include <linux/platform_device.h>
+#include <linux/completion.h>
+
+struct mps_fifo_config
+{
+ size_t head_addr;
+ size_t tail_addr;
+ size_t base_addr;
+ size_t size_addr;
+
+ size_t base;
+ size_t size;
+};
+
+struct mps_fifo {
+ void __iomem *base;
+ void __iomem *head_addr;
+ void __iomem *tail_addr;
+ uint32_t size;
+};
+
+struct mps_mailbox {
+ struct mps_fifo upstream;
+ struct mps_fifo downstream;
+};
+
+enum mps_boot_config
+{
+ MPS_BOOT_LEGACY = 1,
+ MPS_BOOT_ENCRYPTED = 2,
+};
+
+struct mps {
+ struct resource *res;
+ void __iomem *base;
+
+ struct resource *mbox_res;
+ void __iomem *mbox_base;
+
+ struct resource *cp1_res;
+ void __iomem *cp1_base;
+
+ struct device *dev;
+
+ int irq_ad0;
+ int irq_ad1;
+ int irq_base;
+};
+
+void mps_configure_fifo(struct mps *mps, struct mps_fifo *fifo,
+ const struct mps_fifo_config *config);
+
+void mps_configure_mailbox(struct mps *mps, struct mps_mailbox *mbox,
+ const struct mps_fifo_config *upstream_config,
+ const struct mps_fifo_config *downstream_config);
+
+void mps_load_firmware(struct mps *mps, const void *data, size_t size,
+ enum mps_boot_config config);
+
+static inline struct mps *device_to_mps(struct device *dev)
+{
+ return (struct mps *)dev_get_drvdata(dev);
+}
+
+/* fifo */
+void mps_fifo_init(struct mps_fifo *fifo, void __iomem *data_addr,
+ void __iomem *head_addr, void __iomem *tail_addr, uint32_t size);
+void mps_fifo_in(struct mps_fifo *fifo, const uint32_t *from, size_t len);
+void mps_fifo_out(struct mps_fifo *fifo, uint32_t *to, size_t len);
+uint32_t mps_fifo_peek(struct mps_fifo *fifo);
+void mps_fifo_reset(struct mps_fifo *fifo);
+size_t mps_fifo_len(struct mps_fifo *fifo);
+
+/* Mailbox */
+int mps_mailbox_init(struct mps_mailbox *mbox, const char *name, int irq);
+int mps_mailbox_command_read(struct mps_mailbox *mbox, uint32_t cmd,
+ uint32_t *result);
+int mps_mailbox_command_write(struct mps_mailbox *mbox, uint32_t cmd,
+ const uint32_t *data);
+
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-alm.c b/package/lqtapi/src/mps/vmmc-alm.c
new file mode 100644
index 000000000..828376fb9
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-alm.c
@@ -0,0 +1,129 @@
+#include <linux/kernel.h>
+
+#include "vmmc.h"
+#include "vmmc-cmds.h"
+#include "vmmc-alm.h"
+#include "vmmc-module.h"
+#include "mps.h"
+
+static inline struct vmmc_alm *vmmc_module_to_alm(struct vmmc_module *module)
+{
+ return container_of(module, struct vmmc_alm, module);
+}
+
+int vmmc_alm_set_state(struct vmmc_alm *alm, enum vmmc_alm_state state)
+{
+ int ret;
+
+ ret = vmmc_command_write(alm->vmmc, VMMC_CMD_OPMODE(alm->id), &state);
+ if (!ret)
+ alm->state = state;
+
+ return ret;
+}
+
+enum vmmc_alm_state vmmc_alm_get_state(struct vmmc_alm *alm)
+{
+ return alm->state;
+}
+
+static struct vmmc_alm_coef *vmmc_alm_coef_alloc(unsigned int offset, size_t len)
+{
+ struct vmmc_alm_coef *coef;
+
+ coef = kzalloc(sizeof(*coef) + sizeof(uint32_t) * DIV_ROUND_UP(len, 4),
+ GFP_KERNEL);
+ coef->offset = offset;
+ coef->len = len;
+
+ return coef;
+}
+
+int vmcc_alm_set_coefficents(struct vmmc_alm *alm,
+ const struct vmmc_alm_coef *coef_list)
+{
+ int ret = 0;
+ uint32_t cmd;
+ struct vmmc_alm_coef *coef;
+ struct list_head l;
+
+ INIT_LIST_HEAD(&l);
+
+ coef = vmmc_alm_coef_alloc(0x37, 8);
+ coef->data[0] = 0x76d7871d;
+ coef->data[1] = 0x7fbb7ff4;
+ list_add_tail(&coef->list, &l);
+ coef = vmmc_alm_coef_alloc(0x5e, 2);
+ coef->data[0] = 0x7e000000;
+ list_add_tail(&coef->list, &l);
+ coef = vmmc_alm_coef_alloc(0x6c, 2);
+ coef->data[0] = 0x7e000000;
+ list_add_tail(&coef->list, &l);
+
+ list_for_each_entry(coef, &l, list) {
+ cmd = VMMC_CMD_ALM_COEF(alm->id, coef->offset, coef->len);
+ ret = vmmc_command_write(alm->vmmc, cmd, coef->data);
+ if (ret)
+ break;
+ }
+
+ return ret;
+}
+
+static int vmmc_alm_sync(struct vmmc_module *module)
+{
+ struct vmmc_alm *alm = vmmc_module_to_alm(module);
+
+ alm->cmd_cache[0] = VMMC_CMD_ALI_DATA1(1, 0, 0, 1, 0, module->pins[0], 0x4000);
+ alm->cmd_cache[1] = VMMC_CMD_ALI_DATA2(0x4000, module->pins[1], module->pins[2]);
+ alm->cmd_cache[2] = VMMC_CMD_ALI_DATA3(module->pins[3], module->pins[4]);
+
+ return vmmc_command_write(alm->vmmc, VMMC_CMD_ALI(alm->id), alm->cmd_cache);
+}
+
+static int vmmc_alm_enable(struct vmmc_module *module, bool enable)
+{
+ struct vmmc_alm *alm = vmmc_module_to_alm(module);
+
+ return vmmc_command_write(alm->vmmc, VMMC_CMD_ALI(alm->id), alm->cmd_cache);
+}
+
+static const struct vmmc_module_ops vmmc_alm_module_ops = {
+ .sync = vmmc_alm_sync,
+ .enable = vmmc_alm_enable,
+};
+
+int vmmc_alm_init(struct vmmc_alm *alm, struct vmmc *vmmc, unsigned int id)
+{
+ int ret;
+
+ ret = vmmc_module_init(&alm->module, 5, &vmmc_alm_module_ops);
+ if (ret)
+ return ret;
+
+ alm->id = id;
+ alm->module.id = id + 0x4;
+ alm->vmmc = vmmc;
+
+ alm->cmd_cache[0] = VMMC_CMD_ALI_DATA1(1, 0, 0, 1, 0, 0, 0x2000);
+ alm->cmd_cache[1] = VMMC_CMD_ALI_DATA2(0x2000, 0, 0);
+ alm->cmd_cache[2] = VMMC_CMD_ALI_DATA3(0, 0);
+
+ vmmc_command_write(alm->vmmc, VMMC_CMD_ALI(alm->id), alm->cmd_cache);
+ vmcc_alm_set_coefficents(alm, NULL);
+ vmmc_register_module(vmmc, &alm->module);
+
+// disable lec
+// write lec coef
+// write nlp coef
+// enable lec
+
+// ALI_LEC ALI_ES RES_LEC_COEF RES_LEC_NLP_COEF
+
+ return ret;
+}
+
+void vmmc_alm_hook_event_handler(struct vmmc *vmmc, uint32_t id, uint32_t data)
+{
+ tapi_report_hook_event(&vmmc->tdev, &vmmc->tdev.ports[id], data & 1);
+}
diff --git a/package/lqtapi/src/mps/vmmc-alm.h b/package/lqtapi/src/mps/vmmc-alm.h
new file mode 100644
index 000000000..4e59b6627
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-alm.h
@@ -0,0 +1,42 @@
+#ifndef __VMMC_ALM_H__
+#define __VMMC_ALM_H__
+
+#include "vmmc-module.h"
+
+struct vmmc;
+enum vmmc_alm_state {
+ VMMC_ALM_STATE_OFF = 0 << 16,
+ VMMC_ALM_STATE_ONHOOK = 1 << 16,
+ VMMC_ALM_STATE_RING = 3 << 16,
+ VMMC_ALM_STATE_ACTIVE = 2 << 16,
+};
+
+struct vmmc_alm {
+ struct vmmc *vmmc;
+ unsigned int id;
+
+ enum vmmc_alm_state state;
+
+ struct vmmc_module module;
+
+ uint32_t cmd_cache[3];
+};
+
+struct vmmc_alm_coef {
+ struct list_head list;
+ unsigned int offset;
+ size_t len;
+ uint32_t data[0];
+};
+
+int vmmc_alm_init(struct vmmc_alm *alm, struct vmmc *vmmc, unsigned int id);
+
+int vmmc_alm_set_state(struct vmmc_alm *alm, enum vmmc_alm_state state);
+enum vmmc_alm_state vmmc_alm_get_state(struct vmmc_alm *alm);
+
+int vmcc_alm_set_coefficents(struct vmmc_alm *alm,
+ const struct vmmc_alm_coef *coef_list);
+
+void vmmc_alm_hook_event_handler(struct vmmc *vmmc, uint32_t event, uint32_t data);
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-cmds.h b/package/lqtapi/src/mps/vmmc-cmds.h
new file mode 100644
index 000000000..e833062c7
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-cmds.h
@@ -0,0 +1,98 @@
+#ifndef __VMMC_CMDS_H__
+#define __VMMC_CMDS_H__
+
+#define _VMMC_CMD(_x) ((_x) << 24)
+#define _VMMC_MOD(_x) ((_x) << 13)
+#define _VMMC_ECMD(_x) ((_x) << 8)
+
+#define _VMMC_MSG(_cmd, _mod, _ecmd) \
+ (_VMMC_CMD(_cmd) | _VMMC_ECMD(_ecmd) | _VMMC_MOD(_mod))
+
+#define _VMMC_CHAN(_chan) ((_chan) << 16)
+#define _VMMC_LENGTH(_length) ((_length) << 2)
+
+#define VMMC_CMD_OPMODE(_chan) (_VMMC_MSG(1, 0, 0) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(1))
+
+#define VMMC_CMD_SIG(_chan) (_VMMC_MSG(6, 2, 1) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(1))
+#define VMMC_CMD_SIG_DATA(_enable, _event, _rate, _i1, _i2, _mute1, _mute2) \
+ (((_enable) << 31) | ((_event) << 30) | ((_i1) << 24) | ((_i2) << 16) | \
+ ((_rate) << 23) | ((_mute1) << 15) | ((_mute2) << 14))
+
+#define VMMC_CMD_SIG_SET_ENABLE(_data, _enable) (((_data) & ~BIT(31)) | ((_enable) << 31))
+#define VMMC_CMD_SIG_SET_INPUTS(_data, _i1, _i2) (((_data) & ~0x3f3f0000) | \
+ ((_i1) << 24) | ((_i2) << 16))
+
+#define VMMC_CMD_DTMFR(_chan) (_VMMC_MSG(6, 2, 4) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(1))
+#define VMMC_CMD_DTMFR_DATA(_enable, _event, _nr) \
+ (((_enable) << 31) | ((_event) << 30) | (6 << 27) | ((_nr) << 16))
+
+#define VMMC_CMD_CODER(_chan) (_VMMC_MSG(6, 3, 1) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(4))
+
+#define VMMC_CMD_CODER_DATA1(_enable, _rate, _ns, _pte, _nr, _i1, _hp, _pf, \
+ _cng, _bfi, _dec, _im, _pst, _sic, _em, _enc) \
+ (((_enable) << 31) | ((_rate) << 30) | ((_ns) << 29) | ((_pte) << 26) | \
+ ((_nr) << 22) | ((_i1) << 16) | ((_hp) << 15) | ((_pf) << 14) | \
+ ((_cng) << 13) | ((_bfi) << 12) | ((_dec) << 11) | ((_im) << 10) | \
+ ((_pst) << 9) | ((_sic) << 8) | ((_em) << 7) | (_enc))
+
+#define VMMC_CMD_CODER_DATA2(_gain1, _gain2) (((_gain1) << 16) | (_gain2))
+
+#define VMMC_CMD_CODER_DATA3(_de, _ee, _i2, _red, _i3, _plc, _i4, _i5) \
+ (((_de) << 31) | ((_ee) << 30) | ((_i2) << 24) | ((_red) << 22) | \
+ ((_i3) << 16) | ((_plc) << 15) | ((_i4) << 8) | (_i5))
+
+#define VMMC_CMD_SERR_ACK(_chan) _VMMC_MSG(6, 7, 1) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(1)
+
+#define VMMC_CMD_SERR_ACK_DATA1(_foo) ((_foo) << 22)
+
+#define VMMC_CMD_CODER_DATA4(_tsf) ((_tsf) << 31)
+
+#define VMMC_EVENT_ID_MASK (_VMMC_MSG(0x1f, 0x7, 0x1f) | 0xff)
+
+#define VMMC_MSG_GET_CHAN(_msg) (((_msg) >> 16) & 0x1f)
+
+#define VMMC_EVENT_HOOK_STATE(_data) ((_data) & 1)
+
+#define VMMC_EVENT_HOOK_ID (_VMMC_MSG(9, 1, 1) | _VMMC_LENGTH(1))
+#define VMMC_EVENT_DTMF_ID (_VMMC_MSG(9, 2, 0) | _VMMC_LENGTH(1))
+
+#define VMMC_VOICE_DATA(_type, _chan, _len) (((_type) << 24) | ((_chan) << 16) \
+ | (_len))
+
+
+#define VMMC_CMD_ALI(_chan) (_VMMC_MSG(6, 1, 1) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(3))
+
+#define VMMC_CMD_ALI_DATA1(_enable, _rate, _ud, _eh, _eo, _i1, _dg1) \
+ (((_enable) << 31) | ((_rate) << 30) | ((_ud) << 29) | ((_eh) << 27) | \
+ ((_eo) << 26) | ((_i1) << 16) | (_dg1))
+
+#define VMMC_CMD_ALI_DATA2(_dg2, _i2, _i3) \
+ (((_dg2) << 16) | ((_i2) << 8) | (_i3))
+
+#define VMMC_CMD_ALI_DATA3(_i4, _i5) \
+ (((_i4) << 24) | ((_i5) << 16))
+
+#define VMMC_CMD_ALM_COEF(_chan, _offset, _len) \
+ (_VMMC_MSG(2, 0, _offset) | _VMMC_CHAN(_chan) | (_len))
+
+#define CMD_VOICEREC_STATUS_PACKET 0x0
+#define CMD_VOICEREC_DATA_PACKET 0x1
+#define CMD_RTP_VOICE_DATA_PACKET 0x4
+#define CMD_RTP_EVENT_PACKET 0x5
+#define CMD_ADDRESS_PACKET 0x8
+#define CMD_FAX_DATA_PACKET 0x10
+#define CMD_FAX_STATUS_PACKET 0x11
+#define CMD_P_PHONE_DATA_PACKET 0x12
+#define CMD_P_PHONE_STATUS_PACKET 0x13
+
+#define VMMC_CMD_RTP_CFG_US(_chan) \
+ (_VMMC_MSG(6, 3, 17) | _VMMC_CHAN(_chan) | (36))
+#define VMMC_CMD_RTP_CFG_DS(_chan) \
+ (_VMMC_MSG(6, 3, 25) | _VMMC_CHAN(_chan) | (32))
+
+#define VMMC_CMD_LEC(_chan) \
+ (_VMMC_MSG(6, 2, 1) | _VMMC_CHAN(_chan) | _VMMC_LENGTH(1))
+// (_VMMC_MSG(CMD_EOP, ALI_LEC_ECMD, MOD_ALI) | _VMMC_CHAN(_chan) | (32))
+
+#define VMMC_CMD_LEC_DATA()
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-coder.c b/package/lqtapi/src/mps/vmmc-coder.c
new file mode 100644
index 000000000..087a53bc7
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-coder.c
@@ -0,0 +1,221 @@
+#include <linux/kernel.h>
+
+#include "vmmc.h"
+#include "vmmc-cmds.h"
+#include "vmmc-coder.h"
+#include "vmmc-module.h"
+#include "mps.h"
+
+enum vmmc_coder_encoding {
+ VMMC_CODER_ENCODING_ALAW = 2,
+ VMMC_CODER_ENCODING_MLAW = 3,
+ VMMC_CODER_ENCODING_G726_16 = 4,
+ VMMC_CODER_ENCODING_G726_24 = 5,
+ VMMC_CODER_ENCODING_G726_32 = 6,
+ VMMC_CODER_ENCODING_G726_40 = 7,
+ VMMC_CODER_ENCODING_AMR_4_75 = 8,
+ VMMC_CODER_ENCODING_AMR_5_15 = 9,
+ VMMC_CODER_ENCODING_AMR_5_9 = 10,
+ VMMC_CODER_ENCODING_AMR_6_7 = 11,
+ VMMC_CODER_ENCODING_AMR_7_4 = 12,
+ VMMC_CODER_ENCODING_AMR_7_95 = 13,
+ VMMC_CODER_ENCODING_AMR_10_2 = 14,
+ VMMC_CODER_ENCODING_AMR_12_2 = 15,
+ VMMC_CODER_ENCODING_G728_16 = 16,
+ VMMC_CODER_ENCODING_G729AB_8 = 18,
+ VMMC_CODER_ENCODING_G729E_11_8 = 19,
+ VMMC_CODER_ENCODING_G7221_24 = 20,
+ VMMC_CODER_ENCODING_G7221_32 = 21,
+ VMMC_CODER_ENCODING_G722_64 = 22,
+ VMMC_CODER_ENCODING_L16_8 = 24,
+ VMMC_CODER_ENCODING_L16_16 = 25,
+ VMMC_CODER_ENCODING_ILBC_15_2 = 26,
+ VMMC_CODER_ENCODING_ILBC_13_3 = 27,
+ VMMC_CODER_ENCODING_G7231_5_3 = 28,
+ VMMC_CODER_ENCODING_G7231_6_3 = 29,
+ VMMC_CODER_ENCODING_ALAW_VBD = 30,
+ VMMC_CODER_ENCODING_MLAW_VBD = 31,
+};
+
+static const uint8_t vmmc_coder_payload_mapping[] = {
+ [VMMC_CODER_ENCODING_ALAW] = 8,
+ [VMMC_CODER_ENCODING_MLAW] = 0,
+ [VMMC_CODER_ENCODING_G726_16] = 35,
+ [VMMC_CODER_ENCODING_G726_24] = 36,
+ [VMMC_CODER_ENCODING_G726_32] = 37,
+ [VMMC_CODER_ENCODING_G726_40] = 38,
+ [VMMC_CODER_ENCODING_AMR_4_75] = 39,
+ [VMMC_CODER_ENCODING_AMR_5_15] = 40,
+ [VMMC_CODER_ENCODING_AMR_5_9] = 41,
+ [VMMC_CODER_ENCODING_AMR_6_7] = 42,
+ [VMMC_CODER_ENCODING_AMR_7_4] = 43,
+ [VMMC_CODER_ENCODING_AMR_7_95] = 44,
+ [VMMC_CODER_ENCODING_AMR_10_2] = 45,
+ [VMMC_CODER_ENCODING_AMR_12_2] = 46,
+ [VMMC_CODER_ENCODING_G728_16] = 47,
+ [VMMC_CODER_ENCODING_G729AB_8] = 48,
+ [VMMC_CODER_ENCODING_G729E_11_8] = 49,
+ [VMMC_CODER_ENCODING_G7221_24] = 50,
+ [VMMC_CODER_ENCODING_G7221_32] = 51,
+ [VMMC_CODER_ENCODING_G722_64] = 52,
+ [VMMC_CODER_ENCODING_L16_8] = 11,
+ [VMMC_CODER_ENCODING_L16_16] = 10,
+ [VMMC_CODER_ENCODING_ILBC_15_2] = 53,
+ [VMMC_CODER_ENCODING_ILBC_13_3] = 54,
+ [VMMC_CODER_ENCODING_G7231_5_3] = 4,
+ [VMMC_CODER_ENCODING_G7231_6_3] = 4,
+ [VMMC_CODER_ENCODING_ALAW_VBD] = 55,
+ [VMMC_CODER_ENCODING_MLAW_VBD] = 56,
+};
+
+static uint32_t payload_enc[9];
+static uint32_t payload_dec[8];
+
+static inline struct vmmc_coder *vmmc_module_to_coder(struct vmmc_module *module)
+{
+ return container_of(module, struct vmmc_coder, module);
+}
+
+static int vmmc_coder_enable(struct vmmc_module *module, bool enable)
+{
+ struct vmmc_coder *coder = vmmc_module_to_coder(module);
+
+ coder->enabled = enable;
+
+/* coder->cmd_cache[0] = VMMC_CMD_CODER_DATA1(coder->enabled, 0, 0, 0, coder->id,
+ module->pins[0], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ return vmmc_command_write(coder->vmmc, VMMC_CMD_CODER(coder->id),
+ coder->cmd_cache);*/
+ return 0;
+}
+
+static int vmmc_coder_sync(struct vmmc_module *module)
+{
+ struct vmmc_coder *coder = vmmc_module_to_coder(module);
+
+ coder->cmd_cache[0] = VMMC_CMD_CODER_DATA1(coder->enabled, 0, 1, 1, coder->id,
+ module->pins[0], 1, 1, 1, 1, 1, 1, 0, 0, 0, VMMC_CODER_ENCODING_MLAW);
+ coder->cmd_cache[1] = VMMC_CMD_CODER_DATA2(0x2000, 0x2000);
+ coder->cmd_cache[2] = VMMC_CMD_CODER_DATA3(0, 0, module->pins[1], 0,
+ module->pins[2], 0, module->pins[3], module->pins[4]);
+
+ return vmmc_command_write(coder->vmmc, VMMC_CMD_CODER(coder->id), coder->cmd_cache);
+}
+
+static const struct vmmc_module_ops vmmc_coder_module_ops = {
+ .sync = vmmc_coder_sync,
+ .enable = vmmc_coder_enable,
+};
+
+#define VMMC_CMD_CODER_JB(_chan) (_VMMC_MSG(6, 3, 18) | _VMMC_CHAN(_chan) | 8)
+#define VMMC_CMD_CODER_JB_DATA1(_sf, _prp, _pje, _dvf, _nam, _rad, _adap, _init_pod) \
+ (((_sf) << 31) | ((_prp) << 23) | ((_pje) << 22) | ((_dvf) << 21) | \
+ ((_nam) << 20) | ((_rad) << 17) | ((_adap) << 16) | (_init_pod))
+#define VMMC_CMD_CODER_JB_DATA2(_min_pod, _max_pod) \
+ (((_min_pod) << 16) | (_max_pod))
+#define VMMC_CMD_CODER_JB_DATA3(_adap_factor, _min_margin, _mode) \
+ (((_adap_factor) << 24) | ((_min_margin) << 16) | (_mode))
+
+int vmmc_coder_init(struct vmmc_coder *coder, struct vmmc *vmmc, unsigned int id)
+{
+ int ret;
+
+ ret = vmmc_module_init(&coder->module, 5, &vmmc_coder_module_ops);
+ if (ret)
+ return ret;
+
+ coder->id = id;
+ coder->module.id = id + 0x18;
+ coder->vmmc = vmmc;
+ coder->enabled = 0;
+
+ coder->cmd_cache[0] = VMMC_CMD_CODER_DATA1(0, 0, 0, 0, id, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ coder->cmd_cache[1] = VMMC_CMD_CODER_DATA2(0, 0);
+ coder->cmd_cache[2] = VMMC_CMD_CODER_DATA3(0, 0, 0, 0, 0, 0, 0, 0);
+ coder->cmd_cache[3] = VMMC_CMD_CODER_DATA4(0);
+
+ coder->jitter_buffer_cache[0] = VMMC_CMD_CODER_JB_DATA1(0x16, 1, 0, 0, 1, 1,
+ 1, 0x50);
+ coder->jitter_buffer_cache[1] = VMMC_CMD_CODER_JB_DATA2(0x50, 0x05a0);
+ coder->jitter_buffer_cache[2] = VMMC_CMD_CODER_JB_DATA3(0x0d, 0x28, 1);
+
+ vmmc_command_write(coder->vmmc, VMMC_CMD_RTP_CFG_US(coder->id), payload_enc);
+ vmmc_command_write(coder->vmmc, VMMC_CMD_RTP_CFG_DS(coder->id), payload_dec);
+ vmmc_command_write(coder->vmmc, VMMC_CMD_CODER_JB(coder->id),
+ coder->jitter_buffer_cache);
+ vmmc_command_write(coder->vmmc, VMMC_CMD_CODER(coder->id), coder->cmd_cache);
+
+ vmmc_register_module(vmmc, &coder->module);
+
+ return ret;
+}
+
+void vmmc_coder_event(struct vmmc *vmmc, unsigned int chan, unsigned int type)
+{
+}
+
+/*
+void vmmc_coder_event(struct vmmc_coder *coder, unsigned int len)
+{
+ struct sk_buff *skb;
+ provide_mem_region(coder->vmmc, vmmc_coder_alloc_paket(coder)->head, 512);
+
+ skb = skb_dequeue(&coder->paket_queue);
+ skb_put(skb, len);
+
+ tapi_stream_recv(&coder->vmmc->tdev, skb);
+}
+*/
+/*
+int vmmc_coder_set_codec(struct vmmc_coder *coder, enum vmmc_codec codec)
+{
+}*/
+
+void vmmc_init_coders(struct vmmc *vmmc)
+{
+ unsigned int i;
+
+ payload_enc[0] = 0;
+ payload_enc[1] = 0x0;
+ payload_enc[1] |= vmmc_coder_payload_mapping[2] << 8;
+ payload_enc[1] |= vmmc_coder_payload_mapping[3] << 8;
+ for (i = 2; i < 9; ++i) {
+ payload_enc[i] = vmmc_coder_payload_mapping[i*4 - 4] << 24;
+ payload_enc[i] |= vmmc_coder_payload_mapping[i*4 - 3] << 16;
+ payload_enc[i] |= vmmc_coder_payload_mapping[i*4 - 2] << 8;
+ payload_enc[i] |= vmmc_coder_payload_mapping[i*4 - 1];
+ payload_enc[i] |= 0x80808080;
+ }
+ for (i = 0; i < 7; ++i) {
+ payload_dec[i] = vmmc_coder_payload_mapping[i*4 + 2] << 24;
+ payload_dec[i] |= vmmc_coder_payload_mapping[i*4 + 3] << 16;
+ payload_dec[i] |= vmmc_coder_payload_mapping[i*4 + 4] << 8;
+ payload_dec[i] |= vmmc_coder_payload_mapping[i*4 + 5];
+ }
+ payload_dec[i] = vmmc_coder_payload_mapping[i*4 + 2] << 24;
+ payload_dec[i] |= vmmc_coder_payload_mapping[i*4 + 3] << 16;
+
+
+ vmmc->num_coders = 5;
+ vmmc->coder = kcalloc(sizeof(*vmmc->coder), vmmc->num_coders, GFP_KERNEL);
+
+ for (i = 0; i < vmmc->num_coders; ++i)
+ vmmc_coder_init(&vmmc->coder[i], vmmc, i);
+}
+
+struct vmmc_coder *vmmc_coder_get(struct vmmc *vmmc)
+{
+ unsigned int i;
+ for (i = 0; i < vmmc->num_coders; ++i) {
+ if (!test_and_set_bit(i, &vmmc->coder_used))
+ return &vmmc->coder[i];
+ }
+
+ return NULL;
+}
+
+void vmmc_coder_put(struct vmmc *vmmc, struct vmmc_coder *coder)
+{
+ clear_bit(coder->id, &vmmc->coder_used);
+}
diff --git a/package/lqtapi/src/mps/vmmc-coder.h b/package/lqtapi/src/mps/vmmc-coder.h
new file mode 100644
index 000000000..f5a87dcef
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-coder.h
@@ -0,0 +1,14 @@
+
+struct vmmc_coder {
+ struct vmmc *vmmc;
+ unsigned int id;
+
+ struct vmmc_module module;
+
+ unsigned int enabled;
+
+ uint32_t cmd_cache[4];
+ uint32_t jitter_buffer_cache[3];
+
+ struct tapi_stream *stream;
+};
diff --git a/package/lqtapi/src/mps/vmmc-core.c b/package/lqtapi/src/mps/vmmc-core.c
new file mode 100644
index 000000000..99b0d1d3d
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-core.c
@@ -0,0 +1,646 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+
+#include <linux/firmware.h>
+
+#include <linux/delay.h>
+
+#include <ifxmips_gptu.h>
+
+#include <linux/tapi/tapi.h>
+
+#include "vmmc.h"
+#include "mps.h"
+#include "mps-msg.h"
+#include "mps-irq.h"
+#include "vmmc-cmds.h"
+
+#include "vmmc-port.h"
+#include "vmmc-stream.h"
+#include "vmmc-link.h"
+#include "vmmc-coder.h"
+
+struct vmmc_capabilities {
+ uint8_t num_alm;
+ uint8_t num_pcm;
+ uint8_t num_signal;
+ uint8_t num_coder;
+ uint8_t num_agc;
+ uint8_t num_eq;
+ uint8_t num_nlec;
+ uint8_t num_wlec;
+ uint8_t num_nwlec;
+ uint8_t num_wwlec;
+ uint8_t num_tone_generators;
+ uint8_t num_dtmf_generators;
+ uint8_t num_caller_id_senders;
+ uint8_t num_caller_id_recivers;
+};
+
+#define MPS_FIRMWARE_MAGIC 0xcc123456
+
+struct vmmc_firmware_head {
+ uint32_t crc;
+ uint32_t crc_start_addr;
+ uint32_t crc_end_addr;
+ uint32_t version;
+ uint32_t encrypted;
+ uint32_t magic;
+ uint32_t mem;
+} __packed;
+
+#define VMMC_FIFO_UPSTREAM_CMD_BASE_ADDR 0x00
+#define VMMC_FIFO_UPSTREAM_CMD_SIZE_ADDR 0x04
+#define VMMC_FIFO_DOWNSTREAM_CMD_BASE_ADDR 0x08
+#define VMMC_FIFO_DOWNSTREAM_CMD_SIZE_ADDR 0x0c
+#define VMMC_FIFO_UPSTREAM_DATA_BASE_ADDR 0x10
+#define VMMC_FIFO_UPSTREAM_DATA_SIZE_ADDR 0x14
+#define VMMC_FIFO_DOWNSTREAM_DATA_BASE_ADDR 0x18
+#define VMMC_FIFO_DOWNSTREAM_DATA_SIZE_ADDR 0x1c
+#define VMMC_FIFO_UPSTREAM_CMD_TAIL_ADDR 0x20
+#define VMMC_FIFO_UPSTREAM_CMD_HEAD_ADDR 0x24
+#define VMMC_FIFO_DOWNSTREAM_CMD_TAIL_ADDR 0x28
+#define VMMC_FIFO_DOWNSTREAM_CMD_HEAD_ADDR 0x2c
+#define VMMC_FIFO_UPSTREAM_DATA_TAIL_ADDR 0x30
+#define VMMC_FIFO_UPSTREAM_DATA_HEAD_ADDR 0x34
+#define VMMC_FIFO_DOWNSTREAM_DATA_TAIL_ADDR 0x38
+#define VMMC_FIFO_DOWNSTREAM_DATA_HEAD_ADDR 0x3c
+
+#define VMMC_FIFO_EVENT_BASE_ADDR 0x180
+#define VMMC_FIFO_EVENT_SIZE_ADDR 0x184
+#define VMMC_FIFO_EVENT_TAIL_ADDR 0x188
+#define VMMC_FIFO_EVENT_HEAD_ADDR 0x18c
+
+
+/* Calculates the base of the fifo behind the given fifo */
+#define VMMC_NEXT_FIFO_BASE0(_fifo) \
+ (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
+#define VMMC_NEXT_FIFO_BASE1(_fifo) \
+ (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
+#define VMMC_NEXT_FIFO_BASE2(_fifo) \
+ (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
+
+/* Fifo sizes */
+#define VMMC_FIFO_UPSTREAM_CMD_SIZE 64
+#define VMMC_FIFO_DOWNSTREAM_CMD_SIZE 64
+#define VMMC_FIFO_UPSTREAM_DATA_SIZE 64
+#define VMMC_FIFO_DOWNSTREAM_DATA_SIZE 128
+#define VMMC_FIFO_EVENT_SIZE 64
+
+/* Fifo addresses */
+#define VMMC_FIFO_UPSTREAM_CMD_BASE 0x40
+#define VMMC_FIFO_DOWNSTREAM_CMD_BASE VMMC_NEXT_FIFO_BASE0(UPSTREAM_CMD)
+#define VMMC_FIFO_UPSTREAM_DATA_BASE VMMC_NEXT_FIFO_BASE1(DOWNSTREAM_CMD)
+#define VMMC_FIFO_DOWNSTREAM_DATA_BASE VMMC_NEXT_FIFO_BASE2(UPSTREAM_DATA)
+#define VMMC_FIFO_EVENT_BASE 0x190
+
+#define VMMC_DECLARE_FIFO_CONFIG(_name, _fifo) \
+static const struct mps_fifo_config _name = { \
+ .tail_addr = VMMC_FIFO_ ## _fifo ## _TAIL_ADDR, \
+ .head_addr = VMMC_FIFO_ ## _fifo ## _HEAD_ADDR, \
+ .base_addr = VMMC_FIFO_ ## _fifo ## _BASE_ADDR, \
+ .size_addr = VMMC_FIFO_ ## _fifo ## _SIZE_ADDR, \
+ .base = VMMC_FIFO_ ## _fifo ## _BASE, \
+ .size = VMMC_FIFO_ ## _fifo ## _SIZE, \
+}
+
+VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_upstream_cmd, UPSTREAM_CMD);
+VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_downstream_cmd, DOWNSTREAM_CMD);
+VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_upstream_data, UPSTREAM_DATA);
+VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_downstream_data, DOWNSTREAM_DATA);
+VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_event, EVENT);
+
+static void vmmc_setup_fifos(struct vmmc *vmmc)
+{
+ mps_configure_mailbox(vmmc->mps, &vmmc->mbox_cmd,
+ &vmmc_fifo_config_upstream_cmd, &vmmc_fifo_config_downstream_cmd);
+ mps_configure_mailbox(vmmc->mps, &vmmc->mbox_data,
+ &vmmc_fifo_config_upstream_data, &vmmc_fifo_config_downstream_data);
+
+ mps_configure_fifo(vmmc->mps, &vmmc->fifo_event, &vmmc_fifo_config_event);
+}
+
+static uint32_t cram_data[] = {
+0x00200000, 0x00008e59, 0x165235cd, 0x17e2f141, 0xe3eef301, 0x0a431281,
+0x04fdf20d, 0x7fe363d5, 0xfd4b7333, 0x7ffffd44, 0xfcf80298, 0xfecd00c9,
+0xff900042, 0xfff70003, 0x000923b7, 0xe92a354d, 0xc8981f44, 0x9c0f1257,
+0x26aacf33, 0x27db9836, 0x10586f5b, 0x9c167d2d, 0x94b679a7, 0x8c227660,
+0x83fa7491, 0x7ce0826a, 0x7ff87ff4, 0x296b4e22, 0x76e67fff, 0x008ffc04,
+0x02cbfb36, 0x026afeba, 0x009effc3, 0x0013fffd, 0x23b7e92a, 0x354dc898,
+0x1f449c0f, 0x125726aa, 0xcf3327db, 0x98361058, 0x74bc93d6, 0x7ebc8f61,
+0x7d068986, 0x7b46833b, 0x7a3b7f00, 0x287a47b1, 0x05800367, 0x20ae2715,
+0x0fb5da12, 0x1935f53b, 0x01230240, 0xfc717f00, 0x2000d346,
+};
+
+static void vmmc_push_data_paket(struct vmmc *vmmc, int type, unsigned int chan,
+ void __iomem *addr, size_t len)
+{
+ uint32_t data[3];
+
+ data[0] = VMMC_VOICE_DATA(type, chan, 8);
+ data[1] = CPHYSADDR(addr);
+ data[2] = len;
+
+ mps_fifo_in(&vmmc->mbox_data.downstream, data, 3);
+}
+
+static struct sk_buff *vmmc_alloc_data_paket(struct vmmc *vmmc)
+{
+ struct sk_buff *skb;
+
+ skb = alloc_skb(512, GFP_KERNEL);
+
+ skb_queue_tail(&vmmc->recv_queue, skb);
+
+ return skb;
+}
+
+static void vmmc_provide_paket(struct vmmc *vmmc)
+{
+ struct sk_buff *skb = vmmc_alloc_data_paket(vmmc);
+ vmmc_push_data_paket(vmmc, CMD_ADDRESS_PACKET, 0, skb->data, skb->len);
+}
+
+static void vmmc_recv_paket(struct vmmc *vmmc, unsigned int chan, void __iomem *addr, size_t len)
+{
+ struct sk_buff *skb;
+ struct sk_buff *tmp;
+
+ skb_queue_walk_safe(&vmmc->recv_queue, skb, tmp) {
+ if (skb->data == addr)
+ break;
+ }
+
+ if (skb == (struct sk_buff *)(&vmmc->recv_queue)) {
+ printk("AHHHH\n");
+ return;
+ }
+
+ dma_cache_inv((u32)addr, len);
+ skb_unlink(skb, &vmmc->recv_queue);
+
+ if (!vmmc->coder[chan].stream) {
+ kfree_skb(skb);
+ return;
+ }
+
+ skb_put(skb, len);
+ tapi_stream_recv(&vmmc->tdev, vmmc->coder[chan].stream, skb);
+}
+
+void vmmc_send_paket(struct vmmc *vmmc, unsigned int chan, struct sk_buff *skb)
+{
+ skb_queue_tail(&vmmc->send_queue, skb);
+
+ dma_cache_wback((u32)skb->data, skb->len);
+ vmmc_push_data_paket(vmmc, CMD_RTP_VOICE_DATA_PACKET, chan, skb->data,
+ skb->len);
+}
+
+static void vmmc_free_paket(struct vmmc *vmmc, void __iomem *addr, size_t len)
+{
+ struct sk_buff *skb;
+ struct sk_buff *tmp;
+
+ skb_queue_walk_safe(&vmmc->send_queue, skb, tmp) {
+ if (skb->data == addr)
+ break;
+ }
+
+ if (skb == (struct sk_buff *)(&vmmc->send_queue)) {
+ printk("AHHHH\n");
+ } else {
+ skb_unlink(skb, &vmmc->send_queue);
+ kfree_skb(skb);
+ }
+}
+
+
+static void vmmc_write_cram_data(struct vmmc *vmmc, unsigned int id,
+ uint32_t *data, size_t length)
+{
+ size_t transfer_length;
+ size_t offset = 0;
+ uint32_t cmd;
+
+ length *= 4;
+ offset = 0x5;
+
+ while (length) {
+ transfer_length = length > 56 ? 56 : length;
+ cmd = VMMC_CMD_ALM_COEF(id, offset, transfer_length);
+ vmmc_command_write(vmmc, cmd, data);
+
+ data += transfer_length >> 2;
+ offset += transfer_length >> 1;
+ length -= transfer_length;
+ }
+}
+
+int vmmc_command_read(struct vmmc *vmmc, uint32_t cmd, uint32_t *result)
+{
+ struct mps_mailbox *mbox = &vmmc->mbox_cmd;
+
+ INIT_COMPLETION(vmmc->cmd_completion);
+
+ mps_fifo_in(&mbox->downstream, &cmd, 1);
+
+ wait_for_completion(&vmmc->cmd_completion);
+
+ mps_fifo_out(&mbox->upstream, result, 1);
+ mps_fifo_out(&mbox->upstream, result, (*result & 0xff) / 4);
+
+ return 0;
+}
+
+int vmmc_command_write(struct vmmc *vmmc, uint32_t cmd,
+ const uint32_t *data)
+{
+ struct mps_mailbox *mbox = &vmmc->mbox_cmd;
+/* int i;
+
+ printk("cmd: %x\n", cmd);
+ for (i = 0; i < DIV_ROUND_UP((cmd & 0xff), 4); ++i) {
+ printk("data[%d] = %x\n", i, data[i]);
+ }
+*/
+ while (mps_fifo_len(&mbox->downstream) < (cmd & 0xff) + 4)
+ mdelay(100);
+
+ mps_fifo_in(&mbox->downstream, &cmd, 1);
+ mps_fifo_in(&mbox->downstream, data, DIV_ROUND_UP((cmd & 0xff), 4));
+
+ mdelay(100);
+
+ return 0;
+}
+
+static int vmmc_modules_sync(struct tapi_device *tapi)
+{
+ struct vmmc *vmmc = tdev_to_vmmc(tapi);
+ struct vmmc_module *module;
+
+ list_for_each_entry(module, &vmmc->modules, head)
+ vmmc_module_sync(module);
+
+ return 0;
+}
+
+static const struct tapi_ops vmmc_tapi_ops = {
+ .send_dtmf_event = vmmc_port_send_dtmf_event,
+ .ring = vmmc_port_ring,
+
+ .sync = vmmc_modules_sync,
+
+ .stream_alloc = vmmc_stream_alloc,
+ .stream_free = vmmc_stream_free,
+ .stream_send = vmmc_stream_send,
+
+ .link_alloc = vmmc_tapi_link_alloc,
+ .link_free = vmmc_tapi_link_free,
+ .link_enable = vmmc_tapi_link_enable,
+ .link_disable = vmmc_tapi_link_disable,
+};
+
+static void setup_alm(struct vmmc *vmmc)
+{
+ int i;
+
+ vmmc->tdev.ports = kcalloc(2, sizeof(*vmmc->tdev.ports), GFP_KERNEL);
+ vmmc->ports = kcalloc(2, sizeof(*vmmc->ports), GFP_KERNEL);
+
+ for (i = 0; i < 2; ++i)
+ vmmc_port_init(vmmc, &vmmc->ports[i], &vmmc->tdev.ports[i], i);
+
+ skb_queue_head_init(&vmmc->send_queue);
+ skb_queue_head_init(&vmmc->recv_queue);
+
+ for (i = 0; i < 10; ++i)
+ vmmc_provide_paket(vmmc);
+
+ vmmc->tdev.num_ports = 2;
+ vmmc->tdev.ops = &vmmc_tapi_ops;
+ tapi_device_register(&vmmc->tdev, "vmmc", vmmc->dev);
+}
+
+static void vmmc_init_timer(struct vmmc *vmmc)
+{
+ unsigned int timer;
+ unsigned int timer_flags;
+ int ret;
+ unsigned long loops, count;
+
+ timer = TIMER1B;
+
+ timer_flags =
+ TIMER_FLAG_16BIT | TIMER_FLAG_COUNTER | TIMER_FLAG_CYCLIC |
+ TIMER_FLAG_DOWN | TIMER_FLAG_FALL_EDGE | TIMER_FLAG_SYNC |
+ TIMER_FLAG_CALLBACK_IN_IRQ;
+ ret = ifxmips_request_timer (timer, timer_flags, 1, 0, 0);
+ if (ret < 0) {
+ printk("FAILED TO INIT TIMER\n");
+ return;
+ }
+ ret = ifxmips_start_timer (timer, 0);
+ if (ret < 0) {
+ printk("FAILED TO START TIMER\n");
+ return;
+ }
+ do
+ {
+ loops++;
+ ifxmips_get_count_value(timer, &count);
+ } while (count);
+
+ *((volatile uint32_t *) (KSEG1 + 0x1e100a00 + 0x0014)) = 0x000005c5;
+}
+
+static void vmmc_free_timer(struct vmmc *vmmc)
+{
+ ifxmips_free_timer(TIMER1B);
+}
+
+static void vmmc_get_capabilities(struct vmmc *vmmc)
+{
+ uint32_t data[10];
+ uint8_t len;
+
+ vmmc_command_read(vmmc,
+ MPS_MSG_CMD_EOP_SYSTEM(SYS_CAP_ECMD, sizeof(uint32_t)), data);
+
+ len = ((data[0] >> 16) & 0xff) - sizeof(uint32_t);
+
+ if (len > sizeof(data))
+ len = sizeof(data);
+
+ vmmc_command_read(vmmc,
+ MPS_MSG_CMD_EOP_SYSTEM(SYS_CAP_ECMD, len), data);
+
+ len /= 4;
+
+/* for (;len > 0; --len) {
+ printk("fw cap(%d): %.2x\n", 10-len, data[10-len]);
+ }
+*/
+ setup_alm(vmmc);
+}
+
+static void vmmc_get_firmware_version(struct vmmc *vmmc)
+{
+ uint32_t data[1];
+
+ vmmc_command_read(vmmc, MPS_CMD_GET_VERSION, data);
+
+ printk("firmware version: %x\n", *data);
+
+ vmmc_get_capabilities(vmmc);
+}
+
+static irqreturn_t vmmc_firmware_loaded_irq(int irq, void *devid)
+{
+ struct vmmc *vmmc = devid;
+ complete(&vmmc->firmware_loaded_completion);
+ printk("Firmware loaded irq\n");
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t vmmc_cmd_error_irq(int irq, void *devid)
+{
+/* struct vmmc *vmmc = devid;*/
+
+ printk("cmd error!!!!\n");
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t vmmc_recv_ov_irq(int irq, void *devid)
+{
+ struct vmmc *vmmc = devid;
+ uint32_t data[2] = {
+ VMMC_CMD_SERR_ACK(0),
+ VMMC_CMD_SERR_ACK_DATA1(1)
+ };
+ uint32_t voice_data[64];
+
+ return IRQ_HANDLED;
+
+ mps_fifo_in(&vmmc->mbox_cmd.downstream, data, 2);
+ mps_fifo_out(&vmmc->mbox_data.upstream, voice_data, 15);
+
+ printk("recv overflow: %x\n", voice_data[0]);
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t vmmc_event_fifo_irq(int irq, void *devid)
+{
+ struct vmmc *vmmc = devid;
+ uint32_t event, event_id;
+ uint32_t data = 0;
+ unsigned int chan;
+
+ mps_fifo_out(&vmmc->fifo_event, &event, 1);
+
+ event_id = event & VMMC_EVENT_ID_MASK;
+ chan = VMMC_MSG_GET_CHAN(event);
+
+ if (event & 0xff)
+ mps_fifo_out(&vmmc->fifo_event, &data, 1);
+
+ switch (event_id) {
+ case VMMC_EVENT_HOOK_ID:
+ vmmc_alm_hook_event_handler(vmmc, chan, data);
+ break;
+ case VMMC_EVENT_DTMF_ID:
+ vmmc_sig_dtmf_event_handler(vmmc, chan, data);
+ break;
+ default:
+ printk("Ein unbekanntes Event: %x %x\n", event, data);
+ break;
+ }
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t vmmc_mbox_data_irq_handler(int irq, void *devid)
+{
+ struct vmmc *vmmc = devid;
+ struct mps_mailbox *mbox = &vmmc->mbox_data;
+ unsigned int count, type, chan;
+ uint32_t data[2];
+ void __iomem *addr;
+ size_t len;
+
+ mps_fifo_out(&mbox->upstream, data, 1);
+
+ count = (data[0] & 0xff) / 8;
+ type = (data[0] >> 24) & 0xff;
+ chan = (data[0] >> 16) & 0xff;
+
+ while (count) {
+ mps_fifo_out(&mbox->upstream, data, 2);
+
+ addr = (void __iomem *)CKSEG0ADDR(data[0]);
+ len = data[1];
+
+ switch (type) {
+ case CMD_ADDRESS_PACKET:
+ vmmc_free_paket(vmmc, addr, len);
+ break;
+ case CMD_RTP_VOICE_DATA_PACKET:
+ vmmc_provide_paket(vmmc);
+ vmmc_recv_paket(vmmc, chan, addr, len);
+ break;
+ }
+ --count;
+ }
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t vmmc_mbox_cmd_irq_handler(int irq, void *devid)
+{
+ struct vmmc *vmmc = devid;
+
+ complete(&vmmc->cmd_completion);
+
+ return IRQ_HANDLED;
+}
+
+static void vmmc_load_firmware(const struct firmware *fw, void *context)
+{
+ struct vmmc *vmmc = context;
+ struct vmmc_firmware_head *fw_head;
+ size_t tail_size;
+ enum mps_boot_config config;
+
+ if (!fw) {
+ printk("failed to load tapi firmware\n");
+// request_firmware_nowait(THIS_MODULE, 1, "danube_firmware.bin", vmmc->dev,
+// GFP_KERNEL, vmmc, vmmc_load_firmware);
+ return;
+ }
+
+ if (fw->size < sizeof(*fw_head))
+ return;
+
+ fw_head = (struct vmmc_firmware_head *)((uint8_t *)fw->data + fw->size - sizeof(*fw_head));
+
+ if (fw_head->magic != MPS_FIRMWARE_MAGIC) {
+ config = MPS_BOOT_LEGACY;
+ tail_size = sizeof(uint32_t);
+ } else {
+ config = MPS_BOOT_ENCRYPTED;
+ tail_size = sizeof(*fw_head) - sizeof(uint32_t);
+ }
+
+ vmmc_setup_fifos(vmmc);
+ init_completion(&vmmc->firmware_loaded_completion);
+ mps_load_firmware(vmmc->mps, fw->data, fw->size - tail_size, config);
+ wait_for_completion_timeout(&vmmc->firmware_loaded_completion, 5*HZ);
+ vmmc_init_timer(vmmc);
+ vmmc_write_cram_data(vmmc, 0, cram_data, ARRAY_SIZE(cram_data));
+ vmmc_write_cram_data(vmmc, 1, cram_data, ARRAY_SIZE(cram_data));
+ vmmc_get_firmware_version(vmmc);
+ vmmc_init_coders(vmmc);
+}
+
+static int vmmc_request_irqs(struct vmmc *vmmc)
+{
+ int ret;
+
+ ret = request_irq(vmmc->irq_fw_loaded, vmmc_firmware_loaded_irq, 0, "vmmc fw loaded", vmmc);
+ ret = request_irq(vmmc->irq_event_fifo, vmmc_event_fifo_irq, 0, "vmmc event fifo", vmmc);
+ ret = request_irq(vmmc->irq_cmd_error, vmmc_cmd_error_irq, 0,
+ "cmd error irq", vmmc);
+ ret = request_irq(MPS_IRQ_RCV_OVERFLOW, vmmc_recv_ov_irq, 0,
+ "recv_ov irq", vmmc);
+
+ ret = request_irq(vmmc->irq_mbox_cmd, vmmc_mbox_cmd_irq_handler, 0,
+ "vmmc cmd mailbox irq", vmmc);
+
+ ret = request_irq(vmmc->irq_mbox_data, vmmc_mbox_data_irq_handler, 0,
+ "vmmc data mailbox irq", vmmc);
+
+ return ret;
+}
+
+static int __devinit vmmc_probe(struct platform_device *pdev)
+{
+ struct vmmc *vmmc;
+ int ret = 0;
+
+ vmmc = kzalloc(sizeof(*vmmc), GFP_KERNEL);
+
+ if (!vmmc)
+ return -ENOMEM;
+
+ vmmc->dev = &pdev->dev;
+ vmmc->mps = device_to_mps(pdev->dev.parent);
+
+ if (!vmmc->mps) {
+ goto err_free;
+ ret = -EBUSY;
+ }
+
+ INIT_LIST_HEAD(&vmmc->modules);
+ init_completion(&vmmc->cmd_completion);
+
+ vmmc->irq_fw_loaded = MPS_IRQ_DOWNLOAD_DONE;
+ vmmc->irq_mbox_cmd = MPS_IRQ_CMD_UPSTREAM;
+ vmmc->irq_mbox_data = MPS_IRQ_DATA_UPSTREAM;
+ vmmc->irq_event_fifo = MPS_IRQ_EVENT;
+ vmmc->irq_cmd_error = MPS_IRQ_CMD_ERROR;
+
+ platform_set_drvdata(pdev, vmmc);
+
+ vmmc_request_irqs(vmmc);
+
+ request_firmware_nowait(THIS_MODULE, 1, "danube_firmware.bin", &pdev->dev,
+ GFP_KERNEL, vmmc, vmmc_load_firmware);
+
+ return 0;
+
+err_free:
+ kfree(vmmc);
+
+ return ret;
+}
+
+static int __devexit vmmc_remove(struct platform_device *pdev)
+{
+ struct vmmc *vmmc = platform_get_drvdata(pdev);
+ vmmc_free_timer(vmmc);
+
+ tapi_device_unregister(&vmmc->tdev);
+
+ return 0;
+}
+
+static struct platform_driver vmmc_driver = {
+ .probe = vmmc_probe,
+ .remove = __devexit_p(vmmc_remove),
+ .driver = {
+ .name = "vmmc",
+ .owner = THIS_MODULE
+ },
+};
+
+static int __init vmmc_init(void)
+{
+ return platform_driver_register(&vmmc_driver);
+}
+module_init(vmmc_init);
+
+static void __exit vmmc_exit(void)
+{
+ platform_driver_unregister(&vmmc_driver);
+}
+module_exit(vmmc_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
diff --git a/package/lqtapi/src/mps/vmmc-link.c b/package/lqtapi/src/mps/vmmc-link.c
new file mode 100644
index 000000000..42d11dbb6
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-link.c
@@ -0,0 +1,52 @@
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/tapi/tapi.h>
+
+#include "vmmc-link.h"
+#include "vmmc-module.h"
+
+struct vmmc_tapi_link {
+ struct tapi_link tapi_link;
+ struct vmmc_link vmmc_link;
+};
+
+struct tapi_link *vmmc_tapi_link_alloc(struct tapi_device *tdev,
+ struct tapi_endpoint *ep1, struct tapi_endpoint *ep2)
+{
+ struct vmmc_tapi_link *link = kzalloc(sizeof(*link), GFP_KERNEL);
+ struct vmmc_module *module1 = tapi_endpoint_to_vmmc_module(ep1);
+ struct vmmc_module *module2 = tapi_endpoint_to_vmmc_module(ep2);
+
+ vmmc_link_init(&link->vmmc_link, module1, module2);
+
+ return &link->tapi_link;
+}
+
+void vmmc_tapi_link_free(struct tapi_device *tdev, struct tapi_link *tapi_link)
+{
+ struct vmmc_tapi_link *link = container_of(tapi_link, struct vmmc_tapi_link,
+ tapi_link);
+
+ vmmc_link_put(&link->vmmc_link);
+ kfree(link);
+}
+
+int vmmc_tapi_link_enable(struct tapi_device *tdev,
+ struct tapi_link *tapi_link)
+{
+ struct vmmc_tapi_link *link = container_of(tapi_link, struct vmmc_tapi_link,
+ tapi_link);
+
+ vmmc_link_enable(&link->vmmc_link);
+ return 0;
+}
+
+int vmmc_tapi_link_disable(struct tapi_device *tdev,
+ struct tapi_link *tapi_link)
+{
+ struct vmmc_tapi_link *link = container_of(tapi_link, struct vmmc_tapi_link,
+ tapi_link);
+
+ vmmc_link_disable(&link->vmmc_link);
+ return 0;
+}
diff --git a/package/lqtapi/src/mps/vmmc-link.h b/package/lqtapi/src/mps/vmmc-link.h
new file mode 100644
index 000000000..9f818bd83
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-link.h
@@ -0,0 +1,10 @@
+#ifndef __VMMC_LINK_H__
+#define __VMMC_LINK_H__
+
+struct tapi_link *vmmc_tapi_link_alloc(struct tapi_device *tdev,
+ struct tapi_endpoint *ep1, struct tapi_endpoint *ep2);
+void vmmc_tapi_link_free(struct tapi_device *tdev, struct tapi_link *link);
+int vmmc_tapi_link_enable(struct tapi_device *tdev, struct tapi_link *link);
+int vmmc_tapi_link_disable(struct tapi_device *tdev, struct tapi_link *link);
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-module.c b/package/lqtapi/src/mps/vmmc-module.c
new file mode 100644
index 000000000..181f0c6b7
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-module.c
@@ -0,0 +1,130 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+
+#include <asm/bitops.h>
+
+#include "vmmc-module.h"
+
+int vmmc_module_init(struct vmmc_module *module, size_t num_pins,
+ const struct vmmc_module_ops *ops)
+{
+ module->pins = kcalloc(num_pins, sizeof(*module->pins), GFP_KERNEL);
+
+ if (!module->pins)
+ return -ENOMEM;
+
+ module->num_pins = num_pins;
+ module->ops = ops;
+
+ mutex_init(&module->lock);
+ module->refcount = 0;
+
+ return 0;
+}
+
+int vmmc_module_sync(struct vmmc_module *module)
+{
+ if (!test_and_clear_bit(VMMC_MODULE_FLAG_MODIFIED, &module->flags))
+ return 0;
+
+ return module->ops->sync(module);
+}
+
+int vmmc_module_get_pin(struct vmmc_module *module)
+{
+ size_t i = 0;
+ int ret = 0;
+
+ for (i = 0; i < module->num_pins; ++i) {
+ if (!test_and_set_bit(VMMC_MODULE_FLAG_PIN_USED(i), &module->flags))
+ break;
+ }
+ if (i == module->num_pins)
+ ret = -EBUSY;
+ else
+ ret = i;
+
+ return ret;
+}
+
+void vmmc_module_put_pin(struct vmmc_module *module, unsigned int pin)
+{
+ module->pins[pin] = 0;
+ clear_bit(VMMC_MODULE_FLAG_PIN_USED(pin), &module->flags);
+}
+
+void vmmc_module_set_pin_input(struct vmmc_module *module, unsigned int pin,
+ struct vmmc_module *input)
+{
+ if (input)
+ module->pins[pin] = input->id;
+ else
+ module->pins[pin] = 0;
+
+ set_bit(VMMC_MODULE_FLAG_MODIFIED, &module->flags);
+}
+
+static void vmmc_module_enable(struct vmmc_module *module)
+{
+ mutex_lock(&module->lock);
+
+ if (++module->refcount == 1)
+ module->ops->enable(module, true);
+
+ mutex_unlock(&module->lock);
+}
+
+static void vmmc_module_disable(struct vmmc_module *module)
+{
+ mutex_lock(&module->lock);
+
+ if (module->refcount <= 0)
+ printk(KERN_ERR "vmmc module: unbalanced disable\n");
+ else if (--module->refcount == 0)
+ module->ops->enable(module, false);
+
+ mutex_unlock(&module->lock);
+}
+
+
+unsigned int vmmc_link_init(struct vmmc_link *link,
+ struct vmmc_module *a, struct vmmc_module *b)
+{
+ link->pins[0] = vmmc_module_get_pin(a);
+ link->pins[1] = vmmc_module_get_pin(b);
+ link->modules[0] = a;
+ link->modules[1] = b;
+
+ return 0;
+}
+
+void vmmc_link_put(struct vmmc_link *link)
+{
+ vmmc_link_disable(link);
+ vmmc_module_sync(link->modules[0]);
+ vmmc_module_sync(link->modules[1]);
+ vmmc_module_put_pin(link->modules[0], link->pins[0]);
+ vmmc_module_put_pin(link->modules[1], link->pins[1]);
+}
+
+void vmmc_link_enable(struct vmmc_link *link)
+{
+ vmmc_module_set_pin_input(link->modules[0], link->pins[0],
+ link->modules[1]);
+ vmmc_module_set_pin_input(link->modules[1], link->pins[1],
+ link->modules[0]);
+
+ vmmc_module_enable(link->modules[0]);
+ vmmc_module_enable(link->modules[1]);
+}
+
+void vmmc_link_disable(struct vmmc_link *link)
+{
+ vmmc_module_set_pin_input(link->modules[0], link->pins[0], NULL);
+ vmmc_module_set_pin_input(link->modules[1], link->pins[1], NULL);
+
+ vmmc_module_disable(link->modules[0]);
+ vmmc_module_disable(link->modules[1]);
+}
diff --git a/package/lqtapi/src/mps/vmmc-module.h b/package/lqtapi/src/mps/vmmc-module.h
new file mode 100644
index 000000000..b598d0dcd
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-module.h
@@ -0,0 +1,64 @@
+#ifndef __VMMC_MODULE_H__
+#define __VMMC_MODULE_H__
+
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/tapi/tapi.h>
+
+struct vmmc_module;
+
+struct vmmc_module_ops {
+ int (*sync)(struct vmmc_module *);
+ int (*enable)(struct vmmc_module *, bool enable);
+};
+
+struct vmmc_module
+{
+ unsigned int id;
+
+ size_t num_pins;
+ unsigned int *pins;
+
+ const struct vmmc_module_ops *ops;
+
+ unsigned long flags;
+#define VMMC_MODULE_FLAG_PIN_USED(x) (x)
+#define VMMC_MODULE_FLAG_MODIFIED 31
+ struct mutex lock;
+ struct list_head head;
+
+ unsigned int refcount;
+};
+
+int vmmc_module_init(struct vmmc_module *module, size_t num_pins,
+ const struct vmmc_module_ops *ops);
+int vmmc_module_sync(struct vmmc_module *module);
+
+struct vmmc_link {
+ struct vmmc_module *modules[2];
+ unsigned int pins[2];
+};
+
+struct vmmc_endpoint {
+ struct tapi_endpoint ep;
+ struct vmmc_module *module;
+};
+
+void vmmc_link_enable(struct vmmc_link *link);
+void vmmc_link_disable(struct vmmc_link *link);
+unsigned int vmmc_link_init(struct vmmc_link *link,
+ struct vmmc_module *a, struct vmmc_module *b);
+void vmmc_link_put(struct vmmc_link *link);
+
+int vmmc_module_get_pin(struct vmmc_module *module);
+void vmmc_module_put_pin(struct vmmc_module *module, unsigned int pin);
+void vmmc_module_set_pin_input(struct vmmc_module *module, unsigned int pin,
+ struct vmmc_module *input);
+
+
+static inline struct vmmc_module *tapi_endpoint_to_vmmc_module(struct tapi_endpoint *ep)
+{
+ return tapi_endpoint_get_data(ep);
+}
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-port.c b/package/lqtapi/src/mps/vmmc-port.c
new file mode 100644
index 000000000..aa620a1e0
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-port.c
@@ -0,0 +1,48 @@
+#include <linux/kernel.h>
+#include <linux/slab.h>
+
+#include <linux/tapi/tapi.h>
+
+#include "vmmc.h"
+#include "vmmc-port.h"
+#include "vmmc-alm.h"
+#include "vmmc-sig.h"
+
+int vmmc_port_ring(struct tapi_device *tdev, struct tapi_port *port, bool ring)
+{
+ struct vmmc *vmmc = tdev_to_vmmc(tdev);
+
+ return vmmc_alm_set_state(&vmmc->ports[port->id].alm,
+ ring ? VMMC_ALM_STATE_RING : VMMC_ALM_STATE_ONHOOK);
+}
+
+int vmmc_port_send_dtmf_event(struct tapi_device *tdev,
+ struct tapi_port *port, struct tapi_dtmf_event *event)
+{
+ return 0;
+}
+
+struct vmmc_port *vmmc_port_init(struct vmmc *vmmc, struct vmmc_port *port,
+ struct tapi_port *tport, unsigned int id)
+{
+ vmmc_alm_init(&port->alm, vmmc, id);
+ vmmc_sig_init(&port->sig, vmmc, id);
+
+ port->sig_pin = vmmc_module_get_pin(&port->sig.module);
+ vmmc_module_set_pin_input(&port->sig.module, port->sig_pin,
+ &port->alm.module);
+
+ vmmc_module_sync(&port->sig.module);
+
+ vmmc_alm_set_state(&port->alm, VMMC_ALM_STATE_ONHOOK);
+
+ tport->id = id;
+ tapi_endpoint_set_data(&tport->ep, &port->alm.module);
+
+ return port;
+}
+
+void vmmc_port_put(struct vmmc *vmmc, struct vmmc_port *port)
+{
+ vmmc_module_put_pin(&port->sig.module, port->sig_pin);
+}
diff --git a/package/lqtapi/src/mps/vmmc-port.h b/package/lqtapi/src/mps/vmmc-port.h
new file mode 100644
index 000000000..1efceb0b2
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-port.h
@@ -0,0 +1,22 @@
+#ifndef __VMMC_PORT_H__
+#define __VMMC_PORT_H__
+
+#include "vmmc-alm.h"
+#include "vmmc-sig.h"
+
+void vmmc_port_free(struct vmmc *vmmc, struct vmmc_port *port);
+
+int vmmc_port_ring(struct tapi_device *tdev, struct tapi_port *port, bool ring);
+int vmmc_port_send_dtmf_event(struct tapi_device *tdev,
+ struct tapi_port *port, struct tapi_dtmf_event *event);
+struct vmmc_port *vmmc_port_init(struct vmmc *vmmc, struct vmmc_port *port,
+struct tapi_port *tport, unsigned int id);
+
+struct vmmc_port
+{
+ struct vmmc_alm alm;
+ struct vmmc_sig sig;
+ unsigned int sig_pin;
+};
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-sig.h b/package/lqtapi/src/mps/vmmc-sig.h
new file mode 100644
index 000000000..e8f047063
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-sig.h
@@ -0,0 +1,19 @@
+#ifndef __VMMC_SIG_H__
+#define __VMMC_SIG_H__
+
+#include "vmmc-module.h"
+
+struct vmmc_sig {
+ struct vmmc *vmmc;
+ unsigned int id;
+ struct vmmc_module module;
+
+ uint32_t sig_cache;
+ uint32_t dtmfr_cache;
+};
+
+int vmmc_sig_init(struct vmmc_sig *sig, struct vmmc *vmmc, unsigned int id);
+
+void vmmc_sig_dtmf_event_handler(struct vmmc *vmmc, uint32_t event, uint32_t data);
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc-signal.c b/package/lqtapi/src/mps/vmmc-signal.c
new file mode 100644
index 000000000..83fea6083
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-signal.c
@@ -0,0 +1,69 @@
+#include <linux/kernel.h>
+
+#include "vmmc.h"
+#include "vmmc-sig.h"
+#include "vmmc-cmds.h"
+
+static struct vmmc_sig *vmmc_module_to_sig(struct vmmc_module *module)
+{
+ return container_of(module, struct vmmc_sig, module);
+}
+
+static int vmmc_sig_enable(struct vmmc_module *module, bool enabled)
+{
+ struct vmmc_sig *sig = vmmc_module_to_sig(module);
+
+ return 0;
+
+ sig->sig_cache = VMMC_CMD_SIG_SET_ENABLE(sig->sig_cache, enabled);
+
+ return vmmc_command_write(sig->vmmc, VMMC_CMD_SIG(sig->id), &sig->sig_cache);
+}
+
+static int vmmc_sig_sync(struct vmmc_module *module)
+{
+ struct vmmc_sig *sig = vmmc_module_to_sig(module);
+
+ sig->sig_cache = VMMC_CMD_SIG_SET_INPUTS(sig->sig_cache,
+ module->pins[0], module->pins[1]);
+
+ vmmc_command_write(sig->vmmc, VMMC_CMD_SIG(sig->id),
+ &sig->sig_cache);
+
+ return vmmc_command_write(sig->vmmc, VMMC_CMD_DTMFR(sig->id),
+ &sig->dtmfr_cache);
+}
+
+static const struct vmmc_module_ops vmmc_sig_ops = {
+ .enable = vmmc_sig_enable,
+ .sync = vmmc_sig_sync,
+};
+
+int vmmc_sig_init(struct vmmc_sig *sig, struct vmmc *vmmc, unsigned int id)
+{
+ int ret;
+
+ ret = vmmc_module_init(&sig->module, 2, &vmmc_sig_ops);
+ if (ret)
+ return ret;
+
+ sig->id = id;
+ sig->module.id = id + 0x1e;
+ sig->vmmc = vmmc;
+ sig->sig_cache = VMMC_CMD_SIG_DATA(1, 1, 0, 0, 0, 0, 0);
+ sig->dtmfr_cache = VMMC_CMD_DTMFR_DATA(1, 1, id);
+
+ vmmc_register_module(vmmc, &sig->module);
+
+ vmmc_command_write(sig->vmmc, VMMC_CMD_SIG(sig->id),
+ &sig->sig_cache);
+ vmmc_command_write(sig->vmmc, VMMC_CMD_DTMFR(sig->id),
+ &sig->dtmfr_cache);
+
+ return ret;
+}
+
+void vmmc_sig_dtmf_event_handler(struct vmmc *vmmc, uint32_t id, uint32_t data)
+{
+ tapi_report_dtmf_event(&vmmc->tdev, &vmmc->tdev.ports[id], data & 0xf);
+}
diff --git a/package/lqtapi/src/mps/vmmc-stream.c b/package/lqtapi/src/mps/vmmc-stream.c
new file mode 100644
index 000000000..36f5eef80
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-stream.c
@@ -0,0 +1,73 @@
+#include <linux/kernel.h>
+#include <linux/tapi/tapi.h>
+#include <linux/skbuff.h>
+
+#include "vmmc.h"
+#include "vmmc-coder.h"
+
+struct vmmc_tapi_stream {
+ struct vmmc_coder *coder;
+ struct tapi_stream stream;
+};
+
+struct vmmc_tapi_stream *tapi_to_vmmc_stream(struct tapi_stream * stream)
+{
+ return container_of(stream, struct vmmc_tapi_stream, stream);
+}
+
+struct tapi_stream *vmmc_stream_alloc(struct tapi_device *tdev)
+{
+ struct vmmc *vmmc = tdev_to_vmmc(tdev);
+ struct vmmc_tapi_stream *stream;
+ struct vmmc_coder *coder;
+
+ coder = vmmc_coder_get(vmmc);
+ if (!coder)
+ return ERR_PTR(-ENODEV);
+
+ stream = kzalloc(sizeof(*stream), GFP_KERNEL);
+ if (!stream)
+ return ERR_PTR(-ENOMEM);
+
+ stream->coder = coder;
+ coder->stream = &stream->stream;
+ tapi_endpoint_set_data(&stream->stream.ep, &coder->module);
+
+ return &stream->stream;
+}
+
+void vmmc_stream_free(struct tapi_device *tdev, struct tapi_stream *tstream)
+{
+ struct vmmc *vmmc = tdev_to_vmmc(tdev);
+ struct vmmc_tapi_stream *stream = tapi_to_vmmc_stream(tstream);
+
+ stream->coder->stream = NULL;
+
+ vmmc_coder_put(vmmc, stream->coder);
+ kfree(stream);
+}
+
+int vmmc_stream_start(struct tapi_device *tdev, struct tapi_stream *stream)
+{
+ return 0;
+}
+
+int vmmc_stream_stop(struct tapi_device *tdev, struct tapi_stream *stream)
+{
+ return 0;
+}
+
+int vmmc_stream_send(struct tapi_device *tdev, struct tapi_stream *stream,
+ struct sk_buff *skb)
+{
+ struct vmmc *vmmc = tdev_to_vmmc(tdev);
+ struct vmmc_coder *coder = tapi_to_vmmc_stream(stream)->coder;
+
+ vmmc_send_paket(vmmc, coder->id, skb);
+ return 0;
+}
+/*
+int vmmc_stream_recv(struct vmmc_stream *stream)
+{
+ tapi_stream_recv(&stream->coder->vmmc->tdev stream->stream, skb);
+}*/
diff --git a/package/lqtapi/src/mps/vmmc-stream.h b/package/lqtapi/src/mps/vmmc-stream.h
new file mode 100644
index 000000000..7e029734f
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc-stream.h
@@ -0,0 +1,10 @@
+#ifndef __VMMC_STREAM_H__
+#define __VMMC_STREAM_H__
+
+struct tapi_stream *vmmc_stream_alloc(struct tapi_device *tdev);
+void vmmc_stream_free(struct tapi_device *tdev, struct tapi_stream *stream);
+int vmmc_stream_start(struct tapi_device *tdev, struct tapi_stream *stream);
+int vmmc_stream_send(struct tapi_device *tdev, struct tapi_stream *stream,
+ struct sk_buff *skb);
+
+#endif
diff --git a/package/lqtapi/src/mps/vmmc.c b/package/lqtapi/src/mps/vmmc.c
new file mode 100644
index 000000000..ba7d435af
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc.c
@@ -0,0 +1,90 @@
+static uint32_t magic_init[] = {
+/* ALI INIT */
+/*0x0601210c, 0x88002000, 0x20000000, 0x00000000, 0xffffffff,*/
+/* COD_CHAN_SPEECH_ECMD */
+/*0x06016110, 0x2462f700, 0x20002000, 0x00000000, 0x00000000, 0xffffffff,*/
+/* COD_DEC_STAT_ECMD */
+/*0x06017504, 0x00c00000, 0xffffffff,*/
+/* COD_JB_CONF_ECMD */
+/*0x06017208, 0x16410050, 0x005005a0, 0xffffffff,*/
+/* SIG_RTP_SUP */
+/*0x0601500c, 0x00000000, 0x00000060, 0x0712007f, 0xffffffff,*/
+/* SIG_CHAN */
+/*0x06014104, 0xc0190000, 0xffffffff,*/
+/* SIG_CIDS_CTRL_ECMD */
+/*0x06014204, 0x3811e000, 0xffffffff, */
+/* SIG_DTMFATG_DATA */
+/*0x06014b04, 0x00010000, 0xffffffff,*/
+/* SIG_DTMFATG_CTRL */
+/*0x06014304, 0x6a110000, 0xffffffff,
+0x0601cc04, 0xe21c2000, 0xffffffff,
+0x06014404, 0xb0110000, 0xffffffff,
+0x06014a04, 0x04510000, 0xffffffff,
+0x06014604, 0x04560000, 0xffffffff,
+0x06014104, 0xc0190000, 0xffffffff,*/
+/* COD_CHAN_RTP_SUP_CFG_USD */
+/*0x06017124, 0x00000000, 0x00008880, 0xe3e4e5e6, 0x72727272, 0x72727272,
+0x0f7f1261, 0x7374097f, 0xf1f06767, 0x04047675, 0xffffffff,*/
+/* COD_CHAN_RTP_SUP_CFG_DS */
+/* 0x06017920, 0x08006364, 0x65667272, 0x72727272, 0x72720f7f, 0x12617374,
+0x097f7170, 0x67670404, 0x76750000, 0xffffffff, */
+/* OPMODE_CMD */
+0x01010004, 0x00010000, 0xffffffff,
+0x01000004, 0x00030000, 0xffffffff,
+/*0x01010004, 0x00010000, 0xffffffff,*/
+/* COD_CHAN_RTP_SUP_CFG_US */
+/* 0x06017124, 0x00000000, 0x00008880, 0xe3e4e5e6, 0x72727272, 0x72727272,
+0x0f7f1261, 0x7374097f, 0xf1f06767, 0x04047675, 0xffffffff, */
+/* COD_CHAN_RTP_SUP_CFG_DS */
+/* 0x06017920, 0x08006364, 0x65667272, 0x72727272, 0x72720f7f, 0x12617374,
+0x097f7170, 0x67670404, 0x76750000, 0xffffffff, */
+/* COD_JB_CONF */
+/* 0x06017208, 0x16410050, 0x005005a0, 0xffffffff, */
+/* COD_CHAN_RTP_SUP_CFG_US */
+/*0x06017108, 0x00000000, 0x00008880, 0xffffffff,*/
+/* COD_CHAN_RTP_TIMESTAMP */
+/*0x06017004, 0x00000000, 0xffffffff,*/
+/* SIG_RTP_SUP */
+/* 0x0601500c, 0x00000000, 0x00000062, 0x0712007f, 0xffffffff,*/
+/* SIG_DTMFR_CTRL */
+/*0x06014404, 0xb0010000, 0xffffffff,*/
+/* COD_CHAN_SPEECH */
+/* 0x06016110, 0x0462d600, 0x20002000, 0x00000000, 0x00000000, 0xffffffff, */
+/* ALI_CHAN */
+0x0601210c, 0x88232000, 0x20000000, 0x00000000, 0xffffffff,
+/* SIG_CHAN */
+/*0x06014104, 0xc5190000, 0xffffffff,*/
+/* SIG_DTMFR_CTRL_ECMD */
+/*0x06014404, 0x30010000, 0xffffffff,*/
+/* SIG_CHAN_ECMD */
+/*0x06014104, 0x45190000, 0xffffffff,*/
+};
+
+static void setup_alm(struct mps *mps, int chan)
+{
+ uint32_t *data = magic_init;
+ int size, i;
+
+/* data[0] = ALI_CHAN_DATA1(1, 0, 0, 1, 1, 0, 0);
+ data[1] = ALI_CHAN_DATA2(0, 0, 0);
+ data[2] = ALI_CHAN_DATA3(0, 0);*/
+
+ size = 1;
+ for (i = 1; i < ARRAY_SIZE(magic_init); ++i) {
+ if (magic_init[i] == 0xffffffff) {
+
+ printk("cmd: %x\n", *data);
+ VMMC_FIFO_fifo_in(&mps->mbox_cmd.downstream, data, size);
+ size = 0;
+ data = &magic_init[i+1];
+ mdelay(500);
+ } else {
+ size += 1;
+ }
+ }
+
+
+/* VMMC_FIFO_mailbox_command_write(&mps->mbox_cmd, MPS_CMD_ALI(chan), data);*/
+}
+
+
diff --git a/package/lqtapi/src/mps/vmmc.h b/package/lqtapi/src/mps/vmmc.h
new file mode 100644
index 000000000..f442a9ab4
--- /dev/null
+++ b/package/lqtapi/src/mps/vmmc.h
@@ -0,0 +1,68 @@
+#ifndef __VMMC_H__
+
+#include <linux/list.h>
+#include <linux/tapi/tapi.h>
+
+#include "mps.h"
+#include "vmmc-module.h"
+
+struct vmmc
+{
+ struct mps *mps;
+ struct device *dev;
+
+ struct vmmc_port *ports;
+
+ struct completion firmware_loaded_completion;
+ struct completion cmd_completion;
+
+ struct mps_mailbox mbox_cmd;
+ struct mps_mailbox mbox_data;
+ struct mps_fifo fifo_event;
+
+ int irq_fw_loaded;
+ int irq_mbox_cmd;
+ int irq_mbox_data;
+ int irq_event_fifo;
+ int irq_cmd_error;
+
+ unsigned int num_coders;
+ struct vmmc_coder *coder;
+ unsigned long coder_used;
+
+ struct list_head modules;
+
+ struct tapi_device tdev;
+
+ struct sk_buff_head recv_queue;
+ struct sk_buff_head send_queue;
+};
+
+static inline struct vmmc *tdev_to_vmmc(struct tapi_device *tdev)
+{
+ return container_of(tdev, struct vmmc, tdev);
+}
+
+static inline void vmmc_register_module(struct vmmc *vmmc,
+ struct vmmc_module *module)
+{
+ list_add_tail(&module->head, &vmmc->modules);
+}
+
+static inline void vmmc_unregister_module(struct vmmc *vmmc,
+ struct vmmc_module *module)
+{
+ list_del(&module->head);
+}
+
+int vmmc_command_write(struct vmmc *vmmc, uint32_t cmd,
+ const uint32_t *data);
+int vmmc_command_read(struct vmmc *vmmc, uint32_t cmd, uint32_t *result);
+
+struct vmmc_coder *vmmc_coder_get(struct vmmc *);
+void vmmc_coder_put(struct vmmc *, struct vmmc_coder *);
+void vmmc_init_coders(struct vmmc *);
+
+void vmmc_send_paket(struct vmmc *vmmc, unsigned int chan, struct sk_buff *skb);
+
+#endif
diff --git a/package/lqtapi/src/tapi/Makefile b/package/lqtapi/src/tapi/Makefile
new file mode 100644
index 000000000..2992d4b3a
--- /dev/null
+++ b/package/lqtapi/src/tapi/Makefile
@@ -0,0 +1,7 @@
+
+tapi-objs := tapi-core.o tapi-port.o tapi-input.o
+tapi-objs += tapi-control.o
+tapi-objs += tapi-stream.o
+tapi-objs += tapi-sysfs-port.o
+
+obj-m += tapi.o
diff --git a/package/lqtapi/src/tapi/tapi-control.c b/package/lqtapi/src/tapi/tapi-control.c
new file mode 100644
index 000000000..a4f245e92
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-control.c
@@ -0,0 +1,193 @@
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <linux/tapi/tapi.h>
+#include <linux/tapi/tapi-ioctl.h>
+
+/* FIXME Does it acutally make sense to allow more then one application at a
+ * time to open the control device? For example calling sync from one app will
+ * also sync all others. */
+
+struct tapi_control_file {
+ struct tapi_device *tdev;
+ struct list_head links;
+};
+
+static struct tapi_endpoint *tapi_lookup_endpoint(struct tapi_device *tdev,
+ unsigned int ep_id)
+{
+ struct tapi_stream *stream;
+
+ if (ep_id < tdev->num_ports)
+ return &tdev->ports[ep_id].ep;
+
+ list_for_each_entry(stream, &tdev->streams, head) {
+ if (stream->ep.id == ep_id)
+ return &stream->ep;
+ }
+
+ return ERR_PTR(-ENOENT);
+}
+
+static inline struct tapi_device *inode_to_tdev(struct inode *inode)
+{
+ return container_of(inode->i_cdev, struct tapi_char_device, cdev)->tdev;
+}
+
+static int tapi_control_open(struct inode *inode, struct file *file)
+{
+ int ret;
+ struct tapi_device *tdev = inode_to_tdev(inode);
+ struct tapi_control_file *tctrl;
+
+ get_device(&tdev->dev);
+
+ tctrl = kzalloc(sizeof(*tctrl), GFP_KERNEL);
+ if (!tctrl) {
+ ret = -ENOMEM;
+ goto err_put_device;
+ }
+
+ INIT_LIST_HEAD(&tctrl->links);
+ tctrl->tdev = tdev;
+
+ file->private_data = tctrl;
+
+ return 0;
+
+err_put_device:
+ put_device(&tdev->dev);
+
+ return ret;
+}
+
+static int tapi_control_release(struct inode *inode, struct file *file)
+{
+ struct tapi_control_file *tctrl = file->private_data;
+ struct tapi_link *link;
+
+ if (tctrl) {
+ list_for_each_entry(link, &tctrl->links, head)
+ tapi_link_free(tctrl->tdev, link);
+
+ put_device(&tctrl->tdev->dev);
+ }
+
+ return 0;
+}
+
+static long tapi_control_ioctl_link_alloc(struct tapi_control_file *tctrl,
+ unsigned long arg)
+{
+ struct tapi_link *link;
+ struct tapi_endpoint *ep1, *ep2;
+
+ ep1 = tapi_lookup_endpoint(tctrl->tdev, arg >> 16);
+ ep2 = tapi_lookup_endpoint(tctrl->tdev, arg & 0xffff);
+
+ link = tapi_link_alloc(tctrl->tdev, ep1, ep2);
+ if (IS_ERR(link))
+ return PTR_ERR(link);
+
+ list_add_tail(&link->head, &tctrl->links);
+
+ return link->id;
+}
+
+struct tapi_link *tapi_control_lookup_link(struct tapi_control_file *tctrl,
+ unsigned int id)
+{
+ struct tapi_link *link;
+
+ list_for_each_entry(link, &tctrl->links, head) {
+ if (link->id == id)
+ return link;
+ }
+
+ return NULL;
+}
+
+static long tapi_control_ioctl_link_free(struct tapi_control_file *tctrl,
+ unsigned long arg)
+{
+ struct tapi_link *link = tapi_control_lookup_link(tctrl, arg);
+ if (!link)
+ return -ENOENT;
+
+ tapi_link_free(tctrl->tdev, link);
+ list_del(&link->head);
+
+ return 0;
+}
+
+static long tapi_control_ioctl_link_enable(struct tapi_control_file *tctrl,
+ unsigned long arg)
+{
+ struct tapi_link *link = tapi_control_lookup_link(tctrl, arg);
+ if (!link)
+ return -ENOENT;
+
+ return tapi_link_enable(tctrl->tdev, link);
+}
+
+static long tapi_control_ioctl_link_disable(struct tapi_control_file *tctrl,
+ unsigned long arg)
+{
+ struct tapi_link *link = tapi_control_lookup_link(tctrl, arg);
+ if (!link)
+ return -ENOENT;
+
+ return tapi_link_disable(tctrl->tdev, link);
+}
+
+static long tapi_control_ioctl_sync(struct tapi_control_file *tctrl)
+{
+ return tapi_sync(tctrl->tdev);
+}
+
+static long tapi_control_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int ret;
+ struct tapi_control_file *tctrl = file->private_data;
+
+ switch (cmd) {
+ case TAPI_CONTROL_IOCTL_LINK_ALLOC:
+ ret = tapi_control_ioctl_link_alloc(tctrl, arg);
+ break;
+ case TAPI_CONTROL_IOCTL_LINK_FREE:
+ ret = tapi_control_ioctl_link_free(tctrl, arg);
+ break;
+ case TAPI_CONTROL_IOCTL_LINK_ENABLE:
+ ret = tapi_control_ioctl_link_enable(tctrl, arg);
+ break;
+ case TAPI_CONTROL_IOCTL_LINK_DISABLE:
+ ret = tapi_control_ioctl_link_disable(tctrl, arg);
+ break;
+ case TAPI_CONTROL_IOCTL_SYNC:
+ ret = tapi_control_ioctl_sync(tctrl);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct file_operations tapi_control_file_ops = {
+ .owner = THIS_MODULE,
+ .open = tapi_control_open,
+ .release = tapi_control_release,
+ .unlocked_ioctl = tapi_control_ioctl,
+};
+
+int tapi_register_control_device(struct tapi_device* tdev)
+{
+ dev_set_name(&tdev->control_dev.dev, "tapi%uC", tdev->id);
+ return tapi_char_device_register(tdev, &tdev->control_dev, &tapi_control_file_ops);
+}
diff --git a/package/lqtapi/src/tapi/tapi-core.c b/package/lqtapi/src/tapi/tapi-core.c
new file mode 100644
index 000000000..2e112a376
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-core.c
@@ -0,0 +1,250 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/list.h>
+
+#include <linux/cdev.h>
+#include <linux/err.h>
+
+#include <linux/tapi/tapi.h>
+
+
+void tapi_alloc_input(struct tapi_device *tdev, struct tapi_port *port);
+int tapi_register_port_device(struct tapi_device* tdev, struct tapi_port *port);
+int tapi_register_stream_device(struct tapi_device* tdev);
+int tapi_register_control_device(struct tapi_device* tdev);
+
+static struct class *tapi_class;
+static int tapi_major;
+
+#define TAPI_MAX_MINORS 255
+
+static bool tapi_minors[TAPI_MAX_MINORS];
+
+static int tapi_get_free_minor(void)
+{
+ int i;
+ for (i = 0; i < TAPI_MAX_MINORS; ++i) {
+ if (!tapi_minors[i]) {
+ tapi_minors[i] = true;
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+/*
+int tapi_port_send_dtmf_events(struct tapi_device *tdev, unsigned int port, struct tapi_dtmf *, size_t num_events, unsigned int dealy)
+{
+}
+EXPORT_SYMBOL_GPL(tapi_port_send_dtmf_events);
+*/
+
+void tapi_report_hook_event(struct tapi_device *tdev, struct tapi_port *port,
+ bool on)
+{
+ struct tapi_event event;
+ event.type = TAPI_EVENT_TYPE_HOOK;
+ event.port = port->id;
+ event.hook.on = on;
+
+ tapi_report_event(tdev, &event);
+}
+EXPORT_SYMBOL_GPL(tapi_report_hook_event);
+
+void tapi_report_dtmf_event(struct tapi_device *tdev, struct tapi_port *port,
+ unsigned char code)
+{
+ struct tapi_event event;
+ event.type = TAPI_EVENT_TYPE_DTMF;
+ event.port = port->id;
+ event.dtmf.code = code;
+
+ tapi_report_event(tdev, &event);
+}
+EXPORT_SYMBOL_GPL(tapi_report_dtmf_event);
+
+struct tapi_stream *tapi_stream_alloc(struct tapi_device *tdev)
+{
+ struct tapi_stream *stream;
+ printk("tdev %p\n", tdev);
+
+ if (!tdev->ops || !tdev->ops->stream_alloc)
+ return ERR_PTR(-ENOSYS);
+
+ stream = tdev->ops->stream_alloc(tdev);
+ printk("stream %p\n", stream);
+ if (IS_ERR(stream))
+ return stream;
+
+ stream->id = atomic_inc_return(&tdev->stream_id) - 1;
+ stream->ep.id = stream->id;
+
+/* mutex_lock(&tdev->lock);*/
+ list_add_tail(&stream->head, &tdev->streams);
+/* mutex_unlock(&tdev->lock);*/
+
+ return stream;
+}
+EXPORT_SYMBOL_GPL(tapi_stream_alloc);
+
+void tapi_stream_free(struct tapi_device *tdev, struct tapi_stream *stream)
+{
+ mutex_lock(&tdev->lock);
+ list_del(&stream->head);
+ mutex_unlock(&tdev->lock);
+
+ tdev->ops->stream_free(tdev, stream);
+}
+EXPORT_SYMBOL_GPL(tapi_stream_free);
+
+struct tapi_link *tapi_link_alloc(struct tapi_device *tdev,
+ struct tapi_endpoint *ep1, struct tapi_endpoint *ep2)
+{
+ struct tapi_link *link;
+
+ if (!tdev->ops || !tdev->ops->link_alloc)
+ return ERR_PTR(-ENOSYS);
+
+ link = tdev->ops->link_alloc(tdev, ep1, ep2);
+ if (IS_ERR(link))
+ return link;
+
+ link->id = atomic_inc_return(&tdev->link_id) - 1;
+
+/*
+ mutex_lock(&tdev->lock);
+ list_add_tail(&link->head, &tdev->links);
+ mutex_unlock(&tdev->lock);
+*/
+ return link;
+}
+EXPORT_SYMBOL_GPL(tapi_link_alloc);
+
+void tapi_link_free(struct tapi_device *tdev, struct tapi_link *link)
+{
+/*
+ mutex_lock(&tdev->lock);
+ list_del(&link->head);
+ mutex_unlock(&tdev->lock);
+*/
+ tdev->ops->link_free(tdev, link);
+}
+EXPORT_SYMBOL_GPL(tapi_link_free);
+
+int tapi_char_device_register(struct tapi_device *tdev,
+ struct tapi_char_device *tchrdev, const struct file_operations *fops)
+{
+ int ret;
+ struct device *dev = &tchrdev->dev;
+ dev_t devt;
+ int minor = tapi_get_free_minor();
+
+ devt = MKDEV(tapi_major, minor);
+
+ dev->devt = devt;
+ dev->class = tapi_class;
+ dev->parent = &tdev->dev;
+
+ tchrdev->tdev = tdev;
+
+ cdev_init(&tchrdev->cdev, fops);
+ tchrdev->cdev.owner = THIS_MODULE;
+ ret = cdev_add(&tchrdev->cdev, devt, 1);
+ if (ret)
+ return ret;
+
+ ret = device_register(&tchrdev->dev);
+ if (ret)
+ goto err_cdev_del;
+
+ return 0;
+
+err_cdev_del:
+ cdev_del(&tchrdev->cdev);
+
+ return ret;
+}
+
+int tapi_device_register(struct tapi_device *tdev, const char *name,
+ struct device *parent)
+{
+ static atomic_t tapi_device_id = ATOMIC_INIT(0);
+ int ret, i;
+
+ tdev->dev.class = tapi_class;
+ tdev->dev.parent = parent;
+ dev_set_name(&tdev->dev, "%s", name);
+
+ ret = device_register(&tdev->dev);
+ if (ret)
+ return ret;
+
+ tdev->id = atomic_inc_return(&tapi_device_id) - 1;
+
+ mutex_init(&tdev->lock);
+ INIT_LIST_HEAD(&tdev->streams);
+ INIT_LIST_HEAD(&tdev->links);
+ atomic_set(&tdev->link_id, 0);
+ atomic_set(&tdev->stream_id, tdev->num_ports);
+
+ tapi_register_stream_device(tdev);
+ tapi_register_control_device(tdev);
+
+ for (i = 0; i < tdev->num_ports; ++i) {
+ tapi_port_alloc(tdev, i);
+ tapi_alloc_input(tdev, &tdev->ports[i]);
+ tapi_register_port_device(tdev, &tdev->ports[i]);
+ tdev->ports[i].id = i;
+ tdev->ports[i].ep.id = i;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(tapi_device_register);
+
+void tapi_device_unregister(struct tapi_device *tdev)
+{
+ device_unregister(&tdev->dev);
+}
+EXPORT_SYMBOL_GPL(tapi_device_unregister);
+
+static int __init tapi_class_init(void)
+{
+ int ret;
+ dev_t dev;
+
+ tapi_class = class_create(THIS_MODULE, "tapi");
+
+ if (IS_ERR(tapi_class)) {
+ ret = PTR_ERR(tapi_class);
+ printk(KERN_ERR "tapi: Failed to create device class: %d\n", ret);
+ goto err;
+ }
+
+ ret = alloc_chrdev_region(&dev, 0, TAPI_MAX_MINORS, "tapi");
+ if (ret) {
+ printk(KERN_ERR "tapi: Failed to allocate chrdev region: %d\n", ret);
+ goto err_class_destory;
+ }
+ tapi_major = MAJOR(dev);
+
+ return 0;
+err_class_destory:
+ class_destroy(tapi_class);
+err:
+ return ret;
+}
+subsys_initcall(tapi_class_init);
+
+static void __exit tapi_class_exit(void)
+{
+ unregister_chrdev_region(MKDEV(tapi_major, 0), TAPI_MAX_MINORS);
+ class_destroy(tapi_class);
+}
+module_exit(tapi_class_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("TAPI class");
+MODULE_LICENSE("GPL");
diff --git a/package/lqtapi/src/tapi/tapi-input.c b/package/lqtapi/src/tapi/tapi-input.c
new file mode 100644
index 000000000..999aaefa9
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-input.c
@@ -0,0 +1,99 @@
+
+#include <linux/tapi/tapi.h>
+
+#include <linux/input.h>
+
+static unsigned short tapi_keycodes[] = {
+ [0] = KEY_NUMERIC_0,
+ [1] = KEY_NUMERIC_1,
+ [2] = KEY_NUMERIC_2,
+ [3] = KEY_NUMERIC_3,
+ [4] = KEY_NUMERIC_4,
+ [5] = KEY_NUMERIC_5,
+ [6] = KEY_NUMERIC_6,
+ [7] = KEY_NUMERIC_7,
+ [8] = KEY_NUMERIC_8,
+ [9] = KEY_NUMERIC_9,
+ [10] = KEY_NUMERIC_STAR,
+ [11] = KEY_NUMERIC_POUND,
+ [12] = KEY_ENTER,
+ [13] = KEY_ESC,
+};
+
+static int tapi_input_event(struct input_dev *input, unsigned int type,
+ unsigned int code, int value)
+{
+ struct tapi_device *tdev = dev_to_tapi(input->dev.parent);
+ struct tapi_port *port = input_get_drvdata(input);
+
+
+ if (type != EV_SND || code != SND_BELL)
+ return -EINVAL;
+
+ tapi_port_set_ring(tdev, port, value);
+
+ return 0;
+}
+
+void tapi_alloc_input(struct tapi_device *tdev, struct tapi_port *port)
+{
+ struct input_dev *input;
+ int i;
+ char *phys;
+
+ input = input_allocate_device();
+
+ phys = kzalloc(sizeof("tapi/input000"), GFP_KERNEL);
+ sprintf(phys, "tapi/input%d", port->id);
+
+ input->name = "tapi";
+ input->phys = phys;
+ input->id.bustype = BUS_HOST;
+ input->dev.parent = &tdev->dev;
+ input->evbit[0] = BIT(EV_KEY) | BIT(EV_SND);
+ input->sndbit[0] = BIT(SND_BELL);
+
+ input->event = tapi_input_event;
+
+ input->keycodesize = sizeof(unsigned short);
+ input->keycodemax = ARRAY_SIZE(tapi_keycodes);
+ input->keycode = tapi_keycodes;
+
+ port->input = input;
+
+ for (i = 0; i < ARRAY_SIZE(tapi_keycodes); ++i)
+ __set_bit(tapi_keycodes[i], input->keybit);
+
+ input_set_drvdata(input, port);
+ input_register_device(input);
+}
+
+void tapi_report_event(struct tapi_device *tdev,
+ struct tapi_event *event)
+{
+ unsigned short key_code;
+ struct input_dev *input;
+
+ if (!tdev || !tdev->ports)
+ return;
+
+ switch (event->type) {
+ case TAPI_EVENT_TYPE_HOOK:
+ if (event->hook.on)
+ key_code = KEY_ENTER;
+ else
+ key_code = KEY_ESC;
+ break;
+ case TAPI_EVENT_TYPE_DTMF:
+ key_code = tapi_keycodes[event->dtmf.code];
+ break;
+ default:
+ return;
+ }
+
+ input = tdev->ports[event->port].input;
+ input_report_key(input, key_code, 1);
+ input_sync(input);
+ input_report_key(input, key_code, 0);
+ input_sync(input);
+}
diff --git a/package/lqtapi/src/tapi/tapi-nl.c b/package/lqtapi/src/tapi/tapi-nl.c
new file mode 100644
index 000000000..c066742b6
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-nl.c
@@ -0,0 +1,62 @@
+
+static struct tapi_attr default_port[] = {
+ [PORTS] = {
+ .type = TAPI_TYPE_PORTS,
+ .name = "ports",
+ .description = "foobar",
+ .set = tapi_set_ports,
+ .get = tapi_get_ports,
+ },
+};
+
+static const struct nla_policy tapi_policy[] = {
+ [TAPI_ATTR_ID] = { .type = NLA_U32 },
+ [TAPI_ATTR_PORT] = { .type = NLA_U32 },
+ [TAPI_ATTR_ENDPOINT] = { .type = NLA_U32 },
+ [TAPI_ATTR_STREAM] = { .type = NLA_U32 }
+};
+
+static const struct nla_policy tapi_port_policy[] = {
+ [TAPI_PORT_ID] = { .type = NLA_U32 },
+};
+
+static const struct nla_policy tapi_endpoint_policy[] = {
+ [TAPI_ENDPOINT_ID] = { .type = NLA_U32 },
+};
+
+static const struct nla_policy tapi_stream_policy[] = {
+ [TAPI_STREAM_ID] = { .type = NLA_U32 },
+};
+
+static struct genl_family tapi_nl_family = {
+ .id = GENL_ID_GENERATE,
+ .name = "tapi",
+ .hdrsize = 0,
+ .version = 1,
+ .maxattr = ARRAY_SIZE(tapi_policy),
+};
+
+
+
+static struct genl_ops tapi_nl_ops[] = {
+ TAPI_NL_OP(TAPI_CMD_LIST, list_attr),
+
+};
+
+static int __init tapi_nl_init(void)
+{
+ ret = genl_unregister_family(&tapi_nl_family);
+ if (ret)
+ return ret;
+
+ genl_register_ops(&tapi_nl_family, tapi_nl_ops);
+
+ return 0;
+}
+module_init(tapi_nl_init);
+
+static void __exit tapi_nl_exit(void)
+{
+ genl_unregister_family(&tapi_nl_family);
+}
+
diff --git a/package/lqtapi/src/tapi/tapi-port.c b/package/lqtapi/src/tapi/tapi-port.c
new file mode 100644
index 000000000..0ef955567
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-port.c
@@ -0,0 +1,82 @@
+#include <linux/cdev.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <linux/tapi/tapi.h>
+#include <linux/tapi/tapi-ioctl.h>
+
+static inline struct tapi_port *tapi_char_device_to_port(struct tapi_char_device *chrdev)
+{
+ return container_of(chrdev, struct tapi_port, chrdev);
+}
+
+static int tapi_port_open(struct inode *inode, struct file *file)
+{
+ struct tapi_device *tdev = cdev_to_tapi_char_device(inode->i_cdev)->tdev;
+
+ get_device(&tdev->dev);
+ file->private_data = cdev_to_tapi_char_device(inode->i_cdev);
+
+ return 0;
+}
+
+static int tapi_port_release(struct inode *inode, struct file *file)
+{
+ struct tapi_device *tdev = cdev_to_tapi_char_device(inode->i_cdev)->tdev;
+
+ put_device(&tdev->dev);
+
+ return 0;
+}
+
+static long tapi_port_ioctl_get_endpoint(struct tapi_device *tdev,
+ struct tapi_port *port, unsigned long arg)
+{
+ return port->ep.id;
+}
+
+static long tapi_port_ioctl_set_ring(struct tapi_device *tdev,
+ struct tapi_port *port, unsigned long arg)
+{
+ tapi_port_set_ring(tdev, port, arg);
+ return 0;
+}
+
+static long tapi_port_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int ret;
+ struct tapi_char_device *tchrdev = file->private_data;
+ struct tapi_device *tdev = tchrdev->tdev;
+ struct tapi_port *port = tapi_char_device_to_port(tchrdev);
+
+ switch (cmd) {
+ case TAPI_PORT_IOCTL_GET_ENDPOINT:
+ ret = tapi_port_ioctl_get_endpoint(tdev, port, arg);
+ break;
+ case TAPI_PORT_IOCTL_SET_RING:
+ ret = tapi_port_ioctl_set_ring(tdev, port, arg);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static const struct file_operations tapi_port_file_ops = {
+ .owner = THIS_MODULE,
+ .open = tapi_port_open,
+ .release = tapi_port_release,
+ .unlocked_ioctl = tapi_port_ioctl,
+};
+
+int tapi_register_port_device(struct tapi_device* tdev, struct tapi_port *port)
+{
+ dev_set_name(&port->chrdev.dev, "tapi%uP%u", tdev->id, port->id);
+ return tapi_char_device_register(tdev, &port->chrdev, &tapi_port_file_ops);
+}
diff --git a/package/lqtapi/src/tapi/tapi-stream.c b/package/lqtapi/src/tapi/tapi-stream.c
new file mode 100644
index 000000000..7277a5c61
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-stream.c
@@ -0,0 +1,201 @@
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/poll.h>
+
+#include <linux/tapi/tapi.h>
+#include <linux/tapi/tapi-ioctl.h>
+
+
+struct tapi_stream_file {
+ struct tapi_device *tdev;
+ struct tapi_stream *stream;
+};
+
+static inline struct tapi_device *inode_to_tdev(struct inode *inode)
+{
+ return container_of(inode->i_cdev, struct tapi_char_device, cdev)->tdev;
+}
+
+static int tapi_stream_open(struct inode *inode, struct file *file)
+{
+ int ret;
+ struct tapi_device *tdev = inode_to_tdev(inode);
+ struct tapi_stream_file *stream;
+
+ get_device(&tdev->dev);
+
+ stream = kzalloc(sizeof(*stream), GFP_KERNEL);
+ if (!stream) {
+ ret = -ENOMEM;
+ goto err_put;
+ }
+
+ stream->stream = tapi_stream_alloc(tdev);
+ if (IS_ERR(stream->stream)) {
+ ret = PTR_ERR(stream->stream);
+ goto err_free;
+ }
+ stream->tdev = tdev;
+
+ init_waitqueue_head(&stream->stream->recv_wait);
+ skb_queue_head_init(&stream->stream->recv_queue);
+
+ file->private_data = stream;
+
+ return 0;
+
+err_free:
+ kfree(stream);
+err_put:
+ put_device(&tdev->dev);
+ return ret;
+}
+
+static int tapi_stream_release(struct inode *inode, struct file *file)
+{
+ struct tapi_stream_file *stream = file->private_data;
+
+ if (stream) {
+ tapi_stream_free(stream->tdev, stream->stream);
+ put_device(&stream->tdev->dev);
+ kfree(stream);
+ }
+
+ return 0;
+}
+
+static long tapi_stream_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int ret = 0;
+ struct tapi_stream_file *stream = file->private_data;
+ struct tapi_device *tdev = stream->tdev;
+
+ switch (cmd) {
+ case TAPI_STREAM_IOCTL_GET_ENDPOINT:
+ ret = stream->stream->ep.id;
+ break;
+ case TAPI_STREAM_IOCTL_CONFIGURE:
+ break;
+ case TAPI_STREAM_IOCTL_START:
+ ret = tapi_stream_start(tdev, stream->stream);
+ break;
+ case TAPI_STREAM_IOCTL_STOP:
+ ret = tapi_stream_stop(tdev, stream->stream);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static unsigned int tapi_stream_poll(struct file *file, struct poll_table_struct *wait)
+{
+ struct tapi_stream_file *stream = file->private_data;
+ int ret;
+
+ poll_wait(file, &stream->stream->recv_wait, wait);
+
+ ret = POLLOUT;
+
+ if (!skb_queue_empty(&stream->stream->recv_queue))
+ ret |= POLLIN;
+
+ return ret;
+}
+
+static ssize_t tapi_stream_read(struct file *file, char __user *buffer,
+ size_t count, loff_t *offset)
+{
+ struct tapi_stream_file *stream = file->private_data;
+ struct sk_buff *skb;
+
+ skb = skb_dequeue(&stream->stream->recv_queue);
+ if (!skb) {
+ if (file->f_flags & O_NONBLOCK)
+ return -EAGAIN;
+
+ do {
+ interruptible_sleep_on(&stream->stream->recv_wait);
+ skb = skb_dequeue(&stream->stream->recv_queue);
+ } while (skb == NULL && !signal_pending(current));
+
+ if (skb == NULL)
+ return -ERESTARTNOHAND;
+ }
+
+ if (skb->len > count) {
+ skb_queue_head(&stream->stream->recv_queue, skb);
+ return -EMSGSIZE;
+ }
+
+ if (copy_to_user(buffer, skb->data, skb->len)) {
+ skb_queue_head(&stream->stream->recv_queue, skb);
+ return -EFAULT;
+ }
+
+ count = skb->len;
+
+ kfree_skb(skb);
+
+ return count;
+}
+
+static ssize_t tapi_stream_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ struct tapi_stream_file *stream = file->private_data;
+ struct tapi_device *tdev = stream->tdev;
+ struct sk_buff *skb;
+
+ if (count == 0)
+ return 0;
+
+ skb = alloc_skb(count, GFP_USER);
+ if (!skb)
+ return -ENOMEM;
+
+ if (copy_from_user(skb_put(skb, count), buffer, count)) {
+ kfree_skb(skb);
+ return -EFAULT;
+ }
+
+ tdev->ops->stream_send(tdev, stream->stream, skb);
+
+ return count;
+}
+
+static const struct file_operations tapi_stream_file_ops = {
+ .owner = THIS_MODULE,
+ .read = tapi_stream_read,
+ .write = tapi_stream_write,
+ .open = tapi_stream_open,
+ .release = tapi_stream_release,
+ .poll = tapi_stream_poll,
+ .unlocked_ioctl = tapi_stream_ioctl,
+};
+
+int tapi_register_stream_device(struct tapi_device* tdev)
+{
+ dev_set_name(&tdev->stream_dev.dev, "tapi%uS", tdev->id);
+ return tapi_char_device_register(tdev, &tdev->stream_dev, &tapi_stream_file_ops);
+}
+
+int tapi_stream_recv(struct tapi_device *tdev, struct tapi_stream * stream,
+ struct sk_buff *skb)
+{
+ skb_queue_tail(&stream->recv_queue, skb);
+ wake_up(&stream->recv_wait);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(tapi_stream_recv);
diff --git a/package/lqtapi/src/tapi/tapi-sysfs-port.c b/package/lqtapi/src/tapi/tapi-sysfs-port.c
new file mode 100644
index 000000000..f6e5ee066
--- /dev/null
+++ b/package/lqtapi/src/tapi/tapi-sysfs-port.c
@@ -0,0 +1,107 @@
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/sysfs.h>
+
+#include <linux/err.h>
+#include <linux/tapi/tapi.h>
+
+struct tapi_sysfs_port {
+ struct tapi_device *tdev;
+ unsigned int id;
+ struct kobject kobj;
+};
+
+struct tapi_sysfs_entry {
+ ssize_t (*show)(struct tapi_device *, unsigned int port, char *);
+ ssize_t (*store)(struct tapi_device *, unsigned int port, const char *, size_t);
+ struct attribute attr;
+};
+
+static ssize_t tapi_port_store(struct kobject *kobj, struct attribute *attr,
+ const char *s, size_t len)
+{
+ struct tapi_sysfs_port *port = container_of(kobj, struct tapi_sysfs_port, kobj);
+ struct tapi_sysfs_entry *entry = container_of(attr, struct tapi_sysfs_entry,
+ attr);
+
+ if (!entry->store)
+ return -ENOSYS;
+
+ return entry->store(port->tdev, port->id, s, len);
+}
+
+static ssize_t tapi_port_show(struct kobject *kobj, struct attribute *attr,
+ char *s)
+{
+ return -ENOSYS;
+}
+
+#define TAPI_PORT_ATTR(_name, _mode, _show, _store) \
+ struct tapi_sysfs_entry tapi_port_ ## _name ## _attr = \
+ __ATTR(_name, _mode, _show, _store)
+
+static int tapi_port_store_ring(struct tapi_device *tdev, unsigned int port,
+ const char *s, size_t len)
+{
+ int ret;
+ unsigned long val;
+
+ ret = strict_strtoul(s, 10, &val);
+
+ if (ret)
+ return ret;
+
+ ret = tapi_port_set_ring(tdev, &tdev->ports[port], val);
+ if (ret)
+ return ret;
+ return len;
+}
+
+static TAPI_PORT_ATTR(ring, 0644, NULL, tapi_port_store_ring);
+
+static struct attribute *tapi_port_default_attrs[] = {
+ &tapi_port_ring_attr.attr,
+ NULL,
+};
+
+static void tapi_port_free(struct kobject *kobj)
+{
+ struct tapi_sysfs_port *port = container_of(kobj, struct tapi_sysfs_port, kobj);
+ kfree(port);
+}
+
+static struct sysfs_ops tapi_port_sysfs_ops = {
+ .show = tapi_port_show,
+ .store = tapi_port_store,
+};
+
+static struct kobj_type tapi_port_ktype = {
+ .release = tapi_port_free,
+ .sysfs_ops = &tapi_port_sysfs_ops,
+ .default_attrs = tapi_port_default_attrs,
+};
+
+struct tapi_sysfs_port *tapi_port_alloc(struct tapi_device *tdev, unsigned int id)
+{
+ struct tapi_sysfs_port *port;
+ int ret;
+
+ port = kzalloc(sizeof(*port), GFP_KERNEL);
+ port->tdev = tdev;
+ port->id = id;
+
+ ret = kobject_init_and_add(&port->kobj, &tapi_port_ktype, &tdev->dev.kobj,
+ "port%d", id);
+ if (ret) {
+ kfree(port);
+ return ERR_PTR(ret);
+ }
+
+ return port;
+}
+
+void tapi_port_delete(struct tapi_sysfs_port *port)
+{
+ kobject_del(&port->kobj);
+ kobject_put(&port->kobj);
+}