firewire: deadline for PHY config transmission
[linux-2.6.git] / drivers / firewire / fw-transaction.c
index 3052698..03ae8a7 100644 (file)
@@ -1,6 +1,5 @@
-/*                                             -*- c-basic-offset: 8 -*-
- *
- * fw-transaction.c - core IEEE1394 transaction logic
+/*
+ * Core IEEE1394 transaction logic
  *
  * Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net>
  *
@@ -19,7 +18,9 @@
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#include <linux/completion.h>
 #include <linux/kernel.h>
+#include <linux/kref.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/kthread.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 
 #include "fw-transaction.h"
 #include "fw-topology.h"
 #include "fw-device.h"
 
-#define header_pri(pri)                        ((pri) << 0)
-#define header_tcode(tcode)            ((tcode) << 4)
-#define header_retry(retry)            ((retry) << 8)
-#define header_tlabel(tlabel)          ((tlabel) << 10)
-#define header_destination(destination)        ((destination) << 16)
-#define header_source(source)          ((source) << 16)
-#define header_rcode(rcode)            ((rcode) << 12)
-#define header_offset_high(offset_high)        ((offset_high) << 0)
-#define header_data_length(length)     ((length) << 16)
-#define header_extended_tcode(tcode)   ((tcode) << 0)
-
-#define header_get_tcode(q)            (((q) >> 4) & 0x0f)
-#define header_get_tlabel(q)           (((q) >> 10) & 0x3f)
-#define header_get_rcode(q)            (((q) >> 12) & 0x0f)
-#define header_get_destination(q)      (((q) >> 16) & 0xffff)
-#define header_get_source(q)           (((q) >> 16) & 0xffff)
-#define header_get_offset_high(q)      (((q) >> 0) & 0xffff)
-#define header_get_data_length(q)      (((q) >> 16) & 0xffff)
-#define header_get_extended_tcode(q)   (((q) >> 0) & 0xffff)
-
-#define phy_config_gap_count(gap_count)        (((gap_count) << 16) | (1 << 22))
-#define phy_config_root_id(node_id)    ((((node_id) & 0x3f) << 24) | (1 << 23))
-#define phy_identifier(id)             ((id) << 30)
+#define HEADER_PRI(pri)                        ((pri) << 0)
+#define HEADER_TCODE(tcode)            ((tcode) << 4)
+#define HEADER_RETRY(retry)            ((retry) << 8)
+#define HEADER_TLABEL(tlabel)          ((tlabel) << 10)
+#define HEADER_DESTINATION(destination)        ((destination) << 16)
+#define HEADER_SOURCE(source)          ((source) << 16)
+#define HEADER_RCODE(rcode)            ((rcode) << 12)
+#define HEADER_OFFSET_HIGH(offset_high)        ((offset_high) << 0)
+#define HEADER_DATA_LENGTH(length)     ((length) << 16)
+#define HEADER_EXTENDED_TCODE(tcode)   ((tcode) << 0)
+
+#define HEADER_GET_TCODE(q)            (((q) >> 4) & 0x0f)
+#define HEADER_GET_TLABEL(q)           (((q) >> 10) & 0x3f)
+#define HEADER_GET_RCODE(q)            (((q) >> 12) & 0x0f)
+#define HEADER_GET_DESTINATION(q)      (((q) >> 16) & 0xffff)
+#define HEADER_GET_SOURCE(q)           (((q) >> 16) & 0xffff)
+#define HEADER_GET_OFFSET_HIGH(q)      (((q) >> 0) & 0xffff)
+#define HEADER_GET_DATA_LENGTH(q)      (((q) >> 16) & 0xffff)
+#define HEADER_GET_EXTENDED_TCODE(q)   (((q) >> 0) & 0xffff)
+
+#define PHY_CONFIG_GAP_COUNT(gap_count)        (((gap_count) << 16) | (1 << 22))
+#define PHY_CONFIG_ROOT_ID(node_id)    ((((node_id) & 0x3f) << 24) | (1 << 23))
+#define PHY_IDENTIFIER(id)             ((id) << 30)
 
 static int
 close_transaction(struct fw_transaction *transaction,
@@ -85,21 +85,27 @@ close_transaction(struct fw_transaction *transaction,
        return -ENOENT;
 }
 
-/* Only valid for transactions that are potentially pending (ie have
- * been sent). */
+/*
+ * Only valid for transactions that are potentially pending (ie have
+ * been sent).
+ */
 int
 fw_cancel_transaction(struct fw_card *card,
                      struct fw_transaction *transaction)
 {
-       /* Cancel the packet transmission if it's still queued.  That
+       /*
+        * Cancel the packet transmission if it's still queued.  That
         * will call the packet transmission callback which cancels
-        * the transaction. */
+        * the transaction.
+        */
 
        if (card->driver->cancel_packet(card, &transaction->packet) == 0)
                return 0;
 
-       /* If the request packet has already been sent, we need to see
-        * if the transaction is still pending and remove it in that case. */
+       /*
+        * If the request packet has already been sent, we need to see
+        * if the transaction is still pending and remove it in that case.
+        */
 
        return close_transaction(transaction, card, RCODE_CANCELLED, NULL, 0);
 }
