ieee1394: whitespace cleanup in hosts.[ch], ieee1394_core.[ch]
Stefan Richter [Thu, 1 Dec 2005 23:52:03 +0000 (18:52 -0500)]
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Signed-off-by: Jody McIntyre <scjody@modernduck.com>

drivers/ieee1394/hosts.c
drivers/ieee1394/hosts.h
drivers/ieee1394/ieee1394_core.c
drivers/ieee1394/ieee1394_core.h

index d245abe..ba09741 100644 (file)
@@ -61,12 +61,12 @@ static void delayed_reset_bus(void * __reset_info)
 
 static int dummy_transmit_packet(struct hpsb_host *h, struct hpsb_packet *p)
 {
-        return 0;
+       return 0;
 }
 
 static int dummy_devctl(struct hpsb_host *h, enum devctl_cmd c, int arg)
 {
-        return -1;
+       return -1;
 }
 
 static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg)
@@ -75,9 +75,9 @@ static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned
 }
 
 static struct hpsb_host_driver dummy_driver = {
-        .transmit_packet = dummy_transmit_packet,
-        .devctl =          dummy_devctl,
-       .isoctl =          dummy_isoctl
+       .transmit_packet = dummy_transmit_packet,
+       .devctl =          dummy_devctl,
+       .isoctl =          dummy_isoctl
 };
 
 static int alloc_hostnum_cb(struct hpsb_host *host, void *__data)
@@ -110,12 +110,12 @@ static DECLARE_MUTEX(host_num_alloc);
 struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
                                  struct device *dev)
 {
-        struct hpsb_host *h;
+       struct hpsb_host *h;
        int i;
        int hostnum = 0;
 
-        h = kzalloc(sizeof(*h) + extra, SLAB_KERNEL);
-        if (!h)
+       h = kzalloc(sizeof(*h) + extra, SLAB_KERNEL);
+       if (!h)
                return NULL;
 
        h->csr.rom = csr1212_create_csr(&csr_bus_ops, CSR_BUS_INFO_SIZE, h);
@@ -125,7 +125,7 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
        }
 
        h->hostdata = h + 1;
-        h->driver = drv;
+       h->driver = drv;
 
        skb_queue_head_init(&h->pending_packet_queue);
        INIT_LIST_HEAD(&h->addr_space);
@@ -145,8 +145,8 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
        h->timeout.function = abort_timedouts;
        h->timeout_interval = HZ / 20; // 50ms by default
 
-        h->topology_map = h->csr.topology_map + 3;
-        h->speed_map = (u8 *)(h->csr.speed_map + 2);
+       h->topology_map = h->csr.topology_map + 3;
+       h->speed_map = (u8 *)(h->csr.speed_map + 2);
 
        down(&host_num_alloc);
 
