summaryrefslogtreecommitdiff
path: root/xpp/xpp_proto.c
diff options
context:
space:
mode:
Diffstat (limited to 'xpp/xpp_proto.c')
-rw-r--r--xpp/xpp_proto.c1044
1 files changed, 1044 insertions, 0 deletions
diff --git a/xpp/xpp_proto.c b/xpp/xpp_proto.c
new file mode 100644
index 0000000..b020caf
--- /dev/null
+++ b/xpp/xpp_proto.c
@@ -0,0 +1,1044 @@
+#include <linux/module.h>
+#include <linux/delay.h> /* for udelay */
+#include "xpd.h"
+#include "xpp_proto.h"
+#include "xpp_zap.h"
+
+static char rcsid[] = "$Id$";
+
+extern int print_dbg;
+#include "zap_debug.h"
+
+typedef struct xpp_command xpp_command_t;
+typedef int (*xpp_handler_t)(xbus_t *xbus, int id, xpp_command_t *cmd, xpacket_t *packet);
+
+struct xpp_command {
+ xpp_opcode_t opcode;
+ unsigned int header_size;
+ bool varsize;
+ const char *name;
+ const char *desc;
+ xpp_handler_t handler;
+};
+
+#define S_(s,l,...) \
+ { \
+ .lines = s, \
+ { \
+ .len = l, \
+ .data = { __VA_ARGS__ }, \
+ } \
+ }
+
+struct slic_init_data {
+ xpp_line_t lines;
+ slic_data_t slic_data;
+} slic_init_data[] = {
+#include "slic_init.inc"
+};
+
+static int packet_process(xbus_t *xbus, int xpd_num, xpacket_t *pack);
+static int simulate_xpd(xbus_t *xbus, int xpd_num, xpacket_t *sent_packet);
+static bool pcm_valid(xpd_t *xpd, xpacket_t *reply);
+
+#define NEW_PACKET(p, xbus, name, to) \
+ do { \
+ p = xbus->ops->packet_new(xbus, GFP_ATOMIC); \
+ if(!p) \
+ return -ENOMEM; \
+ PACKET_INIT(p, name); \
+ XPD_ADDR_SET(p->content.addr, to); \
+ } while(0);
+
+/*------------------------- SLIC Handling --------------------------*/
+
+int proc_xpd_slic_read(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+ int len = 0;
+ unsigned long flags;
+ xpd_t *xpd = data;
+ //slic_reply_t *info;
+
+ BUG_ON(!xpd);
+ spin_lock_irqsave(&xpd->lock, flags);
+#if 0
+ info = (slic_reply_t *)&xpd->slic_info;
+ len += sprintf(page + len, "SLIC_REPLY: %s reg_num=0x%X, dataH=0x%X dataL=0x%X\n",
+ (info->indirect)?"I":"D",
+ info->reg_num, info->data_high, info->data_low);
+#endif
+ spin_unlock_irqrestore(&xpd->lock, flags);
+ if (len <= off+count)
+ *eof = 1;
+ *start = page + off;
+ len -= off;
+ if (len > count)
+ len = count;
+ if (len < 0)
+ len = 0;
+ return len;
+}
+
+static int parse_slic_cmd(const char *buf, slic_cmd_t *sc)
+{
+ char op; /* [W]rite, [R]ead */
+ char reg_type; /* [D]irect, [I]ndirect */
+ int s1, s2, s3, s4;
+ int reg_num;
+ int data_low, data_high;
+ xpp_line_t lines;
+ int ret;
+
+ ret = sscanf(buf, "%x %x %x %x %c%c %x %x %x",
+ &s1, &s2, &s3, &s4, &op, &reg_type, &reg_num, &data_high, &data_low);
+ lines = (s4 << 24) | (s3 << 16) | (s2 << 8) | (s1);
+ switch(op) {
+ case 'R':
+ if(reg_type == 'D' && ret == 7) {
+ // DBG("0x%X 0x%X 0x%X 0x%X %c %x\n", s1, s2, s3, s4, reg_type, reg_num);
+ ret = slic_cmd_direct_read(sc, lines, reg_num);
+ } else if(reg_type == 'I' && ret == 7) {
+ // DBG("0x%X 0x%X 0x%X 0x%X %c %x\n", s1, s2, s3, s4, reg_type, reg_num);
+ ret = slic_cmd_indirect_read(sc, lines, reg_num);
+ } else {
+ NOTICE("%s: Bad read input: ret=%d buf='%s' reg_type=%c\n", __FUNCTION__, ret, buf, reg_type);
+ goto err;
+ }
+ break;
+ case 'W':
+ if(reg_type == 'D' && ret == 8) {
+ // DBG("0x%X 0x%X 0x%X 0x%X %c %x %X\n", s1, s2, s3, s4, reg_type, reg_num, data_high);
+ ret = slic_cmd_direct_write(sc, lines, reg_num, data_high);
+ } else if(reg_type == 'I' && ret == 9) {
+ // DBG("0x%X 0x%X 0x%X 0x%X %c %x %X %X\n", s1, s2, s3, s4, reg_type, reg_num, data_high, data_low);
+ ret = slic_cmd_indirect_write(sc, lines, reg_num, data_low, data_high);
+ } else {
+ NOTICE("%s: Bad write input: ret=%d buf='%s' reg_type=%c\n", __FUNCTION__, ret, buf, reg_type);
+ goto err;
+ }
+ break;
+ default:
+ NOTICE("%s: Bad input: ret=%d buf='%s' op=%c\n", __FUNCTION__, ret, buf, op);
+ goto err;
+ }
+ return ret;
+err:
+ return -EINVAL;
+}
+
+static int process_slic_cmdline(xpd_t *xpd, char *cmdline)
+{
+ xbus_t *xbus;
+ slic_cmd_t sc;
+ xpacket_t *pack_tx;
+ char *p;
+ int len = strlen(cmdline);
+
+ BUG_ON(!xpd);
+ xbus = xpd->xbus;
+ if((p = strchr(cmdline, '#')) != NULL) /* Truncate comments */
+ *p = '\0';
+ if((p = strchr(cmdline, ';')) != NULL) /* Truncate comments */
+ *p = '\0';
+ for(p = cmdline; *p && (*p == ' ' || *p == '\t'); p++) /* Trim leading whitespace */
+ ;
+ if(*p == '\0')
+ return 0;
+ len = parse_slic_cmd(p, &sc);
+ if(len < 0)
+ return len;
+ sc.lines &= xpd->enabled_chans; // Ignore disabled channels
+ if(!sc.lines) {
+ NOTICE("%s: no enabled channels are marked. Skip.\n", __FUNCTION__);
+ return 0;
+ }
+ dump_slic_cmd("WRITE_SLIC", &sc);
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd) = sc;
+ pack_tx->datalen = len;
+ packet_send(xbus, pack_tx);
+ return 0;
+}
+
+int proc_xpd_slic_write(struct file *file, const char __user *buffer, unsigned long count, void *data)
+{
+ xpd_t *xpd = data;
+ const int LINE_LEN = 500;
+ char buf[LINE_LEN];
+ char *p;
+ int i;
+ int ret;
+
+ BUG_ON(!xpd);
+ for(i = 0; i < count; /* noop */) {
+ for(p = buf; p < buf + LINE_LEN; p++) { /* read a line */
+ if(i >= count)
+ break;
+ if(get_user(*p, buffer + i))
+ return -EFAULT;
+ i++;
+ if(*p == '\n' || *p == '\r') /* whatever */
+ break;
+ }
+ if(p >= buf + LINE_LEN)
+ return -E2BIG;
+ *p = '\0';
+ ret = process_slic_cmdline(xpd, buf);
+ if(ret < 0)
+ return ret;
+ }
+ return count;
+}
+
+
+
+/*------------------------- Protocol Functions ---------------------*/
+
+#define HOSTCMD(name, ...) \
+ DECLARE_CMD(name, ## __VA_ARGS__ ); \
+ EXPORT_SYMBOL(xpp_proto_ ## name); \
+ DECLARE_CMD(name, ## __VA_ARGS__ )
+
+
+/* 0x04 */ HOSTCMD(DESC_REQ, int xpd_num)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+
+ DBG("\n");
+ if(!xbus) {
+ DBG("NO XBUS\n");
+ return -EINVAL;
+ }
+ NEW_PACKET(pack_tx, xbus, DESC_REQ, xpd_num);
+ DBG("calling packet_send for a DESC_REQ packet.\n");
+ ret = packet_send(xbus, pack_tx);
+ DBG("after packet_send, updating counter (ret=%d)\n", ret);
+ XBUS_COUNTER(xbus, DESC_REQ)++;
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(CHAN_POWER, xpp_line_t lines, bool on)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ lines &= xpd->enabled_chans; // Ignore disabled channels
+ if(!lines) {
+ return 0;
+ }
+ DBG("Channel Power: 0x%04X %s\n", lines, (on) ? "up" : "down");
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ if(on) {
+ // Power up
+ len = slic_cmd_direct_write(sc, lines, 0x42, 0x06);
+ } else {
+ // Power down
+ len = slic_cmd_direct_write(sc, lines, 0x42, 0x00);
+ }
+ pack_tx->datalen = len;
+
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(CHAN_ENABLE, xpp_line_t lines, bool on)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ lines &= xpd->enabled_chans; // Ignore disabled channels
+ if(!lines) {
+ return 0;
+ }
+ DBG("Channel Activation: 0x%4X %s\n", lines, (on) ? "on" : "off");
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ len = slic_cmd_direct_write(sc, lines, 0x40, (on)?0x01:0x00);
+ pack_tx->datalen = len;
+
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(RING, int pos, bool on)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ xpp_line_t mask = (1 << pos);
+ int len;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ mask &= xpd->enabled_chans; // Ignore disabled channels
+ if(!mask) {
+ return 0;
+ }
+ DBG("%s pos=%d %s\n", xpd->xpdname, pos, (on) ? "on" : "off");
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ len = slic_cmd_direct_write(sc, mask, 0x40, (on)?0x04:0x01);
+ pack_tx->datalen = len;
+
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(SETHOOK, xpp_line_t hook_status)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ hook_status &= xpd->enabled_chans; // Ignore disabled channels
+ if(!hook_status) {
+ return 0;
+ }
+ DBG("New hook_status: %d\n", hook_status);
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ /* FIXME: This is fake, until Dima implements FXO */
+ len = slic_cmd_direct_write(sc, hook_status, 0x02, 0x00);
+ pack_tx->datalen = len;
+
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/*
+ * LED control is done via SLIC register 0x06:
+ * 7 6 5 4 3 2 1 0
+ * +-----+-----+-----+-----+-----+-----+-----+-----+
+ * | MR | MG | MB | R | OG | OB | G | B |
+ * +-----+-----+-----+-----+-----+-----+-----+-----+
+ *
+ * B - BLUE LED (0 - OFF, 1 - ON)
+ * G - GREEN LED (0 - OFF, 1 - ON)
+ * OB - Output BLUE (this line is output)
+ * OG - Output GREEN (this line is output)
+ * R - RED LED (0 - OFF, 1 - ON)
+ * MB - Mask BLUE. (1 - B effect the BLUE LED)
+ * MR - Mask RED. (1 - R effect the RED LED)
+ * MG - Mask GREEN. (1 - G effect the GREEN LED)
+ *
+ * The BLUE LED (actually a relay out) is connected to line 0 and 4 only.
+ */
+
+// GREEN RED BLUE
+static int led_mask[NUM_LEDS] = { BIT(6), BIT(7), BIT(5) };
+static int led_vals[NUM_LEDS] = { BIT(1), BIT(4), BIT(0) };
+
+/* 0x0F */ HOSTCMD(LED, xpp_line_t lines, byte which, bool on)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+ int value;
+ int i;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ lines &= xpd->enabled_chans; // Ignore disabled channels
+ if(!lines) {
+ return 0;
+ }
+ DBG("LED: lines=0x%04X which=%d -- %s\n", lines, which, (on) ? "on" : "off");
+ which = which % NUM_LEDS;
+ value = BIT(2) | BIT(3);
+ value |= ((BIT(5) | BIT(6) | BIT(7)) & ~led_mask[which]);
+ if(on)
+ value |= led_vals[which];
+ for(i = 0; i < CHANNELS_PERXPD; i++) {
+ if(!IS_SET(lines, i))
+ continue;
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ len = slic_cmd_direct_write(sc, lines, 0x06, value);
+ DBG("LED pack: line=%d value=0x%04X\n", i, value);
+ pack_tx->datalen = len;
+ packet_send(xbus, pack_tx);
+ }
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(RELAY_OUT, byte which, bool on)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+ int value;
+ xpp_line_t lines;
+ int relay_channels[] = { 0, 4 };
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+
+ DBG("RELAY_OUT: which=%d -- %s\n", which, (on) ? "on" : "off");
+ which = which % ARRAY_SIZE(relay_channels);
+ lines = BIT(relay_channels[which]);
+ value = BIT(2) | BIT(3);
+ value |= ((BIT(5) | BIT(6) | BIT(7)) & ~led_mask[LED_BLUE]);
+ if(on)
+ value |= led_vals[LED_BLUE];
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ len = slic_cmd_direct_write(sc, lines, 0x06, value);
+
+ DBG("RELAY_OUT pack: line=%d value=0x%04X\n", lines, value);
+ pack_tx->datalen = len;
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(SLIC_INIT)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_data_t *slic;
+ struct slic_init_data *source;
+ int i;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ DBG("INITIALIZING SLIC\n");
+ for(i = 0; i < ARRAY_SIZE(slic_init_data); i++) {
+ source = &slic_init_data[i];
+ NEW_PACKET(pack_tx, xbus, SLIC_INIT, xpd->id);
+ PACKET_FIELD(pack_tx, SLIC_INIT, lines) = source->lines;
+
+ slic = &PACKET_FIELD(pack_tx, SLIC_INIT, slic_data);
+ slic->len = source->slic_data.len;
+ memcpy(slic->data, source->slic_data.data, source->slic_data.len);
+ pack_tx->datalen = sizeof(xpp_line_t) + slic->len + 1;
+// dump_packet("SLIC", pack_tx, print_dbg);
+ packet_send(xbus, pack_tx);
+ mdelay(10); // FIXME: Temporary -- Dima need to fix it
+ }
+ return ret;
+}
+
+/* 0x0F */ HOSTCMD(SLIC_QUERY, int pos, byte reg_num)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ slic_cmd_t *sc;
+ int len;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ NEW_PACKET(pack_tx, xbus, SLIC_WRITE, xpd->id);
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ len = slic_cmd_direct_read(sc, (1<<pos), reg_num);
+
+ pack_tx->datalen = len;
+
+ packet_send(xbus, pack_tx);
+ return ret;
+}
+
+/* 0x11 */ HOSTCMD(PCM_WRITE, xpp_line_t lines, volatile byte *buf)
+{
+ int ret = 0;
+ xpacket_t *pack_tx;
+ byte *pcm;
+ byte *start_pcm;
+ int i;
+ extern ulong pcm_gen;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ lines &= xpd->enabled_chans;
+ // DBG("PCM_WRITE\n");
+ if(pcm_gen != 0)
+ return 0;
+// if(lines == 0)
+// return 0;
+
+ /*
+ * FIXME: Workaround a bug in sync code of the Astribank.
+ * Send dummy PCM for sync.
+ */
+ if(lines == 0)
+ lines = BIT(0);
+
+ NEW_PACKET(pack_tx, xbus, PCM_WRITE, xpd->id);
+ PACKET_FIELD(pack_tx, PCM_WRITE, lines) = lines;
+ start_pcm = pcm = PACKET_FIELD(pack_tx, PCM_WRITE, pcm);
+ for(i = 0; i < CHANNELS_PERXPD; i++) {
+ if(IS_SET(lines, i)) {
+ memcpy(pcm, (byte *)buf, ZT_CHUNKSIZE);
+ pcm += ZT_CHUNKSIZE;
+ }
+ buf += ZT_CHUNKSIZE;
+ }
+ pack_tx->datalen = sizeof(xpp_line_t) + (pcm - start_pcm);
+ packet_send(xbus, pack_tx);
+ XPD_COUNTER(xpd, PCM_WRITE)++;
+ XBUS_COUNTER(xbus, PCM_WRITE)++;
+ return ret;
+}
+
+/* 0x13 */ HOSTCMD(PCM_GEN, xpp_line_t lines, volatile byte *buf)
+{
+ xpacket_t *pack_tx;
+ bool gen_seq = ((lines != 0) && (buf != NULL));
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ lines &= xpd->enabled_chans; // Ignore disabled channels
+ if(!lines) {
+ return 0;
+ }
+ DBG("PCM_GEN lines=0x%04X %s\n", lines, (gen_seq) ? "seq" : "off");
+ NEW_PACKET(pack_tx, xbus, PCM_GEN, xpd->id);
+ PACKET_FIELD(pack_tx, PCM_GEN, lines) = lines;
+ if(gen_seq) {
+ PACKET_FIELD(pack_tx, PCM_GEN, gen) = 0;
+ memcpy(&PACKET_FIELD(pack_tx, PCM_GEN, pcm_seq), (byte *)buf, ZT_CHUNKSIZE);
+ } else {
+ PACKET_FIELD(pack_tx, PCM_GEN, gen) = 2;
+ }
+ packet_send(xbus, pack_tx);
+ return 0;
+}
+
+/*
+ * Sync source is controled by a mask byte to 0x19 command:
+ * 7 6 5 4 3 2 1 0
+ * +-----+-----+-----+-----+-----+-----+-----+-----+
+ * | | | | | | | RW | AB |
+ * +-----+-----+-----+-----+-----+-----+-----+-----+
+ *
+ * RW - Read or set (0 - Write, 1 - Read)
+ * AB - This Astribank provide sync (0 - no, 1 - yes)
+ *
+ */
+
+/* 0x19 */ HOSTCMD(SYNC_SOURCE, bool setit, bool is_master)
+{
+ xpacket_t *pack_tx;
+ byte mask = 0;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ if(is_master)
+ mask |= BIT(0);
+ if(!setit)
+ mask |= BIT(1);
+ DBG("SYNC_SOURCE %s setit=%s is_master=%s (mask=0x%X)\n",
+ xpd->xpdname, (setit)?"yes":"no", (is_master)?"yes":"no", mask);
+ NEW_PACKET(pack_tx, xbus, SYNC_SOURCE, xpd->id);
+ PACKET_FIELD(pack_tx, SYNC_SOURCE, mask) = mask;
+ packet_send(xbus, pack_tx);
+ return 0;
+}
+
+/* 0x31 */ HOSTCMD(LOOPBACK_AX, byte *data, unsigned int size)
+{
+ xpacket_t *pack_tx;
+
+ BUG_ON(!xbus);
+ BUG_ON(!xpd);
+ DBG("LOOPBACK_AX %d bytes\n", size);
+ NEW_PACKET(pack_tx, xbus, LOOPBACK_AX, xpd->id);
+ memcpy(&PACKET_FIELD(pack_tx, LOOPBACK_AX, data), data, size);
+ packet_send(xbus, pack_tx);
+ return 0;
+}
+
+/*------------------------- Protocol Simulator ---------------------*/
+
+
+static int simulate_xpd(xbus_t *xbus, int xpd_num, xpacket_t *sent_packet)
+{
+ xpacket_t *pack = sent_packet;
+ struct xpd_sim *xpd_sim;
+ struct xpd_sim *loopto_sim;
+ xpp_opcode_t opcode;
+ int dest_xpd_num;
+ int ret = 0;
+
+ // Sanity checks
+ BUG_ON(!xbus);
+ BUG_ON(xpd_num > MAX_XPDS || xpd_num < 0);
+ BUG_ON(!sent_packet);
+ BUG_ON(!xbus->sim[xpd_num].simulated);
+
+ XBUS_COUNTER(xbus, SIM_PACKETS)++;
+ xpd_sim = &xbus->sim[xpd_num];
+ opcode = pack->content.opcode;
+ dest_xpd_num = xpd_sim->loopto;
+ loopto_sim = &xbus->sim[dest_xpd_num];
+// DBG("before: addr=%d, opcode=0x%X\n", xpd_num, opcode);
+ switch(opcode) {
+ case XPP_DESC_REQ:
+ DBG("SIM DESC_REQ (xpd_num=%d)\n", xpd_num);
+ PACKET_INIT(pack, DEV_DESC);
+ PACKET_FIELD(pack, DEV_DESC, type) = xpd_sim->xpd_type;
+ dest_xpd_num = xpd_num; // Reply as the original XPD
+ break;
+ case XPP_PCM_WRITE:
+ PACKET_INIT(pack, PCM_READ);
+ XPD_ADDR_SET(pack->content.addr, dest_xpd_num);
+ break;
+ case XPP_SLIC_WRITE:
+#if FINISHED_DECODING_SLICS
+ slic_cmd_t *sc;
+ int len;
+
+ sc = &PACKET_FIELD(pack_tx, SLIC_WRITE, slic_cmd);
+ lines = sc->lines;
+ bool slic_write = ! (slic->data[0] & 0x80);
+ int slic_reg = slic->data[0] & ~0x80;
+
+ if(slic->len == 2 && slic_write && slic_reg == 0x40) { // RING
+ bool on = (slic->data[1] == 0x04);
+ if(on) {
+ loopto_sim->hookstate |= lines;
+ } else {
+ loopto_sim->hookstate &= ~lines;
+ }
+
+ DBG("SIM RING to: xpd=%d (type=%d): (%s) ringing=0x%04X lines=0x%04X\n", dest_xpd_num, loopto_sim->xpd_type,
+ (on)?"on":"off", loopto_sim->hookstate, lines);
+ PACKET_INIT(pack, SIG_CHANGED);
+ PACKET_FIELD(pack, SIG_CHANGED, type) = loopto_sim->xpd_type;
+ PACKET_FIELD(pack, SIG_CHANGED, sig_status) = loopto_sim->hookstate;
+ PACKET_FIELD(pack, SIG_CHANGED, sig_toggles) = lines;
+ dump_packet("SIM RING TO", pack, print_dbg);
+ break;
+ } else if(slic->len == 1 && slic_write && slic_reg == 0x02) { // SETHOOK
+ DBG("SIM SETHOOK: xpd=%d: hookstate=0x%04X lines=0x%04X\n", dest_xpd_num, loopto_sim->hookstate, lines);
+ PACKET_INIT(pack, SIG_CHANGED);
+ PACKET_FIELD(pack, SIG_CHANGED, type) = loopto_sim->xpd_type;
+ PACKET_FIELD(pack, SIG_CHANGED, sig_status) = lines;
+ PACKET_FIELD(pack, SIG_CHANGED, sig_toggles) = loopto_sim->hookstate ^ lines;
+ loopto_sim->hookstate = lines;
+ break;
+ } else if(slic->len == 2 && slic_write && slic_reg == 0x06) { // LED
+ DBG("SIM LED: xpd=%d: 0x%04X=%s\n", xpd_num, lines, (0x10)? "on" : "off");
+ ret = 0;
+ goto junk;
+ } else if(slic->len == 2 && ! slic_write) { // SLIC_QUERY
+ DBG("SIM SLIC_QUERY: xpd=%d: register=0x%02X\n", xpd_num, slic_reg);
+ ret = 0;
+ goto junk;
+ } else if(slic->len >= 4) { // INITIALIZATION?
+ DBG("SIM INITIALIZATION? xpd=%d len=%d\n", xpd_num, slic->len);
+ ret = 0;
+ goto junk;
+ }
+ NOTICE("%s: xpd=%d: SLIC_WRITE: len=%d\n", __FUNCTION__, xpd_num, slic->len);
+#endif
+ dump_packet("BAD SLIC_WRITE", pack, print_dbg);
+ // FALL THROUGH
+ default:
+ NOTICE("%s: xpd=%d: CANNOT SIMULATE OPCODE=0x%02X\n",
+ __FUNCTION__, xpd_num, opcode);
+// dump_packet("BAD OPCODE", pack, print_dbg);
+ ret = -EINVAL;
+ goto junk;
+ }
+// DBG("after reversing: addr=%d, opcode=0x%X\n", xpd_num, pack->header.opcode);
+ return packet_process(xbus, dest_xpd_num, pack);
+junk:
+ xbus->ops->packet_free(xbus, pack);
+ return ret;
+}
+
+#define VERBOSE_DEBUG 1
+#define ERR_REPORT_LIMIT 20
+
+void dump_packet(const char *msg, xpacket_t *packet, bool print_dbg)
+{
+ xpp_opcode_t op = (byte)packet->content.opcode;
+
+ if(!print_dbg)
+ return;
+ DBG("%s: @0x%02X OP=0x%02X flags=0x%02X LEN=%d\n",
+ msg,
+ XPD_NUM(packet->content.addr),
+ op,
+ (byte)packet->flags,
+ (byte)packet->datalen);
+#if VERBOSE_DEBUG
+ {
+ int i;
+ byte *p = packet->content.raw;
+
+ for(i = 0; i < packet->datalen; i++) {
+ static int limiter = 0;
+
+ if(i >= sizeof(xpp_packet_r_t)) {
+ if(limiter < ERR_REPORT_LIMIT) {
+ ERR("dump_packet: length overflow i=%d > sizeof(xpp_packet_r_t)=%d\n",
+ i+1, sizeof(xpp_packet_r_t));
+ } else if(limiter == ERR_REPORT_LIMIT) {
+ ERR("dump_packet: error packet #%d... squelsh reports.\n", limiter);
+ }
+ limiter++;
+ break;
+ }
+ DBG(" %2d> %02X\n", i+1, p[i]);
+ }
+ }
+#endif
+}
+
+/*------------------------- Reply Handlers -------------------------*/
+
+#define HANDLER_DEF(name) \
+ int CALL_PROTO(name, xbus_t *xbus, int xpd_num, xpp_command_t *cmd, xpacket_t *reply)
+
+/*
+static HANDLER_DEF(notimp)
+{
+ NOTICE("xpp protocol error: command %s is not implemented yet\n", cmd->name);
+ return -EPROTO;
+}
+*/
+static HANDLER_DEF(DEV_DESC)
+{
+ byte type = PACKET_FIELD(reply, DEV_DESC, type) & 0x7; // 3 LSB's
+ byte rev = PACKET_FIELD(reply, DEV_DESC, rev);
+ xpp_line_t line_status = PACKET_FIELD(reply, DEV_DESC, line_status);
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+
+ if(xpd) {
+ NOTICE("Received DEV_DESC packet for an existing xpd %s of type %d\n",
+ xpd->xpdname, type);
+ return 0;
+ }
+ XBUS_COUNTER(xbus, DEV_DESC)++;
+ DBG("xpd=%d type=%d rev=%d line_status=0x%04X\n", xpd_num, type, rev, line_status);
+ switch(type) {
+ case XPD_TYPE_FXS:
+ break;
+ case XPD_TYPE_FXO:
+ break;
+ case XPD_TYPE_NOMODULE:
+ DBG("No module at address=%d\n", xpd_num);
+ return 0;
+ default:
+ NOTICE("DEV_DESC: unkown type=%d\n", type);
+ return -EPROTO;
+ }
+ if((xpd = xpd_new(xbus, xpd_num, type, rev)) == NULL) {
+ NOTICE("xpd_new failed\n");
+ }
+ xpp_check_hookstate(xpd, line_status);
+ return 0;
+}
+
+/**
+ * Handle signalling
+ */
+static HANDLER_DEF(SIG_CHANGED)
+{
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+ xpp_line_t sig_status = PACKET_FIELD(reply, SIG_CHANGED, sig_status);
+
+ if(!xpd) {
+ NOTICE("%s: received %s for non-existing xpd: %d\n", __FUNCTION__, cmd->name, xpd_num);
+ return -EPROTO;
+ }
+ if(xpd->direction == TO_PHONE) { /* Hook state changes */
+ DBG("%s (PHONE) sig_status=0x%04X\n", xpd->xpdname, sig_status);
+ xpp_check_hookstate(xpd, sig_status);
+ } else { /* TO_TRUNK - line ring changes */
+ unsigned long flags;
+ int i;
+
+ DBG("%s (TRUNK) sig_status=0x%04X\n", xpd->xpdname, sig_status);
+ spin_lock_irqsave(&xpd->lock, flags);
+ for(i = 0; i < xpd->channels; i++) {
+ if(IS_SET(sig_status, i)) {
+ xpd->ringing[i] = RINGS_NUM*2;
+ zt_hooksig(&xpd->chans[i], ZT_RXSIG_OFFHOOK);
+ } else {
+ zt_hooksig(&xpd->chans[i], ZT_RXSIG_ONHOOK);
+ xpd->ringing[i] = 0;
+ }
+ }
+ spin_unlock_irqrestore(&xpd->lock, flags);
+ }
+ return 0;
+}
+
+static HANDLER_DEF(SLIC_REPLY)
+{
+ slic_reply_t *info = &PACKET_FIELD(reply, SLIC_REPLY, info);
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+ unsigned long flags;
+
+ if(!xpd) {
+ NOTICE("%s: received %s for non-existing xpd: %d\n", __FUNCTION__, cmd->name, xpd_num);
+ return -EPROTO;
+ }
+ spin_lock_irqsave(&xpd->lock, flags);
+ DBG("SLIC_REPLY: xpd #%d %s reg_num=0x%X, dataL=0x%X dataH=0x%X\n",
+ xpd_num, (info->indirect)?"I":"D",
+ info->reg_num, info->data_low, info->data_high);
+ spin_unlock_irqrestore(&xpd->lock, flags);
+ return 0;
+}
+
+static HANDLER_DEF(PCM_READ)
+{
+ /* FIXME: work around temporary hardware bug */
+ xpd_num = 0;
+
+ xpp_line_t lines = PACKET_FIELD(reply, PCM_READ, lines);
+ const byte *pcm = PACKET_FIELD(reply, PCM_READ, pcm);
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+ volatile u_char *readchunk;
+ volatile u_char *r;
+ unsigned long flags;
+ int i;
+
+ if(!xpd) {
+ NOTICE("%s: received %s for non-existing xpd: %d\n", __FUNCTION__, cmd->name, xpd_num);
+ return -EPROTO;
+ }
+ // DBG("lines=0x%04X\n", lines);
+
+ if(!pcm_valid(xpd, reply)) {
+ return -EPROTO;
+ }
+ spin_lock_irqsave(&xpd->lock, flags);
+ if (xpd->timer_count & 1) {
+ /* First part */
+ r = readchunk = xpd->readchunk;
+ } else {
+ r = readchunk = xpd->readchunk + ZT_CHUNKSIZE * CHANNELS_PERXPD;
+ }
+
+ /* Copy PCM and put each channel in its index */
+ for (i = 0; i < CHANNELS_PERXPD; i++) {
+ if(IS_SET(lines, i)) {
+ memcpy((u_char *)r, pcm, ZT_CHUNKSIZE);
+ //memset((u_char *)r, 0x5A, ZT_CHUNKSIZE); // DEBUG
+ pcm += ZT_CHUNKSIZE;
+ }
+ r += ZT_CHUNKSIZE;
+ }
+
+ XPD_COUNTER(xpd, PCM_READ)++;
+ XBUS_COUNTER(xpd->xbus, PCM_READ)++;
+ spin_unlock_irqrestore(&xpd->lock, flags);
+ if(xpd->id == 0)
+ xpp_tick(0);
+ return 0;
+}
+
+static HANDLER_DEF(SYNC_REPLY)
+{
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+
+ if(!xpd) {
+ NOTICE("%s: received %s for non-existing xpd: %d\n", __FUNCTION__, cmd->name, xpd_num);
+ return -EPROTO;
+ }
+ DBG("SYNC_REPLY: 0x%X\n", PACKET_FIELD(reply, SYNC_REPLY, mask));
+ return 0;
+}
+
+static HANDLER_DEF(LOOPBACK_XA)
+{
+ xpd_t *xpd = xpd_of(xbus, xpd_num);
+
+ if(!xpd) {
+ NOTICE("%s: received %s for non-existing xpd: %d\n", __FUNCTION__, cmd->name, xpd_num);
+ return -EPROTO;
+ }
+ dump_packet("LOOPBACK_XA", reply, print_dbg);
+ CALL_PROTO(LED, xpd->xbus, xpd, xpd->enabled_chans, LED_RED, 0); // FIXME: Find usage for extra LED
+ return 0;
+}
+
+static HANDLER_DEF(DIAG_FE)
+{
+ dump_packet("DIAG_FE", reply, print_dbg);
+ return 0;
+}
+
+static const xpp_packet_r_t FOR_SIZE_CALC; // Ugly hack, so we have something to sizeof()
+
+#define C_(op,var,txt) \
+ [ XPP_##op ] { \
+ .opcode = XPP_##op, \
+ .varsize = var, \
+ .header_size = sizeof(FOR_SIZE_CALC.cmd_##op), \
+ .name = #op, \
+ .desc = txt, \
+ .handler = PROTO_FUNC(op) \
+ }
+
+static xpp_command_t xpp_commands[] = {
+ /* OP V DESCRIPTION */
+ C_( DEV_DESC, 0, "Device description reply"),
+ C_( SIG_CHANGED, 0, "Signaling change (hookstate/ringing)"),
+ C_( SLIC_REPLY, 0, "Reply to slic state"),
+ C_( PCM_READ, 1, "Read PCM data"),
+ C_( SYNC_REPLY, 0, "SYNC_REPLY"),
+ C_( LOOPBACK_XA, 1, "LOOPBACK Reply"),
+ C_( DIAG_FE, 1, "DIAG FE Opcode"),
+};
+
+#undef C_
+
+static unsigned int xpp_max_opcode(void)
+{
+ return ARRAY_SIZE(xpp_commands);
+}
+
+static bool xpp_valid_opcode(xpp_opcode_t op)
+{
+ if(op <= 0 || op >= xpp_max_opcode())
+ return 0;
+ return xpp_commands[op].opcode != XPP_NOTIMP;
+}
+
+static xpp_command_t *xpp_command(xpp_opcode_t op)
+{
+ if(!xpp_valid_opcode(op))
+ return 0;
+ return &xpp_commands[op];
+}
+
+static bool xpp_valid_size(xpp_opcode_t op, xpacket_t *pack)
+{
+ xpp_command_t *cmd = xpp_command(op);
+ unsigned int hsize = cmd->header_size;
+ unsigned int size = pack->datalen;
+ int varsize = cmd->varsize;
+
+ // ERR("op=%d hsize=%d size=%d\n", op, hsize, size);
+ return (hsize == size) ||
+ (varsize && size <= sizeof(struct xpp_packet_r));
+}
+
+static bool pcm_valid(xpd_t *xpd, xpacket_t *reply)
+{
+ xpp_opcode_t op;
+ xpp_command_t *cmd;
+ xpp_line_t lines = PACKET_FIELD(reply, PCM_READ, lines);
+ int i;
+ int count = 0;
+
+ BUG_ON(!reply);
+ op = reply->content.opcode;
+ cmd = xpp_command(op);
+ if(!cmd) {
+ ERR("xpp: %s -- bad command op=0x%02X\n", __FUNCTION__, op);
+ return 0;
+ }
+ for (i = 0; i < CHANNELS_PERXPD; i++)
+ if(IS_SET(lines, i))
+ count++;
+ if(reply->datalen != (sizeof(xpp_line_t) + count * 8)) {
+ static int rate_limit = 0;
+
+ XPD_COUNTER(xpd, RECV_ERRORS)++;
+ if((rate_limit++ % 1000) <= 10) {
+ ERR("BAD PCM REPLY: reply->datalen=%d, count=%d\n", reply->datalen, count);
+ }
+ return 0;
+ }
+ return 1;
+}
+
+int packet_receive(xbus_t *xbus, xpacket_t *pack)
+{
+ int xpd_num = XPD_NUM(pack->content.addr);
+
+ if(!VALID_XPD_NUM(xpd_num)) {
+ dump_packet("martian packet", pack, print_dbg);
+ xbus->ops->packet_free(xbus, pack);
+ return -EPROTO;
+ }
+ if(xbus->sim[xpd_num].simulated) {
+ //dump_packet("packet_receive -> simulate", pack, print_dbg);
+ return simulate_xpd(xbus, xpd_num, pack);
+ } else {
+ //dump_packet("packet_receive -> process", pack, print_dbg);
+ return packet_process(xbus, xpd_num, pack);
+ }
+}
+
+static int packet_process(xbus_t *xbus, int xpd_num, xpacket_t *pack)
+{
+ xpp_opcode_t op;
+ xpp_command_t *cmd;
+ xpp_handler_t handler;
+ int ret = 0;
+
+ BUG_ON(!pack);
+ op = pack->content.opcode;
+ cmd = xpp_command(op);
+ /*-------- Validations -----------*/
+ if(!cmd) {
+ ERR("xpp: %s -- bad command op=0x%02X\n", __FUNCTION__, op);
+ dump_packet("packet_process -- bad command", pack, print_dbg);
+ ret = -EPROTO;
+ goto out;
+ }
+ if(!xpp_valid_size(op, pack)) {
+ ERR("xpp: %s: wrong size %d for op=0x%02X\n",
+ __FUNCTION__, pack->datalen, op);
+ dump_packet("packet_process -- wrong size", pack, print_dbg);
+ ret = -EPROTO;
+ goto out;
+ }
+ handler = cmd->handler;
+ BUG_ON(!handler);
+ XBUS_COUNTER(xbus, RX_BYTES) += pack->datalen;
+ handler(xbus, xpd_num, cmd, pack);
+out:
+ xbus->ops->packet_free(xbus, pack);
+ return ret;
+}
+
+
+void process_sim_queue(void *data)
+{
+ xbus_t *xbus = data;
+ xpacket_t *pack;
+
+// DBG("\n");
+ BUG_ON(!xbus);
+ while((pack = xbus_dequeue_packet(&xbus->sim_packet_queue)) != NULL) {
+// DBG("pack->addr=0x%X pack->opcode=0x%X\n", XPD_NUM(pack->addr), pack->header.opcode);
+ packet_receive(xbus, pack);
+ }
+}
+
+/**
+ * processes a packet recieved from the lower-level.
+ * @xbus the data bus
+ * @pack the handled packet
+ * @returns return status (0 for success).
+ *
+ * Should not be blocking.
+ * Has separate handling for PCM packets (direct write) and command packets (queued)
+ */
+
+EXPORT_SYMBOL(dump_packet);
+EXPORT_SYMBOL(packet_receive);
+EXPORT_SYMBOL(proc_xpd_slic_read);
+EXPORT_SYMBOL(proc_xpd_slic_write);
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-28 02:05:25 +0000