From 72835b3d805ac6c7cdaac7d3aff107567e938314 Mon Sep 17 00:00:00 2001 From: Jinkun Jang Date: Wed, 13 Mar 2013 01:42:35 +0900 Subject: Tizen 2.1 base --- io/hpmud/dot4.c | 750 +++++++++++++++++ io/hpmud/dot4.h | 187 +++++ io/hpmud/hp-mkuri.c | 543 +++++++++++++ io/hpmud/hpmud.c | 699 ++++++++++++++++ io/hpmud/hpmud.h | 581 +++++++++++++ io/hpmud/hpmudi.h | 212 +++++ io/hpmud/jd.c | 906 +++++++++++++++++++++ io/hpmud/jd.h | 56 ++ io/hpmud/list.h | 131 +++ io/hpmud/mlc.c | 772 ++++++++++++++++++ io/hpmud/mlc.h | 150 ++++ io/hpmud/model.c | 633 +++++++++++++++ io/hpmud/musb.c | 2197 ++++++++++++++++++++++++++++++++++++++++++++++++++ io/hpmud/musb.h | 121 +++ io/hpmud/pml.c | 520 ++++++++++++ io/hpmud/pml.h | 77 ++ io/hpmud/pp.c | 1310 ++++++++++++++++++++++++++++++ io/hpmud/pp.h | 100 +++ io/mudext/hpmudext.c | 495 ++++++++++++ 19 files changed, 10440 insertions(+) create mode 100644 io/hpmud/dot4.c create mode 100644 io/hpmud/dot4.h create mode 100644 io/hpmud/hp-mkuri.c create mode 100644 io/hpmud/hpmud.c create mode 100644 io/hpmud/hpmud.h create mode 100644 io/hpmud/hpmudi.h create mode 100644 io/hpmud/jd.c create mode 100644 io/hpmud/jd.h create mode 100644 io/hpmud/list.h create mode 100644 io/hpmud/mlc.c create mode 100644 io/hpmud/mlc.h create mode 100644 io/hpmud/model.c create mode 100644 io/hpmud/musb.c create mode 100644 io/hpmud/musb.h create mode 100644 io/hpmud/pml.c create mode 100644 io/hpmud/pml.h create mode 100644 io/hpmud/pp.c create mode 100644 io/hpmud/pp.h create mode 100644 io/mudext/hpmudext.c (limited to 'io') 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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; idevice[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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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 +#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= 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 +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#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; idescriptor.bNumConfigurations; i++) + { + for (j=0; jconfig[i].bNumInterfaces; j++) + { + for (k=0; kconfig[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; idescriptor.bNumConfigurations; i++) + { + if (dev->config == NULL) + goto bugout; + + for (j=0; jconfig[i].bNumInterfaces; j++) + { + if (dev->config[i].interface == NULL) + goto bugout; + + for (k=0; kconfig[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; ibNumEndpoints; 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; ibNumEndpoints; 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; iid[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; iid, 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; imutex); + + 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; ichannel[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; ichannel[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 +#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 +#include +#include "hpmud.h" +#include "hpmudi.h" + +#ifdef HAVE_LIBNETSNMP +#ifdef HAVE_UCDSNMP +#include +#include +#else +#include +#include +#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; ierrstat == 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 && ival_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; ichannel[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; ichannel[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 +#include +#include +#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 +#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); + +} + + -- cgit v1.2.3