@@ -131,8 +137,10 @@ transmit_complete_callback(struct fw_packet *packet,
                close_transaction(t, card, RCODE_TYPE_ERROR, NULL, 0);
                break;
        default:
-               /* In this case the ack is really a juju specific
-                * rcode, so just forward that to the callback. */
+               /*
+                * In this case the ack is really a juju specific
+                * rcode, so just forward that to the callback.
+                */
                close_transaction(t, card, status, NULL, 0);
                break;
        }
@@ -140,24 +148,24 @@ transmit_complete_callback(struct fw_packet *packet,
 
 static void
 fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
-               int node_id, int generation, int speed,
+               int node_id, int source_id, int generation, int speed,
                unsigned long long offset, void *payload, size_t length)
 {
        int ext_tcode;
 
        if (tcode > 0x10) {
-               ext_tcode = tcode - 0x10;
+               ext_tcode = tcode & ~0x10;
                tcode = TCODE_LOCK_REQUEST;
        } else
                ext_tcode = 0;
 
        packet->header[0] =
-               header_retry(RETRY_X) |
-               header_tlabel(tlabel) |
-               header_tcode(tcode) |
-               header_destination(node_id);
+               HEADER_RETRY(RETRY_X) |
+               HEADER_TLABEL(tlabel) |
+               HEADER_TCODE(tcode) |
+               HEADER_DESTINATION(node_id);
        packet->header[1] =
-               header_offset_high(offset >> 32) | header_source(0);
+               HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id);
        packet->header[2] =
                offset;
 
@@ -171,8 +179,8 @@ fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
        case TCODE_LOCK_REQUEST:
        case TCODE_WRITE_BLOCK_REQUEST:
                packet->header[3] =
-                       header_data_length(length) |
-                       header_extended_tcode(ext_tcode);
+                       HEADER_DATA_LENGTH(length) |
+                       HEADER_EXTENDED_TCODE(ext_tcode);
                packet->header_length = 16;
                packet->payload = payload;
                packet->payload_length = length;
@@ -185,8 +193,8 @@ fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
 
        case TCODE_READ_BLOCK_REQUEST:
                packet->header[3] =
-                       header_data_length(length) |
-                       header_extended_tcode(ext_tcode);
+                       HEADER_DATA_LENGTH(length) |
+                       HEADER_EXTENDED_TCODE(ext_tcode);
                packet->header_length = 16;
                packet->payload_length = 0;
                break;
@@ -221,7 +229,7 @@ fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
  *
  * @param card the card from which to send the request
  * @param tcode the tcode for this transaction.  Do not use
- *   TCODE_LOCK_REQUEST directly, insted use TCODE_LOCK_MASK_SWAP
+ *   TCODE_LOCK_REQUEST directly, instead use TCODE_LOCK_MASK_SWAP
  *   etc. to specify tcode and ext_tcode.
  * @param node_id the destination node ID (bus ID and PHY ID concatenated)
  * @param generation the generation for which node_id is valid
