[Linux1394-cvslog] rev 622 - trunk
Brought to you by:
aeb,
bencollins
Menu
▾
▴
[Linux1394-cvslog] rev 622 - trunk
|
From: SVN U. <ben...@li...> - 2002-10-20 05:59:36
|
Author: bencollins
Date: 2002-10-20 01:59:30 -0400 (Sun, 20 Oct 2002)
New Revision: 622
Modified:
trunk/ieee1394_core.c
trunk/ieee1394_transactions.c
trunk/ieee1394_transactions.h
trunk/raw1394.c
Log:
Consolidate hpsb_make_readqpacket and hpsb_make_readbpacket into one
single hpsb_make_readpacket.
Do the same for hpsb_make_write{b,q}packet (it was already done, but I
removed the other two functions.
Remove the defines for hpsb_make_write{b,q}packet and hpsb_make_read{b,q}packet.
Move all the fill_*_resp() functions to ieee1394_core.c since that's the
only place where they were used. Made them static, and removed exporting
them.
Made all but fill_async_writequad and fill_async_writeblock static in
ieee1394_transactions.c (of the fill_* functions), and removed them
exporting of them aswell.
SBP-2 is the only place where fill_async_writequad and
fill_async_writeblock is used. Fix for that is forthcoming.
Modified: trunk/ieee1394_core.c
==============================================================================
--- trunk/ieee1394_core.c (original)
+++ trunk/ieee1394_core.c 2002-10-20 01:59:31.000000000 -0400
@@ -651,6 +651,54 @@
return p;
}
+#define PREP_ASYNC_HEAD_RCODE(tc) \
+ packet->tcode = tc; \
+ packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
+ | (1 << 8) | (tc << 4); \
+ packet->header[1] = (packet->host->node_id << 16) | (rcode << 12); \
+ packet->header[2] = 0
+
+static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
+ quadlet_t data)
+{
+ PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE);
+ packet->header[3] = data;
+ packet->header_size = 16;
+ packet->data_size = 0;
+}
+
+static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
+ int length)
+{
+ if (rcode != RCODE_COMPLETE)
+ length = 0;
+
+ PREP_ASYNC_HEAD_RCODE(TCODE_READB_RESPONSE);
+ packet->header[3] = length << 16;
+ packet->header_size = 16;
+ packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
+}
+
+static void fill_async_write_resp(struct hpsb_packet *packet, int rcode)
+{
+ PREP_ASYNC_HEAD_RCODE(TCODE_WRITE_RESPONSE);
+ packet->header[2] = 0;
+ packet->header_size = 12;
+ packet->data_size = 0;
+}
+
+static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
+ int length)
+{
+ if (rcode != RCODE_COMPLETE)
+ length = 0;
+
+ PREP_ASYNC_HEAD_RCODE(TCODE_LOCK_RESPONSE);
+ packet->header[3] = (length << 16) | extcode;
+ packet->header_size = 16;
+ packet->data_size = length;
+}
+
#define PREP_REPLY_PACKET(length) \
packet = create_reply_packet(host, data, length); \
if (packet == NULL) break
@@ -1175,26 +1223,15 @@
/** ieee1394_transactions.c **/
EXPORT_SYMBOL(hpsb_get_tlabel);
EXPORT_SYMBOL(hpsb_free_tlabel);
-EXPORT_SYMBOL(fill_async_readquad);
-EXPORT_SYMBOL(fill_async_readquad_resp);
-EXPORT_SYMBOL(fill_async_readblock);
-EXPORT_SYMBOL(fill_async_readblock_resp);
EXPORT_SYMBOL(fill_async_writequad);
EXPORT_SYMBOL(fill_async_writeblock);
-EXPORT_SYMBOL(fill_async_write_resp);
-EXPORT_SYMBOL(fill_async_lock);
-EXPORT_SYMBOL(fill_async_lock_resp);
-EXPORT_SYMBOL(fill_iso_packet);
-EXPORT_SYMBOL(fill_phy_packet);
-EXPORT_SYMBOL(hpsb_make_readqpacket);
-EXPORT_SYMBOL(hpsb_make_readbpacket);
-EXPORT_SYMBOL(hpsb_make_writeqpacket);
-EXPORT_SYMBOL(hpsb_make_writebpacket);
+EXPORT_SYMBOL(hpsb_make_readpacket);
EXPORT_SYMBOL(hpsb_make_lockpacket);
EXPORT_SYMBOL(hpsb_make_lock64packet);
EXPORT_SYMBOL(hpsb_make_phypacket);
+EXPORT_SYMBOL(hpsb_make_isopacket);
EXPORT_SYMBOL(hpsb_packet_success);
-EXPORT_SYMBOL(hpsb_make_packet);
+EXPORT_SYMBOL(hpsb_make_writepacket);
EXPORT_SYMBOL(hpsb_read);
EXPORT_SYMBOL(hpsb_write);
EXPORT_SYMBOL(hpsb_lock);
Modified: trunk/raw1394.c
==============================================================================
--- trunk/raw1394.c (original)
+++ trunk/raw1394.c 2002-10-20 01:59:31.000000000 -0400
@@ -641,45 +641,30 @@
switch (req->req.type) {
case RAW1394_REQ_ASYNC_READ:
- if (req->req.length == 4) {
- DBGMSG("quadlet_read_request called");
- packet = hpsb_make_readqpacket(fi->host, node, addr);
- if (!packet) return -ENOMEM;
+ DBGMSG("read_request called");
+ packet = hpsb_make_readpacket(fi->host, node, addr, req->req.length);
- req->data = &packet->header[3];
- } else {
- DBGMSG("block_read_request called");
- packet = hpsb_make_readbpacket(fi->host, node, addr,
- req->req.length);
- if (!packet) return -ENOMEM;
+ if (!packet)
+ return -ENOMEM;
- req->data = packet->data;
- }
+ if (req->req.length == 4)
+ req->data = &packet->header[3];
+ else
+ req->data = packet->data;
+
break;
case RAW1394_REQ_ASYNC_WRITE:
- if (req->req.length == 4) {
- quadlet_t x;
-
- DBGMSG("quadlet_write_request called");
- if (copy_from_user(&x, int2ptr(req->req.sendb), 4)) {
- req->req.error = RAW1394_ERROR_MEMFAULT;
- }
+ DBGMSG("write_request called");
+ packet = hpsb_make_writepacket(fi->host, node, addr, NULL,
+ req->req.length);
+ if (!packet)
+ return -ENOMEM;
+
+ if (copy_from_user(packet->data, int2ptr(req->req.sendb),
+ req->req.length))
+ req->req.error = RAW1394_ERROR_MEMFAULT;
- packet = hpsb_make_writeqpacket(fi->host, node, addr,
- x);
- if (!packet) return -ENOMEM;
- } else {
- DBGMSG("block_write_request called");
- packet = hpsb_make_writebpacket(fi->host, node, addr,
- req->req.length);
- if (!packet) return -ENOMEM;
-
- if (copy_from_user(packet->data, int2ptr(req->req.sendb),
- req->req.length)) {
- req->req.error = RAW1394_ERROR_MEMFAULT;
- }
- }
req->req.length = 0;
break;
@@ -774,15 +759,14 @@
{
struct hpsb_packet *packet;
- packet = alloc_hpsb_packet(req->req.length);
- if (!packet) return -ENOMEM;
- req->packet = packet;
+ packet = hpsb_make_isopacket(fi->host, req->req.length, channel & 0x3f,
+ (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
+ if (!packet)
+ return -ENOMEM;
- fill_iso_packet(packet, req->req.length, channel & 0x3f,
- (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
- packet->type = hpsb_iso;
packet->speed_code = req->req.address & 0x3;
- packet->host = fi->host;
+
+ req->packet = packet;
if (copy_from_user(packet->data, int2ptr(req->req.sendb),
req->req.length)) {
Modified: trunk/ieee1394_transactions.c
==============================================================================
--- trunk/ieee1394_transactions.c (original)
+++ trunk/ieee1394_transactions.c 2002-10-20 01:59:31.000000000 -0400
@@ -29,15 +29,8 @@
packet->header[1] = (packet->host->node_id << 16) | (addr >> 32); \
packet->header[2] = addr & 0xffffffff
-#define PREP_ASYNC_HEAD_RCODE(tc) \
- packet->tcode = tc; \
- packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
- | (1 << 8) | (tc << 4); \
- packet->header[1] = (packet->host->node_id << 16) | (rcode << 12); \
- packet->header[2] = 0
-
-void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
+static void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
{
PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ);
packet->header_size = 12;
@@ -45,16 +38,7 @@
packet->expect_response = 1;
}
-void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
- quadlet_t data)
-{
- PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE);
- packet->header[3] = data;
- packet->header_size = 16;
- packet->data_size = 0;
-}
-
-void fill_async_readblock(struct hpsb_packet *packet, u64 addr, int length)
+static void fill_async_readblock(struct hpsb_packet *packet, u64 addr, int length)
{
PREP_ASYNC_HEAD_ADDRESS(TCODE_READB);
packet->header[3] = length << 16;
@@ -63,19 +47,6 @@
packet->expect_response = 1;
}
-void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
- int length)
-{
- if (rcode != RCODE_COMPLETE) {
- length = 0;
- }
-
- PREP_ASYNC_HEAD_RCODE(TCODE_READB_RESPONSE);
- packet->header[3] = length << 16;
- packet->header_size = 16;
- packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
-}
-
void fill_async_writequad(struct hpsb_packet *packet, u64 addr, quadlet_t data)
{
PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ);
@@ -94,15 +65,7 @@
packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
}
-void fill_async_write_resp(struct hpsb_packet *packet, int rcode)
-{
- PREP_ASYNC_HEAD_RCODE(TCODE_WRITE_RESPONSE);
- packet->header[2] = 0;
- packet->header_size = 12;
- packet->data_size = 0;
-}
-
-void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
+static void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
int length)
{
PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST);
@@ -112,20 +75,7 @@
packet->expect_response = 1;
}
-void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
- int length)
-{
- if (rcode != RCODE_COMPLETE) {
- length = 0;
- }
-
- PREP_ASYNC_HEAD_RCODE(TCODE_LOCK_RESPONSE);
- packet->header[3] = (length << 16) | extcode;
- packet->header_size = 16;
- packet->data_size = length;
-}
-
-void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
+static void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
int tag, int sync)
{
packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
@@ -137,7 +87,7 @@
packet->tcode = TCODE_ISO_DATA;
}
-void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
+static void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
{
packet->header[0] = data;
packet->header[1] = ~data;
@@ -292,86 +242,70 @@
HPSB_PANIC("reached unreachable code 2 in %s", __FUNCTION__);
}
-struct hpsb_packet *hpsb_make_readqpacket(struct hpsb_host *host, nodeid_t node,
- u64 addr)
+struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node,
+ u64 addr, size_t length)
{
- struct hpsb_packet *p;
-
- p = alloc_hpsb_packet(0);
- if (!p) return NULL;
+ struct hpsb_packet *packet;
- p->host = host;
- p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
- free_hpsb_packet(p);
+ if (length == 0)
return NULL;
- }
- fill_async_readquad(p, addr);
- return p;
-}
+ if (length % 4)
+ length += 4 - (length % 4);
-struct hpsb_packet *hpsb_make_readbpacket(struct hpsb_host *host, nodeid_t node,
- u64 addr, size_t length)
-{
- struct hpsb_packet *p;
+ packet = alloc_hpsb_packet(length);
+ if (!packet)
+ return NULL;
- p = alloc_hpsb_packet(length + (length % 4 ? 4 - (length % 4) : 0));
- if (!p) return NULL;
+ packet->host = host;
+ packet->node_id = node;
- p->host = host;
- p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
- free_hpsb_packet(p);
+ if (hpsb_get_tlabel(packet, in_interrupt() ? 0 : 1)) {
+ free_hpsb_packet(packet);
return NULL;
}
- fill_async_readblock(p, addr, length);
- return p;
+ if (length == 4)
+ fill_async_readquad(packet, addr);
+ else
+ fill_async_readblock(packet, addr, length);
+
+ return packet;
}
-struct hpsb_packet *hpsb_make_writeqpacket(struct hpsb_host *host,
- nodeid_t node, u64 addr,
- quadlet_t data)
+struct hpsb_packet *hpsb_make_writepacket (struct hpsb_host *host, nodeid_t node,
+ u64 addr, quadlet_t *buffer, size_t length)
{
- struct hpsb_packet *p;
-
- p = alloc_hpsb_packet(0);
- if (!p) return NULL;
+ struct hpsb_packet *packet;
- p->host = host;
- p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
- free_hpsb_packet(p);
+ if (length == 0)
return NULL;
- }
- fill_async_writequad(p, addr, data);
- return p;
-}
+ if (length % 4)
+ length += 4 - (length % 4);
-struct hpsb_packet *hpsb_make_writebpacket(struct hpsb_host *host,
- nodeid_t node, u64 addr,
- size_t length)
-{
- struct hpsb_packet *p;
-
- p = alloc_hpsb_packet(length + (length % 4 ? 4 - (length % 4) : 0));
- if (!p) return NULL;
+ packet = alloc_hpsb_packet(length);
+ if (!packet)
+ return NULL;
- if (length % 4) {
- p->data[length / 4] = 0;
- }
+ packet->data[length >> 2] = 0;
+ packet->host = host;
+ packet->node_id = node;
- p->host = host;
- p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
- free_hpsb_packet(p);
+ if (hpsb_get_tlabel(packet, in_interrupt() ? 0 : 1)) {
+ free_hpsb_packet(packet);
return NULL;
}
- fill_async_writeblock(p, addr, length);
- return p;
+ if (length == 4) {
+ fill_async_writequad(packet, addr, buffer ? *buffer : 0);
+ } else {
+ fill_async_writeblock(packet, addr, length);
+ if (buffer)
+ memcpy(packet->data, buffer, length);
+ }
+
+ return packet;
}
struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node,
@@ -384,7 +318,7 @@
p->host = host;
p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
+ if (hpsb_get_tlabel(p, in_interrupt() ? 0 : 1)) {
free_hpsb_packet(p);
return NULL;
}
@@ -412,7 +346,7 @@
p->host = host;
p->node_id = node;
- if (hpsb_get_tlabel(p, 1)) {
+ if (hpsb_get_tlabel(p, in_interrupt() ? 0 : 1)) {
free_hpsb_packet(p);
return NULL;
}
@@ -444,6 +378,23 @@
return p;
}
+struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host,
+ int length, int channel,
+ int tag, int sync)
+{
+ struct hpsb_packet *p;
+
+ p = alloc_hpsb_packet(length);
+ if (!p) return NULL;
+
+ p->host = host;
+ fill_iso_packet(p, length, channel, tag, sync);
+
+ p->generation = get_hpsb_generation(host);
+
+ return p;
+}
+
/*
* FIXME - these functions should probably read from / write to user space to
* avoid in kernel buffers for user space callers
@@ -455,15 +406,12 @@
struct hpsb_packet *packet;
int retval = 0;
- if (length == 0) {
+ if (length == 0)
return -EINVAL;
- }
- if (length == 4) {
- packet = hpsb_make_readqpacket(host, node, addr);
- } else {
- packet = hpsb_make_readbpacket(host, node, addr, length);
- }
+ BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
+
+ packet = hpsb_make_readpacket(host, node, addr, length);
if (!packet) {
return -ENOMEM;
@@ -494,29 +442,6 @@
return retval;
}
-struct hpsb_packet *hpsb_make_packet (struct hpsb_host *host, nodeid_t node,
- u64 addr, quadlet_t *buffer, size_t length)
-{
- struct hpsb_packet *packet;
-
- if (length == 0)
- return NULL;
-
- if (length == 4)
- packet = hpsb_make_writeqpacket(host, node, addr, *buffer);
- else
- packet = hpsb_make_writebpacket(host, node, addr, length);
-
- if (!packet)
- return NULL;
-
- /* Sometimes this may be called without data, just to allocate the
- * packet. */
- if (length != 4 && buffer)
- memcpy(packet->data, buffer, length);
-
- return packet;
-}
int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
u64 addr, quadlet_t *buffer, size_t length)
@@ -527,7 +452,9 @@
if (length == 0)
return -EINVAL;
- packet = hpsb_make_packet (host, node, addr, buffer, length);
+ BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
+
+ packet = hpsb_make_writepacket (host, node, addr, buffer, length);
if (!packet)
return -ENOMEM;
@@ -556,6 +483,8 @@
{
struct hpsb_packet *packet;
int retval = 0, length;
+
+ BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
packet = alloc_hpsb_packet(8);
if (!packet) {
Modified: trunk/ieee1394_transactions.h
==============================================================================
--- trunk/ieee1394_transactions.h (original)
+++ trunk/ieee1394_transactions.h 2002-10-20 01:59:31.000000000 -0400
@@ -7,22 +7,8 @@
/*
* Utility functions to fill out packet headers.
*/
-void fill_async_readquad(struct hpsb_packet *packet, u64 addr);
-void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
- quadlet_t data);
-void fill_async_readblock(struct hpsb_packet *packet, u64 addr, int length);
-void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
- int length);
void fill_async_writequad(struct hpsb_packet *packet, u64 addr, quadlet_t data);
void fill_async_writeblock(struct hpsb_packet *packet, u64 addr, int length);
-void fill_async_write_resp(struct hpsb_packet *packet, int rcode);
-void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
- int length);
-void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
- int length);
-void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
- int tag, int sync);
-void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data);
/*
* Get and free transaction labels.
@@ -30,23 +16,19 @@
int hpsb_get_tlabel(struct hpsb_packet *packet, int wait);
void hpsb_free_tlabel(struct hpsb_packet *packet);
-struct hpsb_packet *hpsb_make_readqpacket(struct hpsb_host *host, nodeid_t node,
- u64 addr);
-struct hpsb_packet *hpsb_make_readbpacket(struct hpsb_host *host, nodeid_t node,
- u64 addr, size_t length);
-struct hpsb_packet *hpsb_make_writeqpacket(struct hpsb_host *host,
- nodeid_t node, u64 addr,
- quadlet_t data);
-struct hpsb_packet *hpsb_make_writebpacket(struct hpsb_host *host,
- nodeid_t node, u64 addr,
- size_t length);
+struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node,
+ u64 addr, size_t length);
struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node,
u64 addr, int extcode);
struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host, nodeid_t node,
u64 addr, int extcode);
struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host,
quadlet_t data) ;
-
+struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host,
+ int length, int channel,
+ int tag, int sync);
+struct hpsb_packet *hpsb_make_writepacket (struct hpsb_host *host, nodeid_t node,
+ u64 addr, quadlet_t *buffer, size_t length);
/*
* hpsb_packet_success - Make sense of the ack and reply codes and
@@ -76,9 +58,4 @@
int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
u64 addr, int extcode, quadlet_t *data, quadlet_t arg);
-/* Generic packet creation. Used by hpsb_write. Also useful for protocol
- * drivers that want to implement their own hpsb_write replacement. */
-struct hpsb_packet *hpsb_make_packet (struct hpsb_host *host, nodeid_t node,
- u64 addr, quadlet_t *buffer, size_t length);
-
#endif /* _IEEE1394_TRANSACTIONS_H */
|