5 files changed, 177 insertions, 73 deletions

diff --git a/drivers/firewire/Kconfig b/drivers/firewire/Kconfig
index 13efcd362072..a9371b36a9b9 100644
--- a/drivers/firewire/Kconfig
+++ b/drivers/firewire/Kconfig
@@ -1,5 +1,10 @@
+menu "IEEE 1394 (FireWire) support"
+        depends on PCI || BROKEN
+        # firewire-core does not depend on PCI but is
+        # not useful without PCI controller driver
+
 comment "You can enable one or both FireWire driver stacks."
-comment "See the help texts for more information."
+comment "The newer stack is recommended."
 
 config FIREWIRE
         tristate "FireWire driver stack"
@@ -15,16 +20,6 @@ config FIREWIRE
           To compile this driver as a module, say M here: the module will be
           called firewire-core.
 
-          This module functionally replaces ieee1394, raw1394, and video1394.
-          To access it from application programs, you generally need at least
-          libraw1394 v2.  IIDC/DCAM applications need libdc1394 v2.
-          No libraries are required to access storage devices through the
-          firewire-sbp2 driver.
-
-          NOTE:
-          FireWire audio devices currently require the old drivers (ieee1394,
-          ohci1394, raw1394).
-
 config FIREWIRE_OHCI
         tristate "OHCI-1394 controllers"
         depends on PCI && FIREWIRE
@@ -34,22 +29,7 @@ config FIREWIRE_OHCI
           is the only chipset in use, so say Y here.
 
           To compile this driver as a module, say M here:  The module will be