@@ -241,18 +249,23 @@ fw_send_request(struct fw_card *card, struct fw_transaction *t,
                fw_transaction_callback_t callback, void *callback_data)
 {
        unsigned long flags;
-       int tlabel;
+       int tlabel, source;
 
-       /* Bump the flush timer up 100ms first of all so we
-        * don't race with a flush timer callback. */
+       /*
+        * Bump the flush timer up 100ms first of all so we
+        * don't race with a flush timer callback.
+        */
 
        mod_timer(&card->flush_timer, jiffies + DIV_ROUND_UP(HZ, 10));
 
-       /* Allocate tlabel from the bitmap and put the transaction on
-        * the list while holding the card spinlock. */
+       /*
+        * Allocate tlabel from the bitmap and put the transaction on
+        * the list while holding the card spinlock.
+        */
 
        spin_lock_irqsave(&card->lock, flags);
 
+       source = card->node_id;
        tlabel = card->current_tlabel;
        if (card->tlabel_mask & (1 << tlabel)) {
                spin_unlock_irqrestore(&card->lock, flags);
@@ -274,49 +287,66 @@ fw_send_request(struct fw_card *card, struct fw_transaction *t,
        t->callback_data = callback_data;
 
        fw_fill_request(&t->packet, tcode, t->tlabel,
-                       node_id, generation, speed, offset, payload, length);
+                       node_id, source, generation,
+                       speed, offset, payload, length);
        t->packet.callback = transmit_complete_callback;
 
        card->driver->send_request(card, &t->packet);
 }
 EXPORT_SYMBOL(fw_send_request);
 
-static void
-transmit_phy_packet_callback(struct fw_packet *packet,
-                            struct fw_card *card, int status)
+struct fw_phy_packet {
+       struct fw_packet packet;
+       struct completion done;
+       struct kref kref;
+};
+
+static void phy_packet_release(struct kref *kref)
 {
-       kfree(packet);
+       struct fw_phy_packet *p =
+                       container_of(kref, struct fw_phy_packet, kref);
+       kfree(p);
 }
 
-static void send_phy_packet(struct fw_card *card, u32 data, int generation)
+static void transmit_phy_packet_callback(struct fw_packet *packet,
+                                        struct fw_card *card, int status)
 {
-       struct fw_packet *packet;
-
-       packet = kzalloc(sizeof *packet, GFP_ATOMIC);
-       if (packet == NULL)
-               return;
-
-       packet->header[0] = data;
-       packet->header[1] = ~data;
-       packet->header_length = 8;
-       packet->payload_length = 0;
-       packet->speed = SCODE_100;
-       packet->generation = generation;
-       packet->callback = transmit_phy_packet_callback;
+       struct fw_phy_packet *p =
+                       container_of(packet, struct fw_phy_packet, packet);
 
-       card->driver->send_request(card, packet);
+       complete(&p->done);
+       kref_put(&p->kref, phy_packet_release);
 }
 
 void fw_send_phy_config(struct fw_card *card,
                        int node_id, int generation, int gap_count)
 {
-       u32 q;
-
-       q = phy_identifier(PHY_PACKET_CONFIG) |
-               phy_config_root_id(node_id) |
-               phy_config_gap_count(gap_count);
+       struct fw_phy_packet *p;
+       long timeout = DIV_ROUND_UP(HZ, 10);
+       u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG) |
+                  PHY_CONFIG_ROOT_ID(node_id) |
+                  PHY_CONFIG_GAP_COUNT(gap_count);
+
+       p = kmalloc(sizeof(*p), GFP_KERNEL);
+       if (p == NULL)
+               return;
 
-       send_phy_packet(card, q, generation);
+       p->packet.header[0] = data;
+       p->packet.header[1] = ~data;
+       p->packet.header_length = 8;
+       p->packet.payload_length = 0;
+       p->packet.speed = SCODE_100;
+       p->packet.generation = generation;
+       p->packet.callback = transmit_phy_packet_callback;
+       init_completion(&p->done);
+       kref_set(&p->kref, 2);
+
+       card->driver->send_request(card, &p->packet);
+       timeout = wait_for_completion_timeout(&p->done, timeout);
+       kref_put(&p->kref, phy_packet_release);
+
+       /* will leak p if the callback is never executed */
+       WARN_ON(timeout == 0);
 }
 
 void fw_flush_transactions(struct fw_card *card)