@@ -186,14 +186,14 @@ int hpsb_add_host(struct hpsb_host *host)
 
 void hpsb_remove_host(struct hpsb_host *host)
 {
-        host->is_shutdown = 1;
+       host->is_shutdown = 1;
 
        cancel_delayed_work(&host->delayed_reset);
        flush_scheduled_work();
 
-        host->driver = &dummy_driver;
+       host->driver = &dummy_driver;
 
-        highlevel_remove_host(host);
+       highlevel_remove_host(host);
 
        hpsb_remove_extra_config_roms(host);
 
index ae9b02c..07d188c 100644 (file)
@@ -17,47 +17,47 @@ struct hpsb_packet;
 struct hpsb_iso;
 
 struct hpsb_host {
-        struct list_head host_list;
+       struct list_head host_list;
 
-        void *hostdata;
+       void *hostdata;
 
-        atomic_t generation;
+       atomic_t generation;
 
        struct sk_buff_head pending_packet_queue;
 
        struct timer_list timeout;
        unsigned long timeout_interval;
 
-        unsigned char iso_listen_count[64];
+       unsigned char iso_listen_count[64];
 
-        int node_count; /* number of identified nodes on this bus */
-        int selfid_count; /* total number of SelfIDs received */
+       int node_count; /* number of identified nodes on this bus */
+       int selfid_count; /* total number of SelfIDs received */
        int nodes_active; /* number of nodes that are actually active */
 
-        nodeid_t node_id; /* node ID of this host */
-        nodeid_t irm_id; /* ID of this bus' isochronous resource manager */
-        nodeid_t busmgr_id; /* ID of this bus' bus manager */
+       nodeid_t node_id; /* node ID of this host */
+       nodeid_t irm_id; /* ID of this bus' isochronous resource manager */
+       nodeid_t busmgr_id; /* ID of this bus' bus manager */
 
-        /* this nodes state */
-        unsigned in_bus_reset:1;
-        unsigned is_shutdown:1;
+       /* this nodes state */
+       unsigned in_bus_reset:1;
+       unsigned is_shutdown:1;
        unsigned resume_packet_sent:1;
 
-        /* this nodes' duties on the bus */
-        unsigned is_root:1;
-        unsigned is_cycmst:1;
-        unsigned is_irm:1;
-        unsigned is_busmgr:1;
+       /* this nodes' duties on the bus */
+       unsigned is_root:1;
+       unsigned is_cycmst:1;
+       unsigned is_irm:1;
+       unsigned is_busmgr:1;
 
-        int reset_retries;
-        quadlet_t *topology_map;
-        u8 *speed_map;
-        struct csr_control csr;
+       int reset_retries;
+       quadlet_t *topology_map;
+       u8 *speed_map;
+       struct csr_control csr;
 
        /* Per node tlabel pool allocation */
        struct hpsb_tlabel_pool tpool[64];
 
-        struct hpsb_host_driver *driver;
+       struct hpsb_host_driver *driver;
 
        struct pci_dev *pdev;
 
@@ -77,34 +77,34 @@ struct hpsb_host {
 
 
 enum devctl_cmd {
-        /* Host is requested to reset its bus and cancel all outstanding async
-         * requests.  If arg == 1, it shall also attempt to become root on the
-         * bus.  Return void. */
-        RESET_BUS,
-
-        /* Arg is void, return value is the hardware cycle counter value. */
-        GET_CYCLE_COUNTER,
-
-        /* Set the hardware cycle counter to the value in arg, return void.
-         * FIXME - setting is probably not required. */
-        SET_CYCLE_COUNTER,
-
-        /* Configure hardware for new bus ID in arg, return void. */
-        SET_BUS_ID,
-
-        /* If arg true, start sending cycle start packets, stop if arg == 0.
-         * Return void. */
-        ACT_CYCLE_MASTER,
-
-        /* Cancel all outstanding async requests without resetting the bus.
-         * Return void. */
-        CANCEL_REQUESTS,
-
-        /* Start or stop receiving isochronous channel in arg.  Return void.
-         * This acts as an optimization hint, hosts are not required not to
-         * listen on unrequested channels. */
-        ISO_LISTEN_CHANNEL,
-        ISO_UNLISTEN_CHANNEL
+       /* Host is requested to reset its bus and cancel all outstanding async
+        * requests.  If arg == 1, it shall also attempt to become root on the
+        * bus.  Return void. */
+       RESET_BUS,
+
+       /* Arg is void, return value is the hardware cycle counter value. */
+       GET_CYCLE_COUNTER,
+
+       /* Set the hardware cycle counter to the value in arg, return void.
+        * FIXME - setting is probably not required. */
+       SET_CYCLE_COUNTER,
+
+       /* Configure hardware for new bus ID in arg, return void. */
+       SET_BUS_ID,
+
+       /* If arg true, start sending cycle start packets, stop if arg == 0.
+        * Return void. */
+       ACT_CYCLE_MASTER,
+
+       /* Cancel all outstanding async requests without resetting the bus.
+        * Return void. */
+       CANCEL_REQUESTS,
+
+       /* Start or stop receiving isochronous channel in arg.  Return void.
+        * This acts as an optimization hint, hosts are not required not to
+        * listen on unrequested channels. */
+       ISO_LISTEN_CHANNEL,
+       ISO_UNLISTEN_CHANNEL
 };
 
 enum isoctl_cmd {
@@ -135,13 +135,13 @@ enum isoctl_cmd {
 };
 
 enum reset_types {
-        /* 166 microsecond reset -- only type of reset available on
-           non-1394a capable controllers */
-        LONG_RESET,
+       /* 166 microsecond reset -- only type of reset available on
+          non-1394a capable controllers */
+       LONG_RESET,
 
-        /* Short (arbitrated) reset -- only available on 1394a capable
-           controllers */
-        SHORT_RESET,
+       /* Short (arbitrated) reset -- only available on 1394a capable
+          controllers */
+       SHORT_RESET,
 
        /* Variants that set force_root before issueing the bus reset */
        LONG_RESET_FORCE_ROOT, SHORT_RESET_FORCE_ROOT,
@@ -159,22 +159,22 @@ struct hpsb_host_driver {
         * reads to the ConfigROM on its own. */
        void (*set_hw_config_rom) (struct hpsb_host *host, quadlet_t *config_rom);
 
-        /* This function shall implement packet transmission based on
-         * packet->type.  It shall CRC both parts of the packet (unless
-         * packet->type == raw) and do byte-swapping as necessary or instruct
-         * the hardware to do so.  It can return immediately after the packet
-         * was queued for sending.  After sending, hpsb_sent_packet() has to be
-         * called.  Return 0 on success, negative errno on failure.
-         * NOTE: The function must be callable in interrupt context.
-         */
-        int (*transmit_packet) (struct hpsb_host *host,
-                                struct hpsb_packet *packet);
-
-        /* This function requests miscellanous services from the driver, see
-         * above for command codes and expected actions.  Return -1 for unknown
-         * command, though that should never happen.
-         */
-        int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg);
+       /* This function shall implement packet transmission based on
+        * packet->type.  It shall CRC both parts of the packet (unless
+        * packet->type == raw) and do byte-swapping as necessary or instruct
+        * the hardware to do so.  It can return immediately after the packet
+        * was queued for sending.  After sending, hpsb_sent_packet() has to be
+        * called.  Return 0 on success, negative errno on failure.
+        * NOTE: The function must be callable in interrupt context.
+        */
+       int (*transmit_packet) (struct hpsb_host *host,
+                               struct hpsb_packet *packet);
+
+       /* This function requests miscellanous services from the driver, see
+        * above for command codes and expected actions.  Return -1 for unknown
+        * command, though that should never happen.
+        */
+       int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg);
 
         /* ISO transmission/reception functions. Return 0 on success, -1
          * (or -EXXX errno code) on failure. If the low-level driver does not
@@ -182,15 +182,15 @@ struct hpsb_host_driver {
          */
        int (*isoctl) (struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg);
 
-        /* This function is mainly to redirect local CSR reads/locks to the iso
-         * management registers (bus manager id, bandwidth available, channels
-         * available) to the hardware registers in OHCI.  reg is 0,1,2,3 for bus
-         * mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids
-         * as OHCI uses).  data and compare are the new data and expected data
-         * respectively, return value is the old value.
-         */
-        quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg,
-                                 quadlet_t data, quadlet_t compare);
+       /* This function is mainly to redirect local CSR reads/locks to the iso
+        * management registers (bus manager id, bandwidth available, channels
+        * available) to the hardware registers in OHCI.  reg is 0,1,2,3 for bus
+        * mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids
+        * as OHCI uses).  data and compare are the new data and expected data
+        * respectively, return value is the old value.
+        */
+       quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg,
+                                quadlet_t data, quadlet_t compare);
 };
 
 
index ff8a409..64fbbb0 100644 (file)
@@ -179,34 +179,34 @@ void hpsb_free_packet(struct hpsb_packet *packet)
 
 int hpsb_reset_bus(struct hpsb_host *host, int type)
 {
-        if (!host->in_bus_reset) {
-                host->driver->devctl(host, RESET_BUS, type);
-                return 0;
-        } else {
-                return 1;
-        }
+       if (!host->in_bus_reset) {
+               host->driver->devctl(host, RESET_BUS, type);
+               return 0;
+       } else {
+               return 1;
+       }
 }
 
 
 int hpsb_bus_reset(struct hpsb_host *host)
 {
-        if (host->in_bus_reset) {
-                HPSB_NOTICE("%s called while bus reset already in progress",
+       if (host->in_bus_reset) {
+               HPSB_NOTICE("%s called while bus reset already in progress",
                            __FUNCTION__);
-                return 1;
-        }
+               return 1;
+       }
 
-        abort_requests(host);
-        host->in_bus_reset = 1;
-        host->irm_id = -1;
+       abort_requests(host);
+       host->in_bus_reset = 1;
+       host->irm_id = -1;
        host->is_irm = 0;
-        host->busmgr_id = -1;
+       host->busmgr_id = -1;
        host->is_busmgr = 0;
        host->is_cycmst = 0;
-        host->node_count = 0;
-        host->selfid_count = 0;
+       host->node_count = 0;
+       host->selfid_count = 0;
 
-        return 0;
+       return 0;
 }
 
 
@@ -216,47 +216,47 @@ int hpsb_bus_reset(struct hpsb_host *host)
  */
 static int check_selfids(struct hpsb_host *host)
 {
-        int nodeid = -1;
-        int rest_of_selfids = host->selfid_count;
-        struct selfid *sid = (struct selfid *)host->topology_map;
-        struct ext_selfid *esid;
-        int esid_seq = 23;
+       int nodeid = -1;
+       int rest_of_selfids = host->selfid_count;
+       struct selfid *sid = (struct selfid *)host->topology_map;
+       struct ext_selfid *esid;
+       int esid_seq = 23;
 
        host->nodes_active = 0;
 
-        while (rest_of_selfids--) {
-                if (!sid->extended) {
-                        nodeid++;
-                        esid_seq = 0;
+       while (rest_of_selfids--) {
+               if (!sid->extended) {
+                       nodeid++;
+                       esid_seq = 0;
 
-                        if (sid->phy_id != nodeid) {
-                                HPSB_INFO("SelfIDs failed monotony check with "
-                                          "%d", sid->phy_id);
-                                return 0;
-                        }
+                       if (sid->phy_id != nodeid) {
+                               HPSB_INFO("SelfIDs failed monotony check with "
+                                         "%d", sid->phy_id);
+                               return 0;
+                       }
 
                        if (sid->link_active) {
                                host->nodes_active++;
                                if (sid->contender)
                                        host->irm_id = LOCAL_BUS | sid->phy_id;
                        }
-                } else {
-                        esid = (struct ext_selfid *)sid;
-
-                        if ((esid->phy_id != nodeid)
-                            || (esid->seq_nr != esid_seq)) {
-                                HPSB_INFO("SelfIDs failed monotony check with "
-                                          "%d/%d", esid->phy_id, esid->seq_nr);
-                                return 0;
-                        }
-                        esid_seq++;
-                }
-                sid++;
-        }
-
-        esid = (struct ext_selfid *)(sid - 1);
-        while (esid->extended) {
-                if ((esid->porta == SELFID_PORT_PARENT) ||
+               } else {
+                       esid = (struct ext_selfid *)sid;
+
+                       if ((esid->phy_id != nodeid)
+                           || (esid->seq_nr != esid_seq)) {
+                               HPSB_INFO("SelfIDs failed monotony check with "
+                                         "%d/%d", esid->phy_id, esid->seq_nr);
+                               return 0;
+                       }
+                       esid_seq++;
+               }
+               sid++;
+       }
+
+       esid = (struct ext_selfid *)(sid - 1);
+       while (esid->extended) {
+               if ((esid->porta == SELFID_PORT_PARENT) ||
                    (esid->portb == SELFID_PORT_PARENT) ||
                    (esid->portc == SELFID_PORT_PARENT) ||
                    (esid->portd == SELFID_PORT_PARENT) ||
@@ -267,47 +267,47 @@ static int check_selfids(struct hpsb_host *host)
                        HPSB_INFO("SelfIDs failed root check on "
                                  "extended SelfID");
                        return 0;
-                }
-                esid--;
-        }
+               }
+               esid--;
+       }
 
-        sid = (struct selfid *)esid;
+       sid = (struct selfid *)esid;
        if ((sid->port0 == SELFID_PORT_PARENT) ||
            (sid->port1 == SELFID_PORT_PARENT) ||
            (sid->port2 == SELFID_PORT_PARENT)) {
                HPSB_INFO("SelfIDs failed root check");
                return 0;
-        }
+       }
 
        host->node_count = nodeid + 1;
-        return 1;
+       return 1;
 }
 
 static void build_speed_map(struct hpsb_host *host, int nodecount)
 {
        u8 speedcap[nodecount];
        u8 cldcnt[nodecount];
-        u8 *map = host->speed_map;
-        struct selfid *sid;
-        struct ext_selfid *esid;
-        int i, j, n;
-
-        for (i = 0; i < (nodecount * 64); i += 64) {
-                for (j = 0; j < nodecount; j++) {
-                        map[i+j] = IEEE1394_SPEED_MAX;
-                }
-        }
-
-        for (i = 0; i < nodecount; i++) {
-                cldcnt[i] = 0;
-        }
-
-        /* find direct children count and speed */
-        for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1],
-                     n = nodecount - 1;
-             (void *)sid >= (void *)host->topology_map; sid--) {
-                if (sid->extended) {
-                        esid = (struct ext_selfid *)sid;
+       u8 *map = host->speed_map;
+       struct selfid *sid;
+       struct ext_selfid *esid;
+       int i, j, n;
+
+       for (i = 0; i < (nodecount * 64); i += 64) {
+               for (j = 0; j < nodecount; j++) {
+                       map[i+j] = IEEE1394_SPEED_MAX;
+               }
+       }
+
+       for (i = 0; i < nodecount; i++) {
+               cldcnt[i] = 0;
+       }
+
+       /* find direct children count and speed */
+       for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1],
+                    n = nodecount - 1;
+            (void *)sid >= (void *)host->topology_map; sid--) {
+               if (sid->extended) {
+                       esid = (struct ext_selfid *)sid;
 
                        if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++;
                        if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++;
@@ -322,50 +322,50 @@ static void build_speed_map(struct hpsb_host *host, int nodecount)
                        if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++;
                        if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++;
 
-                        speedcap[n] = sid->speed;
-                        n--;
-                }
-        }
-
-        /* set self mapping */
-        for (i = 0; i < nodecount; i++) {
-                map[64*i + i] = speedcap[i];
-        }
-
-        /* fix up direct children count to total children count;
-         * also fix up speedcaps for sibling and parent communication */
-        for (i = 1; i < nodecount; i++) {
-                for (j = cldcnt[i], n = i - 1; j > 0; j--) {
-                        cldcnt[i] += cldcnt[n];
-                        speedcap[n] = min(speedcap[n], speedcap[i]);
-                        n -= cldcnt[n] + 1;
-                }
-        }
-
-        for (n = 0; n < nodecount; n++) {
-                for (i = n - cldcnt[n]; i <= n; i++) {
-                        for (j = 0; j < (n - cldcnt[n]); j++) {
-                                map[j*64 + i] = map[i*64 + j] =
-                                        min(map[i*64 + j], speedcap[n]);
-                        }
-                        for (j = n + 1; j < nodecount; j++) {
-                                map[j*64 + i] = map[i*64 + j] =
-                                        min(map[i*64 + j], speedcap[n]);
-                        }
-                }
-        }
+                       speedcap[n] = sid->speed;
+                       n--;
+               }
+       }
+
+       /* set self mapping */
+       for (i = 0; i < nodecount; i++) {
+               map[64*i + i] = speedcap[i];
+       }
+
+       /* fix up direct children count to total children count;
+        * also fix up speedcaps for sibling and parent communication */
+       for (i = 1; i < nodecount; i++) {
+               for (j = cldcnt[i], n = i - 1; j > 0; j--) {
+                       cldcnt[i] += cldcnt[n];
+                       speedcap[n] = min(speedcap[n], speedcap[i]);
+                       n -= cldcnt[n] + 1;
+               }
+       }
+
+       for (n = 0; n < nodecount; n++) {
+               for (i = n - cldcnt[n]; i <= n; i++) {
+                       for (j = 0; j < (n - cldcnt[n]); j++) {
+                               map[j*64 + i] = map[i*64 + j] =
+                                       min(map[i*64 + j], speedcap[n]);
+                       }
+                       for (j = n + 1; j < nodecount; j++) {
+                               map[j*64 + i] = map[i*64 + j] =
+                                       min(map[i*64 + j], speedcap[n]);
+                       }
+               }
+       }
 }
 
 
 void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid)
 {
-        if (host->in_bus_reset) {
-                HPSB_VERBOSE("Including SelfID 0x%x", sid);
-                host->topology_map[host->selfid_count++] = sid;
-        } else {
-                HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
+       if (host->in_bus_reset) {
+               HPSB_VERBOSE("Including SelfID 0x%x", sid);
+               host->topology_map[host->selfid_count++] = sid;
+       } else {
+               HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
                            sid, NODEID_TO_BUS(host->node_id));
-        }
+       }
 }
 
 void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
