summaryrefslogtreecommitdiff
path: root/io
diff options
context:
space:
mode:
Diffstat (limited to 'io')
-rw-r--r--io/hpmud/dot4.c750
-rw-r--r--io/hpmud/dot4.h187
-rw-r--r--io/hpmud/hp-mkuri.c543
-rw-r--r--io/hpmud/hpmud.c699
-rw-r--r--io/hpmud/hpmud.h581
-rw-r--r--io/hpmud/hpmudi.h212
-rw-r--r--io/hpmud/jd.c906
-rw-r--r--io/hpmud/jd.h56
-rw-r--r--io/hpmud/list.h131
-rw-r--r--io/hpmud/mlc.c772
-rw-r--r--io/hpmud/mlc.h150
-rw-r--r--io/hpmud/model.c633
-rw-r--r--io/hpmud/musb.c2197
-rw-r--r--io/hpmud/musb.h121
-rw-r--r--io/hpmud/pml.c520
-rw-r--r--io/hpmud/pml.h77
-rw-r--r--io/hpmud/pp.c1310
-rw-r--r--io/hpmud/pp.h100
-rw-r--r--io/mudext/hpmudext.c495
19 files changed, 10440 insertions, 0 deletions
diff --git a/io/hpmud/dot4.c b/io/hpmud/dot4.c
new file mode 100644
index 0000000..ba56e53
--- /dev/null
+++ b/io/hpmud/dot4.c
@@ -0,0 +1,750 @@
+/*****************************************************************************\
+
+ dot4.c - 1284.4 support multi-point tranport driver
+
+ (c) 2005-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#include "hpmud.h"
+#include "hpmudi.h"
+
+/*
+ * This 1284.4 implementation does not support "Multiple Outstanding Transactions" which is optional.
+ */
+
+/* Write command reply back to peripheral. */
+static int Dot4ForwardReply(mud_channel *pc, int fd, unsigned char *buf, int size)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int len=0;
+
+ if ((len = (pd->vf.write)(fd, buf, size, HPMUD_EXCEPTION_TIMEOUT)) != size)
+ {
+ BUG("unable to Dot4ForwarReply: %m\n");
+ }
+ return len;
+}
+
+/* Execute command from peripheral. */
+static int Dot4ExecReverseCmd(mud_channel *pc, int fd, unsigned char *buf)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ mud_channel *out_of_bound_channel;
+ DOT4Cmd *pCmd;
+ DOT4Reply *pReply;
+ DOT4Credit *pCredit;
+ DOT4CreditReply *pCreditReply;
+ DOT4CreditRequest *pCreditReq;
+ DOT4CreditRequestReply *pCreditReqReply;
+ DOT4Error *pError;
+ int len, size;
+ unsigned char socket;
+ static int cnt;
+
+ pCmd = (DOT4Cmd *)buf;
+
+ /* See if this packet is a command packet. */
+ if (!(pCmd->h.psid == 0 && pCmd->h.ssid == 0))
+ {
+ if (pCmd->h.psid == pCmd->h.ssid)
+ {
+ /* Got a valid data packet handle it. This can happen when channel_read timeouts and p2hcredit=1. */
+ out_of_bound_channel = &pd->channel[pCmd->h.psid];
+
+ if (out_of_bound_channel->ta.p2hcredit <= 0)
+ {
+ BUG("invalid data packet credit=%d\n", out_of_bound_channel->ta.p2hcredit);
+ return 0;
+ }
+
+ size = ntohs(pCmd->h.length) - sizeof(DOT4Header);
+ if (size > (HPMUD_BUFFER_SIZE - out_of_bound_channel->rcnt))
+ {
+ BUG("invalid data packet size=%d\n", size);
+ return 0;
+ }
+ memcpy(&out_of_bound_channel->rbuf[out_of_bound_channel->rcnt], buf+sizeof(MLCHeader), size);
+ out_of_bound_channel->rcnt += size;
+ if (pCmd->h.credit)
+ out_of_bound_channel->ta.h2pcredit += pCmd->h.credit; /* note, piggy back credit is 1 byte wide */
+ out_of_bound_channel->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+ }
+ else
+ {
+ len = ntohs(pCmd->h.length);
+ BUG("unsolicited data packet: psid=%x, ssid=%x, length=%d, credit=%d, status=%x\n", pCmd->h.psid,
+ pCmd->h.ssid, len, pCmd->h.credit, pCmd->h.control);
+ DBG_DUMP(buf, len);
+ }
+ return 0;
+ }
+
+ /* Process any command. */
+ switch (pCmd->cmd)
+ {
+ case DOT4_CREDIT:
+ pCredit = (DOT4Credit *)buf;
+ out_of_bound_channel = &pd->channel[pCredit->psocket];
+ out_of_bound_channel->ta.h2pcredit += ntohs(pCredit->credit);
+ pCreditReply = (DOT4CreditReply *)buf;
+ pCreditReply->h.length = htons(sizeof(DOT4CreditReply));
+ pCreditReply->h.credit = 1; /* transaction credit for next command */
+ pCreditReply->h.control = 0;
+ pCreditReply->cmd |= 0x80;
+ pCreditReply->result = 0;
+ pCreditReply->psocket = out_of_bound_channel->sockid;
+ pCreditReply->ssocket = out_of_bound_channel->sockid;
+ Dot4ForwardReply(pc, fd, (unsigned char *)pCreditReply, sizeof(DOT4CreditReply));
+ break;
+ case DOT4_CREDIT_REQUEST:
+ pCreditReq = (DOT4CreditRequest *)buf;
+ if (cnt++ < 5)
+ BUG("unexpected DOT4CreditRequest: cmd=%x, hid=%x, pid=%x, maxcredit=%d\n", pCreditReq->cmd,
+ pCreditReq->psocket, pCreditReq->ssocket, ntohs(pCreditReq->maxcredit));
+ socket = pCreditReq->ssocket;
+ pCreditReqReply = (DOT4CreditRequestReply *)buf;
+ pCreditReqReply->h.length = htons(sizeof(DOT4CreditRequestReply));
+ pCreditReqReply->h.credit = 1; /* transaction credit for next command */
+ pCreditReqReply->h.control = 0;
+ pCreditReqReply->cmd |= 0x80;
+ pCreditReqReply->result = 0;
+ pCreditReqReply->psocket = socket;
+ pCreditReqReply->ssocket = socket;
+ pCreditReqReply->credit = 0;
+ Dot4ForwardReply(pc, fd, (unsigned char *)pCreditReqReply, sizeof(DOT4CreditRequestReply));
+ break;
+ case DOT4_ERROR:
+ pError = (DOT4Error *)buf;
+ BUG("unexpected DOT4Error: cmd=%x, psocket=%d, ssocket=%d, error=%x\n", pError->cmd, pError->psocket, pError->ssocket, pError->error);
+ return 1;
+ default:
+ pReply = (DOT4Reply *)buf;
+ BUG("unexpected command: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ pReply->h.length = htons(sizeof(DOT4Reply));
+ pReply->h.credit = 1; /* transaction credit for next command */
+ pReply->h.control = 0;
+ pReply->cmd |= 0x80;
+ pReply->result = 1;
+ Dot4ForwardReply(pc, fd, (unsigned char *)pReply, sizeof(DOT4Reply));
+ break;
+ }
+ return 0;
+}
+
+/* Get command from peripheral and processes the reverse command. */
+int __attribute__ ((visibility ("hidden"))) Dot4ReverseCmd(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, size;
+ unsigned int pklen;
+ unsigned char *pBuf;
+ DOT4Reply *pPk;
+
+ pPk = (DOT4Reply *)buf;
+
+ pBuf = buf;
+
+ /* Read packet header. */
+ size = sizeof(DOT4Header);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read Dot4ReverseCmd header: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Determine packet size. */
+ if ((pklen = ntohs(pPk->h.length)) > sizeof(buf))
+ {
+ BUG("invalid Dot4ReverseCmd packet size: size=%d\n", pklen);
+ stat = 1;
+ goto bugout;
+ }
+
+ /* Read packet data field. */
+ size = pklen - sizeof(DOT4Header);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read Dot4ReverseCmd data: %m exp=%zd act=%zd\n", pklen-sizeof(DOT4Header), pklen-sizeof(DOT4Header)-size);
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ stat = Dot4ExecReverseCmd(pc, fd, buf);
+
+bugout:
+ return stat;
+}
+
+/*
+ * Get command reply from peripheral. Waits for reply then returns. Processes any reverse commands
+ * while waiting for a reply.
+ */
+static int Dot4ReverseReply(mud_channel *pc, int fd, unsigned char *buf, int bufsize)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int stat=0, len, size, pklen;
+ unsigned char *pBuf;
+ DOT4Reply *pPk;
+
+ pPk = (DOT4Reply *)buf;
+
+ while (1)
+ {
+ pBuf = buf;
+
+ /* Read packet header. */
+ size = sizeof(DOT4Header);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, 4000000)) < 0) /* wait 4 seconds, 2 fails on PS2575 1200dpi uncompressed scanning */
+ {
+ BUG("unable to read Dot4ReverseReply header: %m bytesRead=%zd\n", sizeof(DOT4Header)-size);
+ stat = 2; /* short timeout */
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Determine packet size. */
+ pklen = ntohs(pPk->h.length);
+ if (pklen <= 0 || pklen > bufsize)
+ {
+ BUG("invalid Dot4ReverseReply packet size: size=%d, buf=%d\n", pklen, bufsize);
+ stat = 1;
+ goto bugout;
+ }
+
+ /* Read packet data field. */
+ size = pklen - sizeof(DOT4Header);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read Dot4ReverseReply data: %m exp=%zd act=%zd\n", pklen-sizeof(DOT4Header), pklen-sizeof(DOT4Header)-size);
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Check for reply. */
+ if (pPk->cmd & 0x80)
+ break;
+
+ stat = Dot4ExecReverseCmd(pc, fd, buf);
+
+ if (stat != 0)
+ break;
+
+ } /* while (1) */
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4Init(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n, cnt;
+ DOT4Init *pCmd;
+ DOT4InitReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4Init));
+ pCmd = (DOT4Init *)buf;
+ n = sizeof(DOT4Init);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1; /* transaction credit for reply */
+ pCmd->cmd = DOT4_INIT;
+ pCmd->rev = 0x20;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write DOT4Init: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ cnt=0;
+ while(1)
+ {
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4InitReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_INIT)) || (pReply->result != 0))
+ {
+ if (errno == EIO && cnt<1)
+ {
+ /* hack for usblp.c 2.6.5 */
+ BUG("invalid DOT4InitReply retrying...\n");
+ sleep(1);
+ cnt++;
+ continue;
+ }
+ if (stat == 2 && cnt<1)
+ {
+ /* hack for Fullhouse, Swami and Northstar */
+ BUG("invalid DOT4InitReply retrying command...\n");
+ memset(buf, 0, sizeof(DOT4Init));
+ n = sizeof(DOT4Init);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1; /* transaction credit for reply */
+ pCmd->cmd = DOT4_INIT;
+ pCmd->rev = 0x20;
+ (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT);
+ cnt++;
+ continue;
+ }
+ BUG("invalid DOT4InitReply: cmd=%x, result=%x\n, revision=%x\n", pReply->cmd, pReply->result, pReply->rev);
+ stat = 1;
+ goto bugout;
+ }
+ break;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4Exit(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4Exit *pCmd;
+ DOT4ExitReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4Exit));
+ pCmd = (DOT4Exit *)buf;
+ n = sizeof(DOT4Exit);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_EXIT;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write DOT4Exit: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4ExitReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_EXIT)) || (pReply->result != 0))
+ {
+ BUG("invalid DOT4ExitReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4GetSocket(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4GetSocket *pCmd;
+ DOT4GetSocketReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4GetSocket));
+ pCmd = (DOT4GetSocket *)buf;
+ n = sizeof(DOT4GetSocket);
+ len = strlen(pc->sn);
+ memcpy(buf+sizeof(DOT4GetSocket), pc->sn, len);
+ n += len;
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_GET_SOCKET;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write DOT4GetSocket: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4GetSocketReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_GET_SOCKET)) || (pReply->result != 0))
+ {
+ BUG("invalid DOT4GetSocketReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->sockid = pReply->socket;
+
+ if (pc->sockid != pc->index)
+ BUG("invalid sockid match sockid=%d index=%d\n", pc->sockid, pc->index);
+
+bugout:
+ return stat;
+}
+
+/* Write data to peripheral. */
+int __attribute__ ((visibility ("hidden"))) Dot4ForwardData(mud_channel *pc, int fd, const void *buf, int size, int usec_timeout)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int stat=0, len, n;
+ DOT4Header h;
+
+ memset(&h, 0, sizeof(h));
+ n = sizeof(DOT4Header) + size;
+ h.length = htons(n);
+ h.psid = pc->sockid;
+ h.ssid = pc->sockid;
+
+ if ((len = (pd->vf.write)(fd, &h, sizeof(DOT4Header), usec_timeout)) != sizeof(DOT4Header))
+ {
+ BUG("unable to write Dot4ForwardData header: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ if ((len = (pd->vf.write)(fd, buf, size, usec_timeout)) != size)
+ {
+ BUG("unable to write Dot4ForwardData: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+/* Read data from peripheral. */
+int __attribute__ ((visibility ("hidden"))) Dot4ReverseData(mud_channel *pc, int fd, void *buf, int length, int usec_timeout)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ mud_channel *out_of_bound_channel;
+ int len, size, total;
+ DOT4Header *pPk;
+
+ pPk = (DOT4Header *)buf;
+
+ while (1)
+ {
+ total = 0;
+
+ /* Read packet header. */
+ size = sizeof(DOT4Header);
+ while (size > 0)
+ {
+ /* Use requested client timeout until we start reading. */
+ if (total == 0)
+ len = (pd->vf.read)(fd, buf+total, size, usec_timeout);
+ else
+ len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT);
+
+ if (len < 0)
+ {
+ /* Got a timeout, if exception timeout or timeout occured after read started thats an error. */
+ if (usec_timeout >= HPMUD_EXCEPTION_TIMEOUT || total > 0)
+ BUG("unable to read Dot4ReverseData header: %m %s\n", pd->uri);
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+
+ /* Determine data size. */
+ size = ntohs(pPk->length) - sizeof(DOT4Header);
+
+ if (size > length)
+ {
+ BUG("invalid Dot4ReverseData size: size=%d, buf=%d\n", size, length);
+ goto bugout;
+ }
+
+ /* Make sure data packet is for this channel. */
+ if (pPk->psid != pc->sockid && pPk->ssid != pc->sockid)
+ {
+ if (pPk->psid == 0 && pPk->ssid == 0)
+ {
+ /* Ok, got a command channel packet instead of a data packet, handle it... */
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read Dot4ReverseData command: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total=len;
+ }
+ Dot4ExecReverseCmd(pc, fd, buf);
+ continue; /* try again for data packet */
+ }
+ else if (pPk->psid == pPk->ssid)
+ {
+ /* Got a valid data packet for another channel handle it. This can happen when ReadData timeouts and p2hcredit=1. */
+ out_of_bound_channel = &pd->channel[pPk->psid];
+ unsigned char *pBuf;
+
+ if (out_of_bound_channel->ta.p2hcredit <= 0)
+ {
+ BUG("invalid data packet credit=%d\n", out_of_bound_channel->ta.p2hcredit);
+ goto bugout;
+ }
+
+ if (size > (HPMUD_BUFFER_SIZE - out_of_bound_channel->rcnt))
+ {
+ BUG("invalid data packet size=%d\n", size);
+ goto bugout;
+ }
+
+ total = 0;
+ pBuf = &out_of_bound_channel->rbuf[out_of_bound_channel->rcnt];
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseData: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+
+ out_of_bound_channel->rcnt += total;
+ if (pPk->credit)
+ out_of_bound_channel->ta.h2pcredit += pPk->credit; /* note, piggy back credit is 1 byte wide */
+ out_of_bound_channel->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+ continue; /* try again for data packet */
+ }
+ else
+ {
+ DOT4Cmd *pCmd = (DOT4Cmd *)buf;
+ BUG("invalid Dot4ReverseData state: unexpected packet psid=%x, ssid=%x, cmd=%x\n", pPk->psid, pPk->ssid, pCmd->cmd);
+ goto bugout;
+ }
+ }
+
+ if (pPk->credit)
+ {
+ pc->ta.h2pcredit += pPk->credit; /* note, piggy back credit is 1 byte wide */
+ }
+
+ total = 0; /* eat packet header */
+
+ /* Read packet data field with exception_timeout. */
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read Dot4ReverseData: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+ break; /* done reading data packet */
+ } /* while (1) */
+
+bugout:
+ return total;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4OpenChannel(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4OpenChannel *pCmd;
+ DOT4OpenChannelReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4OpenChannel));
+ pCmd = (DOT4OpenChannel *)buf;
+ n = sizeof(DOT4OpenChannel);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_OPEN_CHANNEL;
+ pCmd->psocket = pc->sockid;
+ pCmd->ssocket = pc->sockid;
+ pCmd->maxp2s = htons(HPMUD_BUFFER_SIZE); /* max primary to secondary packet size in bytes */
+ pCmd->maxs2p = htons(HPMUD_BUFFER_SIZE); /* max secondary to primary packet size in bytes */
+ pCmd->maxcredit = htons(0xffff); /* "unlimited credit" mode, give primary (sender) as much credit as possible */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write Dot4OpenChannel: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4OpenChannelReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_OPEN_CHANNEL)) || (pReply->result != 0))
+ {
+ BUG("invalid Dot4OpenChannelReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.h2psize = ntohs(pReply->maxp2s);
+ pc->ta.p2hsize = ntohs(pReply->maxs2p);
+ pc->ta.h2pcredit = ntohs(pReply->credit);
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4CloseChannel(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4CloseChannel *pCmd;
+ DOT4CloseChannelReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4CloseChannel));
+ pCmd = (DOT4CloseChannel *)buf;
+ n = sizeof(DOT4CloseChannel);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_CLOSE_CHANNEL;
+ pCmd->psocket = pc->sockid;
+ pCmd->ssocket = pc->sockid;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write Dot4CloseChannel: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4CloseChannelReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_CLOSE_CHANNEL)) || (pReply->result != 0))
+ {
+ BUG("invalid Dot4CloseChannelReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4Credit(mud_channel *pc, int fd, unsigned short credit)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4Credit *pCmd;
+ DOT4CreditReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4Credit));
+ pCmd = (DOT4Credit *)buf;
+ n = sizeof(DOT4Credit);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_CREDIT;
+ pCmd->psocket = pc->sockid;
+ pCmd->ssocket = pc->sockid;
+ pCmd->credit = htons(credit); /* set peripheral to host credit */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write Dot4Credit: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4CreditReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_CREDIT)) || (pReply->result != 0))
+ {
+ BUG("invalid Dot4CreditReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.p2hcredit += credit;
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) Dot4CreditRequest(mud_channel *pc, int fd, unsigned short credit)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ DOT4CreditRequest *pCmd;
+ DOT4CreditRequestReply *pReply;
+
+ memset(buf, 0, sizeof(DOT4CreditRequest));
+ pCmd = (DOT4CreditRequest *)buf;
+ n = sizeof(DOT4CreditRequest);
+ pCmd->h.length = htons(n);
+ pCmd->h.credit = 1;
+ pCmd->cmd = DOT4_CREDIT_REQUEST;
+ pCmd->psocket = pc->sockid;
+ pCmd->ssocket = pc->sockid;
+ // pCmd->maxcredit = htons(credit); /* request host to peripheral credit */
+ pCmd->maxcredit = htons(0xffff); /* request host to peripheral credit */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write Dot4CreditRequest: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = Dot4ReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (DOT4CreditRequestReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | DOT4_CREDIT_REQUEST)) || (pReply->result != 0))
+ {
+ BUG("invalid Dot4CreditRequestReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.h2pcredit += ntohs(pReply->credit);
+
+bugout:
+ return stat;
+}
+
diff --git a/io/hpmud/dot4.h b/io/hpmud/dot4.h
new file mode 100644
index 0000000..2623194
--- /dev/null
+++ b/io/hpmud/dot4.h
@@ -0,0 +1,187 @@
+/*****************************************************************************\
+
+ dot4.h - 1284.4 support for multi-point transport driver
+
+ (c) 2005-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _DOT4_H
+#define _DOT4_H
+
+enum DOT4_COMMAND
+{
+ DOT4_INIT = MLC_INIT,
+ DOT4_OPEN_CHANNEL = MLC_OPEN_CHANNEL,
+ DOT4_CLOSE_CHANNEL = MLC_CLOSE_CHANNEL,
+ DOT4_CREDIT = MLC_CREDIT,
+ DOT4_CREDIT_REQUEST = MLC_CREDIT_REQUEST,
+ DOT4_GET_SOCKET = 0x9,
+ DOT4_GET_SERVICE = 0xa,
+ DOT4_EXIT = MLC_EXIT,
+ DOT4_ERROR = MLC_ERROR
+};
+
+/*
+ * Note, following structures must be packed. The "pragma pack" statement is not recognized by all gcc compilers (ie: ARM based),
+ * so we use __attribute__((packed)) instead.
+ */
+
+typedef struct
+{
+ unsigned char psid; /* primary socket id (ie: host) */
+ unsigned char ssid; /* secondary socket id (ie: peripheral) */
+ unsigned short length; /* packet length (includes header) */
+ unsigned char credit; /* data packet credit, reserved if command */
+ unsigned char control; /* bit field: 0=normal */
+} __attribute__((packed)) DOT4Header;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char rev;
+} __attribute__((packed)) DOT4Init;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char rev;
+} __attribute__((packed)) DOT4InitReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+} __attribute__((packed)) DOT4Exit;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+} __attribute__((packed)) DOT4ExitReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char psocket; /* primary socket id */
+ unsigned char ssocket; /* secondary socket id */
+ unsigned short maxp2s; /* max primary to secondary packet size in bytes */
+ unsigned short maxs2p; /* max secondary to primary packet size in bytes */
+ unsigned short maxcredit; /* max outstanding credit */
+} __attribute__((packed)) DOT4OpenChannel;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char psocket;
+ unsigned char ssocket;
+ unsigned short maxp2s; /* max primary to secondary packet size in bytes */
+ unsigned short maxs2p; /* max secondary to primary packet size in bytes */
+ unsigned short maxcredit; /* max outstanding credit */
+ unsigned short credit;
+} __attribute__((packed)) DOT4OpenChannelReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char psocket; /* primary socket id */
+ unsigned char ssocket; /* secondary socket id */
+} __attribute__((packed)) DOT4CloseChannel;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char psocket; /* primary socket id */
+ unsigned char ssocket; /* secondary socket id */
+} __attribute__((packed)) DOT4CloseChannelReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char socket;
+} __attribute__((packed)) DOT4GetSocketReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char psocket;
+ unsigned char ssocket;
+ unsigned short credit; /* credit for sender */
+} __attribute__((packed)) DOT4Credit;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char psocket;
+ unsigned char ssocket;
+ unsigned short maxcredit; /* maximum outstanding credit */
+} __attribute__((packed)) DOT4CreditRequest;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char psocket;
+ unsigned char ssocket;
+ unsigned short credit; /* credit for sender */
+} __attribute__((packed)) DOT4CreditRequestReply;
+
+typedef struct
+{
+ DOT4Header h;
+ unsigned char cmd;
+ unsigned char psocket; /* primary socket id which contains the error */
+ unsigned char ssocket; /* secondary socket id which contains the error */
+ unsigned char error;
+} __attribute__((packed)) DOT4Error;
+
+typedef DOT4ExitReply DOT4Reply;
+typedef DOT4Exit DOT4Cmd;
+typedef DOT4CloseChannelReply DOT4CreditReply;
+typedef DOT4Exit DOT4GetSocket;
+
+int __attribute__ ((visibility ("hidden"))) Dot4ReverseCmd(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4Init(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4Exit(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4GetSocket(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4ForwardData(struct _mud_channel *pc, int fd, const void *buf, int size, int usec_timeout);
+int __attribute__ ((visibility ("hidden"))) Dot4ReverseData(struct _mud_channel *pc, int fd, void *buf, int length, int usec_timeout);
+int __attribute__ ((visibility ("hidden"))) Dot4OpenChannel(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4CloseChannel(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) Dot4Credit(struct _mud_channel *pc, int fd, unsigned short credit);
+int __attribute__ ((visibility ("hidden"))) Dot4CreditRequest(struct _mud_channel *pc, int fd, unsigned short credit);
+
+#endif // _DOT4_H
+
diff --git a/io/hpmud/hp-mkuri.c b/io/hpmud/hp-mkuri.c
new file mode 100644
index 0000000..7c32ff7
--- /dev/null
+++ b/io/hpmud/hp-mkuri.c
@@ -0,0 +1,543 @@
+/*****************************************************************************\
+
+ hp-mkuri.c - make uri with multi-point transport driver (HPMUD)
+
+ (c) 2008-2009 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <signal.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <dlfcn.h>
+#include "hpmud.h"
+
+#define _STRINGIZE(x) #x
+#define STRINGIZE(x) _STRINGIZE(x)
+//#define BUG(args...) fprintf(stderr, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+#define BUG(args...) syslog(LOG_ERR, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+
+static int verbose;
+static char homedir[255] = "";
+
+static void usage()
+{
+ fprintf(stdout, "HPLIP Make URI %s\n", VERSION);
+ fprintf(stdout, "(c) 2008 Copyright Hewlett-Packard Development Company, LP\n");
+ fprintf(stdout, "usage: hp-mkuri -i ip [-p port]\n");
+ fprintf(stdout, "usage: hp-mkuri -z hostname\n");
+ fprintf(stdout, "usage: hp-mkuri -b busnum -d devnum\n");
+ fprintf(stdout, "usage: hp-mkuri -s serialnum\n");
+ fprintf(stdout, "usage: hp-mkuri -l /dev/parportx\n");
+ fprintf(stdout, "usage: hp-mkuri -m hostname [-p port]\n");
+ fprintf(stdout, "usage: hp-mkuri -o (probe)\n");
+ fprintf(stdout, "usage: hp-mkuri -c [-n (no notifier)] (check support)\n");
+ fprintf(stdout, "\nSupport matrix:\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| return value | printer | fax | plugin_required | plugin_optional |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 0 | yes | | | |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 1 | * | * | * | * |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 2 | yes | | yes | |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 3 | yes | | | yes |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 4 | yes | yes | | |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 5 | yes | yes | yes | |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, "| 6 | yes | yes | | yes |\n");
+ fprintf(stdout, "+--------------+---------+-----+-----------------+-----------------+\n");
+ fprintf(stdout, " * no support or error\n");
+} /* usage */
+
+static int GetPair(char *buf, int buf_len, char *key, char *value, char **tail)
+{
+ int i=0, j;
+
+ key[0] = 0;
+ value[0] = 0;
+
+ if (buf[i] == '#')
+ {
+ for (; buf[i] != '\n' && i < buf_len; i++); /* eat comment line */
+ if (buf[i] == '\n')
+ i++; /* bump past '\n' */
+ }
+
+ j = 0;
+ while ((buf[i] != '=') && (i < buf_len) && (j < HPMUD_LINE_SIZE))
+ key[j++] = buf[i++];
+ for (j--; key[j] == ' ' && j > 0; j--); /* eat white space before = */
+ key[++j] = 0;
+
+ if (buf[i] == '=')
+ for (i++; buf[i] == ' ' && i < buf_len; i++); /* eat white space after = */
+
+ j = 0;
+ while ((buf[i] != '\n') && (i < buf_len) && (j < HPMUD_LINE_SIZE))
+ value[j++] = buf[i++];
+ for (j--; value[j] == ' ' && j > 0; j--); /* eat white space before \n */
+ value[++j] = 0;
+
+ if (buf[i] == '\n')
+ i++; /* bump past '\n' */
+
+ if (tail != NULL)
+ *tail = buf + i; /* tail points to next line */
+
+ return i;
+}
+
+static int ReadConfig()
+{
+ char key[HPMUD_LINE_SIZE];
+ char value[HPMUD_LINE_SIZE];
+ char rcbuf[255];
+ char section[32];
+ char *tail;
+ FILE *inFile = NULL;
+ int stat=1;
+
+ homedir[0] = 0;
+
+ if((inFile = fopen(CONFDIR "/hplip.conf", "r")) == NULL)
+ {
+ BUG("unable to open %s: %m\n", CONFDIR "/hplip.conf");
+ goto bugout;
+ }
+
+ section[0] = 0;
+
+ /* Read the config file */
+ while ((fgets(rcbuf, sizeof(rcbuf), inFile) != NULL))
+ {
+ if (rcbuf[0] == '[')
+ {
+ strncpy(section, rcbuf, sizeof(section)); /* found new section */
+ continue;
+ }
+
+ GetPair(rcbuf, strlen(rcbuf), key, value, &tail);
+
+ if ((strncasecmp(section, "[dirs]", 6) == 0) && (strcasecmp(key, "home") == 0))
+ {
+ strncpy(homedir, value, sizeof(homedir));
+ break; /* done */
+ }
+ }
+
+ stat = 0;
+
+bugout:
+ if (inFile != NULL)
+ fclose(inFile);
+
+ return stat;
+}
+
+static int generalize_model(const char *sz, char *buf, int bufSize)
+{
+ const char *pMd=sz;
+ int i, j, dd=0;
+
+ for (i=0; pMd[i] == ' ' && i < bufSize; i++); /* eat leading white space */
+
+ for (j=0; (pMd[i] != 0) && (pMd[i] != ';') && (j < bufSize); i++)
+ {
+ if (pMd[i]==' ' || pMd[i]=='/')
+ {
+ /* Remove double spaces. */
+ if (!dd)
+ {
+ buf[j++] = '_'; /* convert space to "_" */
+ dd=1;
+ }
+ }
+ else
+ {
+ buf[j++] = tolower(pMd[i]);
+ dd=0;
+ }
+ }
+
+ for (j--; buf[j] == '_' && j > 0; j--); /* eat trailing white space */
+
+ buf[++j] = 0;
+
+ return j; /* length does not include zero termination */
+}
+
+static int set_x_environment(void)
+{
+ DIR *dir=NULL;
+ FILE *file=NULL;
+ struct dirent *entry;
+ char path[32], line[256], cookie[128], *p;
+ int i, c, stat=1;
+
+ if ((dir = opendir("/proc"))==NULL)
+ {
+ BUG("unable to open /proc: %m\n");
+ goto bugout;
+ }
+
+ while ((entry = readdir(dir)) != NULL)
+ {
+ if (!isdigit(*entry->d_name))
+ continue;
+
+ /* Get command line for this PID. */
+ snprintf(path, sizeof(path), "/proc/%s/cmdline", entry->d_name);
+ if ((file = fopen(path, "r")) == NULL)
+ continue;
+ for (i=0; ((c = getc(file)) != EOF) && (i < (sizeof(line)-1)); i++)
+ {
+ if (c == 0)
+ c = ' ';
+ line[i] = c;
+ }
+ line[i]=0;
+ fclose(file);
+ if ((p = strstr(line, "-auth ")))
+ {
+ /* Found X server. */
+ for (p+=6; (*p == ' ') && (*p != 0); p++); /* eat any white space before cookie */
+ for (i=0; (*(p+i) != ' ') && (*(p+i) != 0) && i < (sizeof(cookie)-1); i++)
+ cookie[i] = *(p+i);
+ cookie[i]=0;
+ setenv("XAUTHORITY", cookie, 1);
+ setenv("DISPLAY", ":0.0", 1);
+ break;
+ }
+ } /* while ((entry = readdir(dir)) != NULL) */
+
+ stat = 0;
+
+bugout:
+ if (dir)
+ closedir(dir);
+ return(stat);
+} /* set_x_environment */
+
+static int notify(const char *summary, const char *message, int ms_timeout)
+{
+ void *handle=NULL, *n;
+ int stat=1;
+
+ typedef void (*notify_init_t)(char *);
+ typedef void *(*notify_notification_new_t)(const char *, const char *, const char *, void *);
+ typedef void (*notify_notification_set_timeout_t)(void *, int);
+ typedef void (*notify_notification_show_t)(void *, char *);
+
+ notify_init_t n_init;
+ notify_notification_new_t n_new;
+ notify_notification_set_timeout_t n_timeout;
+ notify_notification_show_t n_show;
+
+ set_x_environment();
+
+ /* Bypass glib build dependencies by loading libnotify manually. */
+
+ if ((handle = dlopen("libnotify.so.1", RTLD_LAZY)) == NULL)
+ {
+ BUG("failed to open libnotify: %m\n");
+ goto bugout;
+ }
+
+ if ((n_init = (notify_init_t)dlsym(handle, "notify_init")) == NULL)
+ {
+ BUG("failed to find notify_init: %m\n");
+ goto bugout;
+ }
+ n_init("Basics");
+
+ if ((n_new = (notify_notification_new_t)dlsym(handle, "notify_notification_new")) == NULL)
+ {
+ BUG("failed to find notify_notification_new: %m\n");
+ goto bugout;
+ }
+ n = n_new(summary, message, NULL, NULL);
+
+ if ((n_timeout = (notify_notification_set_timeout_t)dlsym(handle, "notify_notification_set_timeout")) == NULL)
+ {
+ BUG("failed to find notify_notification_set_timeout: %m\n");
+ goto bugout;
+ }
+ n_timeout(n, ms_timeout);
+
+ if ((n_show = (notify_notification_show_t)dlsym(handle, "notify_notification_show")) == NULL)
+ {
+ BUG("failed to find notify_notification_show: %m\n");
+ goto bugout;
+ }
+ n_show(n, NULL);
+
+ stat=0;
+
+bugout:
+ if (handle)
+ dlclose(handle);
+
+ return stat;
+} /* notify */
+
+static int check_support(int send_notify)
+{
+ struct stat sb;
+ char model[256];
+ int ret=1, plugin_installed=1;
+ const char *pm;
+ char m[256];
+ char datfile[256];
+ char value[32];
+ int support, plugin, fax;
+
+ /* Get hp model from environment variables. */
+ if ((pm = getenv("hp_model")))
+ {
+ strncpy(model, pm, sizeof(model));
+ }
+ else
+ {
+ fprintf(stderr, "error no hp_model environment variable set\n");
+ BUG("error no hp_model environment variable set\n");
+ goto bugout;
+ }
+
+ if (model[0]==0)
+ {
+ BUG("invalid parameter(s)\n");
+ usage();
+ goto bugout;
+ }
+
+ generalize_model(model, m, sizeof(m));
+ snprintf(model, sizeof(model), "[%s]", m);
+
+ if (ReadConfig())
+ goto bugout;
+
+ snprintf(datfile, sizeof(datfile), "%s/data/models/models.dat", homedir);
+
+ if (hpmud_get_key_value(datfile, model, "support-type", value, sizeof(value)) != HPMUD_R_OK)
+ goto bugout;
+ support = strtol(value, NULL, 10);
+ if (hpmud_get_key_value(datfile, model, "plugin", value, sizeof(value)) != HPMUD_R_OK)
+ goto bugout;
+ plugin = strtol(value, NULL, 10);
+ if (hpmud_get_key_value(datfile, model, "fax-type", value, sizeof(value)) != HPMUD_R_OK)
+ goto bugout;
+ fax = strtol(value, NULL, 10);
+
+ /* See if device is supported by hplip. */
+ if (support == HPMUD_SUPPORT_TYPE_NONE)
+ {
+ BUG("%s is not supported by HPLIP %s\n", pm, VERSION);
+ goto bugout;
+ }
+
+ if (stat("/etc/udev/rules.d/86-hpmud-hp_laserjet_1018.rules", &sb) == -1)
+ plugin_installed=0;
+
+ if (send_notify && !plugin_installed)
+ {
+ /* See if device requires a Plugin. */
+ switch (plugin)
+ {
+ case HPMUD_PLUGIN_TYPE_REQUIRED:
+ BUG("%s requires a proprietary plugin\n", pm);
+ notify(pm, "requires a proprietary plugin, run hp-setup", 30000);
+ break;
+ case HPMUD_PLUGIN_TYPE_OPTIONAL:
+ BUG("%s has a optional proprietary plugin\n", pm);
+ notify(pm, "has a optional proprietary plugin, run hp-setup", 30000);
+ break;
+ default:
+ break;
+ }
+ }
+
+ ret = 0;
+ if (plugin == HPMUD_PLUGIN_TYPE_REQUIRED)
+ ret = 2;
+ else if (plugin == HPMUD_PLUGIN_TYPE_OPTIONAL)
+ ret = 3;
+ if (fax > 0)
+ {
+ ret = 4;
+ if (plugin == HPMUD_PLUGIN_TYPE_REQUIRED)
+ ret = 5;
+ else if (plugin == HPMUD_PLUGIN_TYPE_OPTIONAL)
+ ret = 6;
+ }
+
+bugout:
+ return ret;
+} /* check_support */
+
+int main(int argc, char *argv[])
+{
+ char ip[HPMUD_LINE_SIZE]; /* internet address */
+ char bn[HPMUD_LINE_SIZE]; /* usb bus number */
+ char dn[HPMUD_LINE_SIZE]; /* usb device number */
+ char sn[HPMUD_LINE_SIZE]; /* usb serial number */
+ char pp[HPMUD_LINE_SIZE]; /* parallel port device */
+ char uri[HPMUD_LINE_SIZE];
+ char host[HPMUD_LINE_SIZE];
+ int i, port=1, ret=1, probe=0, support=0, send_notify=1;
+ enum HPMUD_RESULT stat;
+ char buf[HPMUD_LINE_SIZE*64];
+ int cnt, bytes_read;
+
+ ip[0] = bn[0] = dn[0] = pp[0] = uri[0] = sn[0] = host[0] = 0;
+ while ((i = getopt(argc, argv, "vhocni:p:b:d:l:s:z:")) != -1)
+ {
+ switch (i)
+ {
+ case 'i':
+ strncpy(ip, optarg, sizeof(ip));
+ break;
+ case 'z':
+ strncpy(host, optarg, sizeof(host));
+ break;
+ case 'p':
+ port = strtol(optarg, NULL, 10);
+ break;
+ case 'b':
+ strncpy(bn, optarg, sizeof(bn));
+ break;
+ case 'd':
+ strncpy(dn, optarg, sizeof(dn));
+ break;
+ case 'l':
+ strncpy(pp, optarg, sizeof(pp));
+ break;
+ case 's':
+ strncpy(sn, optarg, sizeof(sn));
+ break;
+ case 'o':
+ probe++;
+ break;
+ case 'c':
+ support++;
+ break;
+ case 'v':
+ verbose++;
+ break;
+ case 'n':
+ send_notify=0;
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ case '?':
+ usage();
+ fprintf(stderr, "unknown argument: %s\n", argv[1]);
+ exit(-1);
+ default:
+ break;
+ }
+ }
+
+ if (ip[0]==0 && (!(bn[0] && dn[0])) && pp[0]==0 && probe==0 && sn[0]==0 && support==0 && host[0]==0)
+ {
+ fprintf(stderr, "invalid command parameter(s)\n");
+ usage();
+ goto bugout;
+ }
+
+ if (probe)
+ {
+ hpmud_probe_devices(HPMUD_BUS_ALL, buf, sizeof(buf), &cnt, &bytes_read);
+ if (bytes_read)
+ fprintf(stdout, "%s", buf);
+ }
+
+#ifdef HAVE_LIBNETSNMP
+ if (ip[0])
+ {
+ stat = hpmud_make_net_uri(ip, port, uri, sizeof(uri), &bytes_read);
+ if (stat == HPMUD_R_OK)
+ {
+ fprintf(stdout, "%s\n", uri);
+ fprintf(stdout, "hpaio%s\n", &uri[2]);
+ }
+ }
+ if (host[0])
+ {
+ stat = hpmud_make_mdns_uri(host, port, uri, sizeof(uri), &bytes_read);
+ if (stat == HPMUD_R_OK)
+ {
+ fprintf(stdout, "%s\n", uri);
+ fprintf(stdout, "hpaio%s\n", &uri[2]);
+ }
+ }
+#endif
+
+ if (bn[0] && dn[0])
+ {
+ stat = hpmud_make_usb_uri(bn, dn, uri, sizeof(uri), &bytes_read);
+ if (stat == HPMUD_R_OK)
+ {
+ fprintf(stdout, "%s\n", uri);
+ fprintf(stdout, "hpaio%s\n", &uri[2]);
+ }
+ }
+
+ if (sn[0])
+ {
+ stat = hpmud_make_usb_serial_uri(sn, uri, sizeof(uri), &bytes_read);
+ if (stat == HPMUD_R_OK)
+ {
+ fprintf(stdout, "%s\n", uri);
+ fprintf(stdout, "hpaio%s\n", &uri[2]);
+ }
+ }
+
+#ifdef HAVE_PPORT
+ if (pp[0])
+ {
+ stat = hpmud_make_par_uri(pp, uri, sizeof(uri), &bytes_read);
+ if (stat == HPMUD_R_OK)
+ {
+ fprintf(stdout, "%s\n", uri);
+ fprintf(stdout, "hpaio%s\n", &uri[2]);
+ }
+ }
+#endif
+
+ ret = 0;
+
+ if (support)
+ ret = check_support(send_notify);
+
+bugout:
+ exit(ret);
+} /* main */
diff --git a/io/hpmud/hpmud.c b/io/hpmud/hpmud.c
new file mode 100644
index 0000000..d24ebd2
--- /dev/null
+++ b/io/hpmud/hpmud.c
@@ -0,0 +1,699 @@
+/*****************************************************************************\
+
+ hpmud.cpp - multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ Author: Naga Samrat Chowdary Narla,
+ Contributor: Sarbeswar Meher
+\*****************************************************************************/
+
+#include "hpmud.h"
+#include "hpmudi.h"
+
+/* Client data. */
+mud_session ms __attribute__ ((visibility ("hidden"))); /* mud session, one per client */
+mud_session *msp __attribute__ ((visibility ("hidden"))) = &ms;
+
+/*
+ * sysdump() originally came from http://sws.dett.de/mini/hexdump-c , steffen@dett.de .
+ */
+void __attribute__ ((visibility ("hidden"))) sysdump(const void *data, int size)
+{
+ /* Dump size bytes of *data. Output looks like:
+ * [0000] 75 6E 6B 6E 6F 77 6E 20 30 FF 00 00 00 00 39 00 unknown 0.....9.
+ */
+
+ unsigned char *p = (unsigned char *)data;
+ unsigned char c;
+ int n;
+ char bytestr[4] = {0};
+ char addrstr[10] = {0};
+ char hexstr[16*3 + 5] = {0};
+ char charstr[16*1 + 5] = {0};
+ for(n=1;n<=size;n++) {
+ if (n%16 == 1) {
+ /* store address for this line */
+ snprintf(addrstr, sizeof(addrstr), "%.4d", (int)((p-(unsigned char *)data) & 0xffff));
+ }
+
+ c = *p;
+ if (isprint(c) == 0) {
+ c = '.';
+ }
+
+ /* store hex str (for left side) */
+ snprintf(bytestr, sizeof(bytestr), "%02X ", *p);
+ strncat(hexstr, bytestr, sizeof(hexstr)-strlen(hexstr)-1);
+
+ /* store char str (for right side) */
+ snprintf(bytestr, sizeof(bytestr), "%c", c);
+ strncat(charstr, bytestr, sizeof(charstr)-strlen(charstr)-1);
+
+ if(n%16 == 0) {
+ /* line completed */
+ DBG_SZ("[%4.4s] %-50.50s %s\n", addrstr, hexstr, charstr);
+ hexstr[0] = 0;
+ charstr[0] = 0;
+ }
+ p++; /* next byte */
+ }
+
+ if (strlen(hexstr) > 0) {
+ /* print rest of buffer if not empty */
+ DBG_SZ("[%4.4s] %-50.50s %s\n", addrstr, hexstr, charstr);
+ }
+}
+
+/* Given the IEEE 1284 device id string, determine if this is a HP product. */
+int __attribute__ ((visibility ("hidden"))) is_hp(const char *id)
+{
+ char *pMf;
+
+ if ((pMf = strstr(id, "MFG:")) != NULL)
+ pMf+=4;
+ else if ((pMf = strstr(id, "MANUFACTURER:")) != NULL)
+ pMf+=13;
+ else
+ return 0;
+
+ if ((strncasecmp(pMf, "HEWLETT-PACKARD", 15) == 0) ||
+ (strncasecmp(pMf, "APOLLO", 6) == 0) || (strncasecmp(pMf, "HP", 2) == 0))
+ {
+ return 1; /* found HP product */
+ }
+ return 0;
+}
+
+int __attribute__ ((visibility ("hidden"))) generalize_model(const char *sz, char *buf, int bufSize)
+{
+ const char *pMd=sz;
+ int i, j, dd=0;
+
+ for (i=0; pMd[i] == ' ' && i < bufSize; i++); /* eat leading white space */
+
+ for (j=0; (pMd[i] != 0) && (pMd[i] != ';') && (j < bufSize); i++)
+ {
+ if (pMd[i]==' ' || pMd[i]=='/')
+ {
+ /* Remove double spaces. */
+ if (!dd)
+ {
+ buf[j++] = '_'; /* convert space to "_" */
+ dd=1;
+ }
+ }
+ else
+ {
+ buf[j++] = pMd[i];
+ dd=0;
+ }
+ }
+
+ for (j--; buf[j] == '_' && j > 0; j--); /* eat trailing white space */
+
+ buf[++j] = 0;
+
+ return j; /* length does not include zero termination */
+}
+
+int __attribute__ ((visibility ("hidden"))) generalize_serial(const char *sz, char *buf, int bufSize)
+{
+ const char *pMd=sz;
+ int i, j;
+
+ for (i=0; pMd[i] == ' ' && i < bufSize; i++); /* eat leading white space */
+
+ for (j=0; (pMd[i] != 0) && (i < bufSize); i++)
+ {
+ buf[j++] = pMd[i];
+ }
+
+ for (i--; buf[i] == ' ' && i > 0; i--); /* eat trailing white space */
+
+ buf[++i] = 0;
+
+ return i; /* length does not include zero termination */
+}
+
+/* Parse serial number from uri string. */
+int __attribute__ ((visibility ("hidden"))) get_uri_serial(const char *uri, char *buf, int bufSize)
+{
+ char *p;
+ int i;
+
+ buf[0] = 0;
+
+ if ((p = strcasestr(uri, "serial=")) != NULL)
+ p+=7;
+ else
+ return 0;
+
+ for (i=0; (p[i] != 0) && (p[i] != '+') && (i < bufSize); i++)
+ buf[i] = p[i];
+
+ buf[i] = 0;
+
+ return i;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) service_to_channel(mud_device *pd, const char *sn, HPMUD_CHANNEL *index)
+{
+ enum HPMUD_RESULT stat;
+
+ *index=-1;
+
+ /* Check for valid service requests. */
+ if (strncasecmp(sn, "print", 5) == 0)
+ {
+ *index = HPMUD_PRINT_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-ews-ledm", 11) == 0)
+ {
+ *index = HPMUD_EWS_LEDM_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-ews", 6) == 0)
+ {
+ *index = HPMUD_EWS_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-soap-scan", 12) == 0)
+ {
+ *index = HPMUD_SOAPSCAN_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-soap-fax", 11) == 0)
+ {
+ *index = HPMUD_SOAPFAX_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-marvell-scan", 15) == 0)
+ {
+ *index = HPMUD_MARVELL_SCAN_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-marvell-fax", 14) == 0)
+ {
+ *index = HPMUD_MARVELL_FAX_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-ledm-scan", 12) == 0)
+ {
+ *index = HPMUD_LEDM_SCAN_CHANNEL;
+ }
+ /* All the following services require MLC/1284.4. */
+ else if (pd->io_mode == HPMUD_RAW_MODE || pd->io_mode == HPMUD_UNI_MODE)
+ {
+ BUG("invalid channel_open state, current io_mode=raw/uni service=%s %s\n", sn, pd->uri);
+ stat = HPMUD_R_INVALID_STATE;
+ goto bugout;
+ }
+ else if (strncasecmp(sn, "hp-message", 10) == 0)
+ {
+ *index = HPMUD_PML_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-scan", 7) == 0)
+ {
+ *index = HPMUD_SCAN_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-fax-send", 11) == 0)
+ {
+ *index = HPMUD_FAX_SEND_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-card-access", 14) == 0)
+ {
+ *index = HPMUD_MEMORY_CARD_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-configuration-upload", 23) == 0)
+ {
+ *index = HPMUD_CONFIG_UPLOAD_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-configuration-download", 25) == 0)
+ {
+ *index = HPMUD_CONFIG_DOWNLOAD_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-devmgmt", 10) == 0)
+ {
+ *index = HPMUD_DEVMGMT_CHANNEL;
+ }
+ else if (strncasecmp(sn, "hp-wificonfig", 13) == 0)
+ {
+ *index = HPMUD_WIFI_CHANNEL;
+ }
+ else
+ {
+ BUG("invalid service=%s %s\n", sn, pd->uri);
+ stat = HPMUD_R_INVALID_SN;
+ goto bugout;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+static int new_device(const char *uri, enum HPMUD_IO_MODE mode, int *result)
+{
+ int index=0; /* device[0] is unused */
+ int i=1;
+
+ if (uri[0] == 0)
+ return 0;
+
+ pthread_mutex_lock(&msp->mutex);
+
+ if (msp->device[i].index)
+ {
+ BUG("invalid device_open state\n"); /* device is already open for this client, one device per session */
+ *result = HPMUD_R_INVALID_STATE;
+ goto bugout;
+ }
+
+ index = i; /* currently only support one device per client or process */
+
+ /* Based on uri, set local session attributes. */
+ if (strcasestr(uri, ":/usb") != NULL)
+ {
+ msp->device[i].vf = musb_mud_device_vf;
+ }
+#ifdef HAVE_LIBNETSNMP
+ else if (strcasestr(uri, ":/net") != NULL)
+ {
+ msp->device[i].vf = jd_mud_device_vf;
+ }
+#endif
+#ifdef HAVE_PPORT
+ else if (strcasestr(uri, ":/par") != NULL)
+ {
+ msp->device[i].vf = pp_mud_device_vf;
+ }
+#endif
+ else
+ {
+ BUG("invalid uri %s\n", uri);
+ *result = HPMUD_R_INVALID_URI;
+ index = 0;
+ goto bugout;
+ }
+ msp->device[i].io_mode = mode;
+ msp->device[i].index = index;
+ msp->device[i].channel_cnt = 0;
+ msp->device[i].open_fd = -1;
+ strcpy(msp->device[i].uri, uri);
+
+bugout:
+ pthread_mutex_unlock(&msp->mutex);
+
+ return index; /* return device index */
+}
+
+static int del_device(HPMUD_DEVICE index)
+{
+ pthread_mutex_lock(&msp->mutex);
+
+ msp->device[index].index = 0;
+
+ pthread_mutex_unlock(&msp->mutex);
+
+ return 0;
+}
+
+/* Make sure client closed down the device. */
+int device_cleanup(mud_session *ps)
+{
+ int i, dd=1;
+
+ if(!ps->device[dd].index)
+ return 0; /* nothing to do */
+
+ BUG("device_cleanup: device uri=%s\n", ps->device[dd].uri);
+
+ for (i=0; i<HPMUD_CHANNEL_MAX; i++)
+ {
+ if (ps->device[dd].channel[i].client_cnt)
+ {
+ BUG("device_cleanup: close channel %d...\n", i);
+ hpmud_close_channel(dd, ps->device[dd].channel[i].index);
+ BUG("device_cleanup: done closing channel %d\n", i);
+ }
+ }
+
+ BUG("device_cleanup: close device dd=%d...\n", dd);
+ hpmud_close_device(dd);
+ BUG("device_cleanup: done closing device dd=%d\n", dd);
+
+ return 0;
+}
+
+static void __attribute__ ((constructor)) mud_init(void)
+{
+ DBG("[%d] hpmud_init()\n", getpid());
+}
+
+static void __attribute__ ((destructor)) mud_exit(void)
+{
+ DBG("[%d] hpmud_exit()\n", getpid());
+ device_cleanup(msp);
+}
+
+/*******************************************************************************************************************************
+ * Helper functions.
+ */
+
+/* Parse the model from the IEEE 1284 device id string and generalize the model name */
+int hpmud_get_model(const char *id, char *buf, int buf_size)
+{
+ char *pMd;
+
+ buf[0] = 0;
+
+ if ((pMd = strstr(id, "MDL:")) != NULL)
+ pMd+=4;
+ else if ((pMd = strstr(id, "MODEL:")) != NULL)
+ pMd+=6;
+ else
+ return 0;
+
+ return generalize_model(pMd, buf, buf_size);
+}
+
+/* Parse the model from the IEEE 1284 device id string. */
+int hpmud_get_raw_model(char *id, char *raw, int rawSize)
+{
+ char *pMd;
+ int i;
+
+ raw[0] = 0;
+
+ if ((pMd = strstr(id, "MDL:")) != NULL)
+ pMd+=4;
+ else if ((pMd = strstr(id, "MODEL:")) != NULL)
+ pMd+=6;
+ else
+ return 0;
+
+ for (i=0; (pMd[i] != ';') && (i < rawSize); i++)
+ raw[i] = pMd[i];
+ raw[i] = 0;
+
+ return i;
+}
+
+/* Parse device model from uri string. */
+int hpmud_get_uri_model(const char *uri, char *buf, int buf_size)
+{
+ char *p;
+ int i;
+
+ buf[0] = 0;
+
+ if ((p = strstr(uri, "/")) == NULL)
+ return 0;
+ if ((p = strstr(p+1, "/")) == NULL)
+ return 0;
+ p++;
+
+ for (i=0; (p[i] != '?') && (i < buf_size); i++)
+ buf[i] = p[i];
+
+ buf[i] = 0;
+
+ return i;
+}
+
+/* Parse the data link from a uri string. */
+int hpmud_get_uri_datalink(const char *uri, char *buf, int buf_size)
+{
+ char *p;
+ int i;
+ int zc=0;
+#ifdef HAVE_LIBNETSNMP
+ char ip[HPMUD_LINE_SIZE];
+#endif
+
+ buf[0] = 0;
+
+ if ((p = strcasestr(uri, "device=")) != NULL)
+ p+=7;
+ else if ((p = strcasestr(uri, "ip=")) != NULL)
+ p+=3;
+ else if ((p = strcasestr(uri, "zc=")) != NULL)
+ {
+ p+=3;
+ zc=1;
+ }
+ else
+ return 0;
+
+ if (zc)
+ {
+#ifdef HAVE_LIBNETSNMP
+ if (hpmud_mdns_lookup(p, HPMUD_MDNS_TIMEOUT, ip) != HPMUD_R_OK)
+ return 0;
+ for (i=0; (ip[i] != 0) && (i < buf_size); i++)
+ buf[i] = ip[i];
+#else
+ return 0;
+#endif
+ }
+ else {
+ for (i=0; (p[i] != 0) && (p[i] != '&') && (i < buf_size); i++)
+ buf[i] = p[i];
+ }
+
+ buf[i] = 0;
+
+ return i;
+}
+
+/***************************************************************************************************
+ * Core functions.
+ */
+
+enum HPMUD_RESULT hpmud_open_device(const char *uri, enum HPMUD_IO_MODE iomode, HPMUD_DEVICE *dd)
+{
+ HPMUD_DEVICE index=0;
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_URI;
+ int result;
+
+ DBG("[%d,%d,%d,%d,%d,%d] hpmud_device_open() uri=%s iomode=%d\n", getpid(), getppid(), getuid(), geteuid(), getgid(), getegid(), uri, iomode);
+
+ if ((index = new_device(uri, iomode, &result)) == 0)
+ {
+ stat = result;
+ goto bugout;
+ }
+ else
+ {
+ if ((stat = (msp->device[index].vf.open)(&msp->device[index])) != HPMUD_R_OK)
+ {
+ (msp->device[index].vf.close)(&msp->device[index]); /* Open failed perform device cleanup. */
+ del_device(index);
+ goto bugout;
+ }
+ }
+
+ *dd = index;
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_close_device(HPMUD_DEVICE dd)
+{
+ enum HPMUD_RESULT stat;
+
+ DBG("[%d] hpmud_device_close() dd=%d\n", getpid(), dd);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd)
+ {
+ BUG("invalid device_close state\n");
+ stat = HPMUD_R_INVALID_STATE;
+ }
+ else
+ {
+ stat = (msp->device[dd].vf.close)(&msp->device[dd]);
+ del_device(dd);
+ }
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_get_device_id(HPMUD_DEVICE dd, char *buf, int size, int *bytes_read)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_get_device_id() dd=%d\n", getpid(), dd);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd)
+ {
+ BUG("invalid get_device_id state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.get_device_id)(&msp->device[dd], buf, size, bytes_read);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_get_device_status(HPMUD_DEVICE dd, unsigned int *status)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_get_device_status() dd=%d\n", getpid(), dd);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd)
+ {
+ BUG("invalid get_device_status state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.get_device_status)(&msp->device[dd], status);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_probe_devices(enum HPMUD_BUS_ID bus, char *buf, int buf_size, int *cnt, int *bytes_read)
+{
+ int len=0;
+
+ DBG("[%d] hpmud_probe_devices() bus=%d\n", getpid(), bus);
+
+ buf[0] = 0;
+ *cnt = 0;
+
+ if (bus == HPMUD_BUS_USB)
+ {
+ len = musb_probe_devices(buf, buf_size, cnt);
+ }
+#ifdef HAVE_PPORT
+ else if (bus == HPMUD_BUS_PARALLEL)
+ {
+ len = pp_probe_devices(buf, buf_size, cnt);
+ }
+#endif
+ else if (bus == HPMUD_BUS_ALL)
+ {
+ len = musb_probe_devices(buf, buf_size, cnt);
+#ifdef HAVE_PPORT
+ len += pp_probe_devices(buf+len, buf_size-len, cnt);
+#endif
+ }
+
+ *bytes_read = len;
+
+ return HPMUD_R_OK;
+}
+
+enum HPMUD_RESULT hpmud_open_channel(HPMUD_DEVICE dd, const char *channel_name, HPMUD_CHANNEL *cd)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_channel_open() dd=%d name=%s\n", getpid(), dd, channel_name);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd)
+ {
+ BUG("invalid channel_open state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.channel_open)(&msp->device[dd], channel_name, cd);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_close_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_channel_close() dd=%d cd=%d\n", getpid(), dd, cd);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd ||
+ cd <=0 || cd > HPMUD_CHANNEL_MAX || msp->device[dd].channel[cd].client_cnt == 0)
+ {
+ BUG("invalid channel_close state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.channel_close)(&msp->device[dd], &msp->device[dd].channel[cd]);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_write_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd, const void *buf, int size, int sec_timeout, int *bytes_wrote)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_channel_write() dd=%d cd=%d buf=%p size=%d sectime=%d\n", getpid(), dd, cd, buf, size, sec_timeout);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd ||
+ cd <=0 || cd > HPMUD_CHANNEL_MAX || msp->device[dd].channel[cd].client_cnt == 0)
+ {
+ BUG("invalid channel_write state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.channel_write)(&msp->device[dd], &msp->device[dd].channel[cd], buf, size, sec_timeout, bytes_wrote);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_read_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd, void *buf, int size, int sec_timeout, int *bytes_read)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+ DBG("[%d] hpmud_channel_read() dd=%d cd=%d buf=%p size=%d sectime=%d\n", getpid(), dd, cd, buf, size, sec_timeout);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX || msp->device[dd].index != dd ||
+ cd <=0 || cd > HPMUD_CHANNEL_MAX || msp->device[dd].channel[cd].client_cnt == 0)
+ {
+ BUG("invalid channel_read state\n");
+ goto bugout;
+ }
+
+ stat = (msp->device[dd].vf.channel_read)(&msp->device[dd], &msp->device[dd].channel[cd], buf, size, sec_timeout, bytes_read);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_get_dstat(HPMUD_DEVICE dd, struct hpmud_dstat *ds)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_STATE;
+
+ DBG("[%d] hpmud_dstat() dd=%d ds=%p\n", getpid(), dd, ds);
+
+ if (dd <= 0 || dd > HPMUD_DEVICE_MAX)
+ {
+ BUG("invalid dstat state\n");
+ goto bugout;
+ }
+
+ strncpy(ds->uri, msp->device[dd].uri, sizeof(ds->uri));
+ ds->io_mode = msp->device[dd].io_mode;
+ ds->channel_cnt = msp->device[dd].channel_cnt;
+ ds->mlc_up = msp->device[dd].mlc_up;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
diff --git a/io/hpmud/hpmud.h b/io/hpmud/hpmud.h
new file mode 100644
index 0000000..3970d28
--- /dev/null
+++ b/io/hpmud/hpmud.h
@@ -0,0 +1,581 @@
+/*****************************************************************************\
+
+ hpmud.h - public definitions for multi-point transport driver
+
+ (c) 2004-2015 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ Author: Naga Samrat Chowdary Narla, Yashwant Sahu, Sarbeswar Meher
+\*****************************************************************************/
+
+#ifndef _HPMUD_H
+#define _HPMUD_H
+
+enum HPMUD_RESULT
+{
+ HPMUD_R_OK = 0,
+ HPMUD_R_INVALID_DEVICE = 2,
+ HPMUD_R_INVALID_DESCRIPTOR = 3,
+ HPMUD_R_INVALID_URI = 4,
+ HPMUD_R_INVALID_LENGTH = 8,
+ HPMUD_R_IO_ERROR = 12,
+ HPMUD_R_DEVICE_BUSY = 21,
+ HPMUD_R_INVALID_SN = 28,
+ HPMUD_R_INVALID_CHANNEL_ID = 30,
+ HPMUD_R_INVALID_STATE = 31,
+ HPMUD_R_INVALID_DEVICE_OPEN = 37,
+ HPMUD_R_INVALID_DEVICE_NODE = 38,
+ HPMUD_R_INVALID_IP = 45,
+ HPMUD_R_INVALID_IP_PORT = 46,
+ HPMUD_R_INVALID_TIMEOUT = 47,
+ HPMUD_R_DATFILE_ERROR = 48,
+ HPMUD_R_IO_TIMEOUT = 49,
+ HPMUD_R_INVALID_MDNS = 50,
+};
+
+enum HPMUD_IO_MODE
+{
+ HPMUD_UNI_MODE=0, /* uni-di */
+ HPMUD_RAW_MODE=1, /* bi-di */
+ HPMUD_DOT4_MODE=3,
+ HPMUD_DOT4_PHOENIX_MODE=4, /* (ie: clj2550, clj2840, lj3050, lj3055, clj4730mfp) */
+ HPMUD_DOT4_BRIDGE_MODE=5, /* (ie: clj2500) not USB compatable, use HPMUD_RAW_MODE, tested on F10 12/10/08 DES */
+ HPMUD_MLC_GUSHER_MODE=6, /* most new devices */
+ HPMUD_MLC_MISER_MODE=7, /* old stuff */
+};
+
+enum HPMUD_BUS_ID
+{
+ HPMUD_BUS_NA=0,
+ HPMUD_BUS_USB=1,
+ HPMUD_BUS_PARALLEL,
+ HPMUD_BUS_ALL
+};
+
+enum HPMUD_SCANTYPE
+{
+ HPMUD_SCANTYPE_NA = 0,
+ HPMUD_SCANTYPE_SCL = 1,
+ HPMUD_SCANTYPE_PML = 2,
+ HPMUD_SCANTYPE_SOAP = 3, /* Wookie (ie:ljcm1017) */
+ HPMUD_SCANTYPE_MARVELL = 4, /* (ie: ljm1005) */
+ HPMUD_SCANTYPE_SOAPHT = 5, /* HorseThief (ie: ljm1522) */
+ HPMUD_SCANTYPE_SCL_DUPLEX = 6,
+ HPMUD_SCANTYPE_LEDM = 7,
+ HPMUD_SCANTYPE_MARVELL2 = 8, /* (Tsunami lj 1212 and series) */
+};
+
+enum HPMUD_SCANSRC
+{
+ HPMUD_SCANSRC_NA = 0,
+ HPMUD_SCANSRC_FLATBED = 0x1,
+ HPMUD_SCANSRC_ADF= 0x2,
+ HPMUD_SCANSRC_CAMERA = 0x4,
+};
+
+enum HPMUD_STATUSTYPE
+{
+ HPMUD_STATUSTYPE_NA = 0,
+ HPMUD_STATUSTYPE_VSTATUS = 1, /* device-id vstatus */
+ HPMUD_STATUSTYPE_SFIELD = 2, /* device-id s-field */
+ HPMUD_STATUSTYPE_PML = 3, /* laserjet pml */
+ HPMUD_STATUSTYPE_EWS = 6, /* laserjet hp ews */
+ HPMUD_STATUSTYPE_PJL = 8, /* laserjet pjl */
+ HPMUD_STATUSTYPE_PJLPML = 9, /* laserjet pjl and pml */
+};
+
+enum HPMUD_SUPPORT_TYPE
+{
+ HPMUD_SUPPORT_TYPE_NONE = 0, /* not supported */
+ HPMUD_SUPPORT_TYPE_HPIJS = 1, /* supported by hpijs only */
+ HPMUD_SUPPORT_TYPE_HPLIP = 2, /* supported by hpijs and "hp" backend */
+};
+
+enum HPMUD_PLUGIN_TYPE
+{
+ HPMUD_PLUGIN_TYPE_NONE = 0,
+ HPMUD_PLUGIN_TYPE_REQUIRED = 1,
+ HPMUD_PLUGIN_TYPE_OPTIONAL = 2,
+};
+
+#define HPMUD_S_PRINT_CHANNEL "PRINT"
+#define HPMUD_S_PML_CHANNEL "HP-MESSAGE"
+#define HPMUD_S_SCAN_CHANNEL "HP-SCAN"
+#define HPMUD_S_FAX_SEND_CHANNEL "HP-FAX-SEND"
+#define HPMUD_S_CONFIG_UPLOAD_CHANNEL "HP-CONFIGURATION-UPLOAD"
+#define HPMUD_S_CONFIG_DOWNLOAD_CHANNEL "HP-CONFIGURATION-DOWNLOAD"
+#define HPMUD_S_MEMORY_CARD_CHANNEL "HP-CARD-ACCESS"
+#define HPMUD_S_EWS_CHANNEL "HP-EWS"
+#define HPMUD_S_EWS_LEDM_CHANNEL "HP-EWS-LEDM"
+#define HPMUD_S_SOAP_SCAN "HP-SOAP-SCAN"
+#define HPMUD_S_SOAP_FAX "HP-SOAP-FAX"
+#define HPMUD_S_DEVMGMT_CHANNEL "HP-DEVMGMT"
+#define HPMUD_S_MARVELL_SCAN_CHANNEL "HP-MARVELL-SCAN"
+#define HPMUD_S_MARVELL_FAX_CHANNEL "HP-MARVELL-FAX"
+#define HPMUD_S_LEDM_SCAN "HP-LEDM-SCAN"
+#define HPMUD_S_WIFI_CHANNEL "HP-WIFICONFIG"
+
+typedef int HPMUD_DEVICE; /* usb, parallel or jetdirect */
+#define HPMUD_DEVICE_MAX 2 /* zero is not used */
+
+typedef int HPMUD_CHANNEL;
+#define HPMUD_CHANNEL_MAX HPMUD_MAX_CHANNEL_ID
+
+#define HPMUD_LINE_SIZE 256 /* Length of a line. */
+#define HPMUD_BUFFER_SIZE 16384 /* General Read/Write buffer. */
+
+struct hpmud_dstat
+{
+ char uri[HPMUD_LINE_SIZE];
+ int client_cnt; /* number of clients that have this device opend */
+ enum HPMUD_IO_MODE io_mode;
+ int channel_cnt; /* number of open channels */
+ int mlc_up; /* 0 = MLC/1284.4 transport up, 1 = MLD/1284.4 transport down */
+};
+
+struct hpmud_model_attributes
+{
+ enum HPMUD_IO_MODE prt_mode; /* print only (io_mode) */
+ enum HPMUD_IO_MODE mfp_mode; /* pml | scan | fax (io_mode) */
+ enum HPMUD_SCANTYPE scantype; /* scan protocol i.e. SCL, PML, SOAP, MARVELL, LEDM */
+ enum HPMUD_STATUSTYPE statustype;
+ enum HPMUD_SUPPORT_TYPE support;
+ enum HPMUD_PLUGIN_TYPE plugin;
+ enum HPMUD_SUPPORT_TYPE reserved[5];
+ enum HPMUD_SCANSRC scansrc; /*Flatbed, ADF, Camera or combination of these*/
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * hpmud_device_open - open specified device, call normally does not block
+ *
+ * inputs:
+ * uri - specifies device to open
+ * io_mode - see enum definition
+ *
+ * outputs:
+ * dd - device descriptor
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_open_device(const char *uri, enum HPMUD_IO_MODE io_mode, HPMUD_DEVICE *dd);
+
+/*
+ * hpmud_device_close - close specified device, call does not block
+ *
+ * inputs:
+ * dd - device descriptor
+ *
+ * outputs:
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_close_device(HPMUD_DEVICE dd);
+
+/*
+ * hpmud_get_device_id - read IEEE 1284 device ID string, call normally does not block
+ *
+ * If the device is busy, a cached copy may be returned.
+ *
+ * inputs:
+ * dd - device descriptor
+ * buf_size - maximum size of buf
+ *
+ * outputs:
+ * buf - zero terminated device ID string
+ * bytes_read - size of device ID string, does not include zero termination
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_device_id(HPMUD_DEVICE dd, char *buf, int buf_size, int *bytes_read);
+
+/*
+ * hpmud_get_device_status - read 8-bit device status, call normally does not block
+ *
+ * inputs:
+ * dd - device descriptor
+ *
+ * outputs:
+ * status - 3-bit status, supported by inkjets only
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_device_status(HPMUD_DEVICE dd, unsigned int *status);
+
+/*
+ * hpmud_probe_devices - probe local buses for HP supported devices, call normally does not block
+ *
+ * inputs:
+ * bus - see enum definiton
+ * buf_size - size of read buffer
+ *
+ * outputs:
+ * buf - zero terminated CUPS backend formatted data
+ * cnt - number of HP devices found
+ * bytes_read - number of bytes actually read
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_probe_devices(enum HPMUD_BUS_ID bus, char *buf, int buf_size, int *cnt, int *bytes_read);
+
+/*
+ * hpmud_channel_open - open specified channel, call will block
+ *
+ * Only EWS channel can be opened by more than one process.
+ *
+ * inputs:
+ * dd - device descriptor
+ * channel_name - requested service name
+ *
+ * outputs:
+ * cd - channel descriptor
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_open_channel(HPMUD_DEVICE dd, const char *channel_name, HPMUD_CHANNEL *cd);
+
+/*
+ * hpmud_channel_close - close specified channel, call will block
+ *
+ * inputs:
+ * dd - device descriptor
+ * cd - channel descriptor
+ *
+ * outputs:
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_close_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd);
+
+/*
+ * hpmud_channel_write - write data to specified channel, call will block
+ *
+ * May return with partial bytes written (ie: bytes_wrote < size) with or with-out a timeout.
+ *
+ * inputs:
+ * dd - device descriptor
+ * cd - channel descriptor
+ * buf - data to write
+ * size - number of bytes to write
+ * timeout - in seconds
+ *
+ * outputs:
+ * bytes_wrote - number of bytes actually wrote
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_write_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd, const void *buf, int size, int timeout, int *bytes_written);
+
+/*
+ * hpmud_channel_read - read data from specified channel, call will block
+ *
+ * May return with partial bytes read (ie: bytes_read < size) or zero if timeout occured.
+ *
+ * inputs:
+ * dd - device descriptor
+ * cd - channel descriptor
+ * size - number of bytes to read
+ * timeout - in seconds
+ *
+ * outputs:
+ * buf - read data buffer
+ * bytes_read - number of bytes actually read
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_read_channel(HPMUD_DEVICE dd, HPMUD_CHANNEL cd, void *buf, int size, int timeout, int *bytes_read);
+
+/*
+ * hpmud_dstat - get device information
+ *
+ * inputs:
+ * dd - device descriptor
+ *
+ * outputs:
+ * ds - see dstat definition
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_dstat(HPMUD_DEVICE dd, struct hpmud_dstat *ds);
+
+/*
+ * hpmud_set_pml - set pml object
+ *
+ * Set_pml is a high level interface to hpmud. This command calls the hpmud core interface.
+ * This command can be used with local or jetdirect connections. Jetdirect connection will
+ * use snmp.
+ *
+ * inputs:
+ * dd - device descriptor
+ * cc - channel descriptor
+ * snmp_oid - snmp encoded pml oid
+ * type - oid data type
+ * data - data payload
+ * data_size - number of bytes to write
+ *
+ * outputs:
+ * pml_result
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_set_pml(HPMUD_DEVICE device, HPMUD_CHANNEL channel, const char *snmp_oid, int type, void *data, int data_size, int *pml_result);
+
+/*
+ * hpmud_get_pml - get pml object
+ *
+ * Get_pml is a high level interface to hpmud. This command calls the hpmud core interface.
+ * This command can be used with local or jetdirect connections. Jetdirect connection will
+ * use snmp.
+ *
+ * inputs:
+ * dd - device descriptor
+ * cc - channel descriptor
+ * snmp_oid - snmp encoded pml oid
+ * data_size - data buffer size in bytes
+ *
+ * outputs:
+ * data - data payload
+ * type - pml data type
+ * pml_result
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_pml(HPMUD_DEVICE device, HPMUD_CHANNEL channel, const char *snmp_oid, void *buf, int buf_size, int *bytes_read, int *type, int *pml_result);
+
+/*
+ * hpmud_get_model - parse device model from the IEEE 1284 device id string.
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * id - IEEE 1284 device id string
+ * buf_size - size of buf in bytes
+ *
+ * outputs:
+ * buf - device model string (generalized)
+ * return value - length of string in bytes, does not include zero termination
+ */
+int hpmud_get_model(const char *id, char *buf, int buf_size);
+
+/*
+ * hpmud_get_raw_model - parse device model from the IEEE 1284 device id string.
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * id - IEEE 1284 device id string
+ * buf_size - size of buf in bytes
+ *
+ * outputs:
+ * buf - device model string (raw)
+ * return value - length of string in bytes, does not include zero termination
+ */
+int hpmud_get_raw_model(char *id, char *raw, int rawSize);
+
+/*
+ * hpmud_get_uri_model - parse device model from uri
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * uri
+ * buf_size - size of buf in bytes
+ *
+ * outputs:
+ * buf - device model string
+ * return value - length of string in bytes, does not include zero termination
+ */
+int hpmud_get_uri_model(const char *uri, char *buf, int buf_size);
+
+/*
+ * hpmud_get_uri_datalink - parse the data link from uri
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * uri
+ * buf_size - size of buf in bytes
+ *
+ * outputs:
+ * buf - device model string
+ * return value - length of string in bytes, does not include zero termination
+ */
+int hpmud_get_uri_datalink(const char *uri, char *buf, int buf_size);
+
+/*
+ * hpmud_get_model_attributes - get all model attributes for specified device
+ *
+ * Reads device model attributes from models.dat file. This function is a
+ * stateless hpmud helper function.
+ *
+ * inputs:
+ * uri - specifies device
+ * buf_size - size of buf in bytes
+ *
+ * outputs:
+ * buf - buffer for all model attributes, key/value pair, one per line
+ * bytes_read - number of bytes actually read
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_model_attributes(char *uri, char *attr, int attrSize, int *bytes_read);
+
+/*
+ * hpmud_model_query - get model attributes structure for specified device
+ *
+ * Reads device model attributes from models.dat file. This function is a
+ * stateless hpmud helper function.
+ *
+ * inputs:
+ * uri - specifies device
+ *
+ * outputs:
+ * ma - see structure definition
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_query_model(char *uri, struct hpmud_model_attributes *ma);
+
+/*
+ * hpmud_make_usb_uri - make a usb uri from bus:dev pair
+ *
+ * This function is a stateless hpmud helper function. The lsusb command can be used
+ * determine the bus:dev pair.
+ *
+ * inputs:
+ * busnum - specifies usbfs bus number
+ * devnum - specifies usbfs device number
+ * uri_size - size of uri buffer in bytes
+ *
+ * outputs:
+ * uri - zero terminated string
+ * bytes_read - size of uri
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_make_usb_uri(const char *busnum, const char *devnum, char *uri, int uri_size, int *bytes_read);
+
+/*
+ * hpmud_make_usb_serial_uri - make a usb uri from product serial number
+ *
+ * This function is a stateless hpmud helper function. The lsusb command can be used
+ * determine the product serial number.
+ *
+ * inputs:
+ * sn - specifies product serial number
+ * uri_size - size of uri buffer in bytes
+ *
+ * outputs:
+ * uri - zero terminated string
+ * bytes_read - size of uri
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_make_usb_serial_uri(const char *sn, char *uri, int uri_size, int *bytes_read);
+
+/*
+ * hpmud_make_net_uri - make a net uri from IP
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * ip - internet address
+ * port - 1-4
+ * uri_size - size of uri buffer in bytes
+ *
+ * outputs:
+ * uri - zero terminated string
+ * bytes_read - size of uri
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_make_net_uri(const char *ip, int port, char *uri, int uri_size, int *bytes_read);
+
+/*
+ * hpmud_make_par_uri - make a par uri from parallel port
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * dnode - device node
+ * uri_size - size of uri buffer in bytes
+ *
+ * outputs:
+ * uri - zero terminated string
+ * bytes_read - size of uri
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_make_par_uri(const char *dnode, char *uri, int uri_size, int *bytes_read);
+
+/*
+ * hpmud_get_conf - get key value from hplip.conf
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * section - zero terminated string (ie: "[dirs]")
+ * key - zero terminated string (ie: "home")
+ * value_size - size of value buffer in bytes
+ *
+ * outputs:
+ * value - zero terminated string
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_conf(const char *section, const char *key, char *value, int value_size);
+
+/*
+ * hpmud_get_key_value - get key value from specified file
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * file - zero terminated file path
+ * section - zero terminated string (ie: "[dirs]")
+ * key - zero terminated string (ie: "home")
+ * value_size - size of value buffer in bytes
+ *
+ * outputs:
+ * value - zero terminated string
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_get_key_value(const char *file, const char *section, const char *key, char *value, int value_size);
+
+/*
+ * hpmud_mdns_lookup - lookup IP for MDNS host name
+ *
+ * This function is a stateless hpmud helper function.
+ *
+ * inputs:
+ * host_name - zero terminated string (ie: "npi7c8a3e")
+ * sec_timeout - in seconds
+ *
+ * outputs:
+ * ip - zero terminated string
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_mdns_lookup(const char *host_name, int sec_timeout, char *ip);
+
+/*
+ * hpmud_make_mdns_uri - make a network uri from host name
+ *
+ * This function is a stateless hpmud helper function. Requires UDP port 5353 to be open.
+ *
+ * inputs:
+ * host - zero terminated string (ie: "npi7c8a3e")
+ * uri_size - size of uri buffer in bytes
+ *
+ * outputs:
+ * uri - zero terminated string
+ * bytes_read - size of uri
+ * return value - see enum definition
+ */
+enum HPMUD_RESULT hpmud_make_mdns_uri(const char *host, int port, char *uri, int uri_size, int *bytes_read);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _HPMUD_H
+
diff --git a/io/hpmud/hpmudi.h b/io/hpmud/hpmudi.h
new file mode 100644
index 0000000..269cb06
--- /dev/null
+++ b/io/hpmud/hpmudi.h
@@ -0,0 +1,212 @@
+/*****************************************************************************\
+
+ hpmudi.h - internal definitions for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ Author: Naga Samrat Chowdary Narla,
+\*****************************************************************************/
+
+#ifndef _HPMUDI_H
+#define _HPMUDI_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <syslog.h>
+#include <time.h>
+#include <ctype.h>
+#include <pthread.h>
+#include <arpa/inet.h>
+#include "hpmud.h"
+#include "musb.h"
+#include "mlc.h"
+#include "dot4.h"
+#include "pml.h"
+#ifdef HAVE_LIBNETSNMP
+#include "jd.h"
+#endif
+#ifdef HAVE_PPORT
+#include "pp.h"
+#endif
+
+// Don DO NOT commit with HPMUD_DEBUG enabled :(
+//#define HPMUD_DEBUG
+
+#define _STRINGIZE(x) #x
+#define STRINGIZE(x) _STRINGIZE(x)
+
+#define BUG(args...) syslog(LOG_ERR, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+//#define BUG(args...) fprintf(stderr, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+
+#ifdef HPMUD_DEBUG
+ #define DBG(args...) syslog(LOG_INFO, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+// #define DBG(args...) fprintf(stderr, __FILE__ " " STRINGIZE(__LINE__) ": " args)
+ #define DBG_DUMP(data, size) sysdump((data), (size))
+ #define DBG_SZ(args...) syslog(LOG_INFO, args)
+#else
+ #define DBG(args...)
+ #define DBG_DUMP(data, size)
+ #define DBG_SZ(args...)
+#endif
+
+#define HEX2INT(x, i) if (x >= '0' && x <= '9') i |= x - '0'; \
+ else if (x >= 'A' && x <= 'F') i |= 0xA + x - 'A'; \
+ else if (x >= 'a' && x <= 'f') i |= 0xA + x - 'a'
+
+/* offset_of returns the number of bytes that the fieldname MEMBER is offset from the beginning of the structure TYPE */
+#define offset_of(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+
+#define HPMUD_EXCEPTION_TIMEOUT 45000000 /* microseconds */
+#define HPMUD_EXCEPTION_SEC_TIMEOUT 45 /* seconds */
+#define HPMUD_MDNS_TIMEOUT 10 /* seconds */
+
+#define NFAULT_BIT 0x08
+#define PERROR_BIT 0x20
+
+enum HPMUD_CHANNEL_ID
+{
+ HPMUD_PML_CHANNEL = 1,
+ HPMUD_PRINT_CHANNEL = 2,
+ HPMUD_SCAN_CHANNEL = 4,
+ HPMUD_FAX_SEND_CHANNEL = 7,
+ HPMUD_CONFIG_UPLOAD_CHANNEL = 0xe,
+ HPMUD_CONFIG_DOWNLOAD_CHANNEL = 0xf,
+ HPMUD_MEMORY_CARD_CHANNEL = 0x11,
+ HPMUD_EWS_CHANNEL = 0x12, /* Embeded Web Server interface ff/1/1, any unused socket id */
+ HPMUD_SOAPSCAN_CHANNEL = 0x13, /* Soap Scan interface ff/2/1, any unused socket id */
+ HPMUD_SOAPFAX_CHANNEL = 0x14, /* Soap Fax interface ff/3/1, any unused socket id */
+ HPMUD_MARVELL_SCAN_CHANNEL = 0x15, /* Marvell scan interface ff/ff/ff, any unused socket id */
+ HPMUD_MARVELL_FAX_CHANNEL = 0x16, /* Marvell fax interface ff/ff/ff, any unused socket id */
+ HPMUD_EWS_LEDM_CHANNEL = 0x17, /* Embeded Web Server interface ff/4/1, any unused socket id */
+ HPMUD_LEDM_SCAN_CHANNEL = 0x18, /* LEDM scan interface ff/cc/0, any unused socket id */
+ HPMUD_WIFI_CHANNEL = 0x2b, /* WIFI config */
+ HPMUD_DEVMGMT_CHANNEL = 0x2c, /* decimal 44 */
+ HPMUD_MAX_CHANNEL_ID
+};
+
+#define HPMUD_DEVICE_MAX 2 /* zero is not used */
+#define HPMUD_CHANNEL_MAX HPMUD_MAX_CHANNEL_ID
+
+/* MLC/1284.4 attributes. Note for MLC, attributes must remain persistant while transport is up. */
+typedef struct
+{
+ unsigned short h2pcredit; /* host to peripheral credit (dot4: primary socket id credit for sending) */
+ unsigned short p2hcredit; /* peripheral to host credit (dot4: secondary socket id credit for sending) */
+ unsigned short h2psize; /* host to peripheral packet size in bytes (dot4: primary max packet size for sending) */
+ unsigned short p2hsize; /* peripheral to host packet size in bytes (dot4: secondary max packet size for sending) */
+} transport_attributes;
+
+typedef struct _mud_channel_vf
+{
+ enum HPMUD_RESULT (*open)(struct _mud_channel *pc); /* transport specific open */
+ enum HPMUD_RESULT (*close)(struct _mud_channel *pc); /* transport specific close */
+ enum HPMUD_RESULT (*channel_write)(struct _mud_channel *pc, const void *buf, int size, int timeout, int *bytes_wrote); /* tranport specific write */
+ enum HPMUD_RESULT (*channel_read)(struct _mud_channel *pc, void *buf, int size, int timeout, int *bytes_read); /* transport specific read */
+} mud_channel_vf;
+
+typedef struct _mud_device_vf
+{
+ int (*write)(int fd, const void *buf, int size, int usec_timeout); /* low level device write */
+ int (*read)(int fd, void *buf, int size, int usec_timout); /* low level device read */
+ enum HPMUD_RESULT (*open)(struct _mud_device *pd); /* device specific open */
+ enum HPMUD_RESULT (*close)(struct _mud_device *pd); /* device specific close */
+ enum HPMUD_RESULT (*get_device_id)(struct _mud_device *pd, char *id, int size, int *bytes_read); /* IEEE 1284 device id string */
+ enum HPMUD_RESULT (*get_device_status)(struct _mud_device *pd, unsigned int *status); /* device 8-bit status */
+ enum HPMUD_RESULT (*channel_open)(struct _mud_device *pd, const char *channel_name, HPMUD_CHANNEL *cd); /* channel specific open */
+ enum HPMUD_RESULT (*channel_close)(struct _mud_device *pd, struct _mud_channel *pc); /* channel specific close */
+ enum HPMUD_RESULT (*channel_write)(struct _mud_device *pd, struct _mud_channel *pc, const void *buf, int size, int sec_timeout, int *bytes_wrote);
+ enum HPMUD_RESULT (*channel_read)(struct _mud_device *pd, struct _mud_channel *pc, void *buf, int size, int sec_timeout, int *bytes_read);
+} mud_device_vf;
+
+typedef struct _mud_channel
+{
+ char sn[HPMUD_LINE_SIZE]; /* service name */
+ unsigned char sockid; /* socket id */
+ int client_cnt; /* number of clients using this channel */
+ int index; /* channel[index] of this object */
+ int fd; /* file descriptor for this channel */
+ pid_t pid; /* process owner */
+ int dindex; /* device[dindex] parent device */
+
+ /* MLC/1284.4 specific variables. */
+ transport_attributes ta;
+ unsigned char rbuf[HPMUD_BUFFER_SIZE]; /* read packet buffer */
+ int rindex;
+ int rcnt;
+
+ /* JetDirect specific data. */
+ int socket;
+
+ mud_channel_vf vf;
+} mud_channel;
+
+typedef struct _mud_device
+{
+ char uri[HPMUD_LINE_SIZE];
+ char id[1024]; /* device id */
+ int index; /* device[index] of this object */
+ enum HPMUD_IO_MODE io_mode;
+ mud_channel channel[HPMUD_CHANNEL_MAX];
+ int channel_cnt; /* number of open channels */
+ int open_fd; /* file descriptor used by device_open */
+
+ /* MLC/1284.4 specific variables. */
+ int mlc_up; /* 0=transport down, 1=transport up */
+ int mlc_fd; /* file descriptor used by 1284.4/MLC transport */
+
+ /* JetDirect specific data. */
+ char ip[HPMUD_LINE_SIZE]; /* internet address */
+ int port;
+
+ mud_device_vf vf; /* virtual function table */
+ pthread_mutex_t mutex;
+} mud_device;
+
+typedef struct
+{
+ mud_device device[HPMUD_DEVICE_MAX];
+ pthread_mutex_t mutex;
+} mud_session;
+
+extern mud_session *msp __attribute__ ((visibility ("hidden")));
+
+void __attribute__ ((visibility ("hidden"))) sysdump(const void *data, int size);
+int __attribute__ ((visibility ("hidden"))) mm_device_lock(int fd, HPMUD_DEVICE index);
+int __attribute__ ((visibility ("hidden"))) mm_device_unlock(int fd, HPMUD_DEVICE index);
+int __attribute__ ((visibility ("hidden"))) mm_device_trylock(int fd, HPMUD_DEVICE index);
+int __attribute__ ((visibility ("hidden"))) is_hp(const char *id);
+int __attribute__ ((visibility ("hidden"))) generalize_model(const char *sz, char *buf, int bufSize);
+int __attribute__ ((visibility ("hidden"))) generalize_serial(const char *sz, char *buf, int bufSize);
+int __attribute__ ((visibility ("hidden"))) get_uri_model(const char *uri, char *buf, int bufSize);
+int __attribute__ ((visibility ("hidden"))) get_uri_serial(const char *uri, char *buf, int bufSize);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) service_to_channel(mud_device *pd, const char *sn, HPMUD_CHANNEL *index);
+
+#endif // _HPMUDI_H
+
diff --git a/io/hpmud/jd.c b/io/hpmud/jd.c
new file mode 100644
index 0000000..1b7a382
--- /dev/null
+++ b/io/hpmud/jd.c
@@ -0,0 +1,906 @@
+/*****************************************************************************\
+
+ jd.c - JetDirect support for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ Client/Server generic message format (see messaging-protocol.doc):
+
+ Author: Naga Samrat Chowdary Narla, Sarbeswar Meher
+\*****************************************************************************/
+
+#ifdef HAVE_LIBNETSNMP
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <signal.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+mud_device_vf __attribute__ ((visibility ("hidden"))) jd_mud_device_vf =
+{
+ .open = jd_open,
+ .close = jd_close,
+ .get_device_id = jd_get_device_id,
+ .get_device_status = jd_get_device_status,
+ .channel_open = jd_channel_open,
+ .channel_close = jd_channel_close,
+ .channel_write = jd_channel_write,
+ .channel_read = jd_channel_read
+};
+
+static mud_channel_vf jd_channel_vf =
+{
+ .open = jd_s_channel_open,
+ .close = jd_s_channel_close,
+ .channel_write = jd_s_channel_write,
+ .channel_read = jd_s_channel_read
+};
+
+static const int PrintPort[] = { 0, 9100, 9101, 9102 };
+static const int ScanPort0[] = { 0, 9290, 9291, 9292 };
+static const int GenericPort[] = { 0, 9220, 9221, 9222 };
+static const int ScanPort1[] = { 0, 8290, 0, 0 }; /* hack for CLJ28xx */
+static const int GenericPort1[] = { 0, 8292, 0, 0 }; /* hack for CLJ28xx (fax) */
+
+const char __attribute__ ((visibility ("hidden"))) *kStatusOID = "1.3.6.1.4.1.11.2.3.9.1.1.7.0"; /* device id snmp oid */
+
+static int ReadReply(mud_channel *pc)
+{
+ char buf[HPMUD_LINE_SIZE];
+ int len=0, num=0;
+ char *tail;
+ enum HPMUD_RESULT stat;
+
+ stat = jd_s_channel_read(pc, buf, sizeof(buf), 2, &len);
+ buf[len] = 0;
+
+ if (stat == HPMUD_R_OK)
+ num = strtol((char *)buf, &tail, 10);
+
+ return num;
+}
+
+static int device_id(const char *ip, int port, char *buffer, int size)
+{
+ int len=0, maxSize, result, dt, status;
+
+ maxSize = (size > 1024) ? 1024 : size; /* RH8 has a size limit for device id */
+
+ if ((len = GetSnmp(ip, port, (char *)kStatusOID, (unsigned char *)buffer, maxSize, &dt, &status, &result)) == 0)
+ BUG("unable to read device-id\n");
+
+ return len; /* length does not include zero termination */
+}
+
+/* Create channel object given the requested socket id and service name. */
+static int new_channel(mud_device *pd, int index, const char *sn)
+{
+ int stat=1;
+
+ /* Check for existing name service already open. */
+ if (pd->channel[index].client_cnt)
+ {
+#if 0
+ if (index == HPMUD_EWS_CHANNEL)
+ {
+ pd->channel[index].client_cnt++; /* allow multiple clients for separate USB interfaces only */
+ stat = 0;
+ DBG("reused %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+ }
+ else
+#endif
+ BUG("%s channel=%d is busy, used by [%d], clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].pid, pd->channel[index].client_cnt, pd->channel_cnt);
+ goto bugout;
+ }
+
+ pd->channel[index].vf = jd_channel_vf;
+ pd->channel[index].index = index;
+ pd->channel[index].client_cnt = 1;
+ pd->channel[index].sockid = index;
+ pd->channel[index].pid = getpid();
+ pd->channel[index].dindex = pd->index;
+ pd->channel[index].fd = 0;
+ pd->channel[index].socket = -1;
+ strcpy(pd->channel[index].sn, sn);
+ pd->channel_cnt++;
+
+ stat = 0;
+ DBG("new %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+
+bugout:
+ return stat;
+}
+
+/* Remove channel object given the channel decriptor. */
+static int del_channel(mud_device *pd, mud_channel *pc)
+{
+ pc->client_cnt--;
+
+ if (pc->client_cnt <= 0)
+ {
+ pd->channel_cnt--;
+ }
+ DBG("removed %s channel=%d clientCnt=%d channelCnt=%d\n", pc->sn, pc->index, pc->client_cnt, pd->channel_cnt);
+ return 0;
+}
+
+/*********************************************************************************************************************************
+ * JetDirect mud_device functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_open(mud_device *pd)
+{
+ char uri_model[128];
+ char model[128];
+ char *p, *tail;
+ int len=0;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (pd->id[0] == 0)
+ {
+ /* First client. */
+ hpmud_get_uri_datalink(pd->uri, pd->ip, sizeof(pd->ip));
+
+ if ((p = strcasestr(pd->uri, "port=")) != NULL)
+ pd->port = strtol(p+5, &tail, 10);
+ else
+ pd->port = 1;
+ if (pd->port > 3)
+ {
+ stat = HPMUD_R_INVALID_IP_PORT;
+ BUG("invalid ip port=%d\n", pd->port);
+ goto blackout;
+ }
+
+ len = device_id(pd->ip, pd->port, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+ if (len == 0)
+ {
+ stat = HPMUD_R_IO_ERROR;
+ goto blackout;
+ }
+ }
+
+ /* Make sure uri model matches device id model. */
+ hpmud_get_uri_model(pd->uri, uri_model, sizeof(uri_model));
+ hpmud_get_model(pd->id, model, sizeof(model));
+ if (strcmp(uri_model, model) != 0)
+ {
+ stat = HPMUD_R_INVALID_URI; /* different device plugged in */
+ BUG("invalid uri model %s != %s\n", uri_model, model);
+ goto blackout;
+ }
+
+ stat = HPMUD_R_OK;
+
+blackout:
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_close(mud_device *pd)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+ pd->id[0] = 0;
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_get_device_id(mud_device *pd, char *buf, int size, int *len)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *len=0;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ *len = device_id(pd->ip, pd->port, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+
+ if (*len)
+ {
+ memcpy(buf, pd->id, *len > size ? size : *len);
+ stat = HPMUD_R_OK;
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_get_device_status(mud_device *pd, unsigned int *status)
+{
+ *status = NFAULT_BIT; /* there is no 8-bit status, so fake it */
+ return HPMUD_R_OK;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_write(mud_device *pd, mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ enum HPMUD_RESULT stat;
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.channel_write)(pc, buf, length, sec_timeout, bytes_wrote);
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_read(mud_device *pd, mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ enum HPMUD_RESULT stat;
+
+ if (pd->io_mode == HPMUD_UNI_MODE)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid channel_read io_mode=%d\n", pd->io_mode);
+ }
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.channel_read)(pc, buf, length, sec_timeout, bytes_read);
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_open(mud_device *pd, const char *sn, HPMUD_CHANNEL *cd)
+{
+ int index;
+ enum HPMUD_RESULT stat;
+
+ /* Check for valid service requests. */
+ if ((stat = service_to_channel(pd, sn, &index)) != HPMUD_R_OK)
+ goto bugout;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (new_channel(pd, index, sn))
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ }
+ else
+ {
+ if ((stat = (pd->channel[index].vf.open)(&pd->channel[index])) != HPMUD_R_OK) /* call transport specific open */
+ del_channel(pd, &pd->channel[index]); /* open failed, cleanup */
+ else
+ *cd = index;
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_close(mud_device *pd, mud_channel *pc)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.close)(pc); /* call trasport specific close */
+ del_channel(pd, pc);
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * JetDirect channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ struct sockaddr_in pin;
+ char buf[HPMUD_LINE_SIZE];
+ int r, len, port;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ bzero(&pin, sizeof(pin));
+ pin.sin_family = AF_INET;
+ pin.sin_addr.s_addr = inet_addr(pd->ip);
+
+ switch (pc->index)
+ {
+ case HPMUD_PRINT_CHANNEL:
+ port = PrintPort[pd->port];
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open print port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to print port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_SCAN_CHANNEL:
+ if (pd->io_mode == HPMUD_DOT4_PHOENIX_MODE)
+ port = ScanPort1[pd->port];
+ else
+ port = ScanPort0[pd->port];
+ pin.sin_port = htons(port);
+
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to scan err=%d port %d: %m %s\n", errno, port, pd->uri);
+ goto bugout;
+ }
+ if (pd->io_mode != HPMUD_DOT4_PHOENIX_MODE)
+ {
+ r = ReadReply(pc);
+ if (r != 0)
+ {
+ BUG("invalid scan response %d port %d %s\n", r, port, pd->uri);
+ goto bugout;
+ }
+ }
+ break;
+ case HPMUD_MEMORY_CARD_CHANNEL:
+ case HPMUD_FAX_SEND_CHANNEL:
+ case HPMUD_CONFIG_UPLOAD_CHANNEL:
+ case HPMUD_CONFIG_DOWNLOAD_CHANNEL:
+ if (pd->io_mode == HPMUD_DOT4_PHOENIX_MODE)
+ port = GenericPort1[pd->port];
+ else
+ port = GenericPort[pd->port];
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+
+ if (pd->io_mode != HPMUD_DOT4_PHOENIX_MODE)
+ {
+ r = ReadReply(pc);
+ if (r != 220)
+ {
+ BUG("invalid response %d port %d %s\n", r, port, pd->uri);
+ goto bugout;
+ }
+ len = sprintf(buf, "open %d\n", pc->index);
+ send(pc->socket, buf, len, 0);
+ r = ReadReply(pc);
+ if (r != 200)
+ {
+ BUG("invalid response %d port %d %s\n", r, port, pd->uri);
+ goto bugout;
+ }
+ len = sprintf(buf, "data\n");
+ send(pc->socket, "data\n", len, 0);
+ r = ReadReply(pc);
+ if (r != 200)
+ {
+ BUG("invalid response %d port %d %s\n", r, port, pd->uri);
+ goto bugout;
+ }
+ }
+
+ break;
+ case HPMUD_EWS_CHANNEL:
+ port = 80;
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open ews port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to ews port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_SOAPSCAN_CHANNEL:
+ port = 8289;
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open soap-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to soap-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_SOAPFAX_CHANNEL:
+ port = 8295;
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open soap-fax port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to soap-fax port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_MARVELL_SCAN_CHANNEL:
+ port = 8290; /* same as ScanPort1[1] */
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open marvell-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to marvell-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_LEDM_SCAN_CHANNEL:
+ case HPMUD_EWS_LEDM_CHANNEL:
+ port = 8080;
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open ledm-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to ledm-scan port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_MARVELL_FAX_CHANNEL:
+ port = 8285;
+ pin.sin_port = htons(port);
+ if ((pc->socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+ {
+ BUG("unable to open marvell-fax port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ if (connect(pc->socket, (struct sockaddr *)&pin, sizeof(pin)) == -1)
+ {
+ BUG("unable to connect to marvell-fax port %d: %m %s\n", port, pd->uri);
+ goto bugout;
+ }
+ break;
+ case HPMUD_PML_CHANNEL:
+ /* Do nothing here, use GetPml/SetPml instead of ReadData/WriteData. */
+ break;
+ default:
+ BUG("unsupported service %d %s\n", pc->index, pd->uri);
+ stat = HPMUD_R_INVALID_SN;
+ goto bugout;
+ break;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_close(mud_channel *pc)
+{
+ if (pc->socket >= 0)
+ {
+ close(pc->socket);
+
+ /* Delay for back-to-back scanning using scanimage. Otherwise next channel_open(HPMUD_SCAN_CHANNEL) can fail. */
+ sleep(1);
+ }
+
+ pc->socket = -1;
+
+ return HPMUD_R_OK;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_write(mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int len, size, total=0;
+ struct timeval tmo;
+ fd_set master;
+ fd_set writefd;
+ int maxfd, ret;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_wrote=0;
+ size = length;
+
+ if (pc->socket<0)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid data link socket=%d %s\n", pc->socket, pd->uri);
+ goto bugout;
+ }
+
+ FD_ZERO(&master);
+ FD_SET(pc->socket, &master);
+ maxfd = pc->socket;
+ size = length;
+
+ while (size > 0)
+ {
+ tmo.tv_sec = HPMUD_EXCEPTION_SEC_TIMEOUT; /* note linux select will modify tmo */
+ tmo.tv_usec = 0;
+ writefd = master;
+ if ((ret = select(maxfd+1, NULL, &writefd, NULL, &tmo)) == 0)
+ {
+ stat = HPMUD_R_IO_TIMEOUT;
+ BUG("timeout write_channel %s\n", pd->uri);
+ goto bugout; /* timeout */
+ }
+ len = send(pc->socket, buf+total, size, 0);
+ if (len < 0)
+ {
+ BUG("unable to write_channel: %m %s\n", pd->uri);
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ *bytes_wrote+=len;
+ }
+
+ DBG("write socket=%d len=%d size=%d\n", pc->socket, len, length);
+ DBG_DUMP(buf, len < 32 ? len : 32);
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*
+ * Channel_read() tries to read "length" bytes from the peripheral. The returned read count may be zero
+ * (timeout, no data available), less than "length" or equal "length".
+ */
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_read(mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int len=0;
+ struct timeval tmo;
+ fd_set master;
+ fd_set readfd;
+ int maxfd, ret;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_read = 0;
+
+ if (pc->socket<0)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid data link socket=%d %s\n", pc->socket, pd->uri);
+ goto bugout;
+ }
+
+ FD_ZERO(&master);
+ FD_SET(pc->socket, &master);
+ maxfd = pc->socket;
+ tmo.tv_sec = sec_timeout;
+ tmo.tv_usec = 0;
+
+ readfd = master;
+ ret = select(maxfd+1, &readfd, NULL, NULL, &tmo);
+ if (ret < 0)
+ {
+ BUG("unable to read_channel: %m %s\n", pd->uri);
+ goto bugout;
+ }
+ if (ret == 0)
+ {
+ stat = HPMUD_R_IO_TIMEOUT;
+// if (sec_timeout >= HPMUD_EXCEPTION_SEC_TIMEOUT)
+ BUG("timeout read_channel sec=%d %s\n", sec_timeout, pd->uri);
+ goto bugout;
+ }
+ else
+ {
+ if ((len = recv(pc->socket, buf, length, 0)) < 0)
+ {
+ BUG("unable to read_channel: %m %s\n", pd->uri);
+ goto bugout;
+ }
+ }
+
+ DBG("read socket=%d len=%d size=%d\n", pc->socket, len, length);
+ DBG_DUMP(buf, len < 32 ? len : 32);
+
+ *bytes_read = len;
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/* Convert "www.google.com" to "3www6google3com". */
+static int convert_name_to_dns(const char *name, int name_size, unsigned char *dns_name)
+{
+ int i, x=0;
+ unsigned char *p=dns_name;
+
+ for (i=0; i<name_size; i++)
+ {
+ if (name[i]=='.')
+ {
+ *p++ = i-x; /* length */
+ for (; x<i; x++)
+ *p++ = name[x];
+ x++;
+ }
+ }
+
+ if (i)
+ {
+ i--;
+ *p++ = i-x; /* length */
+ for (; x<i; x++)
+ *p++ = name[x];
+ x++;
+ }
+
+ dns_name[x++]=0;
+
+ return x; /* return length DOES include null termination */
+}
+
+/*
+ * Lookup IP for MDNS host name.
+ * MDNS host name example: "npi7c8a3e" (LaserJet p2055dn)
+ */
+enum HPMUD_RESULT hpmud_mdns_lookup(const char *host_name, int sec_timeout, char *ip)
+{
+ struct sockaddr_in send_addr;
+ struct sockaddr_in recv_addr;
+ struct sockaddr_in addr;
+ socklen_t addrlen;
+ struct timeval tmo;
+ fd_set master;
+ fd_set readfd;
+ int i, len, n, host_len, yes=1;
+ int maxfd, ret;
+ int udp_socket;
+ char recvbuffer[256], host[256];
+ unsigned char dnsquery[256]={0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ unsigned char tail[] = {0x0, 0x1, 0x0, 0x1};
+ unsigned char loop=0, ttl=255;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ DBG("mdns lookup '%s'\n", host_name);
+
+ if ((udp_socket = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
+ {
+ BUG("unable to create udp socket: %m\n");
+ goto bugout;
+ }
+
+ /* Get rid of "address already in use" error message. */
+ if (setsockopt(udp_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1)
+ {
+ BUG("unable to setsockopt: %m\n");
+ goto bugout;
+ }
+
+ /* Bind the socket to port and IP equal to INADDR_ANY. */
+ bzero(&recv_addr, sizeof(recv_addr));
+ recv_addr.sin_family = AF_INET;
+ recv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ recv_addr.sin_port = htons(5353);
+ if (bind(udp_socket, (struct sockaddr *)&recv_addr, sizeof(recv_addr)) == -1)
+ {
+ BUG("unable to bind udp socket: %m\n");
+ goto bugout;
+ }
+
+ /* Set multicast loopback off. */
+ if (setsockopt(udp_socket, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) == -1)
+ {
+ BUG("unable to setsockopt: %m\n");
+ goto bugout;
+ }
+
+ /* Set ttl to 255. Required by mdns. */
+ if (setsockopt(udp_socket, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) == -1)
+ {
+ BUG("unable to setsockopt: %m\n");
+ goto bugout;
+ }
+
+ /* Convert host name to mdns host name. */
+ host_len = snprintf(host, sizeof(host), "%s.local", host_name) + 1;
+
+ /* Create dns message. (header + question) */
+ n = convert_name_to_dns(host, host_len, dnsquery+12);
+ memcpy(dnsquery+12+n, tail, sizeof(tail));
+ n = 12+n+sizeof(tail);
+
+ i=0;
+ while (1)
+ {
+
+ DBG("send socket=%d len=%d\n", udp_socket, n);
+ DBG_DUMP(dnsquery, n);
+
+ bzero(&send_addr, sizeof(send_addr));
+ send_addr.sin_family = AF_INET;
+ send_addr.sin_addr.s_addr = inet_addr("224.0.0.251");
+ send_addr.sin_port = htons(5353);
+ sendto(udp_socket, dnsquery, n, 0, (struct sockaddr *)&send_addr, sizeof(send_addr));
+
+ FD_ZERO(&master);
+ FD_SET(udp_socket, &master);
+ maxfd = udp_socket;
+ tmo.tv_sec = 0;
+ tmo.tv_usec = 500000;
+
+ readfd = master;
+ ret = select(maxfd+1, &readfd, NULL, NULL, &tmo);
+ if (ret < 0)
+ {
+ BUG("error mdns lookup %s: %m\n", host);
+ goto bugout;
+ }
+ if (ret == 0)
+ {
+ goto retry;
+ }
+ else
+ {
+ bzero(&addr, sizeof(addr));
+ addrlen = sizeof(addr);
+ if ((len = recvfrom(udp_socket, recvbuffer, sizeof(recvbuffer), 0, (struct sockaddr *)&addr, &addrlen)) < 0)
+ {
+ BUG("error mdns lookup %s: %m\n", host);
+ goto bugout;
+ }
+
+ /* Make sure reply is from specified host. */
+ if (strncasecmp((const char *)dnsquery+12, (const char *)recvbuffer+12, n)==0)
+ break;
+ BUG("error mdns lookup %s: bad hostname in reply from ip=%s port=%d\n", host, inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
+ }
+
+retry:
+ if (i++ >= 2 * sec_timeout)
+ {
+ BUG("error timeout mdns lookup %s\n", host);
+ goto bugout;
+ }
+
+ BUG("mdns lookup %s retry %d...\n", host, i);
+ }
+
+ strcpy(ip, inet_ntoa(addr.sin_addr));
+
+ DBG("recv socket=%d len=%d port=%d ip=%s\n", udp_socket, len, ntohs(addr.sin_port), ip);
+ DBG_DUMP(recvbuffer, len);
+
+ stat = HPMUD_R_OK;
+
+bugout:
+
+ if (udp_socket >= 0)
+ close(udp_socket);
+
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_make_net_uri(const char *ip, int port, char *uri, int uri_size, int *bytes_read)
+{
+ char id[1024];
+ char model[128];
+ enum HPMUD_RESULT stat;
+
+ DBG("[%d] hpmud_make_net_uri() ip=%s port=%d\n", getpid(), ip, port);
+
+ *bytes_read=0;
+
+ uri[0]=0;
+
+ if (ip[0]==0)
+ {
+ BUG("invalid ip %s\n", ip);
+ stat = HPMUD_R_INVALID_IP;
+ goto bugout;
+ }
+
+ if (device_id(ip, port, id, sizeof(id)) > 0 && is_hp(id))
+ {
+ hpmud_get_model(id, model, sizeof(model));
+ if (port == 1)
+ *bytes_read = snprintf(uri, uri_size, "hp:/net/%s?ip=%s", model, ip);
+ else
+ *bytes_read = snprintf(uri, uri_size, "hp:/net/%s?ip=%s&port=%d", model, ip, port);
+ }
+ else
+ {
+ BUG("invalid ip %s\n", ip);
+ stat = HPMUD_R_INVALID_IP;
+ goto bugout;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_make_mdns_uri(const char *host, int port, char *uri, int uri_size, int *bytes_read)
+{
+ char id[1024];
+ char model[128];
+ char ip[HPMUD_LINE_SIZE]; /* internet address */
+ enum HPMUD_RESULT stat;
+
+ DBG("[%d] hpmud_make_mdns_uri() host=%s port=%d\n", getpid(), host, port);
+
+ *bytes_read=0;
+
+ uri[0]=0;
+
+ if (host[0]==0)
+ {
+ BUG("invalid host %s\n", host);
+ stat = HPMUD_R_INVALID_MDNS;
+ goto bugout;
+ }
+
+ if (hpmud_mdns_lookup(host, HPMUD_MDNS_TIMEOUT, ip) != HPMUD_R_OK)
+ {
+ BUG("invalid host %s, check firewall UDP/5353 or try using IP\n", host);
+ stat = HPMUD_R_INVALID_MDNS;
+ goto bugout;
+ }
+
+ if (device_id(ip, port, id, sizeof(id)) > 0 && is_hp(id))
+ {
+ hpmud_get_model(id, model, sizeof(model));
+ if (port == 1)
+ *bytes_read = snprintf(uri, uri_size, "hp:/net/%s?zc=%s", model, host);
+ else
+ *bytes_read = snprintf(uri, uri_size, "hp:/net/%s?zc=%s&port=%d", model, host, port);
+ }
+ else
+ {
+ BUG("invalid host %s, or try using IP\n", host);
+ stat = HPMUD_R_INVALID_MDNS;
+ goto bugout;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+#endif /* HAVE_LIBNETSNMP */
diff --git a/io/hpmud/jd.h b/io/hpmud/jd.h
new file mode 100644
index 0000000..f252fd8
--- /dev/null
+++ b/io/hpmud/jd.h
@@ -0,0 +1,56 @@
+/*****************************************************************************\
+
+ jd.h - JetDirect support for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _JD_H
+#define _JD_H
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+struct _mud_device;
+struct _mud_channel;
+
+extern const char __attribute__ ((visibility ("hidden"))) *kStatusOID; /* device id snmp oid */
+
+extern struct _mud_device_vf __attribute__ ((visibility ("hidden"))) jd_mud_device_vf;
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_open(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_close(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_get_device_id(struct _mud_device *pd, char *buf, int size, int *len);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_get_device_status(struct _mud_device *pd, unsigned int *status);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_open(struct _mud_device *pd, const char *sn, HPMUD_CHANNEL *cd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_close(struct _mud_device *pd, struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_write(struct _mud_device *pd, struct _mud_channel *pc, const void *buf, int length, int timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_channel_read(struct _mud_device *pd, struct _mud_channel *pc, void *buf, int length, int timeout, int *bytes_read);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_write(struct _mud_channel *pc, const void *buf, int length, int timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) jd_s_channel_read(struct _mud_channel *pc, void *buf, int length, int timeout, int *bytes_wrote);
+
+#endif // _JD_H
+
diff --git a/io/hpmud/list.h b/io/hpmud/list.h
new file mode 100644
index 0000000..007e704
--- /dev/null
+++ b/io/hpmud/list.h
@@ -0,0 +1,131 @@
+#ifndef _LIST_H
+#define _LIST_H
+
+/*
+ * This linked list implementation is the same as linux kernel implementation.
+ * Refer to the linux kernel documentation for usage.
+ */
+
+struct list_head {
+ struct list_head *next, *prev;
+};
+
+#define INIT_LIST_HEAD(ptr) do { \
+ (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head * new_entry,
+ struct list_head * prev,
+ struct list_head * next)
+{
+ next->prev = new_entry;
+ new_entry->next = next;
+ new_entry->prev = prev;
+ prev->next = new_entry;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new_entry, struct list_head *head)
+{
+ __list_add(new_entry, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new_entry, struct list_head *head)
+{
+ __list_add(new_entry, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev,
+ struct list_head * next)
+{
+ next->prev = prev;
+ prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ entry->next = entry->prev = 0;
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(struct list_head *head)
+{
+ return head->next == head;
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr: the &struct list_head pointer.
+ * @type: the type of the struct this is embedded in.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+ ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+
+/**
+ * list_for_each - iterate over a list
+ * @pos: the &struct list_head to use as a loop counter.
+ * @head: the head for your list.
+ */
+#define list_for_each(pos, head) \
+ for (pos = (head)->next; pos != (head); \
+ pos = pos->next)
+
+/**
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct list_head to use as a loop counter.
+ * @n: another &struct list_head to use as temporary storage
+ * @head: the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (head); \
+ pos = n, n = pos->next)
+
+#endif /* _LIST_H */
diff --git a/io/hpmud/mlc.c b/io/hpmud/mlc.c
new file mode 100644
index 0000000..e8b9784
--- /dev/null
+++ b/io/hpmud/mlc.c
@@ -0,0 +1,772 @@
+/*****************************************************************************\
+
+ mlc.c - MLC support for multi-point tranport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#include "hpmud.h"
+#include "hpmudi.h"
+
+int __attribute__ ((visibility ("hidden"))) cut_buf(mud_channel *pc, char *buf, int size)
+{
+ int len;
+
+ if (pc->rcnt > size)
+ {
+ /* Return part of rbuf. */
+ len = size;
+ memcpy(buf, &pc->rbuf[pc->rindex], len);
+ pc->rindex += len;
+ pc->rcnt -= len;
+ }
+ else
+ {
+ /* Return all of rbuf. */
+ len = pc->rcnt;
+ memcpy(buf, &pc->rbuf[pc->rindex], len);
+ pc->rindex = pc->rcnt = 0;
+ }
+
+ return len;
+}
+
+/* Write command reply back to peripheral. */
+static int MlcForwardReply(mud_channel *pc, int fd, unsigned char *buf, int size)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int len=0;
+
+ if ((len = (pd->vf.write)(fd, buf, size, HPMUD_EXCEPTION_TIMEOUT)) != size)
+ {
+ BUG("unable to MlcForwarReply: %m\n");
+ }
+ return len;
+}
+
+/* Execute command from peripheral. */
+static int MlcExecReverseCmd(mud_channel *pc, int fd, unsigned char *buf)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ mud_channel *out_of_bound_channel;
+ MLCCmd *pCmd;
+ MLCReply *pReply;
+ MLCCredit *pCredit;
+ MLCCreditReply *pCreditReply;
+ MLCCreditRequest *pCreditReq;
+ MLCCreditRequestReply *pCreditReqReply;
+ MLCError *pError;
+ int len, size;
+ static int cnt;
+
+ pCmd = (MLCCmd *)buf;
+
+ /* See if this packet is a command packet. */
+ if (!(pCmd->h.hsid == 0 && pCmd->h.psid == 0))
+ {
+ if (pCmd->h.hsid == pCmd->h.psid)
+ {
+ /* Got a valid data packet handle it. This can happen when channel_read timeouts and p2hcredit=1. */
+ out_of_bound_channel = &pd->channel[pCmd->h.hsid];
+
+ if (out_of_bound_channel->ta.p2hcredit <= 0)
+ {
+ BUG("invalid data packet credit=%d\n", out_of_bound_channel->ta.p2hcredit);
+ return 0;
+ }
+
+ size = ntohs(pCmd->h.length) - sizeof(MLCHeader);
+ if (size > (HPMUD_BUFFER_SIZE - out_of_bound_channel->rcnt))
+ {
+ BUG("invalid data packet size=%d\n", size);
+ return 0;
+ }
+ memcpy(&out_of_bound_channel->rbuf[out_of_bound_channel->rcnt], buf+sizeof(MLCHeader), size);
+ out_of_bound_channel->rcnt += size;
+ if (pCmd->h.credit)
+ out_of_bound_channel->ta.h2pcredit += pCmd->h.credit; /* note, piggy back credit is 1 byte wide */
+ out_of_bound_channel->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+ }
+ else
+ {
+ len = ntohs(pCmd->h.length);
+ BUG("unsolicited data packet: hsid=%x, psid=%x, length=%d, credit=%d, status=%x\n", pCmd->h.hsid,
+ pCmd->h.psid, len, pCmd->h.credit, pCmd->h.status);
+ DBG_DUMP(buf, len);
+ }
+ return 0;
+ }
+
+ /* Process any command. */
+ switch (pCmd->cmd)
+ {
+ case MLC_CREDIT:
+ pCredit = (MLCCredit *)buf;
+ out_of_bound_channel = &pd->channel[pCredit->hsocket];
+ out_of_bound_channel->ta.h2pcredit += ntohs(pCredit->credit);
+ pCreditReply = (MLCCreditReply *)buf;
+ pCreditReply->h.length = htons(sizeof(MLCCreditReply));
+ pCreditReply->cmd |= 0x80;
+ pCreditReply->result = 0;
+ MlcForwardReply(pc, fd, (unsigned char *)pCreditReply, sizeof(MLCCreditReply));
+ break;
+ case MLC_CREDIT_REQUEST:
+ pCreditReq = (MLCCreditRequest *)buf;
+ if (cnt++ < 5)
+ BUG("unexpected MLCCreditRequest: cmd=%x, hid=%x, pid=%x, credit=%d\n", pCreditReq->cmd,
+ pCreditReq->hsocket, pCreditReq->psocket, ntohs(pCreditReq->credit));
+ pCreditReqReply = (MLCCreditRequestReply *)buf;
+ pCreditReqReply->h.length = htons(sizeof(MLCCreditRequestReply));
+ pCreditReqReply->cmd |= 0x80;
+ pCreditReqReply->result = 0;
+ pCreditReqReply->credit = 0;
+ MlcForwardReply(pc, fd, (unsigned char *)pCreditReqReply, sizeof(MLCCreditRequestReply));
+ break;
+ case MLC_ERROR:
+ pError = (MLCError *)buf;
+ BUG("unexpected MLCError: cmd=%x, result=%x\n", pError->cmd, pError->result);
+ return 1;
+ default:
+ pReply = (MLCReply *)buf;
+ BUG("unexpected command: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ pReply->h.length = htons(sizeof(MLCReply));
+ pReply->cmd |= 0x80;
+ pReply->result = 1;
+ MlcForwardReply(pc, fd, (unsigned char *)pReply, sizeof(MLCReply));
+ break;
+ }
+ return 0;
+}
+
+/* Get command from peripheral and processes the reverse command. */
+int __attribute__ ((visibility ("hidden"))) MlcReverseCmd(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, size;
+ unsigned int pklen;
+ unsigned char *pBuf;
+ MLCReply *pPk;
+
+ pPk = (MLCReply *)buf;
+
+ pBuf = buf;
+
+ /* Read packet header. */
+ size = sizeof(MLCHeader);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseCmd header: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Determine packet size. */
+ if ((pklen = ntohs(pPk->h.length)) > sizeof(buf))
+ {
+ BUG("invalid MlcReverseCmd packet size: size=%d\n", pklen);
+ stat = 1;
+ goto bugout;
+ }
+
+ /* Read packet data field. */
+ size = pklen - sizeof(MLCHeader);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseCmd data: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ stat = MlcExecReverseCmd(pc, fd, buf);
+
+bugout:
+ return stat;
+}
+
+/*
+ * Get command reply from peripheral. Waits for reply then returns. Processes any reverse commands
+ * while waiting for a reply.
+ */
+static int MlcReverseReply(mud_channel *pc, int fd, unsigned char *buf, int bufsize)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int stat=0, len, size, pklen;
+ unsigned char *pBuf;
+ MLCReply *pPk;
+
+ pPk = (MLCReply *)buf;
+
+ while (1)
+ {
+ pBuf = buf;
+
+ /* Read packet header. */
+ size = sizeof(MLCHeader);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, 4000000)) < 0) /* wait 4 seconds, same as dot4 */
+ {
+ BUG("unable to read MlcReverseReply header: %m bytesRead=%zd\n", sizeof(MLCHeader)-size);
+ stat = 2; /* short timeout */
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Determine packet size. */
+ pklen = ntohs(pPk->h.length);
+ if (pklen < 0 || pklen > bufsize)
+ {
+ BUG("invalid MlcReverseReply packet size: size=%d, buf=%d\n", pklen, bufsize);
+ stat = 1;
+ goto bugout;
+ }
+
+ if (pklen == 0)
+ {
+ /* Got invalid MLC header from peripheral, try this "off-by-one" firmware hack (ie: OJ600). */
+ BUG("trying MlcReverseReply firmware hack\n");
+ memcpy(buf, &buf[1], sizeof(MLCHeader)-1);
+ pklen = ntohs(pPk->h.length);
+ if (pklen <= 0 || pklen > bufsize)
+ {
+ BUG("invalid MlcReverseReply packet size: size=%d, buf=%d\n", pklen, bufsize);
+ stat = 1;
+ goto bugout;
+ }
+ if ((len = (pd->vf.read)(fd, --pBuf, 1, 1000000)) < 0) /* wait 1 second */
+ {
+ BUG("unable to read MlcReverseReply header: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+ pBuf++;
+ DBG_DUMP(buf, sizeof(MLCHeader));
+ }
+
+ /* Read packet data field. */
+ size = pklen - sizeof(MLCHeader);
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseReply data: %m exp=%zd act=%zd\n", pklen-sizeof(MLCHeader), pklen-sizeof(MLCHeader)-size);
+ stat = 1;
+ goto bugout;
+ }
+ size-=len;
+ pBuf+=len;
+ }
+
+ /* Check for reply. */
+ if (pPk->cmd & 0x80)
+ break;
+
+ stat = MlcExecReverseCmd(pc, fd, buf);
+
+ if (stat != 0)
+ break;
+
+ } /* while (1) */
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcInit(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n, cnt;
+ MLCInit *pCmd;
+ MLCInitReply *pReply;
+
+ memset(buf, 0, sizeof(MLCInit));
+ pCmd = (MLCInit *)buf;
+ n = sizeof(MLCInit);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_INIT;
+ pCmd->rev = 3;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MLCInit: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ cnt=0;
+ while(1)
+ {
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCInitReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_INIT)) || (pReply->result != 0))
+ {
+ if (errno == EIO && cnt<1)
+ {
+ /* hack for usblp.c 2.6.5 */
+ BUG("invalid MLCInitReply retrying...\n");
+ sleep(1);
+ cnt++;
+ continue;
+ }
+ if (stat == 2 && cnt<1)
+ {
+ /* hack for Tahoe */
+ BUG("invalid MLCInitReply retrying command...\n");
+ memset(buf, 0, sizeof(MLCInit));
+ n = sizeof(MLCInit);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_INIT;
+ pCmd->rev = 3;
+ (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT);
+ cnt++;
+ continue;
+ }
+ BUG("invalid MLCInitReply: cmd=%x, result=%x\n, revision=%x\n", pReply->cmd, pReply->result, pReply->rev);
+ stat = 1;
+ goto bugout;
+ }
+ break;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcExit(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCExit *pCmd;
+ MLCExitReply *pReply;
+
+ memset(buf, 0, sizeof(MLCExit));
+ pCmd = (MLCExit *)buf;
+ n = sizeof(MLCExit);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_EXIT;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MLCExit: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCExitReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_EXIT)) || (pReply->result != 0))
+ {
+ BUG("invalid MLCExitReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcConfigSocket(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCConfigSocket *pCmd;
+ MLCConfigSocketReply *pReply;
+
+ if (pc->ta.h2psize > 0)
+ return stat; /* already got host/peripheral packet sizes */
+
+ memset(buf, 0, sizeof(MLCConfigSocket));
+ pCmd = (MLCConfigSocket *)buf;
+ n = sizeof(MLCConfigSocket);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_CONFIG_SOCKET;
+ pCmd->socket = pc->sockid;
+ pCmd->h2psize = htons(HPMUD_BUFFER_SIZE);
+ pCmd->p2hsize = htons(HPMUD_BUFFER_SIZE);
+ pCmd->status = 0; /* status level?? */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MLCConfigSocket: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCConfigSocketReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_CONFIG_SOCKET)) || (pReply->result != 0))
+ {
+ BUG("invalid MLCConfigSocketReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.h2psize = ntohs(pReply->h2psize);
+ pc->ta.p2hsize = ntohs(pReply->p2hsize);
+
+bugout:
+ return stat;
+}
+
+/* Write data to peripheral. */
+int __attribute__ ((visibility ("hidden"))) MlcForwardData(mud_channel *pc, int fd, const void *buf, int size, int usec_timeout)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int stat=0, len, n;
+ MLCHeader h;
+
+ memset(&h, 0, sizeof(h));
+ n = sizeof(MLCHeader) + size;
+ h.length = htons(n);
+ h.hsid = pc->sockid;
+ h.psid = pc->sockid;
+
+ if ((len = (pd->vf.write)(fd, &h, sizeof(MLCHeader), usec_timeout)) != sizeof(MLCHeader))
+ {
+ BUG("unable to write MlcForwardData header: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ if ((len = (pd->vf.write)(fd, buf, size, usec_timeout)) != size)
+ {
+ BUG("unable to write MlcForwardData: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+/* Read data from peripheral. */
+int __attribute__ ((visibility ("hidden"))) MlcReverseData(mud_channel *pc, int fd, void *buf, int length, int usec_timeout)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ mud_channel *out_of_bound_channel;
+ int len, size, total;
+ MLCHeader *pPk;
+
+ pPk = (MLCHeader *)buf;
+
+ while (1)
+ {
+ total = 0;
+
+ /* Read packet header. */
+ size = sizeof(MLCHeader);
+ while (size > 0)
+ {
+ /* Use requested client timeout until we start reading. */
+ if (total == 0)
+ len = (pd->vf.read)(fd, buf+total, size, usec_timeout);
+ else
+ len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT);
+
+ if (len < 0)
+ {
+ /* Got a timeout, if exception timeout or timeout occured after read started thats an error. */
+ if (usec_timeout >= HPMUD_EXCEPTION_TIMEOUT || total > 0)
+ BUG("unable to read MlcReverseData header: %m %s\n", pd->uri);
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+
+ /* Determine data size. */
+ size = ntohs(pPk->length) - sizeof(MLCHeader);
+
+ if (size > length)
+ {
+ BUG("invalid MlcReverseData size: size=%d, buf=%d\n", size, length);
+ goto bugout;
+ }
+
+ /* Make sure data packet is for this channel. */
+ if (pPk->hsid != pc->sockid && pPk->psid != pc->sockid)
+ {
+ if (pPk->hsid == 0 && pPk->psid == 0)
+ {
+ /* Ok, got a command channel packet instead of a data packet, handle it... */
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseData command: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total=len;
+ }
+ MlcExecReverseCmd(pc, fd, buf);
+ continue; /* try again for data packet */
+ }
+ else if (pPk->hsid == pPk->psid)
+ {
+ /* Got a valid data packet for another channel handle it. This can happen when ReadData timeouts and p2hcredit=1. */
+ out_of_bound_channel = &pd->channel[pPk->hsid];
+ unsigned char *pBuf;
+
+ if (out_of_bound_channel->ta.p2hcredit <= 0)
+ {
+ BUG("invalid data packet credit=%d\n", out_of_bound_channel->ta.p2hcredit);
+ goto bugout;
+ }
+
+ if (size > (HPMUD_BUFFER_SIZE - out_of_bound_channel->rcnt))
+ {
+ BUG("invalid data packet size=%d\n", size);
+ goto bugout;
+ }
+
+ total = 0;
+ pBuf = &out_of_bound_channel->rbuf[out_of_bound_channel->rcnt];
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, pBuf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseData: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+
+ out_of_bound_channel->rcnt += total;
+ if (pPk->credit)
+ out_of_bound_channel->ta.h2pcredit += pPk->credit; /* note, piggy back credit is 1 byte wide */
+ out_of_bound_channel->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+ continue; /* try again for data packet */
+ }
+ else
+ {
+ MLCCmd *pCmd = (MLCCmd *)buf;
+ BUG("invalid MlcReverseData state: exp hsid=%x, act hsid=%x, psid=%x, length=%d, credit=%d, status=%x, cmd=%x\n", pc->sockid,
+ pPk->hsid, pPk->psid, ntohs(pPk->length), pPk->credit, pPk->status, pCmd->cmd);
+ goto bugout;
+ }
+ }
+
+ if (pPk->credit)
+ {
+ pc->ta.h2pcredit += pPk->credit; /* note, piggy back credit is 1 byte wide */
+ }
+
+ total = 0; /* eat packet header */
+
+ /* Read packet data field with exception_timeout. */
+ while (size > 0)
+ {
+ if ((len = (pd->vf.read)(fd, buf+total, size, HPMUD_EXCEPTION_TIMEOUT)) < 0)
+ {
+ BUG("unable to read MlcReverseData: %m\n");
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ }
+ break; /* done reading data packet */
+ } /* while (1) */
+
+bugout:
+ return total;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcOpenChannel(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCOpenChannel *pCmd;
+ MLCOpenChannelReply *pReply;
+
+ memset(buf, 0, sizeof(MLCOpenChannel));
+ pCmd = (MLCOpenChannel *)buf;
+ n = sizeof(MLCOpenChannel);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_OPEN_CHANNEL;
+ pCmd->hsocket = pc->sockid; /* assume static socket ids */
+ pCmd->psocket = pc->sockid;
+ pCmd->credit = htons(0); /* credit sender will accept from receiver (set by MlcDevice::ReadData) */
+ // SetH2PCredit(0); /* initialize sender to receiver credit */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MlcOpenChannel: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCOpenChannelReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_OPEN_CHANNEL)) || (pReply->result != 0))
+ {
+ BUG("invalid MlcOpenChannelReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.h2pcredit = ntohs(pReply->credit);
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcCloseChannel(mud_channel *pc, int fd)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCCloseChannel *pCmd;
+ MLCCloseChannelReply *pReply;
+
+ memset(buf, 0, sizeof(MLCCloseChannel));
+ pCmd = (MLCCloseChannel *)buf;
+ n = sizeof(MLCCloseChannel);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_CLOSE_CHANNEL;
+ pCmd->hsocket = pc->sockid; /* assume static socket ids */
+ pCmd->psocket = pc->sockid;
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MlcCloseChannel: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCCloseChannelReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_CLOSE_CHANNEL)) || (pReply->result != 0))
+ {
+ BUG("invalid MlcCloseChannelReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcCredit(mud_channel *pc, int fd, unsigned short credit)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCCredit *pCmd;
+ MLCCreditReply *pReply;
+
+ memset(buf, 0, sizeof(MLCCredit));
+ pCmd = (MLCCredit *)buf;
+ n = sizeof(MLCCredit);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_CREDIT;
+ pCmd->hsocket = pc->sockid; /* assume static socket ids */
+ pCmd->psocket = pc->sockid;
+ pCmd->credit = htons(credit); /* set peripheral to host credit */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MlcCredit: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCCreditReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_CREDIT)) || (pReply->result != 0))
+ {
+ BUG("invalid MlcCreditReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.p2hcredit += credit;
+
+bugout:
+ return stat;
+}
+
+int __attribute__ ((visibility ("hidden"))) MlcCreditRequest(mud_channel *pc, int fd, unsigned short credit)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char buf[HPMUD_BUFFER_SIZE];
+ int stat=0, len, n;
+ MLCCreditRequest *pCmd;
+ MLCCreditRequestReply *pReply;
+
+ memset(buf, 0, sizeof(MLCCreditRequest));
+ pCmd = (MLCCreditRequest *)buf;
+ n = sizeof(MLCCreditRequest);
+ pCmd->h.length = htons(n);
+ pCmd->cmd = MLC_CREDIT_REQUEST;
+ pCmd->hsocket = pc->sockid; /* assume static socket ids */
+ pCmd->psocket = pc->sockid;
+ pCmd->credit = htons(credit); /* request host to peripheral credit */
+
+ if ((len = (pd->vf.write)(fd, pCmd, n, HPMUD_EXCEPTION_TIMEOUT)) != n)
+ {
+ BUG("unable to write MlcCreditRequest: %m\n");
+ stat = 1;
+ goto bugout;
+ }
+
+ stat = MlcReverseReply(pc, fd, buf, sizeof(buf));
+ pReply = (MLCCreditRequestReply *)buf;
+
+ if ((stat != 0) || (pReply->cmd != (0x80 | MLC_CREDIT_REQUEST)) || (pReply->result != 0))
+ {
+ BUG("invalid MlcCreditRequestReply: cmd=%x, result=%x\n", pReply->cmd, pReply->result);
+ stat = 1;
+ goto bugout;
+ }
+
+ pc->ta.h2pcredit += ntohs(pReply->credit);
+
+bugout:
+ return stat;
+}
+
+
+
diff --git a/io/hpmud/mlc.h b/io/hpmud/mlc.h
new file mode 100644
index 0000000..afc6b22
--- /dev/null
+++ b/io/hpmud/mlc.h
@@ -0,0 +1,150 @@
+/*****************************************************************************\
+
+ mlc.h - MLC support for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _MLC_H
+#define _MLC_H
+
+enum MLC_COMMAND
+{
+ MLC_INIT = 0,
+ MLC_OPEN_CHANNEL = 1,
+ MLC_CLOSE_CHANNEL = 2,
+ MLC_CREDIT = 3,
+ MLC_CREDIT_REQUEST = 4,
+ MLC_DEBIT = 5,
+ MLC_DEBIT_REQUEST = 6,
+ MLC_CONFIG_SOCKET = 7,
+ MLC_EXIT = 8,
+ MLC_ERROR = 0x7f
+};
+
+typedef struct
+{
+ unsigned char hsid; /* host socket id */
+ unsigned char psid; /* peripheral socket id */
+ unsigned short length; /* packet length (includes header) */
+ unsigned char credit; /* data packet credit, reserved if command */
+ unsigned char status; /* upper layer status */
+} __attribute__((packed)) MLCHeader;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char rev;
+} __attribute__((packed)) MLCInit;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned char rev;
+} __attribute__((packed)) MLCInitReply;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+} __attribute__((packed)) MLCExit;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char result;
+} __attribute__((packed)) MLCExitReply;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char socket; /* socket id */
+ unsigned short h2psize; /* host-to-peripheral packet size */
+ unsigned short p2hsize; /* peripheral-to-host packet size */
+ unsigned char status; /* status level */
+} __attribute__((packed)) MLCConfigSocket;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned short h2psize; /* host-to-peripheral packet size */
+ unsigned short p2hsize; /* peripheral-to-host packet size */
+ unsigned char status; /* status level */
+} __attribute__((packed)) MLCConfigSocketReply;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char hsocket; /* host socket id */
+ unsigned char psocket; /* peripheral socket id */
+ unsigned short credit;
+} __attribute__((packed)) MLCOpenChannel;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char result;
+ unsigned short credit;
+} __attribute__((packed)) MLCOpenChannelReply;
+
+typedef struct
+{
+ MLCHeader h;
+ unsigned char cmd;
+ unsigned char hsocket; /* host socket id */
+ unsigned char psocket; /* peripheral socket id */
+} __attribute__((packed)) MLCCloseChannel;
+
+typedef MLCExitReply MLCCloseChannelReply;
+typedef MLCExitReply MLCReply;
+typedef MLCExit MLCCmd;
+typedef MLCOpenChannel MLCCredit;
+typedef MLCExitReply MLCCreditReply;
+typedef MLCOpenChannel MLCCreditRequest;
+typedef MLCOpenChannelReply MLCCreditRequestReply;
+typedef MLCExitReply MLCError;
+
+struct _mud_device;
+struct _mud_channel;
+
+int __attribute__ ((visibility ("hidden"))) cut_buf(struct _mud_channel *pc, char *buf, int size);
+int __attribute__ ((visibility ("hidden"))) MlcInit(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) MlcExit(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) MlcConfigSocket(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) MlcForwardData(struct _mud_channel *pc, int fd, const void *buf, int size, int usec_timeout);
+int __attribute__ ((visibility ("hidden"))) MlcReverseData(struct _mud_channel *pc, int fd, void *buf, int length, int usec_timeout);
+int __attribute__ ((visibility ("hidden"))) MlcOpenChannel(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) MlcCloseChannel(struct _mud_channel *pc, int fd);
+int __attribute__ ((visibility ("hidden"))) MlcCredit(struct _mud_channel *pc, int fd, unsigned short credit);
+int __attribute__ ((visibility ("hidden"))) MlcCreditRequest(struct _mud_channel *pc, int fd, unsigned short credit);
+int __attribute__ ((visibility ("hidden"))) MlcReverseCmd(struct _mud_channel *pc, int fd);
+
+#endif // _MLC_H
+
diff --git a/io/hpmud/model.c b/io/hpmud/model.c
new file mode 100644
index 0000000..3678af5
--- /dev/null
+++ b/io/hpmud/model.c
@@ -0,0 +1,633 @@
+/*****************************************************************************\
+
+ model.c - model parser for hplip devices
+
+ (c) 2006-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include "list.h"
+#include "hpmud.h"
+#include "hpmudi.h"
+
+#define SECTION_SIZE 4096 /* Rough estimate of key/value section size in bytes. */
+
+typedef struct
+{
+ char *name;
+ char *incFile;
+ int valueSize; /* size of list in bytes */
+ char *value; /* list of key/value pairs */
+ struct list_head list;
+} LabelRecord;
+
+static LabelRecord head; /* list of labels from include files */
+static char homedir[255] = "";
+
+static int GetPair(char *buf, int buf_len, char *key, char *value, char **tail)
+{
+ int i=0, j;
+
+ key[0] = 0;
+ value[0] = 0;
+
+ if (buf[i] == '#')
+ {
+ for (; buf[i] != '\n' && i < buf_len; i++); /* eat comment line */
+ if (buf[i] == '\n')
+ i++; /* bump past '\n' */
+ }
+
+ j = 0;
+ while ((buf[i] != '=') && (i < buf_len) && (j < HPMUD_LINE_SIZE))
+ key[j++] = buf[i++];
+ for (j--; key[j] == ' ' && j > 0; j--); /* eat white space before = */
+ key[++j] = 0;
+
+ if (buf[i] == '=')
+ for (i++; buf[i] == ' ' && i < buf_len; i++); /* eat white space after = */
+
+ j = 0;
+ while ((buf[i] != '\n') && (i < buf_len) && (j < HPMUD_LINE_SIZE))
+ value[j++] = buf[i++];
+ for (j--; value[j] == ' ' && j > 0; j--); /* eat white space before \n */
+ value[++j] = 0;
+
+ if (buf[i] == '\n')
+ i++; /* bump past '\n' */
+
+ if (tail != NULL)
+ *tail = buf + i; /* tail points to next line */
+
+ return i;
+}
+
+static int ReadConfig()
+{
+ char key[HPMUD_LINE_SIZE];
+ char value[HPMUD_LINE_SIZE];
+ char rcbuf[255];
+ char section[32];
+ char *tail;
+ FILE *inFile = NULL;
+ int stat=1;
+
+ homedir[0] = 0;
+
+ if((inFile = fopen(CONFDIR "/hplip.conf", "r")) == NULL)
+ {
+ BUG("unable to open %s: %m\n", CONFDIR "/hplip.conf");
+ goto bugout;
+ }
+
+ section[0] = 0;
+
+ /* Read the config file */
+ while ((fgets(rcbuf, sizeof(rcbuf), inFile) != NULL))
+ {
+ if (rcbuf[0] == '[')
+ {
+ strncpy(section, rcbuf, sizeof(section)); /* found new section */
+ continue;
+ }
+
+ GetPair(rcbuf, strlen(rcbuf), key, value, &tail);
+
+ if ((strncasecmp(section, "[dirs]", 6) == 0) && (strcasecmp(key, "home") == 0))
+ {
+ strncpy(homedir, value, sizeof(homedir));
+ break; /* done */
+ }
+ }
+
+ stat = 0;
+
+bugout:
+ if (inFile != NULL)
+ fclose(inFile);
+
+ return stat;
+}
+
+/* Find last occurance of y in x. */
+static char *strrstr(const char *x, const char *y)
+{
+ char *prev=NULL, *next;
+
+ if (*y == '\0')
+ return strchr(x, '\0');
+
+ while ((next = strstr(x, y)) != NULL)
+ {
+ prev = next;
+ x = next + 1;
+ }
+ return prev;
+}
+
+static int CopyLabel(char *label, char *buf, int bufSize)
+{
+ struct list_head *p;
+ LabelRecord *pl;
+ int i=0, found=0;
+
+ /* Look for label. */
+ list_for_each(p, &head.list)
+ {
+ pl = list_entry(p, LabelRecord, list);
+ if (strcasecmp(pl->name, label) == 0)
+ {
+ found = 1; /* found label */
+ break;
+ }
+ }
+
+ if (!found)
+ {
+ BUG("error undefined label %s\n", label);
+ goto bugout;
+ }
+
+ if (pl->valueSize > bufSize)
+ {
+ BUG("error label %s size=%d buf=%d\n", label, pl->valueSize, bufSize);
+ goto bugout;
+ }
+
+ memcpy(buf, pl->value, pl->valueSize);
+ i=pl->valueSize;
+
+bugout:
+ return i;
+}
+
+static int ResolveAttributes(FILE *fp, char *attr, int attrSize)
+{
+ char label[128];
+ int i=0, j, ch;
+
+ /* Process each key/value line. */
+ ch = fgetc(fp);
+ while (ch != EOF)
+ {
+ if (ch == '[')
+ {
+ ungetc(ch, fp); /* found new section, done with current section */
+ break;
+ }
+
+ if (ch == '#' || ch == ' ')
+ {
+ while ((ch = fgetc(fp)) != '\n' && ch != EOF); /* skip line */
+ }
+ else if (ch == '\n')
+ {
+ /* skip blank line */
+ }
+ else if (ch == '%')
+ {
+ j=0;
+ while ((ch = fgetc(fp)) != '\n' && ch != EOF) /* get label */
+ {
+ if (j < sizeof(label)-1)
+ label[j++] = ch;
+ }
+ label[j-1] = 0;
+ i += CopyLabel(label, attr+i, attrSize-i);
+ }
+ else
+ {
+ if (i < attrSize-1)
+ attr[i++] = ch;
+ while ((ch = fgetc(fp)) != '\n' && ch != EOF) /* get key/value line */
+ {
+ if (i < attrSize-1)
+ attr[i++] = ch;
+ }
+ if (i < attrSize-1)
+ attr[i++] = '\n';
+ }
+
+ if (ch == '\n')
+ ch = fgetc(fp); /* bump to next line */
+ continue;
+ }
+
+ attr[i] = 0; /* terminate string */
+
+ return i;
+}
+static int RegisterLabel(FILE *fp, char *incFile, char *label)
+{
+ struct list_head *p;
+ LabelRecord *pl;
+ char buf[SECTION_SIZE];
+ int i=0, stat=1, ch;
+
+ /* Look for duplicate label. */
+ list_for_each(p, &head.list)
+ {
+ pl = list_entry(p, LabelRecord, list);
+ if (strcasecmp(pl->name, label) == 0)
+ {
+ BUG("error duplicate label %s\n", label);
+ goto bugout;
+ }
+ }
+
+ if ((pl = (LabelRecord *)malloc(sizeof(LabelRecord))) == NULL)
+ {
+ BUG("unable to creat label record: %m\n");
+ goto bugout;
+ }
+
+ pl->incFile = strdup(incFile);
+ pl->name = strdup(label);
+
+ /* Process each key/value line. */
+ ch = fgetc(fp);
+ while (ch != EOF)
+ {
+ if (ch == '[')
+ {
+ ungetc(ch, fp); /* found new section, done with label */
+ break;
+ }
+
+ if (ch == '#' || ch == ' ')
+ {
+ while ((ch = fgetc(fp)) != '\n' && ch != EOF); /* skip line */
+ }
+ else if (ch == '\n')
+ {
+ /* skip blank line */
+ }
+ else
+ {
+ if (i < SECTION_SIZE-1)
+ buf[i++] = ch;
+ while ((ch = fgetc(fp)) != '\n' && ch != EOF) /* get key/value line */
+ {
+ if (i < SECTION_SIZE-1)
+ buf[i++] = ch;
+ }
+ if (i < SECTION_SIZE-1)
+ buf[i++] = '\n';
+ }
+
+ if (ch == '\n')
+ ch = fgetc(fp); /* bump to next line */
+ continue;
+ }
+
+ buf[i] = 0; /* terminate string */
+
+ pl->value = strdup(buf);
+ pl->valueSize = i; /* size does not include zero termination */
+
+ list_add(&(pl->list), &(head.list));
+ stat = 0;
+
+bugout:
+
+ return stat;
+}
+
+static int UnRegisterLabel(LabelRecord *pl)
+{
+ if (pl->incFile)
+ free(pl->incFile);
+ if (pl->name)
+ free(pl->name);
+ if (pl->value)
+ free(pl->value);
+ list_del(&(pl->list));
+ free(pl);
+ return 0;
+}
+
+static int DelList()
+{
+ struct list_head *p, *n;
+ LabelRecord *pl;
+
+ /* Remove each label. */
+ list_for_each_safe(p, n, &head.list)
+ {
+ pl = list_entry(p, LabelRecord, list);
+ UnRegisterLabel(pl);
+ }
+ return 0;
+}
+
+/* Parse *.inc file. */
+static int ParseInc(char *incFile)
+{
+ FILE *fp=NULL;
+ struct list_head *p;
+ LabelRecord *pl;
+ char rcbuf[255];
+ char section[128];
+ int stat=1, n;
+
+ /* Look for duplicate include file. */
+ list_for_each(p, &head.list)
+ {
+ pl = list_entry(p, LabelRecord, list);
+ if (strcmp(pl->incFile, incFile) == 0)
+ {
+ BUG("error duplicate include file %s\n", incFile);
+ goto bugout;
+ }
+ }
+
+ if ((fp = fopen(incFile, "r")) == NULL)
+ {
+ BUG("open %s failed: %m\n", incFile);
+ goto bugout;
+ }
+
+ section[0] = 0;
+
+ /* Read the *.inc file, check each line for new label. */
+ while ((fgets(rcbuf, sizeof(rcbuf), fp) != NULL))
+ {
+ if (rcbuf[0] == '[')
+ {
+ strncpy(section, rcbuf+1, sizeof(section)); /* found new section */
+ n = strlen(section);
+ section[n-2]=0; /* remove ']' and CR */
+ RegisterLabel(fp, incFile, section);
+ }
+ }
+
+ stat = 0;
+
+bugout:
+ if (fp)
+ fclose(fp);
+ return stat;
+}
+
+/* Parse *.dat file. */
+static int ParseFile(char *datFile, char *model, char *attr, int attrSize, int *bytes_read)
+{
+ FILE *fp;
+ char rcbuf[255];
+ char section[128];
+ char file[128];
+ int found=0, n;
+
+ if ((fp = fopen(datFile, "r")) == NULL)
+ goto bugout;
+
+ section[0] = 0;
+
+ /* Read the *.dat file, check each line for model match. */
+ while ((fgets(rcbuf, sizeof(rcbuf), fp) != NULL))
+ {
+ if (rcbuf[0] == '[')
+ {
+ strncpy(section, rcbuf+1, sizeof(section)); /* found new section */
+ n = strlen(section);
+ section[n-2]=0; /* remove ']' and CR */
+ if (strcasecmp(model, section) == 0)
+ {
+ /* Found model match. */
+ *bytes_read = ResolveAttributes(fp, attr, attrSize);
+ found = 1;
+ break;
+ }
+ }
+ else if (strncmp(rcbuf, "%include", 8) == 0)
+ {
+ strncpy(file, datFile, sizeof(file)); /* get dirname from *.dat file */
+ n = strrstr(file, "/") - file + 1;
+ strncpy(file+n, rcbuf+9, sizeof(file)-n); /* concatenate include filename to dirname */
+ n = strlen(file);
+ file[n-1]=0; /* remove CR */
+ ParseInc(file);
+ }
+ }
+
+bugout:
+ if (fp)
+ fclose(fp);
+
+ return found;
+}
+
+/* Parse and convert all known key value pairs in buffer. Do sanity check on values. */
+static int parse_key_value_pair(char *buf, int len, struct hpmud_model_attributes *ma)
+{
+ char key[HPMUD_LINE_SIZE];
+ char value[HPMUD_LINE_SIZE];
+ char *tail, *tail2;
+ int i=0, ret=HPMUD_R_OK;
+
+ ma->prt_mode = HPMUD_RAW_MODE;
+ ma->mfp_mode = HPMUD_DOT4_MODE;
+ ma->scantype = 0;
+ ma->statustype = HPMUD_STATUSTYPE_SFIELD;
+ ma->support = HPMUD_SUPPORT_TYPE_NONE;
+
+ if (buf == NULL)
+ return HPMUD_R_OK; /* initialize ma */
+
+ tail = buf;
+
+ while (i < len)
+ {
+ i += GetPair(tail, len-i, key, value, &tail);
+
+ if (strcasecmp(key, "io-mode") == 0)
+ {
+ ma->prt_mode = strtol(value, &tail2, 10); /* uni | raw | mlc */
+ }
+ else if (strcasecmp(key, "io-mfp-mode") == 0)
+ {
+ ma->mfp_mode = strtol(value, &tail2, 10); /* mfc | dot4 */
+ }
+ else if(strcasecmp(key, "scan-type") == 0)
+ {
+ ma->scantype = strtol(value, &tail2, 10); /*SCL, PML, SOAP, MARVELL, LEDM*/
+ }
+ else if(strcasecmp(key, "scan-src") == 0)
+ {
+ ma->scansrc = strtol(value, &tail2, 10); /*Flatbed, ADF, Camera or combination of these*/
+ }
+ else if(strcasecmp(key, "status-type") == 0)
+ {
+ ma->statustype = strtol(value, &tail2, 10);
+ }
+ else if(strcasecmp(key, "support-type") == 0)
+ {
+ ma->support = strtol(value, &tail2, 10);
+ }
+ else if(strcasecmp(key, "plugin") == 0)
+ {
+ ma->plugin = strtol(value, &tail2, 10);
+ }
+ else
+ {
+ /* Unknown keys are ignored (R_AOK). */
+ }
+ } // end while (i < len)
+
+ return ret;
+}
+
+/* Request device model attributes for URI. Return all attributes. */
+enum HPMUD_RESULT hpmud_get_model_attributes(char *uri, char *attr, int attrSize, int *bytes_read)
+{
+ char sz[256];
+ char model[256];
+ int found;
+ enum HPMUD_RESULT stat = HPMUD_R_DATFILE_ERROR;
+
+ memset(attr, 0, attrSize);
+
+ INIT_LIST_HEAD(&head.list);
+
+ if (homedir[0] == 0)
+ ReadConfig();
+
+ hpmud_get_uri_model(uri, model, sizeof(model));
+
+ /* Search /data/models.dat file for specified model. */
+ snprintf(sz, sizeof(sz), "%s/data/models/models.dat", homedir);
+ found = ParseFile(sz, model, attr, attrSize, bytes_read); /* save any labels in *.inc files */
+
+ if (!found)
+ {
+ BUG("no %s attributes found in %s\n", model, sz);
+
+ DelList(); /* Unregister all labels. */
+
+ /* Search /data/models/unreleased/unreleased.dat file for specified model. */
+ snprintf(sz, sizeof(sz), "%s/data/models/unreleased/unreleased.dat", homedir);
+ found = ParseFile(sz, model, attr, attrSize, bytes_read); /* save any *.inc files */
+ }
+
+ if (!found)
+ {
+ BUG("no %s attributes found in %s\n", model, sz);
+ goto bugout;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ DelList(); /* Unregister all labels. */
+ return stat;
+}
+
+/* Request device model attributes for URI. Return filled in hpmud_model_attributes structure. */
+enum HPMUD_RESULT hpmud_query_model(char *uri, struct hpmud_model_attributes *ma)
+{
+ char buf[SECTION_SIZE];
+ int len;
+ enum HPMUD_RESULT stat = HPMUD_R_DATFILE_ERROR;
+
+ parse_key_value_pair(NULL, 0, ma); /* set ma defaults */
+
+ if (hpmud_get_model_attributes(uri, buf, sizeof(buf), &len) != 0)
+ goto bugout; /* model not found, return ma defaults */
+
+ parse_key_value_pair(buf, len, ma);
+
+ stat=HPMUD_R_OK;
+
+bugout:
+
+ return stat;
+}
+
+/* Get value for specified section and key from hplip.conf. */
+enum HPMUD_RESULT hpmud_get_conf(const char *section, const char *key, char *value, int value_size)
+{
+ return hpmud_get_key_value(CONFDIR "/hplip.conf", section, key, value, value_size);
+}
+
+/* Get value for specified section and key from specified file. */
+enum HPMUD_RESULT hpmud_get_key_value(const char *file, const char *section, const char *key, char *value, int value_size)
+{
+ char new_key[HPMUD_LINE_SIZE];
+ char new_value[HPMUD_LINE_SIZE];
+ char rcbuf[255];
+ char new_section[32];
+ char *tail;
+ FILE *inFile;
+ enum HPMUD_RESULT stat = HPMUD_R_DATFILE_ERROR;
+ int i,j;
+
+ if((inFile = fopen(file, "r")) == NULL)
+ {
+ BUG("unable to open %s: %m\n", file);
+ goto bugout;
+ }
+
+ new_section[0] = 0;
+
+ /* Read the config file */
+ while ((fgets(rcbuf, sizeof(rcbuf), inFile) != NULL))
+ {
+ if (rcbuf[0] == '[')
+ {
+ i = j = 0;
+ while ((rcbuf[i] != ']') && (j < (sizeof(new_section)-2)))
+ new_section[j++] = rcbuf[i++];
+ new_section[j++] = rcbuf[i++]; /* ']' */
+ new_section[j] = 0; /* zero terminate */
+ continue;
+ }
+
+ GetPair(rcbuf, strlen(rcbuf), new_key, new_value, &tail);
+
+ if ((strcasecmp(new_section, section) == 0) && (strcasecmp(new_key, key) == 0))
+ {
+ strncpy(value, new_value, value_size);
+ stat = HPMUD_R_OK;
+ break; /* done */
+ }
+ }
+
+ if (stat != HPMUD_R_OK)
+ BUG("unable to find %s %s in %s\n", section, key, file);
+
+bugout:
+ if (inFile != NULL)
+ fclose(inFile);
+
+ return stat;
+}
+
diff --git a/io/hpmud/musb.c b/io/hpmud/musb.c
new file mode 100644
index 0000000..1649297
--- /dev/null
+++ b/io/hpmud/musb.c
@@ -0,0 +1,2197 @@
+/*****************************************************************************\
+
+ musb.c - USB support for multi-point transport driver
+
+ (c) 2010 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ Client/Server generic message format (see messaging-protocol.doc):
+
+ Author: Naga Samrat Chowdary Narla, Sarbeswar Meher
+\*****************************************************************************/
+
+#include "hpmud.h"
+#include "hpmudi.h"
+
+mud_device_vf __attribute__ ((visibility ("hidden"))) musb_mud_device_vf =
+{
+ .read = musb_read,
+ .write = musb_write,
+ .open = musb_open,
+ .close = musb_close,
+ .get_device_id = musb_get_device_id,
+ .get_device_status = musb_get_device_status,
+ .channel_open = musb_channel_open,
+ .channel_close = musb_channel_close,
+ .channel_write = musb_channel_write,
+ .channel_read = musb_channel_read
+};
+
+static mud_channel_vf musb_raw_channel_vf =
+{
+ .open = musb_raw_channel_open,
+ .close = musb_raw_channel_close,
+ .channel_write = musb_raw_channel_write,
+ .channel_read = musb_raw_channel_read
+};
+
+static mud_channel_vf musb_comp_channel_vf =
+{
+ .open = musb_comp_channel_open,
+ .close = musb_raw_channel_close,
+ .channel_write = musb_raw_channel_write,
+ .channel_read = musb_raw_channel_read
+};
+
+static mud_channel_vf musb_mlc_channel_vf =
+{
+ .open = musb_mlc_channel_open,
+ .close = musb_mlc_channel_close,
+ .channel_write = musb_mlc_channel_write,
+ .channel_read = musb_mlc_channel_read
+};
+
+static mud_channel_vf musb_dot4_channel_vf =
+{
+ .open = musb_dot4_channel_open,
+ .close = musb_dot4_channel_close,
+ .channel_write = musb_dot4_channel_write,
+ .channel_read = musb_dot4_channel_read
+};
+
+/*
+ * The folloing fd arrays must match "enum FD_ID" definition.
+ */
+
+static char *fd_name[MAX_FD] =
+{
+ "na",
+ "7/1/2",
+ "7/1/3",
+ "ff/1/1",
+ "ff/2/1",
+ "ff/3/1",
+ "ff/ff/ff",
+ "ff/d4/0",
+ "ff/4/1",
+ "ff/1/0",
+ "ff/cc/0",
+ "ff/2/10",
+};
+
+static int fd_class[MAX_FD] =
+{
+ 0,0x7,0x7,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+};
+
+static int fd_subclass[MAX_FD] =
+{
+ 0,0x1,0x1,0x1,0x2,0x3,0xff,0xd4,0x4,0x1,0xcc,0x2,
+};
+
+static int fd_protocol[MAX_FD] =
+{
+ 0,0x2,0x3,0x1,0x1,0x1,0xff,0,0x1,0,0,0x10,
+};
+
+static const unsigned char venice_power_on[] = {0x1b, '%','P','u','i','f','p','.','p','o','w','e','r',' ','1',';',
+ 'u','d','w','.','q','u','i','t',';',0x1b,'%','-','1','2','3','4','5','X' };
+
+static struct usb_device *libusb_device; /* libusb device referenced by URI */
+//static int open_fd; /* 7/1/2 file descriptor, used by deviceid and status */
+static file_descriptor fd_table[MAX_FD]; /* usb file descriptors */
+
+/* This function is similar to usb_get_string_simple, but it handles zero returns. */
+static int get_string_descriptor(usb_dev_handle *dev, int index, char *buf, size_t buflen)
+{
+ char tbuf[255]; /* Some devices choke on size > 255 */
+ int ret, si, di, cnt=5;
+
+ while (cnt--)
+ {
+ ret = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index,
+ 0x409, tbuf, sizeof(tbuf), LIBUSB_CONTROL_REQ_TIMEOUT);
+ if (ret==0)
+ {
+ /* This retry is necessary for lj1000 and lj1005. des 12/12/07 */
+ BUG("get_string_descriptor zero result, retrying...");
+ continue;
+ }
+ break;
+ }
+
+ if (ret < 0)
+ {
+ BUG("unable get_string_descriptor %d: %m\n", ret);
+ return ret;
+ }
+
+ if (tbuf[1] != USB_DT_STRING)
+ {
+ BUG("invalid get_string_descriptor tag act=%d exp=%d\n", tbuf[1], USB_DT_STRING);
+ return -EIO;
+ }
+
+ if (tbuf[0] > ret)
+ {
+ BUG("invalid get_string_descriptor size act=%d exp=%d\n", tbuf[0], ret);
+ return -EFBIG;
+ }
+
+ for (di = 0, si = 2; si < tbuf[0]; si += 2)
+ {
+ if (di >= (buflen - 1))
+ break;
+
+ if (tbuf[si + 1]) /* high byte */
+ buf[di++] = '0';
+ else
+ buf[di++] = tbuf[si];
+ }
+
+ buf[di] = 0;
+
+ return di;
+}
+
+/* Check for USB interface descriptor with specified class. */
+static int is_interface(struct usb_device *dev, int dclass)
+{
+ struct usb_interface_descriptor *pi;
+ int i, j, k;
+
+ for (i=0; i<dev->descriptor.bNumConfigurations; i++)
+ {
+ for (j=0; j<dev->config[i].bNumInterfaces; j++)
+ {
+ for (k=0; k<dev->config[i].interface[j].num_altsetting; k++)
+ {
+ pi = &dev->config[i].interface[j].altsetting[k];
+ if (pi->bInterfaceClass == dclass)
+ {
+ return 1; /* found interface */
+ }
+ }
+ }
+ }
+ return 0; /* no interface found */
+}
+
+/* Write HP vendor-specific ECP channel message. */
+static int write_ecp_channel(file_descriptor *pfd, int value)
+{
+ usb_dev_handle *hd;
+ int interface = pfd->interface;
+ int len, stat=1;
+ char byte;
+
+ if (pfd->hd == NULL)
+ {
+ BUG("invalid write_ecp_channel state\n");
+ goto bugout;
+ }
+
+ hd = pfd->hd;
+
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, /* bmRequestType */
+ USB_REQ_GET_STATUS, /* bRequest */
+ value, /* wValue */
+ interface, /* wIndex */
+ &byte, 1, LIBUSB_CONTROL_REQ_TIMEOUT);
+
+ if (len != 1)
+ {
+ BUG("invalid write_ecp_channel: %m\n");
+ goto bugout;
+ }
+
+ stat = 0;
+
+bugout:
+ return stat;
+}
+
+/* Set Cypress USS-725 Bridge Chip to 1284.4 mode. */
+static int bridge_chip_up(file_descriptor *pfd)
+{
+ usb_dev_handle *hd;
+ int len, stat=1;
+ char buf[9];
+ char nullByte=0;
+
+ if (pfd->hd == NULL)
+ {
+ BUG("invalid bridge_chip_up state\n");
+ goto bugout;
+ }
+
+ hd = pfd->hd;
+
+ memset(buf, 0, sizeof(buf));
+
+ /* Read register values. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ USB_REQ_SET_FEATURE, /* bRequest */
+ 0, /* wValue */
+ 0, /* wIndex */
+ buf, sizeof(buf), LIBUSB_CONTROL_REQ_TIMEOUT);
+ if (len < 0)
+ {
+ BUG("invalid write_bridge_up: %m\n");
+ goto bugout;
+ }
+
+ /* Check for auto ECP mode. */
+ if (buf[ECRR] != 0x43)
+ {
+ /* Place 725 chip in register mode. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x0758, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ /* Turn off RLE in auto ECP mode. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x0a1d, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ /* Place 725 chip in auto ECP mode. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x0759, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ /* Force negotiation. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x0817, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ /* Read register values. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ USB_REQ_SET_FEATURE, /* bRequest */
+ 0, /* wValue */
+ 0, /* wIndex */
+ buf, sizeof(buf), LIBUSB_CONTROL_REQ_TIMEOUT);
+ if (buf[ECRR] != 0x43)
+ {
+ BUG("invalid auto ecp mode mode=%d\n", buf[ECRR]);
+ }
+ }
+
+ /* Reset to ECP channel 0. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x05ce, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ musb_write(pfd->fd, &nullByte, 1, HPMUD_EXCEPTION_TIMEOUT);
+
+ /* Switch to ECP channel 77. */
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x05cd, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+
+ stat = 0;
+
+bugout:
+ return stat;
+}
+
+/* Set Cypress USS-725 Bridge Chip to compatibility mode. */
+static int bridge_chip_down(file_descriptor *pfd)
+{
+ usb_dev_handle *hd;
+ int len, stat=1;
+
+ if (pfd->hd == NULL)
+ {
+ BUG("invalid bridge_chip_down state\n");
+ goto bugout;
+ }
+
+ hd = pfd->hd;
+
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, /* bmRequestType */
+ 0x04, /* bRequest */
+ 0x080f, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+ if (len < 0)
+ {
+ BUG("invalid write_bridge_up: %m\n");
+ goto bugout;
+ }
+
+ stat = 0;
+
+bugout:
+ return stat;
+}
+
+/* Write HP vendor-specific Setup command. */
+static int write_phoenix_setup(file_descriptor *pfd)
+{
+ usb_dev_handle *hd;
+ int len, stat=1;
+
+ if (pfd->hd == NULL)
+ {
+ BUG("invalid write_phoenix_setup state\n");
+ goto bugout;
+ }
+
+ hd = pfd->hd;
+
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_OUT | USB_TYPE_CLASS | USB_RECIP_OTHER, /* bmRequestType */
+ 0x02, /* bRequest */
+ 0, /* wValue */
+ 0, /* wIndex */
+ NULL, 0, LIBUSB_CONTROL_REQ_TIMEOUT);
+
+ if (len < 0)
+ {
+ BUG("invalid write_phoenix_setup: %m\n");
+ goto bugout;
+ }
+
+ stat = 0;
+
+bugout:
+ return stat;
+}
+
+/* Detach any kernel module that may have claimed specified inteface. */
+static int detach(usb_dev_handle *hd, int interface)
+{
+ char driver[32];
+
+ driver[0] = 0;
+
+#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
+ /* If any kernel module (ie:usblp) has claimed this interface, detach it. */
+ usb_get_driver_np(hd, interface, driver, sizeof(driver));
+ if ((driver[0] != 0) && (strcasecmp(driver, "usbfs") != 0))
+ {
+ DBG("removing %s driver interface=%d\n", driver, interface);
+ if (usb_detach_kernel_driver_np(hd, interface) < 0)
+ BUG("could not remove %s driver interface=%d: %m\n", driver, interface);
+ }
+#endif
+
+ return 0;
+}
+
+/* Get interface descriptor for specified xx/xx/xx protocol. */
+static int get_interface(struct usb_device *dev, enum FD_ID index, file_descriptor *pfd)
+{
+ struct usb_interface_descriptor *pi;
+ int i, j, k;
+
+ for (i=0; i<dev->descriptor.bNumConfigurations; i++)
+ {
+ if (dev->config == NULL)
+ goto bugout;
+
+ for (j=0; j<dev->config[i].bNumInterfaces; j++)
+ {
+ if (dev->config[i].interface == NULL)
+ goto bugout;
+
+ for (k=0; k<dev->config[i].interface[j].num_altsetting; k++)
+ {
+ if (dev->config[i].interface[j].altsetting == NULL)
+ goto bugout;
+
+ pi = &dev->config[i].interface[j].altsetting[k];
+ if (pi->bInterfaceClass == fd_class[index] && pi->bInterfaceSubClass == fd_subclass[index] && pi->bInterfaceProtocol == fd_protocol[index])
+ {
+ pfd->config=i; /* found interface */
+ pfd->interface=j;
+ pfd->alt_setting=k;
+ pfd->fd=index;
+ return 0;
+ }
+ }
+ }
+ }
+
+bugout:
+ return 1; /* no interface found */
+}
+
+/* Get out endpoint for specified interface descriptor. */
+static int get_out_ep(struct usb_device *dev, int config, int interface, int altset, int type)
+{
+ struct usb_interface_descriptor *pi;
+ int i;
+
+ if (dev->config == NULL || dev->config[config].interface == NULL || dev->config[config].interface[interface].altsetting == NULL)
+ goto bugout;
+
+ pi = &dev->config[config].interface[interface].altsetting[altset];
+ for (i=0; i<pi->bNumEndpoints; i++)
+ {
+ if (pi->endpoint == NULL)
+ goto bugout;
+ if (pi->endpoint[i].bmAttributes == type && !(pi->endpoint[i].bEndpointAddress & USB_ENDPOINT_DIR_MASK)) {
+ DBG("get_out_ep(type=%d): out=%d\n", type, pi->endpoint[i].bEndpointAddress);
+ return pi->endpoint[i].bEndpointAddress;
+ }
+ }
+
+bugout:
+ DBG("get_out_ep: ERROR! returning -1\n");
+ return -1; /* no endpoint found */
+}
+
+/* Get in endpoint for specified interface descriptor. */
+static int get_in_ep(struct usb_device *dev, int config, int interface, int altset, int type)
+{
+ struct usb_interface_descriptor *pi;
+ int i;
+
+ if (dev->config == NULL || dev->config[config].interface == NULL || dev->config[config].interface[interface].altsetting == NULL)
+ goto bugout;
+
+ pi = &dev->config[config].interface[interface].altsetting[altset];
+ for (i=0; i<pi->bNumEndpoints; i++)
+ {
+ if (pi->endpoint == NULL)
+ goto bugout;
+ if (pi->endpoint[i].bmAttributes == type && (pi->endpoint[i].bEndpointAddress & USB_ENDPOINT_DIR_MASK)) {
+ DBG("get_in_ep(type=%d): out=%d\n", type, pi->endpoint[i].bEndpointAddress);
+ return pi->endpoint[i].bEndpointAddress;
+ }
+ }
+
+bugout:
+ DBG("get_in_ep: ERROR! returning -1\n");
+ return -1; /* no endpoint found */
+}
+
+static int claim_interface(struct usb_device *dev, file_descriptor *pfd)
+{
+ int stat=1;
+
+ if (pfd->hd != NULL)
+ return 0; /* interface is already claimed */
+
+ if ((pfd->hd = usb_open(dev)) == NULL)
+ {
+ BUG("invalid usb_open: %m\n");
+ goto bugout;
+ }
+
+ detach(pfd->hd, pfd->interface);
+
+#if 0 /* hp devices only have one configuration, so far ... */
+ if (usb_set_configuration(FD[fd].pHD, dev->config[config].bConfigurationValue))
+ goto bugout;
+#endif
+
+ if (usb_claim_interface(pfd->hd, pfd->interface))
+ {
+ usb_close(pfd->hd);
+ pfd->hd = NULL;
+ DBG("invalid claim_interface %s: %m\n", fd_name[pfd->fd]);
+ goto bugout;
+ }
+
+ if (usb_set_altinterface(pfd->hd, pfd->alt_setting))
+ {
+ usb_release_interface(pfd->hd, pfd->interface);
+ usb_close(pfd->hd);
+ pfd->hd = NULL;
+ BUG("invalid set_altinterface %s altset=%d: %m\n", fd_name[pfd->fd], pfd->alt_setting);
+ goto bugout;
+ }
+
+ pfd->write_active=0;
+ pthread_mutex_init(&pfd->mutex, NULL);
+ pthread_cond_init(&pfd->write_done_cond, NULL);
+
+ DBG("claimed %s interface\n", fd_name[pfd->fd]);
+
+ stat=0;
+
+bugout:
+ return stat;
+}
+
+static int release_interface(file_descriptor *pfd)
+{
+ if (pfd->hd == NULL)
+ return 0;
+
+ if (pfd->write_active)
+ {
+ BUG("aborting outstanding %s write\n", fd_name[pfd->fd]);
+ pthread_cancel(pfd->tid); /* kill outstanding write */
+ pfd->write_active = 0;
+ }
+
+ usb_release_interface(pfd->hd, pfd->interface);
+ usb_close(pfd->hd);
+ pfd->hd = NULL;
+ pthread_mutex_destroy(&pfd->mutex);
+ pthread_cond_destroy(&pfd->write_done_cond);
+
+ DBG("released %s interface\n", fd_name[pfd->fd]);
+
+ return 0;
+}
+
+/* Claim any open interface which is valid for device_id and device status. */
+static int claim_id_interface(struct usb_device *dev)
+{
+ enum FD_ID i;
+
+ for (i=FD_7_1_2; i!=MAX_FD; i++)
+ {
+ if (get_interface(dev, i, &fd_table[i]) == 0)
+ {
+ if (claim_interface(libusb_device, &fd_table[i]))
+ continue; /* interface is busy, try next interface */
+ break; /* done */
+ }
+ }
+
+ return i;
+}
+
+/* See if this usb device and URI match. */
+static int is_uri(struct usb_device *dev, const char *uri)
+{
+ usb_dev_handle *hd=NULL;
+ char sz[128];
+ char uriModel[128];
+ char uriSerial[128];
+ char gen[128];
+ int r, stat=0;
+
+ if ((hd = usb_open(dev)) == NULL)
+ {
+ BUG("invalid usb_open: %m\n");
+ goto bugout;
+ }
+
+ if (dev->descriptor.idVendor != 0x3f0)
+ goto bugout;
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iProduct, sz, sizeof(sz))) < 0)
+ {
+ BUG("invalid product id string ret=%d\n", r);
+ goto bugout;
+ }
+
+ generalize_model(sz, gen, sizeof(gen));
+
+ hpmud_get_uri_model(uri, uriModel, sizeof(uriModel));
+ if (strcasecmp(uriModel, gen) != 0)
+ goto bugout;
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iSerialNumber, sz, sizeof(sz))) < 0)
+ {
+ BUG("invalid serial id string ret=%d\n", r);
+ goto bugout;
+ }
+
+ if (sz[0])
+ generalize_serial(sz, gen, sizeof(gen));
+ else
+ strcpy(gen, "0");
+
+ get_uri_serial(uri, uriSerial, sizeof(uriSerial));
+ if (strcmp(uriSerial, gen) != 0)
+ goto bugout;
+
+ stat = 1; /* found usb device that matches uri */
+
+bugout:
+ if (hd != NULL)
+ usb_close(hd);
+
+ return stat;
+}
+
+/* See if this usb device and serial number match. Return model if match. */
+static int is_serial(struct usb_device *dev, const char *sn, char *model, int model_size)
+{
+ usb_dev_handle *hd=NULL;
+ char sz[128];
+ char gen[128];
+ int r, stat=0;
+
+ if ((hd = usb_open(dev)) == NULL)
+ {
+ BUG("invalid usb_open: %m\n");
+ goto bugout;
+ }
+
+ if (dev->descriptor.idVendor != 0x3f0)
+ goto bugout; /* not a HP product */
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iSerialNumber, sz, sizeof(sz))) < 0)
+ {
+ BUG("invalid serial id string ret=%d\n", r);
+ goto bugout;
+ }
+ if (sz[0])
+ generalize_serial(sz, gen, sizeof(gen));
+ else
+ strcpy(gen, "0");
+
+ if (strncmp(sn, gen, sizeof(gen)) != 0)
+ goto bugout; /* match failed */
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iProduct, sz, sizeof(sz))) < 0)
+ {
+ BUG("invalid product id string ret=%d\n", r);
+ goto bugout;
+ }
+ generalize_model(sz, model, model_size);
+
+ stat = 1; /* found usb device that matches sn */
+
+bugout:
+ if (hd != NULL)
+ usb_close(hd);
+
+ return stat;
+}
+
+static struct usb_device *get_libusb_device(const char *uri)
+{
+ struct usb_bus *bus;
+ struct usb_device *dev;
+
+ for (bus=usb_busses; bus; bus=bus->next)
+ for (dev=bus->devices; dev; dev=dev->next)
+ if (dev->descriptor.idVendor == 0x3f0 && is_interface(dev, 7))
+ if (is_uri(dev, uri))
+ return dev; /* found usb device that matches uri */
+
+ return NULL;
+}
+
+static int device_id(int fd, char *buffer, int size)
+{
+ usb_dev_handle *hd;
+ int config,interface,alt;
+ int len=0, rlen, maxSize;
+
+ hd = fd_table[fd].hd;
+ config = fd_table[fd].config;
+ interface = fd_table[fd].interface;
+ alt = fd_table[fd].alt_setting;
+
+ if (hd == NULL)
+ {
+ BUG("invalid device_id state\n");
+ goto bugout;
+ }
+
+ maxSize = (size > 1024) ? 1024 : size; /* RH8 has a size limit for device id (usb) */
+
+ rlen = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, /* bmRequestType */
+ USB_REQ_GET_STATUS, /* bRequest */
+ config, /* wValue */
+ interface, /* wIndex */ /* note firmware does not follow the USB Printer Class specification for wIndex */
+ buffer, maxSize, LIBUSB_CONTROL_REQ_TIMEOUT);
+
+ if (rlen < 0)
+ {
+#if 0 /* Removed this PS A420 hack so a valid error is returned after USB reset. DES 10/1/09 */
+ /* Following retry is necessary for a firmware problem with PS A420 products. DES 4/17/07 */
+ BUG("invalid deviceid wIndex=%x, retrying wIndex=%x: %m\n", interface, interface << 8);
+ rlen = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, /* bmRequestType */
+ USB_REQ_GET_STATUS, /* bRequest */
+ config, /* wValue */
+ interface << 8, /* wIndex */
+ buffer, maxSize, LIBUSB_CONTROL_REQ_TIMEOUT);
+ if (rlen < 0)
+ {
+ BUG("invalid deviceid retry ret=%d: %m\n", rlen);
+ goto bugout;
+ }
+#endif
+ BUG("invalid deviceid ret=%d: %m\n", rlen);
+ goto bugout;
+ }
+
+ len = ntohs(*(short *)buffer);
+ if (len > (size-1))
+ len = size-1; /* leave byte for zero termination */
+ if (len > 2)
+ len -= 2;
+ memcpy(buffer, buffer+2, len); /* remove length */
+ buffer[len]=0;
+ DBG("read actual device_id successfully fd=%d len=%d\n", fd, len);
+
+bugout:
+ return len; /* length does not include zero termination */
+}
+
+static int device_status(int fd, unsigned int *status)
+{
+ usb_dev_handle *hd;
+ int interface;
+ int len, stat=1;
+ char byte;
+
+ hd = fd_table[fd].hd;
+ interface = fd_table[fd].interface;
+
+ if (hd == NULL)
+ {
+ BUG("invalid device_status state\n");
+ goto bugout;
+ }
+
+ len = usb_control_msg(hd,
+ USB_ENDPOINT_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, /* bmRequestType */
+ USB_REQ_CLEAR_FEATURE, /* bRequest */
+ 0, /* wValue */
+ interface, /* wIndex */
+ &byte, 1, LIBUSB_CONTROL_REQ_TIMEOUT);
+
+ if (len < 0)
+ {
+ BUG("invalid device_status: %m\n");
+ goto bugout;
+ }
+
+ *status = (unsigned int)byte;
+ stat = 0;
+ DBG("read actual device_status successfully fd=%d\n", fd);
+
+bugout:
+ return stat;
+}
+
+/* Get VStatus from S-field. */
+static int sfield_printer_state(const char *id)
+{
+ char *pSf;
+ int vstatus=0, ver;
+
+ if ((pSf = strstr(id, ";S:")) == NULL)
+ {
+ BUG("invalid S-field\n");
+ return vstatus;
+ }
+
+ /* Valid S-field, get version number. */
+ pSf+=3;
+ ver = 0;
+ HEX2INT(*pSf, ver);
+ pSf++;
+ ver = ver << 4;
+ HEX2INT(*pSf, ver);
+ pSf++;
+
+ /* Position pointer to printer state subfield. */
+ switch (ver)
+ {
+ case 0:
+ case 1:
+ case 2:
+ pSf+=12;
+ break;
+ case 3:
+ pSf+=14;
+ break;
+ case 4:
+ pSf+=18;
+ break;
+ default:
+ BUG("unknown S-field version=%d\n", ver);
+ pSf+=12;
+ break;
+ }
+
+ /* Extract VStatus.*/
+ vstatus = 0;
+ HEX2INT(*pSf, vstatus);
+ pSf++;
+ vstatus = vstatus << 4;
+ HEX2INT(*pSf, vstatus);
+
+ return vstatus;
+}
+
+/*
+ * Power up printer if necessary. Most all-in-ones have no power down state (ie: OJ K80), so they are already powered up.
+ * Newer single function printers power-up with the print job. May be called by other mud_device.
+ */
+int __attribute__ ((visibility ("hidden"))) power_up(mud_device *pd, int fd)
+{
+ const char *pSf;
+
+ if ((pSf = strstr(pd->id, "CMD:LDL")) != NULL)
+ return 0; /* crossbow don't do power-up */
+
+ if ((pSf = strstr(pd->id, ";S:")) != NULL)
+ {
+ if (sfield_printer_state(pd->id) != 3)
+ return 0; /* already powered up */
+ }
+ else if ((pSf = strstr(pd->id, "VSTATUS:")) != NULL)
+ {
+ /* DJ895C returns $XB0$XC0 (unknown pens) when powered off. */
+ if (!(strstr(pSf+8, "OFFF") || strstr(pSf+8, "PWDN") || strstr(pSf+8, "$X")))
+ return 0; /* already powered up */
+ }
+ else
+ return 0; /* must be laserjet, don't do power-up */
+
+ (pd->vf.write)(fd, venice_power_on, sizeof(venice_power_on), HPMUD_EXCEPTION_TIMEOUT);
+ sleep(2);
+
+ return 0;
+}
+
+/* Create channel object given the requested socket id and service name. */
+static int new_channel(mud_device *pd, int index, const char *sn)
+{
+ int stat=1;
+
+ /* Check for existing name service already open. */
+ if (pd->channel[index].client_cnt)
+ {
+#if 0
+ if (index == HPMUD_EWS_CHANNEL)
+ {
+ pd->channel[index].client_cnt++; /* allow multiple clients for separate USB interfaces only */
+ stat = 0;
+ DBG("reused %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+ }
+ else
+#endif
+ BUG("%s channel=%d is busy, used by [%d], clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].pid, pd->channel[index].client_cnt, pd->channel_cnt);
+ goto bugout;
+ }
+
+ if (index == HPMUD_EWS_CHANNEL || index == HPMUD_EWS_LEDM_CHANNEL ||
+ index == HPMUD_SOAPSCAN_CHANNEL || index == HPMUD_SOAPFAX_CHANNEL ||
+ index == HPMUD_MARVELL_SCAN_CHANNEL || index == HPMUD_MARVELL_FAX_CHANNEL ||
+ index == HPMUD_LEDM_SCAN_CHANNEL) {
+ pd->channel[index].vf = musb_comp_channel_vf;
+ }
+ else if (pd->io_mode == HPMUD_RAW_MODE || pd->io_mode == HPMUD_UNI_MODE) {
+ pd->channel[index].vf = musb_raw_channel_vf;
+ }
+ else if (pd->io_mode == HPMUD_MLC_GUSHER_MODE || pd->io_mode == HPMUD_MLC_MISER_MODE) {
+ pd->channel[index].vf = musb_mlc_channel_vf;
+ }
+ else {
+ pd->channel[index].vf = musb_dot4_channel_vf;
+ }
+
+ pd->channel[index].index = index;
+ pd->channel[index].client_cnt = 1;
+ pd->channel[index].sockid = index; /* static socket id is valid for MLC but not 1284.4 */
+ pd->channel[index].pid = getpid();
+ pd->channel[index].dindex = pd->index;
+ pd->channel[index].fd = 0;
+ strcpy(pd->channel[index].sn, sn);
+ pd->channel_cnt++;
+
+ stat = 0;
+ DBG("new %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+
+bugout:
+ return stat;
+}
+
+/* Remove channel object given the channel decriptor. */
+static int del_channel(mud_device *pd, mud_channel *pc)
+{
+ pc->client_cnt--;
+
+ if (pc->client_cnt <= 0)
+ {
+ pd->channel_cnt--;
+ }
+ DBG("removed %s channel=%d clientCnt=%d channelCnt=%d\n", pc->sn, pc->index, pc->client_cnt, pd->channel_cnt);
+ return 0;
+}
+
+static void write_thread(file_descriptor *pfd)
+{
+ int ep;
+
+ pthread_detach(pthread_self());
+
+ if ((ep = get_out_ep(libusb_device, pfd->config, pfd->interface, pfd->alt_setting, USB_ENDPOINT_TYPE_BULK)) < 0)
+ {
+ BUG("invalid bulk out endpoint\n");
+ goto bugout;
+ }
+
+ /* Wait forever for write to complete (actually 72 hours in ms). */
+ pfd->write_return = usb_bulk_write(pfd->hd, ep, (char *)pfd->write_buf, pfd->write_size, 72*3600*1000);
+
+bugout:
+ pthread_mutex_lock(&pfd->mutex);
+ pfd->write_buf = NULL;
+ pthread_cond_signal(&pfd->write_done_cond); /* signal write is complete */
+ pthread_mutex_unlock(&pfd->mutex);
+
+ return;
+}
+
+/*********************************************************************************************************************************
+ * USB mud_device functions.
+ */
+
+int __attribute__ ((visibility ("hidden"))) musb_write(int fd, const void *buf, int size, int usec)
+{
+ int len=-EIO;
+
+ if (fd_table[fd].hd == NULL)
+ {
+ BUG("invalid musb_write state\n");
+ goto bugout;
+ }
+
+#if 1
+ struct timeval now;
+ struct timespec timeout;
+ int ret;
+ /* If write is still active, probably OOP condition, don't kick off a new write. */
+ if (!fd_table[fd].write_active)
+ {
+ fd_table[fd].write_active = 1;
+ fd_table[fd].write_buf = buf;
+ fd_table[fd].write_size = size;
+
+ /* Create usb_bulk_write thread so we can use our own timeout. Otherwise we cannot handle OOP condition. */
+ if (pthread_create(&fd_table[fd].tid, NULL, (void *(*)(void*))write_thread, (void *)&fd_table[fd]) != 0)
+ {
+ BUG("unable to creat write_thread: %m\n");
+ goto bugout; /* bail */
+ }
+ }
+
+ /* Wait for write to complete. */
+ pthread_mutex_lock(&fd_table[fd].mutex);
+ gettimeofday(&now, NULL);
+ now.tv_usec += usec;
+ now.tv_sec += now.tv_usec / 1000000;
+ now.tv_usec %= 1000000;
+ timeout.tv_sec = now.tv_sec;
+ timeout.tv_nsec = now.tv_usec * 1000;
+ ret = 0;
+ while (fd_table[fd].write_buf && ret != ETIMEDOUT)
+ ret = pthread_cond_timedwait(&fd_table[fd].write_done_cond, &fd_table[fd].mutex, &timeout);
+ pthread_mutex_unlock(&fd_table[fd].mutex);
+
+ if (ret == ETIMEDOUT)
+ {
+ len = -ETIMEDOUT; /* write timeout, let client know */
+ goto bugout;
+ }
+
+ fd_table[fd].write_active = 0;
+
+ len = fd_table[fd].write_return;
+#else
+ int ep;
+ if ((ep = get_out_ep(libusb_device, fd_table[fd].config, fd_table[fd].interface, fd_table[fd].alt_setting, USB_ENDPOINT_TYPE_BULK)) < 0)
+ {
+ BUG("invalid bulk out endpoint\n");
+ goto bugout;
+ }
+
+ len = usb_bulk_write(fd_table[fd].hd, ep, (char *)buf, size, usec);
+#endif
+
+ if (len < 0)
+ {
+ BUG("bulk_write failed buf=%p size=%d len=%d: %m\n", buf, size, len);
+ goto bugout;
+ }
+
+ DBG("write fd=%d len=%d size=%d usec=%d\n", fd, len, size, usec);
+ DBG_DUMP(buf, len < 512 ? len : 512);
+
+bugout:
+ return len;
+}
+
+int __attribute__ ((visibility ("hidden"))) musb_read(int fd, void *buf, int size, int usec)
+{
+ struct timeval t1, t2;
+ int total_usec, tmo_usec=usec;
+ int len=-EIO, ep;
+
+ if (fd_table[fd].hd == NULL)
+ {
+ BUG("invalid musb_read state\n");
+ goto bugout;
+ }
+
+ gettimeofday (&t1, NULL); /* get start time */
+
+ if ((ep = get_in_ep(libusb_device, fd_table[fd].config, fd_table[fd].interface, fd_table[fd].alt_setting, USB_ENDPOINT_TYPE_BULK)) < 0)
+ {
+ BUG("invalid bulk in endpoint\n");
+ goto bugout;
+ }
+
+ while (1)
+ {
+ len = usb_bulk_read(fd_table[fd].hd, ep, (char *)buf, size, tmo_usec/1000);
+
+ if (len == -ETIMEDOUT)
+ goto bugout;
+
+ if (len < 0)
+ {
+ BUG("bulk_read failed: %m\n");
+ goto bugout;
+ }
+
+ if (len == 0)
+ {
+ /* Bulk_read has a timeout, but bulk_read can return zero byte packet(s), so we must use our own timeout here. */
+ gettimeofday(&t2, NULL); /* get current time */
+
+ total_usec = (t2.tv_sec - t1.tv_sec)*1000000;
+ total_usec += (t2.tv_usec > t1.tv_usec) ? t2.tv_usec - t1.tv_usec : t1.tv_usec - t2.tv_usec;
+ if (total_usec > usec)
+ {
+ len = -ETIMEDOUT; /* timeout */
+ goto bugout;
+ }
+ tmo_usec = usec - total_usec; /* decrease timeout */
+ continue;
+ }
+
+ break;
+ }
+
+ DBG("read fd=%d len=%d size=%d usec=%d\n", fd, len, size, usec);
+ DBG_DUMP(buf, len < 32 ? len : 32);
+
+bugout:
+ return len;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_open(mud_device *pd)
+{
+ int len=0, fd=0;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ usb_init();
+ usb_find_busses();
+ usb_find_devices();
+
+ /* Find usb device for specified uri. */
+ if ((libusb_device = get_libusb_device(pd->uri)) == NULL)
+ {
+ BUG("unable to open %s\n", pd->uri);
+ goto bugout;
+ }
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (pd->id[0] == 0)
+ {
+ /* First client. */
+
+ if ((fd = claim_id_interface(libusb_device)) == MAX_FD)
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ goto blackout;
+ }
+
+ len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+
+ if (len > 0 && is_hp(pd->id))
+ power_up(pd, fd);
+
+ release_interface(&fd_table[fd]);
+
+ if (len == 0)
+ goto blackout;
+
+ pd->open_fd = fd;
+ }
+
+ stat = HPMUD_R_OK;
+
+blackout:
+ pthread_mutex_unlock(&pd->mutex);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_close(mud_device *pd)
+{
+ int i;
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ for (i=1; i<MAX_FD; i++)
+ {
+ if (fd_table[i].hd != NULL)
+ release_interface(&fd_table[i]);
+ }
+
+ pd->id[0] = 0;
+
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_get_device_id(mud_device *pd, char *buf, int size, int *len)
+{
+ int i, fd=FD_NA;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+
+ *len=0;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (pd->io_mode == HPMUD_DOT4_BRIDGE_MODE || pd->io_mode == HPMUD_UNI_MODE)
+ {
+ *len = strlen(pd->id); /* usb/parallel bridge chip, use cached copy */
+ }
+ else
+ {
+ /* See if any interface is already claimed. */
+ for (i=1; i<MAX_FD; i++)
+ {
+ if (fd_table[i].hd != NULL)
+ {
+ fd = i;
+ break;
+ }
+ }
+
+ if (fd == FD_NA)
+ {
+ /* Device not in use. Claim interface, but release for other processes. */
+ if ((fd = claim_id_interface(libusb_device)) != MAX_FD)
+ {
+ *len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+ release_interface(&fd_table[fd]);
+ }
+ else
+ {
+ /* Device is in use by another process, return cache copy. */
+ *len = strlen(pd->id);
+ }
+ }
+ else
+ {
+ /* Device in use by current process, leave interface up. Other processes are blocked. */
+ *len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+ }
+ }
+
+ if (*len)
+ {
+ memcpy(buf, pd->id, *len > size ? size : *len);
+ stat = HPMUD_R_OK;
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_get_device_status(mud_device *pd, unsigned int *status)
+{
+ int i, fd=FD_NA;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+ int r=1;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (pd->io_mode == HPMUD_DOT4_BRIDGE_MODE || pd->io_mode == HPMUD_UNI_MODE)
+ *status = NFAULT_BIT; /* usb/parallel bridge chip, fake status */
+ else
+ {
+ /* See if any interface is already claimed. */
+ for (i=1; i<MAX_FD; i++)
+ {
+ if (fd_table[i].hd != NULL)
+ {
+ fd = i;
+ break;
+ }
+ }
+
+ if (fd == FD_NA)
+ {
+ /* Device not in use. Claim interface, but release for other processes. */
+ if ((fd = claim_id_interface(libusb_device)) != MAX_FD)
+ {
+ r = device_status(fd, status);
+ release_interface(&fd_table[fd]);
+ }
+ }
+ else
+ {
+ /* Device in use by current process, leave interface up. Other processes are blocked. */
+ r = device_status(fd, status);
+ }
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+
+ if (r != 0)
+ goto bugout;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_write(mud_device *pd, mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ enum HPMUD_RESULT stat;
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.channel_write)(pc, buf, length, sec_timeout, bytes_wrote);
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_read(mud_device *pd, mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ enum HPMUD_RESULT stat;
+
+ if (pd->io_mode == HPMUD_UNI_MODE)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid channel_read io_mode=%d\n", pd->io_mode);
+ goto bugout;
+ }
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.channel_read)(pc, buf, length, sec_timeout, bytes_read);
+ pthread_mutex_unlock(&pd->mutex);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_open(mud_device *pd, const char *sn, HPMUD_CHANNEL *cd)
+{
+ int index;
+ enum HPMUD_RESULT stat;
+
+ /* Check for valid service requests. */
+ if ((stat = service_to_channel(pd, sn, &index)) != HPMUD_R_OK)
+ goto bugout;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (new_channel(pd, index, sn))
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ }
+ else
+ {
+ if ((stat = (pd->channel[index].vf.open)(&pd->channel[index])) != HPMUD_R_OK) /* call transport specific open */
+ del_channel(pd, &pd->channel[index]); /* open failed, cleanup */
+ else
+ *cd = index;
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_close(mud_device *pd, mud_channel *pc)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.close)(pc); /* call trasport specific close */
+ del_channel(pd, pc);
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * USB raw_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_open(mud_channel *pc)
+{
+ int fd = FD_7_1_2;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+
+ get_interface(libusb_device, fd, &fd_table[fd]);
+
+ if (claim_interface(libusb_device, &fd_table[fd]))
+ goto bugout;
+
+ pc->fd = fd;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_close(mud_channel *pc)
+{
+ int fd = pc->fd;
+
+ // For New laserjet devices like Tsunami, end point was getting stall or halted, hence clearing it
+ int ep = -1;
+ if (( ep = get_in_ep(libusb_device, fd_table[fd].config, fd_table[fd].interface, fd_table[fd].alt_setting, USB_ENDPOINT_TYPE_BULK)) >= 0)
+ {
+ usb_clear_halt(fd_table[fd].hd, ep);
+ }
+
+ if (( ep = get_out_ep(libusb_device, fd_table[fd].config, fd_table[fd].interface, fd_table[fd].alt_setting, USB_ENDPOINT_TYPE_BULK)) >= 0)
+ {
+ usb_clear_halt(fd_table[fd].hd, ep);
+ }
+
+ release_interface(&fd_table[fd]);
+
+ pc->fd = 0;
+
+ return HPMUD_R_OK;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_write(mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ int len, size, total=0;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_wrote=0;
+ size = length;
+
+ while (size > 0)
+ {
+ len = (msp->device[pc->dindex].vf.write)(pc->fd, buf+total, size, sec_timeout*1000000);
+ if (len < 0)
+ {
+ if (len == -ETIMEDOUT)
+ {
+ stat = HPMUD_R_IO_TIMEOUT;
+ if (sec_timeout >= HPMUD_EXCEPTION_SEC_TIMEOUT)
+ BUG("unable to write data %s: %d second io timeout\n", msp->device[pc->dindex].uri, sec_timeout);
+ }
+ else
+ BUG("unable to write data %s: %m\n", msp->device[pc->dindex].uri);
+ goto bugout;
+ }
+ size-=len;
+ total+=len;
+ *bytes_wrote+=len;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*
+ * Channel_read() tries to read "length" bytes from the peripheral. The returned read count may be zero
+ * (timeout, no data available), less than "length" or equal "length".
+ */
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_read(mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ int len=0, usec;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_read = 0;
+
+ if (sec_timeout==0)
+ usec = 1000; /* minmum timeout is 1ms for libusb 0.1.12, hangs forever with zero */
+ else
+ usec = sec_timeout*1000000;
+
+ len = (msp->device[pc->dindex].vf.read)(pc->fd, buf, length, usec);
+ if (len < 0)
+ {
+ if (len == -ETIMEDOUT)
+ {
+ stat = HPMUD_R_IO_TIMEOUT;
+ if (sec_timeout >= HPMUD_EXCEPTION_SEC_TIMEOUT)
+ BUG("unable to read data %s: %d second io timeout\n", msp->device[pc->dindex].uri, sec_timeout);
+ }
+ else
+ BUG("unable to read data %s: %m\n", msp->device[pc->dindex].uri);
+ goto bugout;
+ }
+
+ *bytes_read = len;
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * USB comp_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_comp_channel_open(mud_channel *pc)
+{
+ int fd;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+
+ /* Get requested composite interface. */
+ switch (pc->index)
+ {
+ case HPMUD_EWS_CHANNEL:
+ fd = FD_ff_1_1;
+ break;
+ case HPMUD_EWS_LEDM_CHANNEL:
+ fd = FD_ff_4_1;
+ break;
+ case HPMUD_SOAPSCAN_CHANNEL:
+ fd = FD_ff_2_1;
+ break;
+ case HPMUD_SOAPFAX_CHANNEL:
+ fd = FD_ff_3_1;
+ break;
+ case HPMUD_MARVELL_SCAN_CHANNEL:
+ fd = FD_ff_ff_ff;
+ break;
+ case HPMUD_MARVELL_FAX_CHANNEL: //using vendor specific C/S/P codes for fax too
+ fd = FD_ff_1_0;
+ break;
+ case HPMUD_LEDM_SCAN_CHANNEL: //using vendor specific C/S/P codes for fax too
+ fd = FD_ff_cc_0;
+ break;
+ default:
+ stat = HPMUD_R_INVALID_SN;
+ BUG("invalid %s channel=%d\n", pc->sn, pc->index);
+ goto bugout;
+ break;
+ }
+
+ if (get_interface(libusb_device, fd, &fd_table[fd]))
+ {
+ stat = HPMUD_R_INVALID_SN;
+ BUG("invalid %s channel=%d\n", pc->sn, pc->index);
+ goto bugout;
+ }
+
+ if (claim_interface(libusb_device, &fd_table[fd]))
+ goto bugout;
+
+ pc->fd = fd;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * USB mlc_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum FD_ID fd;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ /* Initialize MLC transport if this is the first MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (get_interface(libusb_device, FD_7_1_3, &fd_table[FD_7_1_3]) == 0 && claim_interface(libusb_device, &fd_table[FD_7_1_3]) == 0)
+ fd = FD_7_1_3; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_ff_ff_ff, &fd_table[FD_ff_ff_ff]) == 0 && claim_interface(libusb_device, &fd_table[FD_ff_ff_ff]) == 0)
+ fd = FD_ff_ff_ff; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_ff_d4_0, &fd_table[FD_ff_d4_0]) == 0 && claim_interface(libusb_device, &fd_table[FD_ff_d4_0]) == 0)
+ fd = FD_ff_d4_0; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_7_1_2, &fd_table[FD_7_1_2]) == 0 && claim_interface(libusb_device, &fd_table[FD_7_1_2]) == 0)
+ fd = FD_7_1_2; /* raw, mlc, dot4 */
+ else
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ goto bugout;
+ }
+
+ if (fd == FD_7_1_2)
+ {
+ /* Emulate 7/1/3 on 7/1/2 using vendor-specific ECP channel-77. */
+ if (write_ecp_channel(&fd_table[fd], 77))
+ goto bugout;
+ }
+
+ unsigned int i;
+#if 0
+// Removed reverse drain I seen it hang forever on read, one-time with PSC750 (FC5 64-bit). DES
+ int len;
+ unsigned char buf[255];
+
+ /* Drain any reverse data. */
+ for (i=0,len=1; len > 0 && i < sizeof(buf); i++)
+ len = (pd->vf.read)(fd, buf+i, 1, 0); /* no blocking */
+#endif
+
+ /* MLC initialize */
+ if (MlcInit(pc, fd) != 0)
+ goto bugout;
+
+ /* Reset transport attributes for all channels. */
+ for (i=0; i<HPMUD_CHANNEL_MAX; i++)
+ memset(&pd->channel[i].ta, 0 , sizeof(transport_attributes));
+
+ pd->mlc_fd = fd;
+ pd->mlc_up=1;
+
+ } /* if (pDev->ChannelCnt==1) */
+
+ if (MlcConfigSocket(pc, pd->mlc_fd))
+ goto bugout;
+
+ if (MlcOpenChannel(pc, pd->mlc_fd))
+ goto bugout;
+
+ pc->rcnt = pc->rindex = 0;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_close(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ unsigned char nullByte=0;
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ if (pd->mlc_up)
+ {
+ if (MlcCloseChannel(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+
+ /* Remove MLC transport if this is the last MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (pd->mlc_up)
+ {
+ if (MlcExit(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+ pd->mlc_up=0;
+
+ if (pd->mlc_fd == FD_7_1_2)
+ {
+ write_ecp_channel(&fd_table[pd->mlc_fd], 78);
+ (pd->vf.write)(pd->mlc_fd, &nullByte, 1, HPMUD_EXCEPTION_TIMEOUT);
+ write_ecp_channel(&fd_table[pd->mlc_fd], 0);
+ }
+
+ release_interface(&fd_table[pd->mlc_fd]);
+
+ /* Delay for back-to-back scanning using scanimage (OJ 7110, OJ d135). */
+ sleep(1);
+ }
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_write(mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int ret, len, size, dlen, total=0;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_wrote=0;
+ size = length;
+ dlen = pc->ta.h2psize - sizeof(MLCHeader);
+ while (size > 0)
+ {
+ len = (size > dlen) ? dlen : size;
+
+ if (pc->ta.h2pcredit == 0 && pd->io_mode == HPMUD_MLC_MISER_MODE)
+ {
+ if (MlcCreditRequest(pc, pd->mlc_fd, 1)) /* Miser flow control */
+ {
+ BUG("invalid MlcCreditRequest from peripheral\n");
+ goto bugout;
+ }
+ }
+
+ if (pc->ta.h2pcredit == 0)
+ {
+ ret = MlcReverseCmd(pc, pd->mlc_fd);
+ if (pc->ta.h2pcredit == 0)
+ {
+ if (ret == 0)
+ continue; /* Got a reverse command, but no MlcCredit, try again. */
+
+ if (pd->io_mode != HPMUD_MLC_MISER_MODE)
+ {
+ /* If miser flow control works for this device, set "miser" in models.dat. */
+ BUG("invalid MlcCredit from peripheral, trying miser\n");
+ pd->io_mode = HPMUD_MLC_MISER_MODE;
+ continue;
+ }
+
+ BUG("invalid MlcCredit from peripheral\n");
+ goto bugout;
+ }
+ }
+
+ if (MlcForwardData(pc, pd->mlc_fd, buf+total, len, sec_timeout*1000000))
+ {
+ goto bugout;
+ }
+
+ pc->ta.h2pcredit--;
+ size-=len;
+ total+=len;
+ *bytes_wrote+=len;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*
+ * Mlc_channel_read() tries to read "length" bytes from the peripheral. ReadData() reads data in packet size chunks.
+ * The returned read count may be zero (timeout, no data available), less than "length" or equal "length".
+ *
+ * Mlc_channel_read() may read more the "length" if the data packet is greater than "length". For this case the
+ * return value will equal "length" and the left over data will be buffered for the next ReadData() call.
+ *
+ * The "timeout" specifies how many seconds to wait for a data packet. Once the read of the data packet has
+ * started the "timeout" is no longer used.
+ *
+ * Note, if a "timeout" occurs one peripheral to host credit is left outstanding. Which means the peripheral
+ * can send unsolicited data later.
+ */
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_read(mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_read=0;
+ if (pc->ta.p2hsize==0)
+ {
+ BUG("invalid channel_read state\n");
+ goto bugout;
+ }
+
+ if (pc->rcnt)
+ {
+ stat=HPMUD_R_OK;
+ *bytes_read = cut_buf(pc, buf, length);
+ goto bugout;
+ }
+
+ if (pc->ta.p2hcredit == 0)
+ {
+ /* Issue enough credit to the peripheral to read one data packet. */
+ if (MlcCredit(pc, pd->mlc_fd, 1))
+ goto bugout;
+ }
+
+ stat=HPMUD_R_OK;
+ pc->rcnt = MlcReverseData(pc, pd->mlc_fd, pc->rbuf, sizeof(pc->rbuf), sec_timeout*1000000);
+ if (pc->rcnt)
+ pc->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+
+ *bytes_read = cut_buf(pc, buf, length);
+
+bugout:
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * USB dot4_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum FD_ID fd;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ /* Initialize MLC transport if this is the first MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (get_interface(libusb_device, FD_7_1_3, &fd_table[FD_7_1_3]) == 0 && claim_interface(libusb_device, &fd_table[FD_7_1_3]) == 0)
+ fd = FD_7_1_3; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_ff_ff_ff, &fd_table[FD_ff_ff_ff]) == 0 && claim_interface(libusb_device, &fd_table[FD_ff_ff_ff]) == 0)
+ fd = FD_ff_ff_ff; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_ff_d4_0, &fd_table[FD_ff_d4_0]) == 0 && claim_interface(libusb_device, &fd_table[FD_ff_d4_0]) == 0)
+ fd = FD_ff_d4_0; /* mlc, dot4 */
+ else if (get_interface(libusb_device, FD_7_1_2, &fd_table[FD_7_1_2]) == 0 && claim_interface(libusb_device, &fd_table[FD_7_1_2]) == 0)
+ fd = FD_7_1_2; /* raw, mlc, dot4 */
+ else
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ goto bugout;
+ }
+
+ if (fd == FD_7_1_2)
+ {
+ if (pd->io_mode == HPMUD_DOT4_BRIDGE_MODE)
+ {
+ /* Emulate 7/1/3 on 7/1/2 using the bridge chip set (ie: CLJ2500). */
+ if (bridge_chip_up(&fd_table[fd]))
+ goto bugout;
+ }
+ else
+ {
+ /* Emulate 7/1/3 on 7/1/2 using vendor-specific ECP channel-77. */
+ if (write_ecp_channel(&fd_table[fd], 77))
+ goto bugout;
+ }
+ }
+
+ if (pd->io_mode == HPMUD_DOT4_PHOENIX_MODE)
+ write_phoenix_setup(&fd_table[fd]);
+
+ unsigned int i;
+#if 0
+// Removed reverse drain LJ1015 can hang forever on read (FC5 64-bit). DES
+ unsigned char buf[255];
+ int len;
+
+ /* Drain any reverse data. */
+ for (i=0,len=1; len > 0 && i < sizeof(buf); i++)
+ len = (pd->vf.read)(fd, buf+i, 1, 0); /* no blocking */
+#endif
+ /* DOT4 initialize */
+ if (Dot4Init(pc, fd) != 0)
+ goto bugout;
+
+ /* Reset transport attributes for all channels. */
+ for (i=0; i<HPMUD_CHANNEL_MAX; i++)
+ memset(&pd->channel[i].ta, 0 , sizeof(transport_attributes));
+
+ pd->mlc_fd = fd;
+ pd->mlc_up=1;
+
+ } /* if (pDev->ChannelCnt==1) */
+
+ if (Dot4GetSocket(pc, pd->mlc_fd))
+ goto bugout;
+
+ if (Dot4OpenChannel(pc, pd->mlc_fd))
+ goto bugout;
+
+ if (pd->io_mode == HPMUD_DOT4_PHOENIX_MODE)
+ {
+ /* Issue credit to peripheral. */
+ if (Dot4Credit(pc, pd->mlc_fd, 2))
+ {
+ BUG("invalid Dot4Credit to peripheral\n");
+ goto bugout;
+ }
+ }
+
+ pc->rcnt = pc->rindex = 0;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_close(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ if (pd->mlc_up)
+ {
+ if (Dot4CloseChannel(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+
+ /* Remove 1284.4 transport if this is the last 1284.4 channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (pd->mlc_up)
+ {
+ if (Dot4Exit(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+ pd->mlc_up=0;
+
+ if (pd->mlc_fd == FD_7_1_2)
+ {
+ if (pd->io_mode == HPMUD_DOT4_BRIDGE_MODE)
+ {
+ bridge_chip_down(&fd_table[pd->mlc_fd]);
+ }
+ else
+ {
+ write_ecp_channel(&fd_table[pd->mlc_fd], 78);
+ write_ecp_channel(&fd_table[pd->mlc_fd], 0);
+ }
+ }
+
+ release_interface(&fd_table[pd->mlc_fd]);
+
+ /* Delay for back-to-back scanning using scanimage (OJ 7110, OJ d135). */
+ sleep(1);
+ }
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_write(mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ int ret, len, size, dlen, total=0, cnt=0;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_wrote=0;
+ size = length;
+ dlen = pc->ta.h2psize - sizeof(DOT4Header);
+ while (size > 0)
+ {
+ len = (size > dlen) ? dlen : size;
+
+ if (pc->ta.h2pcredit == 0 && pd->io_mode == HPMUD_DOT4_PHOENIX_MODE)
+ {
+ /* Issue credit request to peripheral. */
+ if (Dot4CreditRequest(pc, pd->mlc_fd, 1))
+ {
+ BUG("invalid Dot4CreditRequest from peripheral\n");
+ goto bugout;
+ }
+ if (pc->ta.h2pcredit == 0)
+ {
+ if (cnt++ > HPMUD_EXCEPTION_SEC_TIMEOUT)
+ {
+ BUG("invalid Dot4CreditRequest from peripheral\n");
+ goto bugout;
+ }
+ sleep(1);
+ continue; /* Got a valid Dot4CreditRequest but no credit from peripheral, try again. */
+ }
+ }
+
+ if (pc->ta.h2pcredit == 0)
+ {
+ ret = Dot4ReverseCmd(pc, pd->mlc_fd);
+ if (pc->ta.h2pcredit == 0)
+ {
+ if (ret == 0)
+ continue; /* Got a reverse command, but no Dot4Credit, try again. */
+
+ BUG("invalid Dot4Credit from peripheral\n");
+ goto bugout;
+ }
+ }
+
+ if (Dot4ForwardData(pc, pd->mlc_fd, buf+total, len, sec_timeout*1000000))
+ {
+ goto bugout;
+ }
+
+ pc->ta.h2pcredit--;
+ size-=len;
+ total+=len;
+ *bytes_wrote+=len;
+ cnt=0;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+/*
+ * dot4_read_data() tries to read "length" bytes from the peripheral. Read_data() reads data in packet size chunks.
+ * The returned read count may be zero (timeout, no data available), less than "length" or equal "length".
+ *
+ * dot4_read_data() may read more the "length" if the data packet is greater than "length". For this case the
+ * return value will equal "length" and the left over data will be buffered for the next read_data() call.
+ *
+ * The "timeout" specifies how many seconds to wait for a data packet. Once the read of the data packet has
+ * started the "timeout" is no longer used.
+ *
+ * Note, if a "timeout" occurs one peripheral to host credit is left outstanding. Which means the peripheral
+ * can send unsolicited data later.
+ */
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_read(mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ *bytes_read=0;
+ if (pc->ta.p2hsize==0)
+ {
+ BUG("invalid channel_read state\n");
+ goto bugout;
+ }
+
+ if (pc->rcnt)
+ {
+ stat=HPMUD_R_OK;
+ *bytes_read = cut_buf(pc, buf, length);
+ goto bugout;
+ }
+
+ if (pc->ta.p2hcredit == 0)
+ {
+ /* Issue enough credit to the peripheral to read one data packet. */
+ if (Dot4Credit(pc, pd->mlc_fd, 1))
+ goto bugout;
+ }
+
+ stat=HPMUD_R_OK;
+ pc->rcnt = Dot4ReverseData(pc, pd->mlc_fd, pc->rbuf, sizeof(pc->rbuf), sec_timeout*1000000);
+ if (pc->rcnt)
+ pc->ta.p2hcredit--; /* one data packet was read, decrement credit count */
+
+ *bytes_read = cut_buf(pc, buf, length);
+
+bugout:
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * USB probe devices, walk the USB bus(s) looking for HP products.
+ */
+
+int __attribute__ ((visibility ("hidden"))) musb_probe_devices(char *lst, int lst_size, int *cnt)
+{
+ struct usb_bus *bus;
+ struct usb_device *dev;
+ usb_dev_handle *hd;
+ struct hpmud_model_attributes ma;
+ char rmodel[128];
+ char rserial[128];
+ char model[128];
+ char serial[128];
+ char mfg[128];
+ char sz[HPMUD_LINE_SIZE];
+ int r, size=0;
+
+ usb_init();
+ usb_find_busses();
+ usb_find_devices();
+
+ for (bus=usb_busses; bus; bus=bus->next)
+ {
+ for (dev=bus->devices; dev; dev=dev->next)
+ {
+
+ model[0] = serial[0] = rmodel[0] = rserial[0] = sz[0] = mfg[0] = 0;
+
+ if (dev->descriptor.idVendor == 0x3f0 && is_interface(dev, 7))
+ {
+ if((hd = usb_open(dev)) == NULL)
+ {
+ BUG("Invalid usb_open: %m\n");
+ continue;
+ }
+ /* Found hp device. */
+ if ((r=get_string_descriptor(hd, dev->descriptor.iProduct, rmodel, sizeof(rmodel))) < 0)
+ BUG("invalid product id string ret=%d\n", r);
+ else
+ generalize_model(rmodel, model, sizeof(model));
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iSerialNumber, rserial, sizeof(rserial))) < 0)
+ BUG("invalid serial id string ret=%d\n", r);
+ else
+ generalize_serial(rserial, serial, sizeof(serial));
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iManufacturer, sz, sizeof(sz))) < 0)
+ BUG("invalid manufacturer string ret=%d\n", r);
+ else
+ generalize_serial(sz, mfg, sizeof(serial));
+
+ if (!serial[0])
+ strcpy(serial, "0"); /* no serial number, make it zero */
+
+ if (model[0])
+ {
+ snprintf(sz, sizeof(sz), "hp:/usb/%s?serial=%s", model, serial);
+
+ /* See if device is supported by hplip. */
+ hpmud_query_model(sz, &ma);
+ if (ma.support != HPMUD_SUPPORT_TYPE_HPLIP)
+ {
+ BUG("ignoring %s support=%d\n", sz, ma.support);
+ continue; /* ignor, not supported */
+ }
+
+ /*
+ * For Cups 1.2 we append a dummy deviceid. A valid deviceid would require us to claim the USB interface, thus removing usblp.
+ * This will allow us to do discovery and not disable other CUPS backend(s) who use /dev/usb/lpx instead of libusb.
+ */
+ if (strncasecmp(rmodel, "hp ", 3) == 0)
+ size += snprintf(lst+size, lst_size-size, "direct %s \"HP %s\" \"HP %s USB %s HPLIP\" \"MFG:%s;MDL:%s;CLS:PRINTER;DES:%s;SN:%s;\"\n",
+ sz, &rmodel[3], &rmodel[3], serial, mfg, rmodel, rmodel, rserial);
+ else
+ size += snprintf(lst+size, lst_size-size, "direct %s \"HP %s\" \"HP %s USB %s HPLIP\" \"MFG:%s;MDL:%s;CLS:PRINTER;DES:%s;SN:%s;\"\n",
+ sz, rmodel, rmodel, serial, mfg, rmodel, rmodel, rserial);
+
+ *cnt+=1;
+ }
+ usb_close(hd);
+ }
+ }
+ }
+
+ return size;
+}
+
+enum HPMUD_RESULT hpmud_make_usb_uri(const char *busnum, const char *devnum, char *uri, int uri_size, int *bytes_read)
+{
+ struct usb_bus *bus;
+ struct usb_device *dev, *found_dev=NULL;
+ usb_dev_handle *hd=NULL;
+ char model[128];
+ char serial[128];
+ char sz[256];
+ int r;
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_DEVICE_NODE;
+
+ DBG("[%d] hpmud_make_usb_uri() bus=%s dev=%s\n", getpid(), busnum, devnum);
+
+ *bytes_read=0;
+
+ usb_init();
+ usb_find_busses();
+ usb_find_devices();
+
+ for (bus=usb_busses; bus && !found_dev; bus=bus->next)
+ if (strcmp(bus->dirname, busnum) == 0)
+ for (dev=bus->devices; dev && !found_dev; dev=dev->next)
+ if (strcmp(dev->filename, devnum) == 0)
+ found_dev = dev; /* found usb device that matches bus:device */
+
+ if (found_dev == NULL)
+ {
+ BUG("invalid busnum:devnum %s:%s\n", busnum, devnum);
+ goto bugout;
+ }
+
+ dev = found_dev;
+ if ((hd = usb_open(dev)) == NULL)
+ {
+ BUG("invalid usb_open: %m\n");
+ goto bugout;
+ }
+
+ model[0] = serial[0] = sz[0] = 0;
+
+ if (dev->descriptor.idVendor == 0x3f0)
+ {
+ /* Found hp device. */
+ if ((r=get_string_descriptor(hd, dev->descriptor.iProduct, sz, sizeof(sz))) < 0)
+ BUG("invalid product id string ret=%d\n", r);
+ else
+ generalize_model(sz, model, sizeof(model));
+
+ if ((r=get_string_descriptor(hd, dev->descriptor.iSerialNumber, sz, sizeof(sz))) < 0)
+ BUG("invalid serial id string ret=%d\n", r);
+ else
+ generalize_serial(sz, serial, sizeof(serial));
+
+ if (!serial[0])
+ strcpy(serial, "0"); /* no serial number, make it zero */
+ }
+ else
+ {
+ BUG("invalid vendor id: %d\n", dev->descriptor.idVendor);
+ goto bugout;
+ }
+
+ if (!model[0] || !serial[0])
+ goto bugout;
+
+ *bytes_read = snprintf(uri, uri_size, "hp:/usb/%s?serial=%s", model, serial);
+ stat = HPMUD_R_OK;
+
+bugout:
+ if (hd != NULL)
+ usb_close(hd);
+
+ return stat;
+}
+
+enum HPMUD_RESULT hpmud_make_usb_serial_uri(const char *sn, char *uri, int uri_size, int *bytes_read)
+{
+ struct usb_bus *bus;
+ struct usb_device *dev, *found_dev=NULL;
+ char model[128];
+ enum HPMUD_RESULT stat = HPMUD_R_INVALID_DEVICE_NODE;
+
+ DBG("[%d] hpmud_make_usb_serial_uri() sn=%s\n", getpid(), sn);
+
+ *bytes_read=0;
+
+ usb_init();
+ usb_find_busses();
+ usb_find_devices();
+
+ for (bus=usb_busses; bus && !found_dev; bus=bus->next)
+ for (dev=bus->devices; dev && !found_dev; dev=dev->next)
+ if (is_serial(dev, sn, model, sizeof(model)))
+ found_dev = dev; /* found usb device that matches serial number */
+
+ if (found_dev == NULL)
+ {
+ BUG("invalid sn %s\n", sn);
+ goto bugout;
+ }
+
+ *bytes_read = snprintf(uri, uri_size, "hp:/usb/%s?serial=%s", model, sn);
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
diff --git a/io/hpmud/musb.h b/io/hpmud/musb.h
new file mode 100644
index 0000000..df4a8a6
--- /dev/null
+++ b/io/hpmud/musb.h
@@ -0,0 +1,121 @@
+/*****************************************************************************\
+
+ musb.h - USB support for multi-point transport driver
+
+ (c) 2010 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ Author: Naga Samrat Chowdary Narla
+\*****************************************************************************/
+
+#ifndef _MUSB_H
+#define _MUSB_H
+
+#include <usb.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+#define LIBUSB_TIMEOUT 30000 /* milliseconds */
+#define LIBUSB_CONTROL_REQ_TIMEOUT 5000
+
+enum FD_ID
+{
+ FD_NA=0,
+ FD_7_1_2, /* bi-di interface */
+ FD_7_1_3, /* 1284.4 interface */
+ FD_ff_1_1, /* HP EWS interface */
+ FD_ff_2_1, /* HP Soap Scan interface */
+ FD_ff_3_1, /* HP Soap Fax interface */
+ FD_ff_ff_ff, /* HP dot4 interface */
+ FD_ff_d4_0, /* HP dot4 interface */
+ FD_ff_4_1, /* orblite scan / rest scan interface */
+ FD_ff_1_0, /* Marvell fax support*/
+ FD_ff_cc_0,
+ FD_ff_2_10,
+ MAX_FD
+};
+
+enum BRIGE_REG_ID
+{
+ ECRR=2,
+ CCTR=3,
+ ATAA=8
+};
+
+/* USB file descriptor, one for each USB protocol. */
+typedef struct
+{
+ usb_dev_handle *hd;
+ enum FD_ID fd;
+ int config;
+ int interface;
+ int alt_setting;
+
+ /* Write thread definitions. */
+ int write_active; /* 0=no, 1=yes */
+ const void *write_buf;
+ int write_size;
+ int write_return; /* return value, normally number bytes written */
+ pthread_t tid;
+ pthread_mutex_t mutex;
+ pthread_cond_t write_done_cond;
+
+ unsigned char ubuf[HPMUD_BUFFER_SIZE]; /* usb read packet buffer */
+ int uindex;
+ int ucnt;
+} file_descriptor;
+
+struct _mud_device;
+struct _mud_channel;
+
+extern struct _mud_device_vf __attribute__ ((visibility ("hidden"))) musb_mud_device_vf;
+
+int __attribute__ ((visibility ("hidden"))) musb_write(int fd, const void *buf, int size, int usec_timout);
+int __attribute__ ((visibility ("hidden"))) musb_read(int fd, void *buf, int size, int usec_timout);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_open(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_close(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_get_device_id(struct _mud_device *pd, char *buf, int size, int *len);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_get_device_status(struct _mud_device *pd, unsigned int *status);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_open(struct _mud_device *pd, const char *sn, HPMUD_CHANNEL *cd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_close(struct _mud_device *pd, struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_write(struct _mud_device *pd, struct _mud_channel *pc, const void *buf, int length, int timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_channel_read(struct _mud_device *pd, struct _mud_channel *pc, void *buf, int length, int timeout, int *bytes_read);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_write(struct _mud_channel *pc, const void *buf, int length, int timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_raw_channel_read(struct _mud_channel *pc, void *buf, int length, int timeout, int *bytes_wrote);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_comp_channel_open(struct _mud_channel *pc);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_write(struct _mud_channel *pc, const void *buf, int length, int timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_mlc_channel_read(struct _mud_channel *pc, void *buf, int length, int timeout, int *bytes_wrote);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_write(struct _mud_channel *pc, const void *buf, int length, int sec_timeout, int *bytes_wrote);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) musb_dot4_channel_read(struct _mud_channel *pc, void *buf, int length, int sec_timeout, int *bytes_read);
+
+int __attribute__ ((visibility ("hidden"))) musb_probe_devices(char *lst, int lst_size, int *cnt);
+int __attribute__ ((visibility ("hidden"))) power_up(struct _mud_device *pd, int fd);
+
+#endif // _MUSB_H
+
diff --git a/io/hpmud/pml.c b/io/hpmud/pml.c
new file mode 100644
index 0000000..a84a9a2
--- /dev/null
+++ b/io/hpmud/pml.c
@@ -0,0 +1,520 @@
+/*****************************************************************************\
+
+ pml.c - get/set pml api for hpmud
+
+ The get/set pml commands are a high level interface to hpmud. This hpmud system
+ interface sits on top of the hpmud core interface. The system interface does
+ not use the hpmud memory map file system.
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+#ifdef HAVE_LIBNETSNMP
+#ifdef HAVE_UCDSNMP
+#include <ucd-snmp/ucd-snmp-config.h>
+#include <ucd-snmp/ucd-snmp-includes.h>
+#else
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#endif
+static const char *SnmpPort[] = { "","public.1","public.2","public.3" };
+#endif
+
+static int PmlOidToHex(const char *szoid, unsigned char *oid, int oidSize)
+{
+ char *tail;
+ int i=0, val;
+
+ if (szoid[0] == 0)
+ goto bugout;
+
+ val = strtol(szoid, &tail, 10);
+
+ while (i < oidSize)
+ {
+ if (val > 128)
+ {
+ BUG("invalid oid size: oid=%s\n", szoid);
+ goto bugout;
+ }
+ oid[i++] = (unsigned char)val;
+
+ if (*tail == 0)
+ break; /* done */
+
+ val = strtol(tail+1, &tail, 10);
+ }
+
+bugout:
+ return i;
+}
+
+/* Convert ascii snmp oid to pml hex oid. */
+static int SnmpToPml(const char *snmp_oid, unsigned char *oid, int oidSize)
+{
+ static const char hp_pml_mib_prefix[] = "1.3.6.1.4.1.11.2.3.9.4.2";
+ static const char standard_printer_mib_prefix[] = "1.3.6.1.2.1.43";
+ static const char host_resource_mib_prefix[] = "1.3.6.1.2.1.25";
+ int len=0;
+
+ if (strncmp(snmp_oid, hp_pml_mib_prefix, sizeof(hp_pml_mib_prefix)-1) == 0)
+ {
+ /* Strip out snmp prefix and convert to hex. */
+ len = 0;
+ len += PmlOidToHex(&snmp_oid[sizeof(hp_pml_mib_prefix)], &oid[0], oidSize);
+ len--; /* remove trailing zero in pml mib */
+ }
+ else if (strncmp(snmp_oid, standard_printer_mib_prefix, sizeof(standard_printer_mib_prefix)-1) == 0)
+ {
+ /* Replace snmp prefix with 2 and convert to hex. */
+ len = 1;
+ oid[0] = 0x2;
+ len += PmlOidToHex(&snmp_oid[sizeof(standard_printer_mib_prefix)], &oid[1], oidSize);
+ }
+ else if (strncmp(snmp_oid, host_resource_mib_prefix, sizeof(host_resource_mib_prefix)-1) == 0)
+ {
+ /* Replace snmp prefix with 3 and convert to hex. */
+ len = 1;
+ oid[0] = 0x3;
+ len += PmlOidToHex(&snmp_oid[sizeof(host_resource_mib_prefix)], &oid[1], oidSize);
+ }
+ else
+ BUG("SnmpToPml failed snmp oid=%s\n", snmp_oid);
+
+ return len;
+}
+
+#ifdef HAVE_LIBNETSNMP
+
+static int SnmpErrorToPml(int snmp_error)
+{
+ int err;
+
+ switch (snmp_error)
+ {
+ case SNMP_ERR_NOERROR:
+ err = PML_EV_OK;
+ break;
+ case SNMP_ERR_TOOBIG:
+ err = PML_EV_ERROR_BUFFER_OVERFLOW;
+ break;
+ case SNMP_ERR_NOSUCHNAME:
+ err = PML_EV_ERROR_UNKNOWN_OBJECT_IDENTIFIER;
+ break;
+ case SNMP_ERR_BADVALUE:
+ err = PML_EV_ERROR_INVALID_OR_UNSUPPORTED_VALUE;
+ break;
+ case SNMP_ERR_READONLY:
+ err = PML_EV_ERROR_OBJECT_DOES_NOT_SUPPORT_REQUESTED_ACTION;
+ break;
+ case SNMP_ERR_GENERR:
+ default:
+ err = PML_EV_ERROR_UNKNOWN_REQUEST;
+ break;
+ }
+
+ return err;
+}
+
+static int SetSnmp(const char *ip, int port, const char *szoid, int type, void *buffer, unsigned int size, int *pml_result, int *result)
+{
+ struct snmp_session session, *ss=NULL;
+ struct snmp_pdu *pdu=NULL;
+ struct snmp_pdu *response=NULL;
+ oid anOID[MAX_OID_LEN];
+ size_t anOID_len = MAX_OID_LEN;
+ unsigned int i, len=0;
+ uint32_t val;
+
+ *result = HPMUD_R_IO_ERROR;
+ *pml_result = PML_EV_ERROR_UNKNOWN_REQUEST;
+
+ init_snmp("snmpapp");
+
+ snmp_sess_init(&session ); /* set up defaults */
+ session.peername = (char *)ip;
+ session.version = SNMP_VERSION_1;
+ session.community = (unsigned char *)SnmpPort[port];
+ session.community_len = strlen((const char *)session.community);
+ ss = snmp_open(&session); /* establish the session */
+ if (ss == NULL)
+ goto bugout;
+
+ pdu = snmp_pdu_create(SNMP_MSG_SET);
+ read_objid(szoid, anOID, &anOID_len);
+
+ switch (type)
+ {
+ case PML_DT_ENUMERATION:
+ case PML_DT_SIGNED_INTEGER:
+ /* Convert PML big-endian to SNMP little-endian byte stream. */
+ for(i=0, val=0; i<size && i<sizeof(val); i++)
+ val = ((val << 8) | ((unsigned char *)buffer)[i]);
+ snmp_pdu_add_variable(pdu, anOID, anOID_len, ASN_INTEGER, (unsigned char *)&val, sizeof(val));
+ break;
+ case PML_DT_REAL:
+ case PML_DT_STRING:
+ case PML_DT_BINARY:
+ case PML_DT_NULL_VALUE:
+ case PML_DT_COLLECTION:
+ default:
+ snmp_pdu_add_variable(pdu, anOID, anOID_len, ASN_OCTET_STR, buffer, size);
+ break;
+ }
+
+
+ /* Send the request and get response. */
+ if (snmp_synch_response(ss, pdu, &response) != STAT_SUCCESS)
+ goto bugout;
+
+ if (response->errstat == SNMP_ERR_NOERROR)
+ {
+ len = size;
+ }
+
+ *pml_result = SnmpErrorToPml(response->errstat);
+ *result = HPMUD_R_OK;
+
+bugout:
+ if (response != NULL)
+ snmp_free_pdu(response);
+ if (ss != NULL)
+ snmp_close(ss);
+ return len;
+}
+
+int __attribute__ ((visibility ("hidden"))) GetSnmp(const char *ip, int port, const char *szoid, void *buffer, unsigned int size, int *type, int *pml_result, int *result)
+{
+ struct snmp_session session, *ss=NULL;
+ struct snmp_pdu *pdu=NULL;
+ struct snmp_pdu *response=NULL;
+ unsigned int i, len=0;
+ oid anOID[MAX_OID_LEN];
+ size_t anOID_len = MAX_OID_LEN;
+ struct variable_list *vars;
+ uint32_t val;
+ unsigned char tmp[sizeof(uint32_t)];
+
+ *result = HPMUD_R_IO_ERROR;
+ *type = PML_DT_NULL_VALUE;
+ *pml_result = PML_EV_ERROR_UNKNOWN_REQUEST;
+
+ init_snmp("snmpapp");
+
+ snmp_sess_init(&session ); /* set up defaults */
+ session.peername = (char *)ip;
+ session.version = SNMP_VERSION_1;
+ session.community = (unsigned char *)SnmpPort[port];
+ session.community_len = strlen((const char *)session.community);
+ session.retries = 2;
+ session.timeout = 1000000; /* 1 second */
+ ss = snmp_open(&session); /* establish the session */
+ if (ss == NULL)
+ goto bugout;
+
+ pdu = snmp_pdu_create(SNMP_MSG_GET);
+ read_objid(szoid, anOID, &anOID_len);
+ snmp_add_null_var(pdu, anOID, anOID_len);
+
+ /* Send the request and get response. */
+ if (snmp_synch_response(ss, pdu, &response) != STAT_SUCCESS)
+ goto bugout;
+
+ if (response->errstat == SNMP_ERR_NOERROR)
+ {
+ vars = response->variables;
+ switch (vars->type)
+ {
+ case ASN_INTEGER:
+ *type = PML_DT_SIGNED_INTEGER;
+
+ /* Convert SNMP little-endian to PML big-endian byte stream. */
+ len = (sizeof(uint32_t) < size) ? sizeof(uint32_t) : size;
+ val = *vars->val.integer;
+ for(i=len; i>0; i--)
+ {
+ tmp[i-1] = val & 0xff;
+ val >>= 8;
+ }
+
+ /* Remove any in-significant bytes. */
+ for (; tmp[i]==0 && i<len; i++)
+ ;
+ len -= i;
+
+ memcpy(buffer, tmp+i, len);
+ break;
+ case ASN_NULL:
+ *type = PML_DT_NULL_VALUE;
+ break;
+ case ASN_OCTET_STR:
+ *type = PML_DT_STRING;
+ len = (vars->val_len < size) ? vars->val_len : size;
+ memcpy(buffer, vars->val.string, len);
+ break;
+ default:
+ BUG("unable to GetSnmp: data type=%d\n", vars->type);
+ goto bugout;
+ break;
+ }
+ }
+
+ *pml_result = SnmpErrorToPml(response->errstat);
+ *result = HPMUD_R_OK;
+
+bugout:
+ if (response != NULL)
+ snmp_free_pdu(response);
+ if (ss != NULL)
+ snmp_close(ss);
+ return len;
+}
+
+#else
+
+int __attribute__ ((visibility ("hidden"))) SetSnmp(const char *ip, int port, const char *szoid, int type, void *buffer, unsigned int size, int *pml_result, int *result)
+{
+ BUG("no JetDirect support enabled\n");
+ return 0;
+}
+
+int __attribute__ ((visibility ("hidden"))) GetSnmp(const char *ip, int port, const char *szoid, void *buffer, unsigned int size, int *type, int *pml_result, int *result)
+{
+ BUG("no JetDirect support enabled\n");
+ return 0;
+}
+
+#endif /* HAVE_LIBSNMP */
+
+/* Set a PML object in the hp device. */
+enum HPMUD_RESULT hpmud_set_pml(HPMUD_DEVICE device, HPMUD_CHANNEL channel, const char *snmp_oid, int type, void *data, int data_size, int *pml_result)
+{
+ unsigned char message[HPMUD_BUFFER_SIZE];
+ unsigned char oid[HPMUD_LINE_SIZE];
+ char ip[HPMUD_LINE_SIZE], *psz, *tail;
+ unsigned char *p=message;
+ int len, dLen, result, reply, status, port;
+ struct hpmud_dstat ds;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ DBG("[%d] hpmud_set_pml() dd=%d cd=%d oid=%s type=%d data=%p size=%d\n", getpid(), device, channel, snmp_oid, type, data, data_size);
+
+ if ((result = hpmud_get_dstat(device, &ds)) != HPMUD_R_OK)
+ {
+ stat = result;
+ goto bugout;
+ }
+
+ if (strcasestr(ds.uri, "net/") != NULL)
+ {
+ /* Process pml via snmp. */
+
+ hpmud_get_uri_datalink(ds.uri, ip, sizeof(ip));
+
+ if ((psz = strstr(ds.uri, "port=")) != NULL)
+ port = strtol(psz+5, &tail, 10);
+ else
+ port = 1;
+
+ SetSnmp(ip, port, snmp_oid, type, data, data_size, &status, &result);
+ if (result != HPMUD_R_OK)
+ {
+ BUG("SetPml failed ret=%d\n", result);
+ stat = result;
+ goto bugout;
+ }
+ }
+ else
+ {
+ /* Process pml via local transport. */
+
+ /* Convert snmp ascii oid to pml hex oid. */
+ dLen = SnmpToPml(snmp_oid, oid, sizeof(oid));
+
+ *p++ = PML_SET_REQUEST;
+ *p++ = PML_DT_OBJECT_IDENTIFIER;
+ *p++ = dLen; /* assume oid length is < 10 bits */
+ memcpy(p, oid, dLen);
+ p+=dLen;
+ *p = type;
+ *p |= data_size >> 8; /* assume data length is 10 bits */
+ *(p+1) = data_size & 0xff;
+ p += 2;
+ memcpy(p, data, data_size);
+
+ result = hpmud_write_channel(device, channel, message, dLen+data_size+3+2, HPMUD_EXCEPTION_SEC_TIMEOUT, &len);
+ if (result != HPMUD_R_OK)
+ {
+ BUG("SetPml channel_write failed ret=%d\n", result);
+ stat = result;
+ goto bugout;
+ }
+
+ result = hpmud_read_channel(device, channel, message, sizeof(message), HPMUD_EXCEPTION_SEC_TIMEOUT, &len);
+ if (result != HPMUD_R_OK || len == 0)
+ {
+ BUG("SetPml channel_read failed ret=%d len=%d\n", result, len);
+ goto bugout;
+ }
+
+ p = message;
+ reply = *p++; /* read command reply */
+ status = *p++; /* read execution outcome */
+
+ if (reply != (PML_SET_REQUEST | 0x80) && status & 0x80)
+ {
+ BUG("SetPml failed reply=%x outcome=%x\n", reply, status);
+ DBG_DUMP(p, len-2);
+ goto bugout;
+ }
+ }
+
+ *pml_result = status;
+ stat = HPMUD_R_OK;
+
+ DBG("set_pml result pmlresult=%x\n", status);
+
+bugout:
+ return stat;
+}
+
+/* Get a PML object from the hp device. */
+enum HPMUD_RESULT hpmud_get_pml(HPMUD_DEVICE device, HPMUD_CHANNEL channel, const char *snmp_oid, void *buf, int buf_size, int *bytes_read, int *type, int *pml_result)
+{
+ unsigned char message[HPMUD_BUFFER_SIZE];
+ unsigned char oid[HPMUD_LINE_SIZE];
+ char ip[HPMUD_LINE_SIZE], *psz, *tail;
+ unsigned char *p=message;
+ int len, dLen, result, reply, status, dt, port;
+ struct hpmud_dstat ds;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ DBG("[%d] hpmud_get_pml() dd=%d cd=%d oid=%s data=%p size=%d\n", getpid(), device, channel, snmp_oid, buf, buf_size);
+
+ if ((result = hpmud_get_dstat(device, &ds)) != HPMUD_R_OK)
+ {
+ stat = result;
+ goto bugout;
+ }
+
+ if (strcasestr(ds.uri, "net/") != NULL)
+ {
+ /* Process pml via snmp. */
+
+ hpmud_get_uri_datalink(ds.uri, ip, sizeof(ip));
+
+ if ((psz = strstr(ds.uri, "port=")) != NULL)
+ port = strtol(psz+5, &tail, 10);
+ else
+ port = 1;
+
+ dLen = GetSnmp(ip, port, snmp_oid, message, sizeof(message), &dt, &status, &result);
+ if (result != HPMUD_R_OK)
+ {
+ BUG("GetPml failed ret=%d\n", result);
+ stat = result;
+ goto bugout;
+ }
+ p = message;
+ }
+ else
+ {
+ /* Process pml via local transport. */
+
+ /* Convert snmp ascii oid to pml hex oid. */
+ dLen = SnmpToPml(snmp_oid, oid, sizeof(oid));
+
+ *p++ = PML_GET_REQUEST;
+ *p++ = PML_DT_OBJECT_IDENTIFIER;
+ *p++ = dLen; /* assume oid length is < 10 bits */
+ memcpy(p, oid, dLen);
+ result = hpmud_write_channel(device, channel, message, dLen+3, HPMUD_EXCEPTION_SEC_TIMEOUT, &len);
+ if (result != HPMUD_R_OK)
+ {
+ BUG("GetPml channel_write failed ret=%d\n", result);
+ stat = result;
+ goto bugout;
+ }
+
+ result = hpmud_read_channel(device, channel, message, sizeof(message), HPMUD_EXCEPTION_SEC_TIMEOUT, &len);
+ if (result != HPMUD_R_OK || len == 0)
+ {
+ BUG("GetPml channel_read failed ret=%d len=%d\n", result, len);
+ goto bugout;
+ }
+
+ p = message;
+ reply = *p++; /* read command reply */
+ status = *p++; /* read execution outcome */
+
+ if (reply != (PML_GET_REQUEST | 0x80) && status & 0x80)
+ {
+ BUG("GetPml failed reply=%x outcome=%x\n", reply, status);
+ DBG_DUMP(p, len-2);
+ goto bugout;
+ }
+
+ dt = *p++; /* read data type */
+
+ if (dt == PML_DT_ERROR_CODE)
+ {
+ /* Ok, but invalid data type requested, get new data type. */
+ p += 2; /* eat length and err code */
+ dt = *p++; /* read data type */
+ }
+
+ if (dt != PML_DT_OBJECT_IDENTIFIER)
+ {
+ BUG("GetPml failed data type=%x\n", dt);
+ goto bugout;
+ }
+
+ dLen = *p++; /* read oid length */
+ p += dLen; /* eat oid */
+
+ dt = *p; /* read data type. */
+ dLen = ((*p & 0x3) << 8 | *(p+1)); /* read 10 bit len from 2 byte field */
+ p += 2; /* eat type and length */
+ }
+
+ memcpy(buf, p, dLen);
+ *bytes_read = dLen;
+ *type = dt;
+ *pml_result = status;
+ stat = HPMUD_R_OK;
+
+ DBG("get_pml result len=%d datatype=%x pmlresult=%x\n", dLen, dt, status);
+ DBG_DUMP(buf, dLen);
+
+bugout:
+ return stat;
+}
+
+
diff --git a/io/hpmud/pml.h b/io/hpmud/pml.h
new file mode 100644
index 0000000..188d584
--- /dev/null
+++ b/io/hpmud/pml.h
@@ -0,0 +1,77 @@
+/*****************************************************************************\
+
+ pml.h - get/set pml api for hpmud
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ (c) 2003-2004 Copyright Hewlett-Packard Development Company, LP
+
+\*****************************************************************************/
+
+#ifndef _PML_H
+#define _PML_H
+
+/*
+ * PML definitions
+ */
+
+enum PML_REQUESTS
+{
+ PML_GET_REQUEST = 0,
+ PML_GET_NEXT_REQUEST = 0x1,
+ PML_BLOCK_REQUEST = 0x3,
+ PML_SET_REQUEST = 0x4,
+ PML_ENABLE_TRAP_REQUEST = 0x5,
+ PML_DISABLE_TRAP_REQUEST = 0x6,
+ PML_TRAP_REQUEST = 0x7
+};
+
+enum PML_ERROR_VALUES
+{
+ PML_EV_OK = 0,
+ PML_EV_OK_END_OF_SUPPORTED_OBJECTS = 0x1,
+ PML_EV_OK_NEAREST_LEGAL_VALUE_SUBSTITUTED = 0x2,
+ PML_EV_ERROR_UNKNOWN_REQUEST = 0x80,
+ PML_EV_ERROR_BUFFER_OVERFLOW = 0x81,
+ PML_EV_ERROR_COMMAND_EXECUTION_ERROR = 0x82,
+ PML_EV_ERROR_UNKNOWN_OBJECT_IDENTIFIER = 0x83,
+ PML_EV_ERROR_OBJECT_DOES_NOT_SUPPORT_REQUESTED_ACTION = 0x84,
+ PML_EV_ERROR_INVALID_OR_UNSUPPORTED_VALUE = 0x85,
+ PML_EV_ERROR_PAST_END_OF_SUPPORTED_OBJECTS = 0x86,
+ PML_EV_ERROR_ACTION_CAN_NOT_BE_PERFORMED_NOW = 0x87
+};
+
+enum PML_DATA_TYPES
+{
+ PML_DT_OBJECT_IDENTIFIER = 0,
+ PML_DT_ENUMERATION = 0x04,
+ PML_DT_SIGNED_INTEGER = 0x08,
+ PML_DT_REAL = 0x0C,
+ PML_DT_STRING = 0x10,
+ PML_DT_BINARY = 0x14,
+ PML_DT_ERROR_CODE = 0x18,
+ PML_DT_NULL_VALUE = 0x1C,
+ PML_DT_COLLECTION = 0x20,
+ PML_DT_UNKNOWN = 0xff
+};
+
+int __attribute__ ((visibility ("hidden"))) GetSnmp(const char *ip, int port, const char *szoid, void *buffer, unsigned int size, int *type, int *pml_result, int *result);
+
+#endif // _PML_H
+
diff --git a/io/hpmud/pp.c b/io/hpmud/pp.c
new file mode 100644
index 0000000..3b95ab7
--- /dev/null
+++ b/io/hpmud/pp.c
@@ -0,0 +1,1310 @@
+/*****************************************************************************\
+
+ pp.c - parallel port support for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ Client/Server generic message format (see messaging-protocol.doc):
+
+\*****************************************************************************/
+
+#ifdef HAVE_PPORT
+
+#include "hpmud.h"
+#include "hpmudi.h"
+
+mud_device_vf __attribute__ ((visibility ("hidden"))) pp_mud_device_vf =
+{
+ .read = pp_read,
+ .write = pp_write,
+ .open = pp_open,
+ .close = pp_close,
+ .get_device_id = pp_get_device_id,
+ .get_device_status = pp_get_device_status,
+ .channel_open = pp_channel_open,
+ .channel_close = pp_channel_close,
+ .channel_write = musb_channel_write,
+ .channel_read = musb_channel_read
+};
+
+static mud_channel_vf pp_raw_channel_vf =
+{
+ .open = pp_raw_channel_open,
+ .close = pp_raw_channel_close,
+ .channel_write = musb_raw_channel_write,
+ .channel_read = musb_raw_channel_read
+};
+
+static mud_channel_vf pp_mlc_channel_vf =
+{
+ .open = pp_mlc_channel_open,
+ .close = pp_mlc_channel_close,
+ .channel_write = musb_mlc_channel_write,
+ .channel_read = musb_mlc_channel_read
+};
+
+static mud_channel_vf pp_dot4_channel_vf =
+{
+ .open = pp_dot4_channel_open,
+ .close = pp_dot4_channel_close,
+ .channel_write = musb_dot4_channel_write,
+ .channel_read = musb_dot4_channel_read
+};
+
+static int frob_control(int fd, unsigned char mask, unsigned char val)
+{
+ struct ppdev_frob_struct frob;
+
+ /* Convert ieee1284 control values to PC-style (invert Strobe, AutoFd and Select) . */
+ frob.val = val ^ (mask & (PARPORT_CONTROL_STROBE | PARPORT_CONTROL_AUTOFD | PARPORT_CONTROL_SELECT));
+
+ frob.mask = mask;
+ return ioctl(fd, PPFCONTROL, &frob);
+}
+
+static unsigned char read_status(int fd)
+{
+ unsigned char status;
+ if (ioctl(fd, PPRSTATUS, &status))
+ BUG("read_status error: %m\n");
+
+ /* Convert PC-style status values to ieee1284 (invert Busy). */
+ return (status ^ PARPORT_STATUS_BUSY);
+}
+
+static int wait_status(int fd, unsigned char mask, unsigned char val, int usec)
+{
+ struct timeval tmo, now;
+ struct timespec min;
+ unsigned char status;
+ int cnt=0;
+
+ gettimeofday (&tmo, NULL);
+ tmo.tv_usec += usec;
+ tmo.tv_sec += tmo.tv_usec / 1000000;
+ tmo.tv_usec %= 1000000;
+
+ min.tv_sec = 0;
+ min.tv_nsec = 5000000; /* 5ms */
+
+ while (1)
+ {
+ status = read_status(fd);
+ if ((status & mask) == val)
+ {
+ // bug("found status=%x mask=%x val=%x cnt=%d: %s %d\n", status, mask, val, cnt, __FILE__, __LINE__);
+ return 0;
+ }
+ cnt++;
+ // nanosleep(&min, NULL);
+ gettimeofday(&now, NULL);
+ if ((now.tv_sec > tmo.tv_sec) || (now.tv_sec == tmo.tv_sec && now.tv_usec > tmo.tv_usec))
+ {
+ DBG("wait_status timeout status=%x mask=%x val=%x us=%d\n", status, mask, val, usec);
+ return -1; /* timeout */
+ }
+ }
+}
+
+static int wait(int usec)
+{
+ struct timeval tmo, now;
+ int cnt=0;
+
+ gettimeofday (&tmo, NULL);
+ tmo.tv_usec += usec;
+ tmo.tv_sec += tmo.tv_usec / 1000000;
+ tmo.tv_usec %= 1000000;
+
+ while (1)
+ {
+ cnt++;
+ gettimeofday(&now, NULL);
+ if ((now.tv_sec > tmo.tv_sec) || (now.tv_sec == tmo.tv_sec && now.tv_usec > tmo.tv_usec))
+ {
+ return 0; /* timeout */
+ }
+ }
+}
+
+static int ecp_is_fwd(int fd)
+{
+ unsigned char status;
+
+ status = read_status(fd);
+ if ((status & PARPORT_STATUS_PAPEROUT) == PARPORT_STATUS_PAPEROUT)
+ return 1;
+ return 0;
+}
+
+static int ecp_is_rev(int fd)
+{
+ unsigned char status;
+
+ status = read_status(fd);
+ if ((status & PARPORT_STATUS_PAPEROUT) == 0)
+ return 1;
+ return 0;
+}
+
+static int ecp_rev_to_fwd(int fd)
+{
+ int dir=0;
+
+ if (ecp_is_fwd(fd))
+ return 0;
+
+ /* Event 47: write NReverseRequest/nInit=1 */
+ frob_control(fd, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
+
+ /* Event 48: wait PeriphClk/nAck=1, PeriphAck/Busy=0 */
+ // wait_status(fd, PARPORT_STATUS_PAPEROUT | PARPORT_STATUS_BUSY, PARPORT_STATUS_PAPEROUT, SIGNAL_TIMEOUT);
+
+ /* Event 49: wait nAckReverse/PError=1 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, PARPORT_STATUS_PAPEROUT, PP_SIGNAL_TIMEOUT);
+
+ ioctl(fd, PPDATADIR, &dir);
+
+ return 0;
+}
+
+static int ecp_fwd_to_rev(int fd)
+{
+ int dir=1;
+
+ if (ecp_is_rev(fd))
+ return 0;
+
+ /* Event 33: NPeriphRequest/nFault=0, PeriphAck/Busy=0 */
+ wait_status(fd, PARPORT_STATUS_BUSY | PARPORT_STATUS_ERROR, 0, PP_DEVICE_TIMEOUT);
+
+ /* Event 38: write HostAck/nAutoFd=0 */
+ ioctl(fd, PPDATADIR, &dir);
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+ wait(PP_SETUP_TIMEOUT);
+
+ /* Event 39: write NReverseRequest/nInit=0 (start bus reversal) */
+ frob_control(fd, PARPORT_CONTROL_INIT, 0);
+
+ /* Event 40: wait nAckReverse/PError=0 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, 0, PP_SIGNAL_TIMEOUT);
+
+ return 0;
+}
+
+static int ecp_write_addr(int fd, unsigned char data)
+{
+ int cnt=0, len=0;
+ unsigned d=(data | 0x80); /* set channel address bit */
+
+ ecp_rev_to_fwd(fd);
+
+ /* Event 33: PeriphAck/Busy=0 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, 0, PP_SIGNAL_TIMEOUT))
+ {
+ BUG("ecp_write_addr transfer stalled\n");
+ goto bugout;
+ }
+
+ while (1)
+ {
+ /* Event 34: write HostAck/nAutoFD=0 (channel command), data */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+ ioctl(fd, PPWDATA, &d);
+
+ /* Event 35: write HostClk/NStrobe=0 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, 0);
+
+ /* Event 36: wait PeriphAck/Busy=1 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, PARPORT_STATUS_BUSY, PP_SIGNAL_TIMEOUT))
+ {
+
+ /* Event 72: write NReverseRequest/nInit=0 (Host Transfer Recovery) */
+ frob_control(fd, PARPORT_CONTROL_INIT, 0);
+
+ /* Event 73: wait nAckReverse/PError=0 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, 0, PP_SIGNAL_TIMEOUT);
+
+ /* Event 74: write NReverseRequest/nInit=1 */
+ frob_control(fd, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
+
+ /* Event 75: wait nAckReverse/PError=1 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, PARPORT_STATUS_PAPEROUT, PP_SIGNAL_TIMEOUT);
+
+ cnt++;
+ if (cnt > 4)
+ {
+ BUG("ecp_write_addr transfer stalled\n");
+ goto bugout;
+ }
+ BUG("ecp_write_addr host transfer recovery cnt=%d\n", cnt);
+ continue; /* retry */
+ }
+ break; /* done */
+ } /* while (1) */
+
+ len = 1;
+
+bugout:
+
+ /* Event 37: write HostClk/NStrobe=1 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE);
+
+ return len;
+}
+
+static int ecp_write_data(int fd, unsigned char data)
+{
+ int cnt=0, len=0;
+
+ // ecp_rev_to_fwd(fd);
+
+ /* Event 33: check PeriphAck/Busy=0 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, 0, PP_SIGNAL_TIMEOUT))
+ {
+ BUG("ecp_write_data transfer stalled\n");
+ goto bugout;
+ }
+
+ while (1)
+ {
+ /* Event 34: write HostAck/nAutoFD=1 (channel data), data */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD);
+ ioctl(fd, PPWDATA, &data);
+
+ /* Event 35: write HostClk/NStrobe=0 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, 0);
+
+ /* Event 36: wait PeriphAck/Busy=1 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, PARPORT_STATUS_BUSY, PP_SIGNAL_TIMEOUT))
+ {
+
+ /* Event 72: write NReverseRequest/nInit=0 (Host Transfer Recovery) */
+ frob_control(fd, PARPORT_CONTROL_INIT, 0);
+
+ /* Event 73: wait nAckReverse/PError=0 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, 0, PP_SIGNAL_TIMEOUT);
+
+ /* Event 74: write NReverseRequest/nInit=1 */
+ frob_control(fd, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
+
+ /* Event 75: wait nAckReverse/PError=1 */
+ wait_status(fd, PARPORT_STATUS_PAPEROUT, PARPORT_STATUS_PAPEROUT, PP_SIGNAL_TIMEOUT);
+
+ cnt++;
+ if (cnt > 4)
+ {
+ BUG("ecp_write_data transfer stalled\n");
+ goto bugout;
+ }
+ BUG("ecp_write_data host transfer recovery cnt=%d\n", cnt);
+ continue; /* retry */
+ }
+ break; /* done */
+ } /* while (1) */
+
+ len = 1;
+
+bugout:
+
+ /* Event 37: write HostClk/NStrobe=1 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE);
+
+ return len;
+}
+
+static int ecp_read_data(int fd, unsigned char *data)
+{
+ int len=0;
+
+ // ecp_fwd_to_rev(fd);
+
+ /* Event 43: wait PeriphClk/NAck=0 */
+ if (wait_status(fd, PARPORT_STATUS_ACK, 0, PP_SIGNAL_TIMEOUT))
+ {
+ len = -1;
+ goto bugout;
+ }
+ ioctl(fd, PPRDATA, data);
+
+ /* Event 44: write HostAck/nAutoFd=1 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD);
+
+ /* Event 45: wait PeriphClk/NAck=1 */
+ wait_status(fd, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK, PP_SIGNAL_TIMEOUT);
+
+ /* Event 46: write HostAck/nAutoFd=0 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+
+ len = 1;
+
+bugout:
+
+ return len;
+}
+
+static int ecp_read(int fd, void *buffer, int size, int usec)
+{
+ int i=0;
+ unsigned char *p = (unsigned char *)buffer;
+
+ ecp_fwd_to_rev(fd);
+
+ while (i < size)
+ {
+ if (ecp_read_data(fd, p+i) != 1)
+ {
+ usec-=PP_SIGNAL_TIMEOUT;
+ if (usec > 0)
+ continue;
+
+// return -1;
+ return -ETIMEDOUT; /* timeout */
+ }
+ i++;
+ }
+ return i;
+}
+
+static int ecp_write(int fd, const void *buffer, int size)
+{
+ int i;
+ unsigned char *p = (unsigned char *)buffer;
+ static int timeout=0;
+
+ if (timeout)
+ {
+ timeout=0;
+ return -1; /* report timeout */
+ }
+
+ ecp_rev_to_fwd(fd);
+
+ for (i=0; i < size; i++)
+ {
+ if (ecp_write_data(fd, p[i]) != 1)
+ {
+ if (i)
+ timeout=1; /* save timeout, report bytes written */
+ else
+ i=-1; /* report timeout */
+ break;
+ }
+ }
+ return i;
+}
+
+static int nibble_read_data(int fd, unsigned char *data)
+{
+ int len=0;
+ unsigned char nibble;
+
+ /* Event 7: write HostBusy/nAutoFd=0 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+
+ /* Event 8: peripheral sets low-order nibble. */
+
+ /* Event 9: wait PtrClk/NAck=0 */
+ if (wait_status(fd, PARPORT_STATUS_ACK, 0, PP_SIGNAL_TIMEOUT))
+ {
+ len = -1;
+ goto bugout;
+ }
+ nibble = read_status(fd) >> 3;
+ nibble = ((nibble & 0x10) >> 1) | (nibble & 0x7);
+ *data = nibble;
+
+ /* Event 10: write HostBusy/nAutoFd=1 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD);
+
+ /* Event 11: wait PtrClk/NAck=1 */
+ wait_status(fd, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK, PP_SIGNAL_TIMEOUT);
+
+ /* Event 7: write HostBusy/nAutoFd=0 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+
+ /* Event 8: peripheral sets high-order nibble. */
+
+ /* Event 9: wait PtrClk/NAck=0 */
+ if (wait_status(fd, PARPORT_STATUS_ACK, 0, PP_SIGNAL_TIMEOUT))
+ {
+ len = -1;
+ goto bugout;
+ }
+ nibble = read_status(fd) >> 3;
+ nibble = ((nibble & 0x10) >> 1) | (nibble & 0x7);
+ *data |= (nibble<<4);
+
+ /* Event 10: write HostBusy/nAutoFd=1 */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, PARPORT_CONTROL_AUTOFD);
+
+ /* Event 11: wait PtrClk/NAck=1 */
+ wait_status(fd, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK, PP_SIGNAL_TIMEOUT);
+
+ len = 1;
+
+bugout:
+
+ return len;
+}
+
+static int nibble_read(int fd, int flag, void *buffer, int size, int usec)
+{
+ int i=0;
+ unsigned char *p = (unsigned char *)buffer;
+ int m = IEEE1284_MODE_NIBBLE | flag;
+ int mc = IEEE1284_MODE_COMPAT;
+ unsigned char status;
+
+ ioctl (fd, PPNEGOT, &mc);
+ if (ioctl (fd, PPNEGOT, &m))
+ {
+ DBG("nibble_read negotiation failed: %m\n");
+ return -1;
+ }
+
+ while (i < size)
+ {
+ if (nibble_read_data(fd, p+i) != 1)
+ {
+ usec-=PP_SIGNAL_TIMEOUT;
+ if (usec > 0)
+ continue;
+
+// return -1;
+ return -ETIMEDOUT; /* timeout */
+ }
+
+ i++;
+
+ /* More data? */
+ status = read_status(fd);
+ if (status & PARPORT_STATUS_ERROR)
+ {
+ /* Event 7: write HostBusy/nAutoFd=0, idle phase */
+ frob_control(fd, PARPORT_CONTROL_AUTOFD, 0);
+
+ break; /* done */
+ }
+ }
+
+ return i;
+}
+
+static int compat_write_data(int fd, unsigned char data)
+{
+ int len=0;
+
+ /* wait Busy=0 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, 0, PP_DEVICE_TIMEOUT))
+ {
+ BUG("compat_write_data transfer stalled\n");
+ goto bugout;
+ }
+
+ ioctl(fd, PPWDATA, &data);
+ wait(PP_SETUP_TIMEOUT);
+
+ /* write NStrobe=0 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, 0);
+
+ /* wait Busy=1 */
+ if (wait_status(fd, PARPORT_STATUS_BUSY, PARPORT_STATUS_BUSY, PP_SIGNAL_TIMEOUT))
+ {
+ BUG("compat_write_data transfer stalled\n");
+ goto bugout;
+ }
+
+ /* write nStrobe=1 */
+ frob_control(fd, PARPORT_CONTROL_STROBE, PARPORT_CONTROL_STROBE);
+
+ len = 1;
+
+bugout:
+ return len;
+}
+
+static int compat_write(int fd, const void *buffer, int size)
+{
+ int i=0;
+ unsigned char *p = (unsigned char *)buffer;
+ int m = IEEE1284_MODE_COMPAT;
+ static int timeout=0;
+
+ if (timeout)
+ {
+ timeout=0;
+ return -1; /* report timeout */
+ }
+
+ if (ioctl(fd, PPNEGOT, &m))
+ {
+ BUG("compat_write failed: %m\n");
+ goto bugout;
+ }
+
+ for (i=0; i < size; i++)
+ {
+ if (compat_write_data(fd, p[i]) != 1)
+ {
+ if (i)
+ timeout=1; /* save timeout, report bytes written */
+ else
+ i=-1; /* report timeout */
+ break;
+ }
+ }
+
+bugout:
+ return i;
+}
+
+static int claim_pp(int fd)
+{
+ int stat=1;
+
+ /* Claim parallel port (can block forever). */
+ if (ioctl(fd, PPCLAIM))
+ {
+ BUG("failed claim_pp fd=%d: %m\n", fd);
+ goto bugout;
+ }
+
+ DBG("claimed pp fd=%d\n", fd);
+
+ stat=0;
+
+bugout:
+ return stat;
+}
+
+static int release_pp(int fd)
+{
+ int stat=1, m=IEEE1284_MODE_COMPAT;
+
+ /* Restore compat_mode (default), otherwise close(fd) may block restoring compat_mode. */
+ if (ioctl(fd, PPNEGOT, &m))
+ {
+ BUG("failed release_pp fd=%d: %m\n", fd);
+ goto bugout;
+ }
+
+ ioctl(fd, PPRELEASE);
+
+ DBG("released pp fd=%d\n", fd);
+
+ stat=0;
+
+bugout:
+ return 0;
+}
+
+static int device_id(int fd, char *buffer, int size)
+{
+ int len=0, maxSize;
+
+ maxSize = (size > 1024) ? 1024 : size; /* RH8 has a size limit for device id */
+
+ len = nibble_read(fd, IEEE1284_DEVICEID, buffer, maxSize, 0);
+ if (len < 0)
+ {
+ BUG("unable to read device-id ret=%d\n", len);
+ len = 0;
+ goto bugout;
+ }
+ if (len > (size-1))
+ len = size-1; /* leave byte for zero termination */
+ if (len > 2)
+ len -= 2;
+ memcpy(buffer, buffer+2, len); /* remove length */
+ buffer[len]=0;
+
+ DBG("read actual device_id successfully fd=%d len=%d\n", fd, len);
+
+bugout:
+ return len; /* length does not include zero termination */
+}
+
+static int device_status(int fd, unsigned int *status)
+{
+ int m, stat=1;
+ unsigned char byte = NFAULT_BIT; /* set default */
+
+ m = IEEE1284_MODE_COMPAT;
+ if (ioctl (fd, PPNEGOT, &m))
+ {
+ BUG("unable to read device_status: %m\n");
+ stat = HPMUD_R_IO_ERROR;
+ goto bugout;
+ }
+ byte = read_status(fd);
+
+ *status = (unsigned int)byte;
+ stat = 0;
+ DBG("read actual device_status successfully fd=%d\n", fd);
+
+bugout:
+ return stat;
+}
+
+/* Create channel object given the requested socket id and service name. */
+static int new_channel(mud_device *pd, int index, const char *sn)
+{
+ int stat=1;
+
+ /* Check for existing name service already open. */
+ if (pd->channel[index].client_cnt)
+ {
+#if 0
+ if (index == HPMUD_EWS_CHANNEL)
+ {
+ pd->channel[index].client_cnt++; /* allow multiple clients for separate USB interfaces only */
+ stat = 0;
+ DBG("reused %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+ }
+ else
+#endif
+ BUG("%s channel=%d is busy, used by [%d], clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].pid, pd->channel[index].client_cnt, pd->channel_cnt);
+ goto bugout;
+ }
+
+ if (pd->io_mode == HPMUD_RAW_MODE || pd->io_mode == HPMUD_UNI_MODE)
+ pd->channel[index].vf = pp_raw_channel_vf;
+ else if (pd->io_mode == HPMUD_MLC_GUSHER_MODE || pd->io_mode == HPMUD_MLC_MISER_MODE)
+ pd->channel[index].vf = pp_mlc_channel_vf;
+ else
+ pd->channel[index].vf = pp_dot4_channel_vf;
+
+ pd->channel[index].index = index;
+ pd->channel[index].client_cnt = 1;
+ pd->channel[index].sockid = index; /* static socket id is valid for MLC but not 1284.4 */
+ pd->channel[index].pid = getpid();
+ pd->channel[index].dindex = pd->index;
+ pd->channel[index].fd = -1;
+ strcpy(pd->channel[index].sn, sn);
+ pd->channel_cnt++;
+
+ stat = 0;
+ DBG("new %s channel=%d clientCnt=%d channelCnt=%d\n", sn, index, pd->channel[index].client_cnt, pd->channel_cnt);
+
+bugout:
+ return stat;
+}
+
+/* Remove channel object given the channel decriptor. */
+static int del_channel(mud_device *pd, mud_channel *pc)
+{
+ pc->client_cnt--;
+
+ if (pc->client_cnt <= 0)
+ {
+ pd->channel_cnt--;
+ }
+ DBG("removed %s channel=%d clientCnt=%d channelCnt=%d\n", pc->sn, pc->index, pc->client_cnt, pd->channel_cnt);
+ return 0;
+}
+
+/*********************************************************************************************************************************
+ * Parallel port mud_device functions.
+ */
+
+int __attribute__ ((visibility ("hidden"))) pp_write(int fd, const void *buf, int size, int usec)
+{
+ int len=0, m;
+
+ ioctl(fd, PPGETMODE, &m);
+
+ if (m & (IEEE1284_MODE_ECPSWE | IEEE1284_MODE_ECP))
+ {
+ len = ecp_write(fd, buf, size);
+ }
+ else
+ {
+ len = compat_write(fd, buf, size);
+ }
+
+ DBG("write fd=%d len=%d size=%d\n", fd, len, size);
+ DBG_DUMP(buf, len < 32 ? len : 32);
+
+ return len;
+}
+
+int __attribute__ ((visibility ("hidden"))) pp_read(int fd, void *buf, int size, int usec)
+{
+ int len=0, m;
+// int sec = usec/1000000;
+
+ ioctl(fd, PPGETMODE, &m);
+
+ if (m & (IEEE1284_MODE_ECPSWE | IEEE1284_MODE_ECP))
+ {
+ len = ecp_read(fd, buf, size, usec);
+ }
+ else
+ {
+ len = nibble_read(fd, 0, buf, size, usec);
+ }
+
+ DBG("read fd=%d len=%d size=%d usec=%d\n", fd, len, size, usec);
+ DBG_DUMP(buf, len < 32 ? len : 32);
+
+ return len;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_open(mud_device *pd)
+{
+ char dev[255], uriModel[128], model[128];
+ int len, m, fd;
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ hpmud_get_uri_model(pd->uri, uriModel, sizeof(uriModel));
+
+ if (pd->id[0] == 0)
+ {
+ /* First client, open actual kernal device, use blocking i/o. */
+ hpmud_get_uri_datalink(pd->uri, dev, sizeof(dev));
+ if ((fd = open(dev, O_RDWR | O_NOCTTY)) < 0)
+ {
+ BUG("unable to open %s: %m\n", pd->uri);
+ goto bugout;
+ }
+
+ /* Open can succeed with no connected device, see if this is a valid device. */
+ if (ioctl(fd, PPGETMODES, &m))
+ {
+ BUG("unable to open %s: %m\n", pd->uri);
+ goto bugout;
+ }
+
+ /* Claim parallel port (can block forever). */
+ if (claim_pp(fd))
+ goto bugout;
+
+ len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy and cache it */
+
+ if (len > 0 && is_hp(pd->id))
+ power_up(pd, fd);
+
+ release_pp(fd);
+
+ if (len == 0)
+ goto bugout;
+
+ pd->open_fd = fd;
+ }
+
+ /* Make sure uri model matches device id model. */
+ hpmud_get_model(pd->id, model, sizeof(model));
+ if (strcmp(uriModel, model) != 0)
+ {
+ stat = HPMUD_R_INVALID_DEVICE_NODE; /* probably a laserjet, or different device plugged in */
+ BUG("invalid model %s != %s\n", uriModel, model);
+ goto bugout;
+ }
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_close(mud_device *pd)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (pd->open_fd >=0)
+ close(pd->open_fd);
+
+ pd->open_fd = -1;
+ pd->id[0] = 0;
+
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_get_device_id(mud_device *pd, char *buf, int size, int *len)
+{
+ int m, fd = pd->open_fd;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+
+ *len=0;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (fd < 0)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid get_device_id state\n");
+ goto bugout;
+ }
+
+ if (pd->io_mode == HPMUD_UNI_MODE)
+ {
+ *len = strlen(pd->id); /* use cached copy */
+ DBG("using cached device_id io_mode=%d\n", pd->io_mode);
+ }
+ else
+ {
+ ioctl(fd, PPGETMODE, &m);
+ if (m & (IEEE1284_MODE_ECPSWE | IEEE1284_MODE_ECP))
+ {
+ *len = strlen(pd->id); /* channel is busy, return cached copy. */
+ DBG("using cached device_id m=%x\n", m);
+ }
+ else
+ {
+ if (pd->channel_cnt == 0)
+ {
+ /* Device not in use. Claim it, but release for other processes. */
+ if (claim_pp(fd))
+ goto bugout;
+ *len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy */
+ release_pp(fd);
+ }
+ else
+ {
+ /* Device already claimed by open_channel. */
+ *len = device_id(fd, pd->id, sizeof(pd->id)); /* get new copy */
+ }
+ }
+ }
+
+ if (*len)
+ {
+ memcpy(buf, pd->id, *len > size ? size : *len);
+ stat = HPMUD_R_OK;
+ }
+
+bugout:
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_get_device_status(mud_device *pd, unsigned int *status)
+{
+ int fd=pd->open_fd;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+ int m, r=0;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (fd < 0)
+ {
+ stat = HPMUD_R_INVALID_STATE;
+ BUG("invalid get_device_id state\n");
+ goto bugout;
+ }
+
+ if (pd->io_mode == HPMUD_UNI_MODE)
+ {
+ *status = NFAULT_BIT; /* fake status */
+ DBG("using cached device_status io_mode=%d\n", pd->io_mode);
+ }
+ else
+ {
+ ioctl(fd, PPGETMODE, &m);
+ if (m & (IEEE1284_MODE_ECPSWE | IEEE1284_MODE_ECP))
+ {
+ *status = NFAULT_BIT; /* channel is busy, fake 8-bit status */
+ DBG("using cached device_status m=%x\n", m);
+ }
+ else
+ {
+ if (pd->channel_cnt == 0)
+ {
+ /* Device not in use. Claim it, but release for other processes. */
+ if (claim_pp(fd))
+ goto bugout;
+ r = device_status(fd, status);
+ release_pp(fd);
+ }
+ else
+ {
+ /* Device already claimed by open_channel. */
+ r = device_status(fd, status);
+ }
+ }
+ }
+
+ if (r != 0)
+ goto bugout;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ pthread_mutex_unlock(&pd->mutex);
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_channel_open(mud_device *pd, const char *sn, HPMUD_CHANNEL *cd)
+{
+ int index;
+ enum HPMUD_RESULT stat = HPMUD_R_DEVICE_BUSY;
+
+ /* Check for valid service requests. */
+ if ((stat = service_to_channel(pd, sn, &index)) != HPMUD_R_OK)
+ goto bugout;
+
+ pthread_mutex_lock(&pd->mutex);
+
+ if (new_channel(pd, index, sn))
+ {
+ stat = HPMUD_R_DEVICE_BUSY;
+ }
+ else
+ {
+ if ((stat = (pd->channel[index].vf.open)(&pd->channel[index])) != HPMUD_R_OK) /* call transport specific open */
+ del_channel(pd, &pd->channel[index]); /* open failed, cleanup */
+ else
+ *cd = index;
+ }
+
+ pthread_mutex_unlock(&pd->mutex);
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_channel_close(mud_device *pd, mud_channel *pc)
+{
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+
+ pthread_mutex_lock(&pd->mutex);
+ stat = (pc->vf.close)(pc); /* call trasport specific close */
+ del_channel(pd, pc);
+ pthread_mutex_unlock(&pd->mutex);
+
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * Parallel port raw_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_raw_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ if (claim_pp(pd->open_fd))
+ return HPMUD_R_IO_ERROR;
+ pc->fd = pd->open_fd;
+ return HPMUD_R_OK;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_raw_channel_close(mud_channel *pc)
+{
+ if (pc->fd >= 0)
+ release_pp(pc->fd);
+ pc->fd = -1;
+ return HPMUD_R_OK;
+}
+
+/*******************************************************************************************************************************
+ * Parallel port mlc_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_mlc_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+ int i, m;
+
+ /* Initialize MLC transport if this is the first MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (claim_pp(pd->open_fd))
+ goto bugout;
+
+ /* Negotiate ECP mode. */
+ m = IEEE1284_MODE_ECPSWE;
+ if (ioctl(pd->open_fd, PPNEGOT, &m))
+ {
+ BUG("unable to negotiate %s ECP mode: %m\n", pd->uri);
+ goto bugout;
+ }
+
+ /* Enable MLC mode with ECP channel-77. */
+ ecp_write_addr(pd->open_fd, 78);
+ ecp_write(pd->open_fd, "\0", 1);
+ ecp_write_addr(pd->open_fd, 77);
+
+ /* MLC initialize */
+ if (MlcInit(pc, pd->open_fd) != 0)
+ goto bugout;
+
+ /* Reset transport attributes for all channels. */
+ for (i=0; i<HPMUD_CHANNEL_MAX; i++)
+ memset(&pd->channel[i].ta, 0 , sizeof(transport_attributes));
+
+ pd->mlc_fd = pd->open_fd;
+ pd->mlc_up=1;
+
+ } /* if (pDev->ChannelCnt==1) */
+
+ if (MlcConfigSocket(pc, pd->mlc_fd))
+ goto bugout;
+
+ if (MlcOpenChannel(pc, pd->mlc_fd))
+ goto bugout;
+
+ pc->rcnt = pc->rindex = 0;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_mlc_channel_close(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+ int m;
+
+ if (pd->mlc_up)
+ {
+ if (MlcCloseChannel(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+
+ /* Remove MLC transport if this is the last MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (pd->mlc_up)
+ {
+ if (MlcExit(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+ pd->mlc_up=0;
+
+ ecp_write_addr(pd->mlc_fd, 78); /* disable MLC mode with ECP channel-78 */
+ ecp_write(pd->mlc_fd, "\0", 1);
+
+ m = IEEE1284_MODE_NIBBLE;
+ ioctl(pd->mlc_fd, PPNEGOT, &m);
+ release_pp(pd->mlc_fd);
+
+ /* Delay for batch scanning. */
+ sleep(1);
+ }
+
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * Parallel port dot4_channel functions.
+ */
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_dot4_channel_open(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+ int i, m;
+
+ /* Initialize MLC transport if this is the first MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (claim_pp(pd->open_fd))
+ goto bugout;
+
+ /* Negotiate ECP mode. */
+ m = IEEE1284_MODE_ECPSWE;
+ if (ioctl(pd->open_fd, PPNEGOT, &m))
+ {
+ BUG("unable to negotiate %s ECP mode: %m\n", pd->uri);
+ goto bugout;
+ }
+
+ /* Enable MLC mode with ECP channel-77. */
+ ecp_write_addr(pd->open_fd, 78);
+ ecp_write(pd->open_fd, "\0", 1);
+ ecp_write_addr(pd->open_fd, 77);
+
+ /* DOT4 initialize */
+ if (Dot4Init(pc, pd->open_fd) != 0)
+ goto bugout;
+
+ /* Reset transport attributes for all channels. */
+ for (i=0; i<HPMUD_CHANNEL_MAX; i++)
+ memset(&pd->channel[i].ta, 0 , sizeof(transport_attributes));
+
+ pd->mlc_fd = pd->open_fd;
+ pd->mlc_up=1;
+
+ } /* if (pDev->ChannelCnt==1) */
+
+ if (Dot4GetSocket(pc, pd->mlc_fd))
+ goto bugout;
+
+ if (Dot4OpenChannel(pc, pd->mlc_fd))
+ goto bugout;
+
+ pc->rcnt = pc->rindex = 0;
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ return stat;
+}
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_dot4_channel_close(mud_channel *pc)
+{
+ mud_device *pd = &msp->device[pc->dindex];
+ enum HPMUD_RESULT stat = HPMUD_R_OK;
+ int m;
+
+ if (pd->mlc_up)
+ {
+ if (Dot4CloseChannel(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+
+ /* Remove MLC transport if this is the last MLC channel. */
+ if (pd->channel_cnt==1)
+ {
+ if (pd->mlc_up)
+ {
+ if (Dot4Exit(pc, pd->mlc_fd))
+ stat = HPMUD_R_IO_ERROR;
+ }
+ pd->mlc_up=0;
+
+ ecp_write_addr(pd->mlc_fd, 78); /* disable MLC mode with ECP channel-78 */
+ ecp_write(pd->mlc_fd, "\0", 1);
+
+ m = IEEE1284_MODE_NIBBLE;
+ ioctl(pd->mlc_fd, PPNEGOT, &m);
+ release_pp(pd->mlc_fd);
+
+ /* Delay for batch scanning. */
+ sleep(1);
+ }
+
+ return stat;
+}
+
+/*******************************************************************************************************************************
+ * Parallel port probe devices, walk the parallel port bus(s) looking for HP products.
+ */
+
+int __attribute__ ((visibility ("hidden"))) pp_probe_devices(char *lst, int lst_size, int *cnt)
+{
+ struct hpmud_model_attributes ma;
+ char dev[HPMUD_LINE_SIZE];
+ char rmodel[128];
+ char model[128];
+ char id[1024];
+ int i, size=0, fd, m;
+
+ for (i=0; i < 4; i++)
+ {
+ sprintf(dev, "/dev/parport%d", i);
+
+ if ((fd = open(dev, O_RDONLY | O_NOCTTY)) < 0)
+ continue;
+
+ /* Silently check the port for valid device (no syslog errors). */
+ if (ioctl(fd, PPGETMODES, &m) == 0)
+ {
+ if (claim_pp(fd) == 0)
+ {
+ if (device_id(fd, id, sizeof(id)) > 0 && is_hp(id))
+ {
+ hpmud_get_model(id, model, sizeof(model));
+ hpmud_get_raw_model(id, rmodel, sizeof(rmodel));
+ snprintf(dev, sizeof(dev), "hp:/par/%s?device=/dev/parport%d", model, i);
+
+ /* See if device is supported by hplip. */
+ hpmud_query_model(dev, &ma);
+ if (ma.support != HPMUD_SUPPORT_TYPE_HPLIP)
+ {
+ BUG("ignoring %s support=%d\n", dev, ma.support);
+ continue; /* ignor, not supported */
+ }
+
+ if (strncasecmp(rmodel, "hp ", 3) == 0)
+ size += sprintf(lst+size,"direct %s \"HP %s\" \"HP %s LPT parport%d HPLIP\" \"%s\"\n", dev, &rmodel[3], &rmodel[3], i, id);
+ else
+ size += sprintf(lst+size,"direct %s \"HP %s\" \"HP %s LPT parport%d HPLIP\" \"%s\"\n", dev, rmodel, rmodel, i, id);
+ *cnt+=1;
+ }
+ release_pp(fd);
+ }
+ else
+ {
+ BUG("unable to probe %s: %m\n", dev); /* device is busy */
+ }
+ }
+ close(fd);
+ }
+ return size;
+}
+
+enum HPMUD_RESULT hpmud_make_par_uri(const char *dnode, char *uri, int uri_size, int *bytes_read)
+{
+ char model[128];
+ char id[1024];
+ enum HPMUD_RESULT stat = HPMUD_R_IO_ERROR;
+ int fd=-1, m;
+
+ DBG("[%d] hpmud_make_par_uri() dnode=%s\n", getpid(), dnode);
+
+ *bytes_read=0;
+
+ uri[0]=0;
+
+ if ((fd = open(dnode, O_RDONLY | O_NOCTTY)) < 0)
+ {
+ BUG("unable to open %s: %m\n", dnode);
+ goto bugout;
+ }
+
+ if (ioctl(fd, PPGETMODES, &m))
+ {
+ BUG("unable to make uri %s: %m\n", dnode);
+ goto bugout;
+ }
+
+ if (claim_pp(fd))
+ {
+ BUG("unable to make uri %s: %m\n", dnode); /* device is busy */
+ goto bugout;
+ }
+
+ if (device_id(fd, id, sizeof(id)) > 0 && is_hp(id))
+ {
+ hpmud_get_model(id, model, sizeof(model));
+ *bytes_read = snprintf(uri, uri_size, "hp:/par/%s?device=%s", model, dnode);
+ }
+ release_pp(fd);
+
+ stat = HPMUD_R_OK;
+
+bugout:
+ if (fd >= 0)
+ close(fd);
+ return stat;
+}
+
+#endif /* HAVE_PPORT */
diff --git a/io/hpmud/pp.h b/io/hpmud/pp.h
new file mode 100644
index 0000000..5a5198f
--- /dev/null
+++ b/io/hpmud/pp.h
@@ -0,0 +1,100 @@
+/*****************************************************************************\
+
+ pp.h - parallel port support for multi-point transport driver
+
+ (c) 2004-2007 Copyright Hewlett-Packard Development Company, LP
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+\*****************************************************************************/
+
+#ifndef _PP_H
+#define _PP_H
+
+#include <sys/ioctl.h>
+#include <linux/parport.h>
+#include <linux/ppdev.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+/*
+ * PC-style parallel port bit definitions.
+ *
+ * Status
+ * bit
+ * 7 - Busy *
+ * 6 - NAck
+ * 5 - PError (PARPORT_STATUS_PAPEROUT)
+ * 4 - Select
+ *
+ * 3 - NFault (PARPORT_STATUS_ERROR)
+ * 2 -
+ * 1 -
+ * 0 -
+ *
+ * Control
+ * bit
+ * 7 -
+ * 6 -
+ * 5 -
+ * 4 -
+ *
+ * 3 - Select *
+ * 2 - Init
+ * 1 - AutoFD *
+ * 0 - Strobe *
+ *
+ * * inverted
+ *
+ * Notes:
+ * For ECP mode use low-level parport ioctl instead of high-level parport read/writes because its more reliable. High-level support
+ * for Compatible and Nibble modes are probably ok, but for consistency low-level parport ioctl is used.
+ *
+ */
+
+#define PP_DEVICE_TIMEOUT 30000000 /* device timeout (us) */
+//#define PP_SIGNAL_TIMEOUT 1000000 /* signal timeout (us), too long for 1ms timeout, DES 8/18/08 */
+//#define PP_SIGNAL_TIMEOUT 1000 /* signal timeout (us), too short for DJ540, DES 8/18/08 */
+#define PP_SIGNAL_TIMEOUT 100000 /* signal timeout (us), DES 8/18/08 */
+#define PP_SETUP_TIMEOUT 10 /* setup timeout (us) */
+
+struct _mud_device;
+struct _mud_channel;
+
+extern struct _mud_device_vf __attribute__ ((visibility ("hidden"))) pp_mud_device_vf;
+
+int __attribute__ ((visibility ("hidden"))) pp_write(int fd, const void *buf, int size, int usec);
+int __attribute__ ((visibility ("hidden"))) pp_read(int fd, void *buf, int size, int usec);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_open(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_close(struct _mud_device *pd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_get_device_id(struct _mud_device *pd, char *buf, int size, int *len);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_get_device_status(struct _mud_device *pd, unsigned int *status);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_channel_open(struct _mud_device *pd, const char *sn, HPMUD_CHANNEL *cd);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_channel_close(struct _mud_device *pd, struct _mud_channel *pc);
+
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_raw_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_raw_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_mlc_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_mlc_channel_close(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_dot4_channel_open(struct _mud_channel *pc);
+enum HPMUD_RESULT __attribute__ ((visibility ("hidden"))) pp_dot4_channel_close(struct _mud_channel *pc);
+
+int __attribute__ ((visibility ("hidden"))) pp_probe_devices(char *lst, int lst_size, int *cnt);
+
+#endif // _PP_H
+
diff --git a/io/mudext/hpmudext.c b/io/mudext/hpmudext.c
new file mode 100644
index 0000000..e387501
--- /dev/null
+++ b/io/mudext/hpmudext.c
@@ -0,0 +1,495 @@
+/*****************************************************************************\
+ hpmudext - Python extension for HP multi-point transport driver (HPMUD)
+
+ (c) Copyright 2010 Hewlett-Packard Development Company, L.P.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Requires:
+Python 2.2+
+
+Authors: Don Welch, David Suffield, Naga Samrat Chowdary Narla
+
+\*****************************************************************************/
+
+#include <Python.h>
+#include "hpmud.h"
+#include "hpmudi.h"
+
+/* Ref: PEP 353 (Python 2.5) */
+#if PY_VERSION_HEX < 0x02050000
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#endif
+
+/*
+HPMUDEXT API:
+
+result_code, dd = open_device(uri, io_mode)
+
+result_code = close_device(dd)
+
+result_code, data = get_device_id(dd)
+
+result_code, data = probe_devices(bus)
+
+result_code, cd = open_channel(dd, channel_name)
+
+result_code = close_channel(dd, cd)
+
+result_code, bytes_written = write_channel(dd, cd, data, [timeout])
+
+result_code, data = read_channel(dd, cd, bytes_to_read, [timeout])
+
+result_code, pml_result_code = set_pml(dd, cd, oid, type, data)
+
+result_code, data, pml_result_code = get_pml(dd, cd, oid, type)
+
+result_code, uri = make_usb_uri(busnum, devnum)
+
+result_code, uri = make_net_uri(ip, port)
+
+result_code, uri = make_zc_uri(ip, port)
+
+result_code, ip_address = get_zc_ip_address(hostname)
+
+result_code, uri = make_par_uri(devnode)
+
+*/
+
+
+ static PyObject *open_device(PyObject *self, PyObject *args)
+{
+ char * uri;
+ enum HPMUD_IO_MODE io_mode;
+ HPMUD_DEVICE dd;
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+
+ if (!PyArg_ParseTuple(args, "si", &uri, &io_mode))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_open_device(uri, io_mode, &dd);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(ii)", result, dd);
+}
+
+static PyObject *close_device(PyObject *self, PyObject *args)
+{
+ HPMUD_DEVICE dd;
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+
+ if (!PyArg_ParseTuple(args, "i", &dd))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_close_device(dd);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("i", result);
+}
+
+static PyObject *get_device_id(PyObject *self, PyObject *args)
+{
+ HPMUD_DEVICE dd;
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ char buf[HPMUD_BUFFER_SIZE];
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "i", &dd))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_get_device_id(dd, buf, HPMUD_BUFFER_SIZE, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, buf, bytes_read);
+
+}
+
+static PyObject *probe_devices(PyObject *self, PyObject *args)
+{
+ enum HPMUD_BUS_ID bus;
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ int cnt = 0;
+ int bytes_read = 0;
+ char buf[HPMUD_BUFFER_SIZE * 4];
+
+ if (!PyArg_ParseTuple(args, "i", &bus))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_probe_devices(bus, buf, HPMUD_BUFFER_SIZE * 4, &cnt, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, buf, bytes_read);
+}
+
+static PyObject *open_channel(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd = -1;
+ char * channel_name;
+ HPMUD_CHANNEL cd = -1;
+
+ if (!PyArg_ParseTuple(args, "is", &dd, &channel_name))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_open_channel(dd, channel_name, &cd);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(ii)", result, cd);
+
+}
+
+static PyObject *close_channel(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd;
+ HPMUD_CHANNEL cd;
+
+ if (!PyArg_ParseTuple(args, "ii", &dd, &cd))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_close_channel(dd, cd);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("i", result);
+}
+
+static PyObject *write_channel(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd;
+ HPMUD_CHANNEL cd;
+ int timeout = 30;
+ char * buf;
+ int buf_size = 0;
+ int bytes_written = 0;
+
+ if (!PyArg_ParseTuple(args, "iis#|i", &dd, &cd, &buf, &buf_size, &timeout))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_write_channel(dd, cd, buf, buf_size, timeout, &bytes_written);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(ii)", result, bytes_written);
+}
+
+static PyObject *read_channel(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd;
+ HPMUD_CHANNEL cd;
+ int timeout = 30;
+ char buf[HPMUD_BUFFER_SIZE];
+ int bytes_read = 0;
+ int bytes_to_read;
+
+ if (!PyArg_ParseTuple(args, "iii|i", &dd, &cd, &bytes_to_read, &timeout))
+ return NULL;
+
+ if (bytes_to_read > HPMUD_BUFFER_SIZE)
+ return Py_BuildValue("(is#)", HPMUD_R_INVALID_LENGTH, "", 0);
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_read_channel(dd, cd, (void *)buf, bytes_to_read, timeout, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, buf, bytes_read);
+}
+
+static PyObject *set_pml(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd;
+ HPMUD_CHANNEL cd;
+ char * oid;
+ int type;
+ char * data;
+ int data_size;
+ int pml_result;
+
+ if (!PyArg_ParseTuple(args, "iisis#", &dd, &cd, &oid, &type, &data, &data_size))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_set_pml(dd, cd, oid, type, (void *)data, data_size, &pml_result);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(ii)", result, pml_result);
+}
+
+static PyObject *get_pml(PyObject *self, PyObject *args)
+{
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ HPMUD_DEVICE dd;
+ HPMUD_CHANNEL cd;
+ char * oid;
+ int type;
+ char buf[HPMUD_BUFFER_SIZE * 4];
+ int pml_result;
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "iisi", &dd, &cd, &oid, &type))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_get_pml(dd, cd, oid, (void *)buf, HPMUD_BUFFER_SIZE * 4, &bytes_read, &type, &pml_result);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#ii)", result, buf, bytes_read, type, pml_result);
+}
+
+static PyObject *make_usb_uri(PyObject *self, PyObject *args)
+{
+ char * busnum;
+ char * devnum;
+ char uri[HPMUD_BUFFER_SIZE];
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "ss", &busnum, &devnum))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_make_usb_uri(busnum, devnum, uri, HPMUD_BUFFER_SIZE, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, uri, bytes_read);
+}
+
+#ifdef HAVE_LIBNETSNMP
+static PyObject *make_net_uri(PyObject *self, PyObject *args)
+{
+ char * ip;
+ int port;
+ char uri[HPMUD_BUFFER_SIZE];
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "si", &ip, &port))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_make_net_uri(ip, port, uri, HPMUD_BUFFER_SIZE, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, uri, bytes_read);
+}
+#else
+static PyObject *make_net_uri(PyObject *self, PyObject *args)
+{
+ return Py_BuildValue("(is#)", HPMUD_R_INVALID_URI, "", 0);
+}
+#endif /* HAVE_LIBSNMP */
+
+#ifdef HAVE_LIBNETSNMP
+static PyObject *make_zc_uri(PyObject *self, PyObject *args)
+{
+ char *hn;
+ int port;
+ char uri[HPMUD_BUFFER_SIZE];
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "si", &hn, &port))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_make_mdns_uri(hn, port, uri, HPMUD_BUFFER_SIZE, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, uri, bytes_read);
+}
+#else
+static PyObject *make_zc_uri(PyObject *self, PyObject *args)
+{
+ return Py_BuildValue("(is#)", HPMUD_R_INVALID_URI, "", 0);
+}
+#endif /* HAVE_LIBSNMP */
+
+#ifdef HAVE_LIBNETSNMP
+static PyObject *get_zc_ip_address(PyObject *self, PyObject *args)
+{
+ char *hn;
+ char ip[HPMUD_BUFFER_SIZE];
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+
+ if (!PyArg_ParseTuple(args, "s", &hn))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_mdns_lookup(hn, HPMUD_MDNS_TIMEOUT, ip);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is)", result, ip);
+}
+#else
+static PyObject *get_zc_ip_address(PyObject *self, PyObject *args)
+{
+ return Py_BuildValue("(is)", HPMUD_R_INVALID_URI, "");
+}
+#endif /* HAVE_LIBSNMP */
+
+#ifdef HAVE_PPORT
+static PyObject *make_par_uri(PyObject *self, PyObject *args)
+{
+ char * devnode;
+ char uri[HPMUD_BUFFER_SIZE];
+ enum HPMUD_RESULT result = HPMUD_R_OK;
+ int bytes_read = 0;
+
+ if (!PyArg_ParseTuple(args, "s", &devnode))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ result = hpmud_make_par_uri(devnode, uri, HPMUD_BUFFER_SIZE, &bytes_read);
+ Py_END_ALLOW_THREADS
+
+ return Py_BuildValue("(is#)", result, uri, bytes_read);
+}
+#else
+static PyObject *make_par_uri(PyObject *self, PyObject *args)
+{
+ return Py_BuildValue("(is#)", HPMUD_R_INVALID_URI, "", 0);
+}
+#endif /* HAVE_PPORT */
+
+// Unwrapped MUD APIs:
+// int hpmud_get_model(const char *id, char *buf, int buf_size);
+// int hpmud_get_uri_model(const char *uri, char *buf, int buf_size);
+// int hpmud_get_uri_datalink(const char *uri, char *buf, int buf_size);
+// enum HPMUD_RESULT hpmud_get_model_attributes(char *uri, char *attr, int attrSize);
+// enum HPMUD_RESULT hpmud_model_query(char *uri, struct hpmud_model_attributes *ma);
+// enum HPMUD_RESULT hpmud_get_device_status(HPMUD_DEVICE dd, unsigned int *status);
+// enum HPMUD_RESULT hpmud_get_dstat(HPMUD_DEVICE dd, struct hpmud_dstat *ds);
+
+
+static PyMethodDef mudext_functions[] =
+{
+ {"open_device", (PyCFunction)open_device, METH_VARARGS },
+ {"close_device", (PyCFunction)close_device, METH_VARARGS },
+ {"get_device_id", (PyCFunction)get_device_id, METH_VARARGS },
+ {"probe_devices", (PyCFunction)probe_devices, METH_VARARGS },
+ {"open_channel", (PyCFunction)open_channel, METH_VARARGS },
+ {"write_channel", (PyCFunction)write_channel, METH_VARARGS },
+ {"read_channel", (PyCFunction)read_channel, METH_VARARGS },
+ {"close_channel", (PyCFunction)close_channel, METH_VARARGS },
+ {"set_pml", (PyCFunction)set_pml, METH_VARARGS },
+ {"get_pml", (PyCFunction)get_pml, METH_VARARGS },
+ {"make_usb_uri", (PyCFunction)make_usb_uri, METH_VARARGS },
+ {"make_net_uri", (PyCFunction)make_net_uri, METH_VARARGS },
+ {"make_zc_uri", (PyCFunction)make_zc_uri, METH_VARARGS },
+ {"get_zc_ip_address", (PyCFunction)get_zc_ip_address, METH_VARARGS },
+ {"make_par_uri", (PyCFunction)make_par_uri, METH_VARARGS },
+ { NULL, NULL }
+};
+
+
+static char mudext_documentation[] = "Python extension for HP multi-point transport driver";
+
+static void insint(PyObject *d, char *name, int value)
+{
+ PyObject *v = PyInt_FromLong((long) value);
+
+ if (!v || PyDict_SetItemString(d, name, v))
+ Py_FatalError("Initialization failed.");
+
+ Py_DECREF(v);
+}
+
+static void insstr(PyObject *d, char *name, char *value)
+{
+ PyObject *v = PyString_FromString(value);
+
+ if (!v || PyDict_SetItemString(d, name, v))
+ Py_FatalError("Initialization failed.");
+
+ Py_DECREF(v);
+}
+
+
+void inithpmudext(void)
+{
+ PyObject *mod = Py_InitModule3("hpmudext", mudext_functions, mudext_documentation);
+
+ if (mod == NULL)
+ return;
+
+ PyObject * d = PyModule_GetDict(mod);
+
+ // enum HPMUD_RESULT
+ insint(d, "HPMUD_R_OK", HPMUD_R_OK);
+ insint(d, "HPMUD_R_INVALID_DEVICE", HPMUD_R_INVALID_DEVICE);
+ insint(d, "HPMUD_R_INVALID_DESCRIPTOR", HPMUD_R_INVALID_DESCRIPTOR);
+ insint(d, "HPMUD_R_INVALID_URI", HPMUD_R_INVALID_URI);
+ insint(d, "HPMUD_R_INVALID_LENGTH", HPMUD_R_INVALID_LENGTH);
+ insint(d, "HPMUD_R_IO_ERROR", HPMUD_R_IO_ERROR);
+ insint(d, "HPMUD_R_DEVICE_BUSY", HPMUD_R_DEVICE_BUSY);
+ insint(d, "HPMUD_R_INVALID_SN", HPMUD_R_INVALID_SN);
+ insint(d, "HPMUD_R_INVALID_CHANNEL_ID", HPMUD_R_INVALID_CHANNEL_ID);
+ insint(d, "HPMUD_R_INVALID_STATE", HPMUD_R_INVALID_STATE);
+ insint(d, "HPMUD_R_INVALID_DEVICE_OPEN", HPMUD_R_INVALID_DEVICE_OPEN);
+ insint(d, "HPMUD_R_INVALID_DEVICE_NODE", HPMUD_R_INVALID_DEVICE_NODE);
+ insint(d, "HPMUD_R_INVALID_IP", HPMUD_R_INVALID_IP);
+ insint(d, "HPMUD_R_INVALID_IP_PORT", HPMUD_R_INVALID_IP_PORT);
+ insint(d, "HPMUD_R_INVALID_TIMEOUT", HPMUD_R_INVALID_TIMEOUT);
+ insint(d, "HPMUD_R_DATFILE_ERROR", HPMUD_R_DATFILE_ERROR);
+ insint(d, "HPMUD_R_IO_TIMEOUT", HPMUD_R_IO_TIMEOUT);
+
+ // enum HPMUD_IO_MODE
+ insint(d, "HPMUD_UNI_MODE", HPMUD_UNI_MODE);
+ insint(d, "HPMUD_RAW_MODE",HPMUD_RAW_MODE);
+ insint(d, "HPMUD_DOT4_MODE", HPMUD_DOT4_MODE);
+ insint(d, "HPMUD_DOT4_PHOENIX_MODE", HPMUD_DOT4_PHOENIX_MODE);
+ insint(d, "HPMUD_DOT4_BRIDGE_MODE", HPMUD_DOT4_BRIDGE_MODE);
+ insint(d, "HPMUD_MLC_GUSHER_MODE", HPMUD_MLC_GUSHER_MODE);
+ insint(d, "HPMUD_MLC_MISER_MODE", HPMUD_MLC_MISER_MODE);
+
+ // enum HPMUD_BUS_ID
+ insint(d, "HPMUD_BUS_NA", HPMUD_BUS_NA);
+ insint(d, "HPMUD_BUS_USB", HPMUD_BUS_USB);
+ insint(d, "HPMUD_BUS_PARALLEL", HPMUD_BUS_PARALLEL);
+ insint(d, "HPMUD_BUS_ALL", HPMUD_BUS_ALL);
+
+ // Channel names
+ insstr(d, "HPMUD_S_PRINT_CHANNEL", HPMUD_S_PRINT_CHANNEL);
+ insstr(d, "HPMUD_S_PML_CHANNEL", HPMUD_S_PML_CHANNEL);
+ insstr(d, "HPMUD_S_SCAN_CHANNEL", HPMUD_S_SCAN_CHANNEL);
+ insstr(d, "HPMUD_S_FAX_SEND_CHANNEL", HPMUD_S_FAX_SEND_CHANNEL);
+ insstr(d, "HPMUD_S_CONFIG_UPLOAD_CHANNEL", HPMUD_S_CONFIG_UPLOAD_CHANNEL);
+ insstr(d, "HPMUD_S_CONFIG_DOWNLOAD_CHANNEL", HPMUD_S_CONFIG_DOWNLOAD_CHANNEL);
+ insstr(d, "HPMUD_S_MEMORY_CARD_CHANNEL", HPMUD_S_MEMORY_CARD_CHANNEL);
+ insstr(d, "HPMUD_S_EWS_CHANNEL", HPMUD_S_EWS_CHANNEL);
+ insstr(d, "HPMUD_S_EWS_LEDM_CHANNEL", HPMUD_S_EWS_LEDM_CHANNEL);
+ insstr(d, "HPMUD_S_SOAP_SCAN", HPMUD_S_SOAP_SCAN);
+ insstr(d, "HPMUD_S_SOAP_FAX", HPMUD_S_SOAP_FAX);
+ insstr(d, "HPMUD_S_DEVMGMT_CHANNEL", HPMUD_S_DEVMGMT_CHANNEL);
+ insstr(d, "HPMUD_S_WIFI_CHANNEL", HPMUD_S_WIFI_CHANNEL);
+ insstr(d, "HPMUD_S_MARVELL_FAX_CHANNEL", HPMUD_S_MARVELL_FAX_CHANNEL);
+ insstr(d, "HPMUD_S_LEDM_SCAN", HPMUD_S_LEDM_SCAN);
+
+ // Max buffer size
+ insint(d, "HPMUD_BUFFER_SIZE", HPMUD_BUFFER_SIZE);
+
+}
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 05:27:23 +0000