-          called firewire-ohci.  It replaces ohci1394 of the classic IEEE 1394
-          stack.
-
-          NOTE:
-          If you want to install firewire-ohci and ohci1394 together, you
-          should configure them only as modules and blacklist the driver(s)
-          which you don't want to have auto-loaded.  Add either
-
-              blacklist firewire-ohci
-          or
-              blacklist ohci1394
-              blacklist video1394
-              blacklist dv1394
-
-          to /etc/modprobe.conf or /etc/modprobe.d/* and update modprobe.conf
-          depending on your distribution.
+          called firewire-ohci.
 
 config FIREWIRE_OHCI_DEBUG
         bool
@@ -66,8 +46,7 @@ config FIREWIRE_SBP2
           like scanners.
 
           To compile this driver as a module, say M here:  The module will be
-          called firewire-sbp2.  It replaces sbp2 of the classic IEEE 1394
-          stack.
+          called firewire-sbp2.
 
           You should also enable support for disks, CD-ROMs, etc. in the SCSI
           configuration section.
@@ -83,5 +62,8 @@ config FIREWIRE_NET
           NOTE, this driver is not stable yet!
 
           To compile this driver as a module, say M here:  The module will be
-          called firewire-net.  It replaces eth1394 of the classic IEEE 1394
-          stack.
+          called firewire-net.
+
+source "drivers/ieee1394/Kconfig"
+
+endmenu
diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 7083bcc1b9c7..5045156c5313 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -57,6 +57,8 @@ static LIST_HEAD(descriptor_list);
 static int descriptor_count;
 
 static __be32 tmp_config_rom[256];
+/* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
+static size_t config_rom_length = 1 + 4 + 1 + 1;
 
 #define BIB_CRC(v)              ((v) <<  0)
 #define BIB_CRC_LENGTH(v)       ((v) << 16)
@@ -73,7 +75,7 @@ static __be32 tmp_config_rom[256];
 #define BIB_CMC                 ((1) << 30)
 #define BIB_IMC                 ((1) << 31)
 
-static size_t generate_config_rom(struct fw_card *card, __be32 *config_rom)
+static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 {
         struct fw_descriptor *desc;
         int i, j, k, length;
@@ -130,23 +132,30 @@ static size_t generate_config_rom(struct fw_card *card, __be32 *config_rom)
         for (i = 0; i < j; i += length + 1)
                 length = fw_compute_block_crc(config_rom + i);
 
-        return j;
+        WARN_ON(j != config_rom_length);
 }
 
 static void update_config_roms(void)
 {
         struct fw_card *card;
-        size_t length;
 
         list_for_each_entry (card, &card_list, link) {
-                length = generate_config_rom(card, tmp_config_rom);
-                card->driver->set_config_rom(card, tmp_config_rom, length);
+                generate_config_rom(card, tmp_config_rom);
+                card->driver->set_config_rom(card, tmp_config_rom,
+                                             config_rom_length);
         }
 }
 
+static size_t required_space(struct fw_descriptor *desc)
+{
+        /* descriptor + entry into root dir + optional immediate entry */
+        return desc->length + 1 + (desc->immediate > 0 ? 1 : 0);
+}
+
 int fw_core_add_descriptor(struct fw_descriptor *desc)
 {
         size_t i;
+        int ret;
 
         /*
          * Check descriptor is valid; the length of all blocks in the
@@ -162,15 +171,21 @@ int fw_core_add_descriptor(struct fw_descriptor *desc)
 
         mutex_lock(&card_mutex);
 
-        list_add_tail(&desc->link, &descriptor_list);
-        descriptor_count++;
-        if (desc->immediate > 0)
+        if (config_rom_length + required_space(desc) > 256) {
+                ret = -EBUSY;
+        } else {
+                list_add_tail(&desc->link, &descriptor_list);
+                config_rom_length += required_space(desc);
                 descriptor_count++;
-        update_config_roms();
+                if (desc->immediate > 0)
+                        descriptor_count++;
+                update_config_roms();
+                ret = 0;
+        }
 
         mutex_unlock(&card_mutex);
 
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL(fw_core_add_descriptor);
 
@@ -179,6 +194,7 @@ void fw_core_remove_descriptor(struct fw_descriptor *desc)
         mutex_lock(&card_mutex);
 
         list_del(&desc->link);
+        config_rom_length -= required_space(desc);
         descriptor_count--;
         if (desc->immediate > 0)
                 descriptor_count--;
@@ -428,7 +444,6 @@ EXPORT_SYMBOL(fw_card_initialize);
 int fw_card_add(struct fw_card *card,
                 u32 max_receive, u32 link_speed, u64 guid)
 {
-        size_t length;
         int ret;
 
         card->max_receive = max_receive;
@@ -437,8 +452,8 @@ int fw_card_add(struct fw_card *card,
 
         mutex_lock(&card_mutex);
 
-        length = generate_config_rom(card, tmp_config_rom);
-        ret = card->driver->enable(card, tmp_config_rom, length);
+        generate_config_rom(card, tmp_config_rom);
+        ret = card->driver->enable(card, tmp_config_rom, config_rom_length);
         if (ret == 0)
                 list_add_tail(&card->link, &card_list);
 
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index 231e6ee5ba43..4eeaed57e219 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -35,6 +35,7 @@
 #include <linux/preempt.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
+#include <linux/string.h>
 #include <linux/time.h>
 #include <linux/uaccess.h>
 #include <linux/vmalloc.h>
@@ -595,14 +596,22 @@ static int ioctl_send_request(struct client *client, void *buffer)
                             client->device->max_speed);
 }
 
+static inline bool is_fcp_request(struct fw_request *request)
+{
+        return request == NULL;
+}
+
 static void release_request(struct client *client,
                             struct client_resource *resource)
 {
         struct inbound_transaction_resource *r = container_of(resource,
                         struct inbound_transaction_resource, resource);
 
-        fw_send_response(client->device->card, r->request,
-                         RCODE_CONFLICT_ERROR);
+        if (is_fcp_request(r->request))
+                kfree(r->data);
+        else
+                fw_send_response(client->device->card, r->request,
+                                 RCODE_CONFLICT_ERROR);
         kfree(r);
 }
 
@@ -615,6 +624,7 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         struct address_handler_resource *handler = callback_data;
         struct inbound_transaction_resource *r;
         struct inbound_transaction_event *e;
+        void *fcp_frame = NULL;
         int ret;
 
         r = kmalloc(sizeof(*r), GFP_ATOMIC);
@@ -626,6 +636,18 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         r->data    = payload;
         r->length  = length;
 
+        if (is_fcp_request(request)) {
+                /*
+                 * FIXME: Let core-transaction.c manage a
+                 * single reference-counted copy?
+                 */
+                fcp_frame = kmemdup(payload, length, GFP_ATOMIC);
+                if (fcp_frame == NULL)
+                        goto failed;
+
+                r->data = fcp_frame;
+        }
+
         r->resource.release = release_request;
         ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC);
         if (ret < 0)
@@ -639,13 +661,16 @@ static void handle_request(struct fw_card *card, struct fw_request *request,
         e->request.closure = handler->closure;
 
         queue_event(handler->client, &e->event,
-                    &e->request, sizeof(e->request), payload, length);
+                    &e->request, sizeof(e->request), r->data, length);
         return;
 
  failed:
         kfree(r);
         kfree(e);