@@ -373,50 +373,50 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
        if (!host->in_bus_reset)
                HPSB_NOTICE("SelfID completion called outside of bus reset!");
 
-        host->node_id = LOCAL_BUS | phyid;
-        host->is_root = isroot;
+       host->node_id = LOCAL_BUS | phyid;
+       host->is_root = isroot;
 
-        if (!check_selfids(host)) {
-                if (host->reset_retries++ < 20) {
-                        /* selfid stage did not complete without error */
-                        HPSB_NOTICE("Error in SelfID stage, resetting");
+       if (!check_selfids(host)) {
+               if (host->reset_retries++ < 20) {
+                       /* selfid stage did not complete without error */
+                       HPSB_NOTICE("Error in SelfID stage, resetting");
                        host->in_bus_reset = 0;
                        /* this should work from ohci1394 now... */
-                        hpsb_reset_bus(host, LONG_RESET);
-                        return;
-                } else {
-                        HPSB_NOTICE("Stopping out-of-control reset loop");
-                        HPSB_NOTICE("Warning - topology map and speed map will not be valid");
+                       hpsb_reset_bus(host, LONG_RESET);
+                       return;
+               } else {
+                       HPSB_NOTICE("Stopping out-of-control reset loop");
+                       HPSB_NOTICE("Warning - topology map and speed map will not be valid");
                        host->reset_retries = 0;
-                }
-        } else {
+               }
+       } else {
                host->reset_retries = 0;
-                build_speed_map(host, host->node_count);
-        }
+               build_speed_map(host, host->node_count);
+       }
 
        HPSB_VERBOSE("selfid_complete called with successful SelfID stage "
                     "... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id);
 
-        /* irm_id is kept up to date by check_selfids() */
-        if (host->irm_id == host->node_id) {
-                host->is_irm = 1;
-        } else {
-                host->is_busmgr = 0;
-                host->is_irm = 0;
-        }
+       /* irm_id is kept up to date by check_selfids() */
+       if (host->irm_id == host->node_id) {
+               host->is_irm = 1;
+       } else {
+               host->is_busmgr = 0;
+               host->is_irm = 0;
+       }
 
-        if (isroot) {
+       if (isroot) {
                host->driver->devctl(host, ACT_CYCLE_MASTER, 1);
                host->is_cycmst = 1;
        }
        atomic_inc(&host->generation);
        host->in_bus_reset = 0;
-        highlevel_host_reset(host);
+       highlevel_host_reset(host);
 }
 
 
 void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
-                      int ackcode)
+                     int ackcode)
 {
        unsigned long flags;
 
@@ -507,13 +507,13 @@ int hpsb_send_packet(struct hpsb_packet *packet)
 {
        struct hpsb_host *host = packet->host;
 
-        if (host->is_shutdown)
+       if (host->is_shutdown)
                return -EINVAL;
        if (host->in_bus_reset ||
            (packet->generation != get_hpsb_generation(host)))
-                return -EAGAIN;
+               return -EAGAIN;
 
-        packet->state = hpsb_queued;
+       packet->state = hpsb_queued;
 
        /* This just seems silly to me */
        WARN_ON(packet->no_waiter && packet->expect_response);
@@ -527,42 +527,42 @@ int hpsb_send_packet(struct hpsb_packet *packet)
                skb_queue_tail(&host->pending_packet_queue, packet->skb);
        }
 
-        if (packet->node_id == host->node_id) {
+       if (packet->node_id == host->node_id) {
                /* it is a local request, so handle it locally */
 
-                quadlet_t *data;
-                size_t size = packet->data_size + packet->header_size;
+               quadlet_t *data;
+               size_t size = packet->data_size + packet->header_size;
 
-                data = kmalloc(size, GFP_ATOMIC);
-                if (!data) {
-                        HPSB_ERR("unable to allocate memory for concatenating header and data");
-                        return -ENOMEM;
-                }
+               data = kmalloc(size, GFP_ATOMIC);
+               if (!data) {
+                       HPSB_ERR("unable to allocate memory for concatenating header and data");
+                       return -ENOMEM;
+               }
 
-                memcpy(data, packet->header, packet->header_size);
+               memcpy(data, packet->header, packet->header_size);
 
-                if (packet->data_size)
+               if (packet->data_size)
                        memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size);
 
-                dump_packet("send packet local", packet->header, packet->header_size, -1);
+               dump_packet("send packet local", packet->header, packet->header_size, -1);
 
-                hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE);
-                hpsb_packet_received(host, data, size, 0);
+               hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE);
+               hpsb_packet_received(host, data, size, 0);
 