@@ -334,9 +364,11 @@ void fw_flush_transactions(struct fw_card *card)
        list_for_each_entry_safe(t, next, &list, link) {
                card->driver->cancel_packet(card, &t->packet);
 
-               /* At this point cancel_packet will never call the
+               /*
+                * At this point cancel_packet will never call the
                 * transaction callback, since we just took all the
-                * transactions out of the list.  So do it here.*/
+                * transactions out of the list.  So do it here.
+                */
                t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
        }
 }
@@ -374,28 +406,33 @@ lookup_enclosing_address_handler(struct list_head *list,
 static DEFINE_SPINLOCK(address_handler_lock);
 static LIST_HEAD(address_handler_list);
 
-const struct fw_address_region fw_low_memory_region =
-       { .start = 0x000000000000ULL, .end = 0x000100000000ULL,  };
 const struct fw_address_region fw_high_memory_region =
        { .start = 0x000100000000ULL, .end = 0xffffe0000000ULL,  };
+EXPORT_SYMBOL(fw_high_memory_region);
+
+#if 0
+const struct fw_address_region fw_low_memory_region =
+       { .start = 0x000000000000ULL, .end = 0x000100000000ULL,  };
 const struct fw_address_region fw_private_region =
        { .start = 0xffffe0000000ULL, .end = 0xfffff0000000ULL,  };
 const struct fw_address_region fw_csr_region =
-       { .start = 0xfffff0000000ULL, .end = 0xfffff0000800ULL,  };
+       { .start = CSR_REGISTER_BASE,
+         .end   = CSR_REGISTER_BASE | CSR_CONFIG_ROM_END,  };
 const struct fw_address_region fw_unit_space_region =
        { .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
-EXPORT_SYMBOL(fw_low_memory_region);
-EXPORT_SYMBOL(fw_high_memory_region);
-EXPORT_SYMBOL(fw_private_region);
-EXPORT_SYMBOL(fw_csr_region);
-EXPORT_SYMBOL(fw_unit_space_region);
+#endif  /*  0  */
 
 /**
  * Allocate a range of addresses in the node space of the OHCI
  * controller.  When a request is received that falls within the
  * specified address range, the specified callback is invoked.  The
  * parameters passed to the callback give the details of the
- * particular request
+ * particular request.
+ *
+ * Return value:  0 on success, non-zero otherwise.
+ * The start offset of the handler's address region is determined by
+ * fw_core_add_address_handler() and is returned in handler->offset.
+ * The offset is quadlet-aligned.
  */
 int
 fw_core_add_address_handler(struct fw_address_handler *handler,
@@ -407,14 +444,15 @@ fw_core_add_address_handler(struct fw_address_handler *handler,
 
        spin_lock_irqsave(&address_handler_lock, flags);
 
-       handler->offset = region->start;
+       handler->offset = roundup(region->start, 4);
        while (handler->offset + handler->length <= region->end) {
                other =
                    lookup_overlapping_address_handler(&address_handler_list,
                                                       handler->offset,
                                                       handler->length);
                if (other != NULL) {
-                       handler->offset += other->length;
+                       handler->offset =
+                           roundup(other->offset + other->length, 4);
                } else {
                        list_add_tail(&handler->link, &address_handler_list);
                        ret = 0;
@@ -470,32 +508,32 @@ fw_fill_response(struct fw_packet *response, u32 *request_header,
 {
        int tcode, tlabel, extended_tcode, source, destination;
 
-       tcode          = header_get_tcode(request_header[0]);
-       tlabel         = header_get_tlabel(request_header[0]);
-       source         = header_get_destination(request_header[0]);
-       destination    = header_get_source(request_header[1]);
-       extended_tcode = header_get_extended_tcode(request_header[3]);
+       tcode          = HEADER_GET_TCODE(request_header[0]);
+       tlabel         = HEADER_GET_TLABEL(request_header[0]);
+       source         = HEADER_GET_DESTINATION(request_header[0]);
+       destination    = HEADER_GET_SOURCE(request_header[1]);
+       extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]);
 
        response->header[0] =
-               header_retry(RETRY_1) |
-               header_tlabel(tlabel) |
-               header_destination(destination);
+               HEADER_RETRY(RETRY_1) |
+               HEADER_TLABEL(tlabel) |
+               HEADER_DESTINATION(destination);
        response->header[1] =
-               header_source(source) |
-               header_rcode(rcode);
+               HEADER_SOURCE(source) |
+               HEADER_RCODE(rcode);
        response->header[2] = 0;
 
        switch (tcode) {
        case TCODE_WRITE_QUADLET_REQUEST:
        case TCODE_WRITE_BLOCK_REQUEST:
-               response->header[0] |= header_tcode(TCODE_WRITE_RESPONSE);
+               response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE);
                response->header_length = 12;
                response->payload_length = 0;
                break;
 
        case TCODE_READ_QUADLET_REQUEST:
                response->header[0] |=
-                       header_tcode(TCODE_READ_QUADLET_RESPONSE);
+                       HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE);
                if (payload != NULL)
                        response->header[3] = *(u32 *)payload;
                else
@@ -506,10 +544,10 @@ fw_fill_response(struct fw_packet *response, u32 *request_header,
 
        case TCODE_READ_BLOCK_REQUEST:
        case TCODE_LOCK_REQUEST:
-               response->header[0] |= header_tcode(tcode + 2);
+               response->header[0] |= HEADER_TCODE(tcode + 2);
                response->header[3] =
-                       header_data_length(length) |
-                       header_extended_tcode(extended_tcode);
+                       HEADER_DATA_LENGTH(length) |
+                       HEADER_EXTENDED_TCODE(extended_tcode);
                response->header_length = 16;
                response->payload = payload;
                response->payload_length = length;
@@ -529,7 +567,7 @@ allocate_request(struct fw_packet *p)
        u32 *data, length;
        int request_tcode, t;
 
-       request_tcode = header_get_tcode(p->header[0]);
+       request_tcode = HEADER_GET_TCODE(p->header[0]);
        switch (request_tcode) {
        case TCODE_WRITE_QUADLET_REQUEST:
                data = &p->header[3];
@@ -539,7 +577,7 @@ allocate_request(struct fw_packet *p)
        case TCODE_WRITE_BLOCK_REQUEST:
        case TCODE_LOCK_REQUEST:
                data = p->payload;
-               length = header_get_data_length(p->header[3]);
+               length = HEADER_GET_DATA_LENGTH(p->header[3]);
                break;
 
        case TCODE_READ_QUADLET_REQUEST:
@@ -549,15 +587,16 @@ allocate_request(struct fw_packet *p)
 
        case TCODE_READ_BLOCK_REQUEST:
                data = NULL;
-               length = header_get_data_length(p->header[3]);
+               length = HEADER_GET_DATA_LENGTH(p->header[3]);
                break;
 
        default:
-               BUG();
+               fw_error("ERROR - corrupt request received - %08x %08x %08x\n",
+                        p->header[0], p->header[1], p->header[2]);
                return NULL;
        }
 
-       request = kmalloc(sizeof *request + length, GFP_ATOMIC);
+       request = kmalloc(sizeof(*request) + length, GFP_ATOMIC);
        if (request == NULL)
                return NULL;
 
@@ -577,7 +616,7 @@ allocate_request(struct fw_packet *p)
        if (data)
                memcpy(request->data, data, length);
 
-       memcpy(request->request_header, p->header, sizeof p->header);
+       memcpy(request->request_header, p->header, sizeof(p->header));
 
        return request;
 }
@@ -585,11 +624,15 @@ allocate_request(struct fw_packet *p)
 void
 fw_send_response(struct fw_card *card, struct fw_request *request, int rcode)
 {
-       /* Broadcast packets are reported as ACK_COMPLETE, so this
+       /*
+        * Broadcast packets are reported as ACK_COMPLETE, so this
         * check is sufficient to ensure we don't send response to
-        * broadcast packets or posted writes. */
-       if (request->ack != ACK_PENDING)
+        * broadcast packets or posted writes.
+        */
+       if (request->ack != ACK_PENDING) {
+               kfree(request);
                return;
+       }
 
        if (rcode == RCODE_COMPLETE)
                fw_fill_response(&request->response, request->request_header,
@@ -611,11 +654,6 @@ fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
        unsigned long flags;
        int tcode, destination, source;
 
-       if (p->payload_length > 2048) {
-               /* FIXME: send error response. */
-               return;
-       }
-
        if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
                return;
 
@@ -627,21 +665,23 @@ fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
 
        offset      =
                ((unsigned long long)
-                header_get_offset_high(p->header[1]) << 32) | p->header[2];
-       tcode       = header_get_tcode(p->header[0]);
-       destination = header_get_destination(p->header[0]);
-       source      = header_get_source(p->header[0]);
+                HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) | p->header[2];
+       tcode       = HEADER_GET_TCODE(p->header[0]);
+       destination = HEADER_GET_DESTINATION(p->header[0]);
+       source      = HEADER_GET_SOURCE(p->header[1]);
 
        spin_lock_irqsave(&address_handler_lock, flags);
        handler = lookup_enclosing_address_handler(&address_handler_list,
                                                   offset, request->length);
        spin_unlock_irqrestore(&address_handler_lock, flags);
 
-       /* FIXME: lookup the fw_node corresponding to the sender of
+       /*
+        * FIXME: lookup the fw_node corresponding to the sender of
         * this request and pass that to the address handler instead
         * of the node ID.  We may also want to move the address
         * allocations to fw_node so we only do this callback if the
-        * upper layers registered it for this node. */
+        * upper layers registered it for this node.
+        */
 
        if (handler == NULL)
                fw_send_response(card, request, RCODE_ADDRESS_ERROR);
@@ -663,11 +703,11 @@ fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
        size_t data_length;
        int tcode, tlabel, destination, source, rcode;
 
-       tcode       = header_get_tcode(p->header[0]);
-       tlabel      = header_get_tlabel(p->header[0]);
-       destination = header_get_destination(p->header[0]);
-       source      = header_get_source(p->header[1]);
-       rcode       = header_get_rcode(p->header[1]);
+       tcode       = HEADER_GET_TCODE(p->header[0]);
+       tlabel      = HEADER_GET_TLABEL(p->header[0]);
+       destination = HEADER_GET_DESTINATION(p->header[0]);
+       source      = HEADER_GET_SOURCE(p->header[1]);
+       rcode       = HEADER_GET_RCODE(p->header[1]);
 
        spin_lock_irqsave(&card->lock, flags);
        list_for_each_entry(t, &card->transaction_list, link) {
@@ -685,8 +725,10 @@ fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
                return;
        }
 
-       /* FIXME: sanity check packet, is length correct, does tcodes
-        * and addresses match. */
+       /*
+        * FIXME: sanity check packet, is length correct, does tcodes
+        * and addresses match.
+        */
 
        switch (tcode) {
        case TCODE_READ_QUADLET_RESPONSE:
@@ -702,7 +744,7 @@ fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
        case TCODE_READ_BLOCK_RESPONSE:
        case TCODE_LOCK_RESPONSE:
                data = p->payload;
-               data_length = header_get_data_length(p->header[3]);
+               data_length = HEADER_GET_DATA_LENGTH(p->header[3]);
                break;
 
        default:
@@ -712,10 +754,113 @@ fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
                break;
        }
 
+       /*
+        * The response handler may be executed while the request handler
+        * is still pending.  Cancel the request handler.
+        */
+       card->driver->cancel_packet(card, &t->packet);
+
        t->callback(card, rcode, data, data_length, t->callback_data);
 }
 EXPORT_SYMBOL(fw_core_handle_response);
 
+static const struct fw_address_region topology_map_region =
+       { .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP,
+         .end   = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, };
+
+static void
+handle_topology_map(struct fw_card *card, struct fw_request *request,
+                   int tcode, int destination, int source,
+                   int generation, int speed,
+                   unsigned long long offset,
+                   void *payload, size_t length, void *callback_data)
+{
+       int i, start, end;
+       __be32 *map;
+
+       if (!TCODE_IS_READ_REQUEST(tcode)) {
+               fw_send_response(card, request, RCODE_TYPE_ERROR);
+               return;
+       }
+
+       if ((offset & 3) > 0 || (length & 3) > 0) {
+               fw_send_response(card, request, RCODE_ADDRESS_ERROR);
+               return;
+       }
+
+       start = (offset - topology_map_region.start) / 4;
+       end = start + length / 4;
+       map = payload;
+
+       for (i = 0; i < length / 4; i++)
+               map[i] = cpu_to_be32(card->topology_map[start + i]);
+
+       fw_send_response(card, request, RCODE_COMPLETE);
+}
+
+static struct fw_address_handler topology_map = {
+       .length                 = 0x200,
+       .address_callback       = handle_topology_map,
+};
+
+static const struct fw_address_region registers_region =
+       { .start = CSR_REGISTER_BASE,
+         .end   = CSR_REGISTER_BASE | CSR_CONFIG_ROM, };
+
+static void
+handle_registers(struct fw_card *card, struct fw_request *request,
+                int tcode, int destination, int source,
+                int generation, int speed,
+                unsigned long long offset,
+                void *payload, size_t length, void *callback_data)
+{
+       int reg = offset & ~CSR_REGISTER_BASE;
+       unsigned long long bus_time;
+       __be32 *data = payload;
+
+       switch (reg) {
+       case CSR_CYCLE_TIME:
+       case CSR_BUS_TIME:
+               if (!TCODE_IS_READ_REQUEST(tcode) || length != 4) {
+                       fw_send_response(card, request, RCODE_TYPE_ERROR);
+                       break;
+               }
+
+               bus_time = card->driver->get_bus_time(card);
+               if (reg == CSR_CYCLE_TIME)
+                       *data = cpu_to_be32(bus_time);
+               else
+                       *data = cpu_to_be32(bus_time >> 25);
+               fw_send_response(card, request, RCODE_COMPLETE);
+               break;
+
+       case CSR_BUS_MANAGER_ID:
+       case CSR_BANDWIDTH_AVAILABLE:
+       case CSR_CHANNELS_AVAILABLE_HI:
+       case CSR_CHANNELS_AVAILABLE_LO:
+               /*
+                * FIXME: these are handled by the OHCI hardware and
+                * the stack never sees these request. If we add
+                * support for a new type of controller that doesn't
+                * handle this in hardware we need to deal with these
+                * transactions.
+                */
+               BUG();
+               break;
+
+       case CSR_BUSY_TIMEOUT:
+               /* FIXME: Implement this. */
+       default:
+               fw_send_response(card, request, RCODE_ADDRESS_ERROR);
+               break;
+       }
+}
+
+static struct fw_address_handler registers = {
+       .length                 = 0x400,
+       .address_callback       = handle_registers,
+};
+
 MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
 MODULE_DESCRIPTION("Core IEEE1394 transaction logic");
 MODULE_LICENSE("GPL");
@@ -767,6 +912,14 @@ static int __init fw_core_init(void)
                return fw_cdev_major;
        }
 
+       retval = fw_core_add_address_handler(&topology_map,
+                                            &topology_map_region);
+       BUG_ON(retval < 0);
+
+       retval = fw_core_add_address_handler(&registers,
+                                            &registers_region);
+       BUG_ON(retval < 0);
+
        /* Add the vendor textual descriptor. */
        retval = fw_core_add_descriptor(&vendor_id_descriptor);
        BUG_ON(retval < 0);