-        fw_send_response(card, request, RCODE_CONFLICT_ERROR);
+        kfree(fcp_frame);
+
+        if (!is_fcp_request(request))
+                fw_send_response(card, request, RCODE_CONFLICT_ERROR);
 }
 
 static void release_address_handler(struct client *client,
@@ -715,14 +740,16 @@ static int ioctl_send_response(struct client *client, void *buffer)
 
         r = container_of(resource, struct inbound_transaction_resource,
                          resource);
+        if (is_fcp_request(r->request))
+                goto out;
+
         if (request->length < r->length)
                 r->length = request->length;
-
         if (copy_from_user(r->data, u64_to_uptr(request->data), r->length)) {
                 ret = -EFAULT;
+                kfree(r->request);
                 goto out;
         }
-
         fw_send_response(client->device->card, r->request, request->rcode);
  out:
         kfree(r);
diff --git a/drivers/firewire/core-transaction.c b/drivers/firewire/core-transaction.c
index 842739df23e2..495849eb13cc 100644
--- a/drivers/firewire/core-transaction.c
+++ b/drivers/firewire/core-transaction.c
@@ -432,14 +432,20 @@ static struct fw_address_handler *lookup_overlapping_address_handler(
         return NULL;
 }
 
+static bool is_enclosing_handler(struct fw_address_handler *handler,
+                                 unsigned long long offset, size_t length)
+{
+        return handler->offset <= offset &&
+                offset + length <= handler->offset + handler->length;
+}
+
 static struct fw_address_handler *lookup_enclosing_address_handler(
         struct list_head *list, unsigned long long offset, size_t length)
 {
         struct fw_address_handler *handler;
 
         list_for_each_entry(handler, list, link) {
-                if (handler->offset <= offset &&
-                    offset + length <= handler->offset + handler->length)
+                if (is_enclosing_handler(handler, offset, length))
                         return handler;
         }
 
@@ -465,6 +471,12 @@ const struct fw_address_region fw_unit_space_region =
         { .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
 #endif  /*  0  */
 
+static bool is_in_fcp_region(u64 offset, size_t length)
+{
+        return offset >= (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
+                offset + length <= (CSR_REGISTER_BASE | CSR_FCP_END);
+}
+
 /**
  * fw_core_add_address_handler - register for incoming requests
  * @handler: callback
@@ -477,8 +489,11 @@ const struct fw_address_region fw_unit_space_region =
  * give the details of the 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.
+ *
+ * Address allocations are exclusive, except for the FCP registers.
  */
 int fw_core_add_address_handler(struct fw_address_handler *handler,
                                 const struct fw_address_region *region)
@@ -498,10 +513,12 @@ int fw_core_add_address_handler(struct fw_address_handler *handler,
 
         handler->offset = region->start;
         while (handler->offset + handler->length <= region->end) {
-                other =
-                    lookup_overlapping_address_handler(&address_handler_list,
-                                                       handler->offset,
-                                                       handler->length);
+                if (is_in_fcp_region(handler->offset, handler->length))
+                        other = NULL;
+                else
+                        other = lookup_overlapping_address_handler
+                                        (&address_handler_list,
+                                         handler->offset, handler->length);
                 if (other != NULL) {
                         handler->offset += other->length;
                 } else {
@@ -668,6 +685,9 @@ static struct fw_request *allocate_request(struct fw_packet *p)
 void fw_send_response(struct fw_card *card,
                       struct fw_request *request, int rcode)
 {
+        if (WARN_ONCE(!request, "invalid for FCP address handlers"))
+                return;
+
         /* unified transaction or broadcast transaction: don't respond */
         if (request->ack != ACK_PENDING ||
             HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) {
@@ -686,26 +706,15 @@ void fw_send_response(struct fw_card *card,
 }
 EXPORT_SYMBOL(fw_send_response);
 
-void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
+static void handle_exclusive_region_request(struct fw_card *card,
+                                            struct fw_packet *p,
+                                            struct fw_request *request,
+                                            unsigned long long offset)
 {
         struct fw_address_handler *handler;
-        struct fw_request *request;
-        unsigned long long offset;
         unsigned long flags;
         int tcode, destination, source;
 
-        if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
-                return;
-
-        request = allocate_request(p);
-        if (request == NULL) {
-                /* FIXME: send statically allocated busy packet. */
-                return;
-        }
-
-        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[1]);
@@ -732,6 +741,73 @@ void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
                                           request->data, request->length,
                                           handler->callback_data);
 }
+
+static void handle_fcp_region_request(struct fw_card *card,
+                                      struct fw_packet *p,
+                                      struct fw_request *request,
+                                      unsigned long long offset)
+{
+        struct fw_address_handler *handler;
+        unsigned long flags;
+        int tcode, destination, source;
+
+        if ((offset != (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
+             offset != (CSR_REGISTER_BASE | CSR_FCP_RESPONSE)) ||
+            request->length > 0x200) {
+                fw_send_response(card, request, RCODE_ADDRESS_ERROR);
+
+                return;
+        }
+
+        tcode       = HEADER_GET_TCODE(p->header[0]);
+        destination = HEADER_GET_DESTINATION(p->header[0]);
+        source      = HEADER_GET_SOURCE(p->header[1]);
+
+        if (tcode != TCODE_WRITE_QUADLET_REQUEST &&
+            tcode != TCODE_WRITE_BLOCK_REQUEST) {
+                fw_send_response(card, request, RCODE_TYPE_ERROR);
+
+                return;
+        }
+
+        spin_lock_irqsave(&address_handler_lock, flags);
+        list_for_each_entry(handler, &address_handler_list, link) {
+                if (is_enclosing_handler(handler, offset, request->length))
+                        handler->address_callback(card, NULL, tcode,
+                                                  destination, source,
+                                                  p->generation, p->speed,
+                                                  offset, request->data,
+                                                  request->length,
+                                                  handler->callback_data);
+        }
+        spin_unlock_irqrestore(&address_handler_lock, flags);
+
+        fw_send_response(card, request, RCODE_COMPLETE);
+}
+
+void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
+{
+        struct fw_request *request;
+        unsigned long long offset;
+
+        if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
+                return;
+
+        request = allocate_request(p);
+        if (request == NULL) {
+                /* FIXME: send statically allocated busy packet. */
+                return;
+        }
+
+        offset = ((u64)HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) |
+                p->header[2];
+
+        if (!is_in_fcp_region(offset, request->length))
+                handle_exclusive_region_request(card, p, request, offset);
+        else
+                handle_fcp_region_request(card, p, request, offset);
+
+}
 EXPORT_SYMBOL(fw_core_handle_request);
 
 void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index 96768e160866..2345d4103fe6 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -2226,7 +2226,6 @@ static int ohci_queue_iso_receive_dualbuffer(struct fw_iso_context *base,
         if (rest == 0)
                 return -EINVAL;
 
-        /* FIXME: make packet-per-buffer/dual-buffer a context option */
         while (rest > 0) {
                 d = context_get_descriptors(&ctx->context,
                                             z + header_z, &d_bus);
@@ -2421,6 +2420,7 @@ static void ohci_pmac_off(struct pci_dev *dev)
 
 #define PCI_VENDOR_ID_AGERE             PCI_VENDOR_ID_ATT
 #define PCI_DEVICE_ID_AGERE_FW643       0x5901
+#define PCI_DEVICE_ID_TI_TSB43AB23      0x8024
 
 static int __devinit pci_probe(struct pci_dev *dev,
                                const struct pci_device_id *ent)
@@ -2470,7 +2470,10 @@ static int __devinit pci_probe(struct pci_dev *dev,
         }
 
         version = reg_read(ohci, OHCI1394_Version) & 0x00ff00ff;
+#if 0
+        /* FIXME: make it a context option or remove dual-buffer mode */
         ohci->use_dualbuffer = version >= OHCI_VERSION_1_1;
+#endif
 
         /* dual-buffer mode is broken if more than one IR context is active */
         if (dev->vendor == PCI_VENDOR_ID_AGERE &&
@@ -2486,7 +2489,8 @@ static int __devinit pci_probe(struct pci_dev *dev,
 #if !defined(CONFIG_X86_32)
         /* dual-buffer mode is broken with descriptor addresses above 2G */
         if (dev->vendor == PCI_VENDOR_ID_TI &&
-            dev->device == PCI_DEVICE_ID_TI_TSB43AB22)
+            (dev->device == PCI_DEVICE_ID_TI_TSB43AB22 ||
+             dev->device == PCI_DEVICE_ID_TI_TSB43AB23))
                 ohci->use_dualbuffer = false;
 #endif