-                kfree(data);
+               kfree(data);
 
-                return 0;
-        }
+               return 0;
+       }
 
-        if (packet->type == hpsb_async && packet->node_id != ALL_NODES) {
-                packet->speed_code =
-                        host->speed_map[NODEID_TO_NODE(host->node_id) * 64
-                                       + NODEID_TO_NODE(packet->node_id)];
-        }
+       if (packet->type == hpsb_async && packet->node_id != ALL_NODES) {
+               packet->speed_code =
+                       host->speed_map[NODEID_TO_NODE(host->node_id) * 64
+                                      + NODEID_TO_NODE(packet->node_id)];
+       }
 
-        dump_packet("send packet", packet->header, packet->header_size, packet->speed_code);
+       dump_packet("send packet", packet->header, packet->header_size, packet->speed_code);
 
-        return host->driver->transmit_packet(host, packet);
+       return host->driver->transmit_packet(host, packet);
 }
 
 /* We could just use complete() directly as the packet complete
@@ -590,81 +590,81 @@ int hpsb_send_packet_and_wait(struct hpsb_packet *packet)
 
 static void send_packet_nocare(struct hpsb_packet *packet)
 {
-        if (hpsb_send_packet(packet) < 0) {
-                hpsb_free_packet(packet);
-        }
+       if (hpsb_send_packet(packet) < 0) {
+               hpsb_free_packet(packet);
+       }
 }
 
 
 static void handle_packet_response(struct hpsb_host *host, int tcode,
                                   quadlet_t *data, size_t size)
 {
-        struct hpsb_packet *packet = NULL;
+       struct hpsb_packet *packet = NULL;
        struct sk_buff *skb;
-        int tcode_match = 0;
-        int tlabel;
-        unsigned long flags;
+       int tcode_match = 0;
+       int tlabel;
+       unsigned long flags;
 
-        tlabel = (data[0] >> 10) & 0x3f;
+       tlabel = (data[0] >> 10) & 0x3f;
 
        spin_lock_irqsave(&host->pending_packet_queue.lock, flags);
 
        skb_queue_walk(&host->pending_packet_queue, skb) {
                packet = (struct hpsb_packet *)skb->data;
-                if ((packet->tlabel == tlabel)
-                    && (packet->node_id == (data[1] >> 16))){
-                        break;
-                }
+               if ((packet->tlabel == tlabel)
+                   && (packet->node_id == (data[1] >> 16))){
+                       break;
+               }
 
                packet = NULL;
-        }
+       }
 
        if (packet == NULL) {
-                HPSB_DEBUG("unsolicited response packet received - no tlabel match");
-                dump_packet("contents", data, 16, -1);
+               HPSB_DEBUG("unsolicited response packet received - no tlabel match");
+               dump_packet("contents", data, 16, -1);
                spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags);
-                return;
-        }
+               return;
+       }
 
-        switch (packet->tcode) {
-        case TCODE_WRITEQ:
-        case TCODE_WRITEB:
-                if (tcode != TCODE_WRITE_RESPONSE)
+       switch (packet->tcode) {
+       case TCODE_WRITEQ:
+       case TCODE_WRITEB:
+               if (tcode != TCODE_WRITE_RESPONSE)
                        break;
                tcode_match = 1;
                memcpy(packet->header, data, 12);
-                break;
-        case TCODE_READQ:
-                if (tcode != TCODE_READQ_RESPONSE)
+               break;
+       case TCODE_READQ:
+               if (tcode != TCODE_READQ_RESPONSE)
                        break;
                tcode_match = 1;
                memcpy(packet->header, data, 16);
-                break;
-        case TCODE_READB:
-                if (tcode != TCODE_READB_RESPONSE)
+               break;
+       case TCODE_READB:
+               if (tcode != TCODE_READB_RESPONSE)
                        break;
                tcode_match = 1;
                BUG_ON(packet->skb->len - sizeof(*packet) < size - 16);
                memcpy(packet->header, data, 16);
                memcpy(packet->data, data + 4, size - 16);
-                break;
-        case TCODE_LOCK_REQUEST:
-                if (tcode != TCODE_LOCK_RESPONSE)
+               break;
+       case TCODE_LOCK_REQUEST:
+               if (tcode != TCODE_LOCK_RESPONSE)
                        break;
                tcode_match = 1;
                size = min((size - 16), (size_t)8);
                BUG_ON(packet->skb->len - sizeof(*packet) < size);
                memcpy(packet->header, data, 16);
                memcpy(packet->data, data + 4, size);
-                break;
-        }
+               break;
+       }
 
-        if (!tcode_match) {
+       if (!tcode_match) {
                spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags);
-                HPSB_INFO("unsolicited response packet received - tcode mismatch");
-                dump_packet("contents", data, 16, -1);
-                return;
-        }
+               HPSB_INFO("unsolicited response packet received - tcode mismatch");
+               dump_packet("contents", data, 16, -1);
+               return;
+       }
 
        __skb_unlink(skb, &host->pending_packet_queue);
 
@@ -683,27 +683,27 @@ static void handle_packet_response(struct hpsb_host *host, int tcode,
 static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
                                               quadlet_t *data, size_t dsize)
 {
-        struct hpsb_packet *p;
+       struct hpsb_packet *p;
 
-        p = hpsb_alloc_packet(dsize);
-        if (unlikely(p == NULL)) {
-                /* FIXME - send data_error response */
-                return NULL;
-        }
+       p = hpsb_alloc_packet(dsize);
+       if (unlikely(p == NULL)) {
+               /* FIXME - send data_error response */
+               return NULL;
+       }
 
-        p->type = hpsb_async;
-        p->state = hpsb_unused;
-        p->host = host;
-        p->node_id = data[1] >> 16;
-        p->tlabel = (data[0] >> 10) & 0x3f;
-        p->no_waiter = 1;
+       p->type = hpsb_async;
+       p->state = hpsb_unused;
+       p->host = host;
+       p->node_id = data[1] >> 16;
+       p->tlabel = (data[0] >> 10) & 0x3f;
+       p->no_waiter = 1;
 
        p->generation = get_hpsb_generation(host);
 
        if (dsize % 4)
                p->data[dsize / 4] = 0;
 
-        return p;
+       return p;
 }
 
 #define PREP_ASYNC_HEAD_RCODE(tc) \
@@ -714,7 +714,7 @@ static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
        packet->header[2] = 0
 
 static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
-                              quadlet_t data)
+                             quadlet_t data)
 {
        PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE);
        packet->header[3] = data;
@@ -723,7 +723,7 @@ static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
 }
 
 static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
-                               int length)
+                              int length)
 {
        if (rcode != RCODE_COMPLETE)
                length = 0;
@@ -743,7 +743,7 @@ static void fill_async_write_resp(struct hpsb_packet *packet, int rcode)
 }
 
 static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
-                          int length)
+                         int length)
 {
        if (rcode != RCODE_COMPLETE)
                length = 0;
@@ -755,184 +755,184 @@ static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extc
 }
 
 #define PREP_REPLY_PACKET(length) \
-                packet = create_reply_packet(host, data, length); \
-                if (packet == NULL) break
+               packet = create_reply_packet(host, data, length); \
+               if (packet == NULL) break
 
 static void handle_incoming_packet(struct hpsb_host *host, int tcode,
                                   quadlet_t *data, size_t size, int write_acked)
 {
-        struct hpsb_packet *packet;
-        int length, rcode, extcode;
-        quadlet_t buffer;
-        nodeid_t source = data[1] >> 16;
-        nodeid_t dest = data[0] >> 16;
-        u16 flags = (u16) data[0];
-        u64 addr;
-
-        /* big FIXME - no error checking is done for an out of bounds length */
-
-        switch (tcode) {
-        case TCODE_WRITEQ:
-                addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
-                rcode = highlevel_write(host, source, dest, data+3,
+       struct hpsb_packet *packet;
+       int length, rcode, extcode;
+       quadlet_t buffer;
+       nodeid_t source = data[1] >> 16;
+       nodeid_t dest = data[0] >> 16;
+       u16 flags = (u16) data[0];
+       u64 addr;
+
+       /* big FIXME - no error checking is done for an out of bounds length */
+
+       switch (tcode) {
+       case TCODE_WRITEQ:
+               addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
+               rcode = highlevel_write(host, source, dest, data+3,
                                        addr, 4, flags);
 
-                if (!write_acked
-                    && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
-                    && (rcode >= 0)) {
-                        /* not a broadcast write, reply */
-                        PREP_REPLY_PACKET(0);
-                        fill_async_write_resp(packet, rcode);
-                        send_packet_nocare(packet);
-                }
-                break;
-
-        case TCODE_WRITEB:
-                addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
-                rcode = highlevel_write(host, source, dest, data+4,
+               if (!write_acked
+                   && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
+                   && (rcode >= 0)) {
+                       /* not a broadcast write, reply */
+                       PREP_REPLY_PACKET(0);
+                       fill_async_write_resp(packet, rcode);
+                       send_packet_nocare(packet);
+               }
+               break;
+
+       case TCODE_WRITEB:
+               addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
+               rcode = highlevel_write(host, source, dest, data+4,
                                        addr, data[3]>>16, flags);
 
-                if (!write_acked
-                    && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
-                    && (rcode >= 0)) {
-                        /* not a broadcast write, reply */
-                        PREP_REPLY_PACKET(0);
-                        fill_async_write_resp(packet, rcode);
-                        send_packet_nocare(packet);
-                }
-                break;
-
-        case TCODE_READQ:
-                addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
-                rcode = highlevel_read(host, source, &buffer, addr, 4, flags);
-
-                if (rcode >= 0) {
-                        PREP_REPLY_PACKET(0);
-                        fill_async_readquad_resp(packet, rcode, buffer);
-                        send_packet_nocare(packet);
-                }
-                break;
-
-        case TCODE_READB:
-                length = data[3] >> 16;
-                PREP_REPLY_PACKET(length);
-
-                addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
-                rcode = highlevel_read(host, source, packet->data, addr,
-                                       length, flags);
-
-                if (rcode >= 0) {
-                        fill_async_readblock_resp(packet, rcode, length);
-                        send_packet_nocare(packet);
-                } else {
-                        hpsb_free_packet(packet);
-                }
-                break;
-
-        case TCODE_LOCK_REQUEST:
-                length = data[3] >> 16;
-                extcode = data[3] & 0xffff;
-                addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
-
-                PREP_REPLY_PACKET(8);
-
-                if ((extcode == 0) || (extcode >= 7)) {
-                        /* let switch default handle error */
-                        length = 0;
-                }
-
-                switch (length) {
-                case 4:
-                        rcode = highlevel_lock(host, source, packet->data, addr,
-                                               data[4], 0, extcode,flags);
-                        fill_async_lock_resp(packet, rcode, extcode, 4);
-                        break;
-                case 8:
-                        if ((extcode != EXTCODE_FETCH_ADD)
-                            && (extcode != EXTCODE_LITTLE_ADD)) {
-                                rcode = highlevel_lock(host, source,
-                                                       packet->data, addr,
-                                                       data[5], data[4],
-                                                       extcode, flags);
-                                fill_async_lock_resp(packet, rcode, extcode, 4);
-                        } else {
-                                rcode = highlevel_lock64(host, source,
-                                             (octlet_t *)packet->data, addr,
-                                             *(octlet_t *)(data + 4), 0ULL,
-                                             extcode, flags);
-                                fill_async_lock_resp(packet, rcode, extcode, 8);
-                        }
-                        break;
-                case 16:
-                        rcode = highlevel_lock64(host, source,
-                                                 (octlet_t *)packet->data, addr,
-                                                 *(octlet_t *)(data + 6),
-                                                 *(octlet_t *)(data + 4),
-                                                 extcode, flags);
-                        fill_async_lock_resp(packet, rcode, extcode, 8);
-                        break;
-                default:
-                        rcode = RCODE_TYPE_ERROR;
-                        fill_async_lock_resp(packet, rcode,
-                                             extcode, 0);
-                }
-
-                if (rcode >= 0) {
-                        send_packet_nocare(packet);
-                } else {
-                        hpsb_free_packet(packet);
-                }
-                break;
-        }
+               if (!write_acked
+                   && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
+                   && (rcode >= 0)) {
+                       /* not a broadcast write, reply */
+                       PREP_REPLY_PACKET(0);
+                       fill_async_write_resp(packet, rcode);
+                       send_packet_nocare(packet);
+               }
+               break;
+
+       case TCODE_READQ:
+               addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
+               rcode = highlevel_read(host, source, &buffer, addr, 4, flags);
+
+               if (rcode >= 0) {
+                       PREP_REPLY_PACKET(0);
+                       fill_async_readquad_resp(packet, rcode, buffer);
+                       send_packet_nocare(packet);
+               }
+               break;
+
+       case TCODE_READB:
+               length = data[3] >> 16;
+               PREP_REPLY_PACKET(length);
+
+               addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
+               rcode = highlevel_read(host, source, packet->data, addr,
+                                      length, flags);
+
+               if (rcode >= 0) {
+                       fill_async_readblock_resp(packet, rcode, length);
+                       send_packet_nocare(packet);
+               } else {
+                       hpsb_free_packet(packet);
+               }
+               break;
+
+       case TCODE_LOCK_REQUEST:
+               length = data[3] >> 16;
+               extcode = data[3] & 0xffff;
+               addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
+
+               PREP_REPLY_PACKET(8);
+
+               if ((extcode == 0) || (extcode >= 7)) {
+                       /* let switch default handle error */
+                       length = 0;
+               }
+
+               switch (length) {
+               case 4:
+                       rcode = highlevel_lock(host, source, packet->data, addr,
+                                              data[4], 0, extcode,flags);
+                       fill_async_lock_resp(packet, rcode, extcode, 4);
+                       break;
+               case 8:
+                       if ((extcode != EXTCODE_FETCH_ADD)
+                           && (extcode != EXTCODE_LITTLE_ADD)) {
+                               rcode = highlevel_lock(host, source,
+                                                      packet->data, addr,
+                                                      data[5], data[4],
+                                                      extcode, flags);
+                               fill_async_lock_resp(packet, rcode, extcode, 4);
+                       } else {
+                               rcode = highlevel_lock64(host, source,
+                                            (octlet_t *)packet->data, addr,
+                                            *(octlet_t *)(data + 4), 0ULL,
+                                            extcode, flags);
+                               fill_async_lock_resp(packet, rcode, extcode, 8);
+                       }
+                       break;
+               case 16:
+                       rcode = highlevel_lock64(host, source,
+                                                (octlet_t *)packet->data, addr,
+                                                *(octlet_t *)(data + 6),
+                                                *(octlet_t *)(data + 4),
+                                                extcode, flags);
+                       fill_async_lock_resp(packet, rcode, extcode, 8);
+                       break;
+               default:
+                       rcode = RCODE_TYPE_ERROR;
+                       fill_async_lock_resp(packet, rcode,
+                                            extcode, 0);
+               }
+
+               if (rcode >= 0) {
+                       send_packet_nocare(packet);
+               } else {
+                       hpsb_free_packet(packet);
+               }
+               break;
+       }
 
 }
 #undef PREP_REPLY_PACKET
 
 
 void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
-                          int write_acked)
+                         int write_acked)
 {
-        int tcode;
-
-        if (host->in_bus_reset) {
-                HPSB_INFO("received packet during reset; ignoring");
-                return;
-        }
-
-        dump_packet("received packet", data, size, -1);
-
-        tcode = (data[0] >> 4) & 0xf;
-
-        switch (tcode) {
-        case TCODE_WRITE_RESPONSE:
-        case TCODE_READQ_RESPONSE:
-        case TCODE_READB_RESPONSE:
-        case TCODE_LOCK_RESPONSE:
-                handle_packet_response(host, tcode, data, size);
-                break;
-
-        case TCODE_WRITEQ:
-        case TCODE_WRITEB:
-        case TCODE_READQ:
-        case TCODE_READB:
-        case TCODE_LOCK_REQUEST:
-                handle_incoming_packet(host, tcode, data, size, write_acked);
-                break;
-
-
-        case TCODE_ISO_DATA:
-                highlevel_iso_receive(host, data, size);
-                break;
-
-        case TCODE_CYCLE_START:
-                /* simply ignore this packet if it is passed on */
-                break;
-
-        default:
-                HPSB_NOTICE("received packet with bogus transaction code %d",
-                            tcode);
-                break;
-        }
+       int tcode;
+
+       if (host->in_bus_reset) {
+               HPSB_INFO("received packet during reset; ignoring");
+               return;
+       }
+
+       dump_packet("received packet", data, size, -1);
+
+       tcode = (data[0] >> 4) & 0xf;
+
+       switch (tcode) {
+       case TCODE_WRITE_RESPONSE:
+       case TCODE_READQ_RESPONSE:
+       case TCODE_READB_RESPONSE:
+       case TCODE_LOCK_RESPONSE:
+               handle_packet_response(host, tcode, data, size);
+               break;
+
+       case TCODE_WRITEQ:
+       case TCODE_WRITEB:
+       case TCODE_READQ:
+       case TCODE_READB:
+       case TCODE_LOCK_REQUEST:
+               handle_incoming_packet(host, tcode, data, size, write_acked);
+               break;
+
+
+       case TCODE_ISO_DATA:
+               highlevel_iso_receive(host, data, size);
+               break;
+
+       case TCODE_CYCLE_START:
+               /* simply ignore this packet if it is passed on */
+               break;
+
+       default:
+               HPSB_NOTICE("received packet with bogus transaction code %d",
+                           tcode);
+               break;
+       }
 }
 
 
@@ -1126,7 +1126,7 @@ static int __init ieee1394_init(void)
                   nodemgr implements functionality required of ieee1394a-2000
                   IRMs */
                hpsb_disable_irm = 1;
-                      
+
                return 0;
        }
 
index 0b31429..b354660 100644 (file)
@@ -10,8 +10,8 @@
 
 
 struct hpsb_packet {
-        /* This struct is basically read-only for hosts with the exception of
-         * the data buffer contents and xnext - see below. */
+       /* This struct is basically read-only for hosts with the exception of
+        * the data buffer contents and xnext - see below. */
 
        /* This can be used for host driver internal linking.
         *
@@ -21,47 +21,47 @@ struct hpsb_packet {
         * driver_list when free'ing it. */
        struct list_head driver_list;
 
-        nodeid_t node_id;
+       nodeid_t node_id;
 
-        /* Async and Iso types should be clear, raw means send-as-is, do not
-         * CRC!  Byte swapping shall still be done in this case. */
-        enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type;
+       /* Async and Iso types should be clear, raw means send-as-is, do not
+        * CRC!  Byte swapping shall still be done in this case. */
+       enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type;
 
-        /* Okay, this is core internal and a no care for hosts.
-         * queued   = queued for sending
-         * pending  = sent, waiting for response
-         * complete = processing completed, successful or not
-         */
-        enum {
-                hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete
-        } __attribute__((packed)) state;
+       /* Okay, this is core internal and a no care for hosts.
+        * queued   = queued for sending
+        * pending  = sent, waiting for response
+        * complete = processing completed, successful or not
+        */
+       enum {
+               hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete
+       } __attribute__((packed)) state;
 
-        /* These are core internal. */
-        signed char tlabel;
+       /* These are core internal. */
+       signed char tlabel;
        signed char ack_code;
        unsigned char tcode;
 
-        unsigned expect_response:1;
-        unsigned no_waiter:1;
+       unsigned expect_response:1;
+       unsigned no_waiter:1;
 
-        /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */
-        unsigned speed_code:2;
+       /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */
+       unsigned speed_code:2;
 
-        /*
-         * *header and *data are guaranteed to be 32-bit DMAable and may be
-         * overwritten to allow in-place byte swapping.  Neither of these is
-         * CRCed (the sizes also don't include CRC), but contain space for at
-         * least one additional quadlet to allow in-place CRCing.  The memory is
-         * also guaranteed to be DMA mappable.
-         */
-        quadlet_t *header;
-        quadlet_t *data;
-        size_t header_size;
-        size_t data_size;
+       /*
+        * *header and *data are guaranteed to be 32-bit DMAable and may be
+        * overwritten to allow in-place byte swapping.  Neither of these is
+        * CRCed (the sizes also don't include CRC), but contain space for at
+        * least one additional quadlet to allow in-place CRCing.  The memory is
+        * also guaranteed to be DMA mappable.
+        */
+       quadlet_t *header;
+       quadlet_t *data;
+       size_t header_size;
+       size_t data_size;
 
 
-        struct hpsb_host *host;
-        unsigned int generation;
+       struct hpsb_host *host;
+       unsigned int generation;
 
        atomic_t refcnt;
 
@@ -73,10 +73,10 @@ struct hpsb_packet {
        /* XXX This is just a hack at the moment */
        struct sk_buff *skb;
 
-        /* Store jiffies for implementing bus timeouts. */
-        unsigned long sendtime;
+       /* Store jiffies for implementing bus timeouts. */
+       unsigned long sendtime;
 
-        quadlet_t embedded_header[5];
+       quadlet_t embedded_header[5];
 };
 
 /* Set a task for when a packet completes */
@@ -102,7 +102,7 @@ void hpsb_free_packet(struct hpsb_packet *packet);
  */
 static inline unsigned int get_hpsb_generation(struct hpsb_host *host)
 {
-        return atomic_read(&host->generation);
+       return atomic_read(&host->generation);
 }
 
 /*
@@ -157,7 +157,7 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot);
  * from within a transmit packet routine.
  */
 void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
-                      int ackcode);
+                     int ackcode);
 
 /*
  * Hand over received packet to the core.  The contents of data are expected to
@@ -171,7 +171,7 @@ void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
  * packet type.
  */
 void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
-                          int write_acked);
+                         int write_acked);
 
 
 /*
@@ -197,20 +197,20 @@ void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
  * Block 15 (240-255)  reserved for drivers under development, etc.
  */
 
-#define IEEE1394_MAJOR               171
+#define IEEE1394_MAJOR                  171
 
-#define IEEE1394_MINOR_BLOCK_RAW1394       0
-#define IEEE1394_MINOR_BLOCK_VIDEO1394     1
-#define IEEE1394_MINOR_BLOCK_DV1394        2
-#define IEEE1394_MINOR_BLOCK_AMDTP         3
+#define IEEE1394_MINOR_BLOCK_RAW1394      0
+#define IEEE1394_MINOR_BLOCK_VIDEO1394    1
+#define IEEE1394_MINOR_BLOCK_DV1394       2
+#define IEEE1394_MINOR_BLOCK_AMDTP        3
 #define IEEE1394_MINOR_BLOCK_EXPERIMENTAL 15
 
-#define IEEE1394_CORE_DEV              MKDEV(IEEE1394_MAJOR, 0)
-#define IEEE1394_RAW1394_DEV           MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)
-#define IEEE1394_VIDEO1394_DEV         MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16)
-#define IEEE1394_DV1394_DEV            MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16)
-#define IEEE1394_AMDTP_DEV             MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16)
-#define IEEE1394_EXPERIMENTAL_DEV      MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16)
+#define IEEE1394_CORE_DEV        MKDEV(IEEE1394_MAJOR, 0)
+#define IEEE1394_RAW1394_DEV     MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)
+#define IEEE1394_VIDEO1394_DEV   MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16)
+#define IEEE1394_DV1394_DEV      MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16)
+#define IEEE1394_AMDTP_DEV       MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16)
+#define IEEE1394_EXPERIMENTAL_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16)
 
 /* return the index (within a minor number block) of a file */
 static inline unsigned char ieee1394_file_to_instance(struct file *file)