17 files changed, 325 insertions, 628 deletions

diff --git a/drivers/ieee1394/Kconfig b/drivers/ieee1394/Kconfig
index 25103a0ef9b3..39142e2f804b 100644
--- a/drivers/ieee1394/Kconfig
+++ b/drivers/ieee1394/Kconfig
@@ -169,27 +169,4 @@ config IEEE1394_RAWIO
           To compile this driver as a module, say M here: the
           module will be called raw1394.
 
-config IEEE1394_CMP
-        tristate "IEC61883-1 Plug support"
-        depends on IEEE1394
-        help
-          This option enables the Connection Management Procedures
-          (IEC61883-1) driver, which implements input and output plugs.
-
-          To compile this driver as a module, say M here: the
-          module will be called cmp.
-
-config IEEE1394_AMDTP
-        tristate "IEC61883-6 (Audio transmission) support"
-        depends on IEEE1394 && IEEE1394_OHCI1394 && IEEE1394_CMP
-        help
-          This option enables the Audio & Music Data Transmission Protocol
-          (IEC61883-6) driver, which implements audio transmission over
-          IEEE1394.
-
-          The userspace interface is documented in amdtp.h.
-
-          To compile this driver as a module, say M here: the
-          module will be called amdtp.
-
 endmenu
diff --git a/drivers/ieee1394/Makefile b/drivers/ieee1394/Makefile
index e8b4d48d376e..6f53611fe255 100644
--- a/drivers/ieee1394/Makefile
+++ b/drivers/ieee1394/Makefile
@@ -14,8 +14,6 @@ obj-$(CONFIG_IEEE1394_RAWIO) += raw1394.o
 obj-$(CONFIG_IEEE1394_SBP2) += sbp2.o
 obj-$(CONFIG_IEEE1394_DV1394) += dv1394.o
 obj-$(CONFIG_IEEE1394_ETH1394) += eth1394.o
-obj-$(CONFIG_IEEE1394_AMDTP) += amdtp.o
-obj-$(CONFIG_IEEE1394_CMP) += cmp.o
 
 quiet_cmd_oui2c = OUI2C   $@
       cmd_oui2c = $(CONFIG_SHELL) $(srctree)/$(src)/oui2c.sh < $< > $@
diff --git a/drivers/ieee1394/csr1212.c b/drivers/ieee1394/csr1212.c
index 61ddd5d37eff..c0f8ed6fca8a 100644
--- a/drivers/ieee1394/csr1212.c
+++ b/drivers/ieee1394/csr1212.c
@@ -1261,7 +1261,7 @@ static int csr1212_parse_bus_info_block(struct csr1212_csr *csr)
                 return CSR1212_EINVAL;
 #endif
 
-        cr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
+        cr = CSR1212_MALLOC(sizeof(*cr));
         if (!cr)
                 return CSR1212_ENOMEM;
 
@@ -1393,8 +1393,7 @@ int csr1212_parse_keyval(struct csr1212_keyval *kv,
         case CSR1212_KV_TYPE_LEAF:
                 if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM) {
                         kv->value.leaf.data = CSR1212_MALLOC(quads_to_bytes(kvi_len));
-                        if (!kv->value.leaf.data)
-                        {
+                        if (!kv->value.leaf.data) {
                                 ret = CSR1212_ENOMEM;
                                 goto fail;
                         }
@@ -1462,7 +1461,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
                 cache->next = NULL;
                 csr->cache_tail = cache;
                 cache->filled_head =
-                        CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
+                        CSR1212_MALLOC(sizeof(*cache->filled_head));
                 if (!cache->filled_head) {
                         return CSR1212_ENOMEM;
                 }
@@ -1484,7 +1483,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
         /* Now seach read portions of the cache to see if it is there. */
         for (cr = cache->filled_head; cr; cr = cr->next) {
                 if (cache_index < cr->offset_start) {
-                        newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
+                        newcr = CSR1212_MALLOC(sizeof(*newcr));
                         if (!newcr)
                                 return CSR1212_ENOMEM;
 
@@ -1508,7 +1507,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv)
 
         if (!cr) {
                 cr = cache->filled_tail;
-                newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region));
+                newcr = CSR1212_MALLOC(sizeof(*newcr));
                 if (!newcr)
                         return CSR1212_ENOMEM;
 
diff --git a/drivers/ieee1394/csr1212.h b/drivers/ieee1394/csr1212.h
index 28c5f4b726e2..cecd5871f2de 100644
--- a/drivers/ieee1394/csr1212.h
+++ b/drivers/ieee1394/csr1212.h
@@ -646,7 +646,7 @@ static inline struct csr1212_csr_rom_cache *csr1212_rom_cache_malloc(u_int32_t o
 {
         struct csr1212_csr_rom_cache *cache;
 
-        cache = CSR1212_MALLOC(sizeof(struct csr1212_csr_rom_cache) + size);
+        cache = CSR1212_MALLOC(sizeof(*cache) + size);
         if (!cache)
                 return NULL;
 
diff --git a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
index cbbbe14b8849..196db7439272 100644
--- a/drivers/ieee1394/dv1394.c
+++ b/drivers/ieee1394/dv1394.c
@@ -123,15 +123,6 @@
 
 #include "ohci1394.h"
 
-#ifndef virt_to_page
-#define virt_to_page(x) MAP_NR(x)
-#endif
-
-#ifndef vmalloc_32
-#define vmalloc_32(x) vmalloc(x)
-#endif
-
-
 /* DEBUG LEVELS:
    0 - no debugging messages
    1 - some debugging messages, but none during DMA frame transmission
@@ -2218,14 +2209,12 @@ static int dv1394_init(struct ti_ohci *ohci, enum pal_or_ntsc format, enum modes
         unsigned long flags;
         int i;
 
-        video = kmalloc(sizeof(struct video_card), GFP_KERNEL);
+        video = kzalloc(sizeof(*video), GFP_KERNEL);
         if (!video) {
                 printk(KERN_ERR "dv1394: cannot allocate video_card\n");
                 goto err;
         }
 
-        memset(video, 0, sizeof(struct video_card));
-
         video->ohci = ohci;
         /* lower 2 bits of id indicate which of four "plugs"
            per host */
diff --git a/drivers/ieee1394/eth1394.c b/drivers/ieee1394/eth1394.c
index c9e92d85c893..30fa0d43a43a 100644
--- a/drivers/ieee1394/eth1394.c
+++ b/drivers/ieee1394/eth1394.c
@@ -88,9 +88,6 @@
         printk(KERN_ERR "%s:%s[%d]: " fmt "\n", driver_name, __FUNCTION__, __LINE__, ## args)
 #define TRACE() printk(KERN_ERR "%s:%s[%d] ---- TRACE\n", driver_name, __FUNCTION__, __LINE__)
 
-static char version[] __devinitdata =
-        "$Rev: 1312 $ Ben Collins <bcollins@debian.org>";
-
 struct fragment_info {
         struct list_head list;
         int offset;
@@ -355,12 +352,12 @@ static int eth1394_probe(struct device *dev)
         if (!hi)
                 return -ENOENT;
 
-        new_node = kmalloc(sizeof(struct eth1394_node_ref),
+        new_node = kmalloc(sizeof(*new_node),
                            in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
         if (!new_node)
                 return -ENOMEM;
 
-        node_info = kmalloc(sizeof(struct eth1394_node_info),
+        node_info = kmalloc(sizeof(*node_info),
                             in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
         if (!node_info) {
                 kfree(new_node);
@@ -436,12 +433,12 @@ static int eth1394_update(struct unit_directory *ud)
         node = eth1394_find_node(&priv->ip_node_list, ud);
 
         if (!node) {
-                node = kmalloc(sizeof(struct eth1394_node_ref),
+                node = kmalloc(sizeof(*node),
                                in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
                 if (!node)
                         return -ENOMEM;
 
-                node_info = kmalloc(sizeof(struct eth1394_node_info),
+                node_info = kmalloc(sizeof(*node_info),
                                     in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
                 if (!node_info) {
                         kfree(node);
@@ -566,7 +563,6 @@ static void ether1394_add_host (struct hpsb_host *host)
         struct eth1394_host_info *hi = NULL;
         struct net_device *dev = NULL;
         struct eth1394_priv *priv;
-        static int version_printed = 0;
         u64 fifo_addr;
 
         if (!(host->config_roms & HPSB_CONFIG_ROM_ENTRY_IP1394))
@@ -581,9 +577,6 @@ static void ether1394_add_host (struct hpsb_host *host)
         if (fifo_addr == ~0ULL)
                 goto out;
 
-        if (version_printed++ == 0)
-                ETH1394_PRINT_G (KERN_INFO, "%s\n", version);
-
         /* We should really have our own alloc_hpsbdev() function in
          * net_init.c instead of calling the one for ethernet then hijacking
          * it for ourselves.  That way we'd be a real networking device. */
@@ -1021,7 +1014,7 @@ static inline int new_fragment(struct list_head *frag_info, int offset, int len)
                 }
         }
 
-        new = kmalloc(sizeof(struct fragment_info), GFP_ATOMIC);
+        new = kmalloc(sizeof(*new), GFP_ATOMIC);
         if (!new)
                 return -ENOMEM;
 
@@ -1040,7 +1033,7 @@ static inline int new_partial_datagram(struct net_device *dev,
 {
         struct partial_datagram *new;
 
-        new = kmalloc(sizeof(struct partial_datagram), GFP_ATOMIC);
+        new = kmalloc(sizeof(*new), GFP_ATOMIC);
         if (!new)
                 return -ENOMEM;
 
@@ -1768,7 +1761,6 @@ fail:
 static void ether1394_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         strcpy (info->driver, driver_name);
-        strcpy (info->version, "$Rev: 1312 $");
         /* FIXME XXX provide sane businfo */
         strcpy (info->bus_info, "ieee1394");
 }
diff --git a/drivers/ieee1394/highlevel.c b/drivers/ieee1394/highlevel.c
index 997e1bf6297f..734b121a0554 100644
--- a/drivers/ieee1394/highlevel.c
+++ b/drivers/ieee1394/highlevel.c
@@ -101,12 +101,10 @@ void *hpsb_create_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
                 return NULL;
         }
 
-        hi = kmalloc(sizeof(*hi) + data_size, GFP_ATOMIC);
+        hi = kzalloc(sizeof(*hi) + data_size, GFP_ATOMIC);
         if (!hi)
                 return NULL;
 
-        memset(hi, 0, sizeof(*hi) + data_size);
-
         if (data_size) {
                 data = hi->data = hi + 1;
                 hi->size = data_size;
@@ -326,11 +324,9 @@ u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl,
                 return retval;
         }
 
-        as = (struct hpsb_address_serve *)
-                kmalloc(sizeof(struct hpsb_address_serve), GFP_KERNEL);
-        if (as == NULL) {
+        as = kmalloc(sizeof(*as), GFP_KERNEL);
+        if (!as)
                 return retval;
-        }
 
         INIT_LIST_HEAD(&as->host_list);
         INIT_LIST_HEAD(&as->hl_list);
@@ -383,11 +379,9 @@ int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
                 return 0;
         }
 
-        as = (struct hpsb_address_serve *)
-                kmalloc(sizeof(struct hpsb_address_serve), GFP_ATOMIC);
-        if (as == NULL) {
-                return 0;
-        }
+        as = kmalloc(sizeof(*as), GFP_ATOMIC);
+        if (!as)
+                return 0;
 
         INIT_LIST_HEAD(&as->host_list);
         INIT_LIST_HEAD(&as->hl_list);
diff --git a/drivers/ieee1394/hosts.c b/drivers/ieee1394/hosts.c
index aeeaeb670d03..d245abe4033c 100644
--- a/drivers/ieee1394/hosts.c
+++ b/drivers/ieee1394/hosts.c
@@ -114,9 +114,9 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
         int i;
         int hostnum = 0;
 
-        h = kmalloc(sizeof(struct hpsb_host) + extra, SLAB_KERNEL);
-        if (!h) return NULL;
-        memset(h, 0, sizeof(struct hpsb_host) + extra);
+        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);
         if (!h->csr.rom) {
diff --git a/drivers/ieee1394/ieee1394-ioctl.h b/drivers/ieee1394/ieee1394-ioctl.h
index f92b566363d5..156703986348 100644
--- a/drivers/ieee1394/ieee1394-ioctl.h
+++ b/drivers/ieee1394/ieee1394-ioctl.h
@@ -7,14 +7,6 @@
 #include <linux/ioctl.h>
 #include <linux/types.h>
 
-
-/* AMDTP Gets 6 */
-#define AMDTP_IOC_CHANNEL       _IOW('#', 0x00, struct amdtp_ioctl)
-#define AMDTP_IOC_PLUG          _IOW('#', 0x01, struct amdtp_ioctl)
-#define AMDTP_IOC_PING          _IOW('#', 0x02, struct amdtp_ioctl)
-#define AMDTP_IOC_ZAP           _IO ('#', 0x03)
-
-
 /* DV1394 Gets 10 */
 
 /* Get the driver ready to transmit video.  pass a struct dv1394_init* as
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 7fff5a1d2ea4..3f0917bbd7f5 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -743,21 +743,20 @@ static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr
                                               unsigned int generation)
 {
         struct hpsb_host *host = hi->host;
-        struct node_entry *ne;
-
-        ne = kmalloc(sizeof(struct node_entry), GFP_KERNEL);
-        if (!ne) return NULL;
+        struct node_entry *ne;
 
-        memset(ne, 0, sizeof(struct node_entry));
+        ne = kzalloc(sizeof(*ne), GFP_KERNEL);
+        if (!ne)
+                return NULL;
 
         ne->tpool = &host->tpool[nodeid & NODE_MASK];
 
-        ne->host = host;
-        ne->nodeid = nodeid;
+        ne->host = host;
+        ne->nodeid = nodeid;
         ne->generation = generation;
         ne->needs_probe = 1;
 
-        ne->guid = guid;
+        ne->guid = guid;
         ne->guid_vendor_id = (guid >> 40) & 0xffffff;
         ne->guid_vendor_oui = nodemgr_find_oui_name(ne->guid_vendor_id);
         ne->csr = csr;
@@ -787,7 +786,7 @@ static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr
                    (host->node_id == nodeid) ? "Host" : "Node",
                    NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
 
-        return ne;
+        return ne;
 }
 
 
@@ -872,12 +871,10 @@ static struct unit_directory *nodemgr_process_unit_directory
         struct csr1212_keyval *kv;
         u8 last_key_id = 0;
 
-        ud = kmalloc(sizeof(struct unit_directory), GFP_KERNEL);
+        ud = kzalloc(sizeof(*ud), GFP_KERNEL);
         if (!ud)
                 goto unit_directory_error;
 
-        memset (ud, 0, sizeof(struct unit_directory));
-
         ud->ne = ne;
         ud->ignore_driver = ignore_drivers;
         ud->address = ud_kv->offset + CSR1212_CONFIG_ROM_SPACE_BASE;
@@ -937,10 +934,10 @@ static struct unit_directory *nodemgr_process_unit_directory
                         /* Logical Unit Number */
                         if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
                                 if (ud->flags & UNIT_DIRECTORY_HAS_LUN) {
-                                        ud_child = kmalloc(sizeof(struct unit_directory), GFP_KERNEL);
+                                        ud_child = kmalloc(sizeof(*ud_child), GFP_KERNEL);
                                         if (!ud_child)
                                                 goto unit_directory_error;
-                                        memcpy(ud_child, ud, sizeof(struct unit_directory));
+                                        memcpy(ud_child, ud, sizeof(*ud_child));
                                         nodemgr_register_device(ne, ud_child, &ne->device);
                                         ud_child = NULL;
                                         
@@ -1200,7 +1197,7 @@ static void nodemgr_node_scan_one(struct host_info *hi,
         struct csr1212_csr *csr;
         struct nodemgr_csr_info *ci;
 
-        ci = kmalloc(sizeof(struct nodemgr_csr_info), GFP_KERNEL);
+        ci = kmalloc(sizeof(*ci), GFP_KERNEL);
         if (!ci)
                 return;
 
diff --git a/drivers/ieee1394/ohci1394.c b/drivers/ieee1394/ohci1394.c
index 4cf9b8f3e336..97b6f48033c4 100644
--- a/drivers/ieee1394/ohci1394.c
+++ b/drivers/ieee1394/ohci1394.c
@@ -161,9 +161,6 @@ printk(level "%s: " fmt "\n" , OHCI1394_DRIVER_NAME , ## args)
 #define PRINT(level, fmt, args...) \
 printk(level "%s: fw-host%d: " fmt "\n" , OHCI1394_DRIVER_NAME, ohci->host->id , ## args)
 
-static char version[] __devinitdata =
-        "$Rev: 1313 $ Ben Collins <bcollins@debian.org>";
-
 /* Module Parameters */
 static int phys_dma = 1;
 module_param(phys_dma, int, 0644);
@@ -2960,28 +2957,23 @@ alloc_dma_rcv_ctx(struct ti_ohci *ohci, struct dma_rcv_ctx *d,
         d->ctrlClear = 0;
         d->cmdPtr = 0;
 
-        d->buf_cpu = kmalloc(d->num_desc * sizeof(quadlet_t*), GFP_ATOMIC);
-        d->buf_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_ATOMIC);
+        d->buf_cpu = kzalloc(d->num_desc * sizeof(*d->buf_cpu), GFP_ATOMIC);
+        d->buf_bus = kzalloc(d->num_desc * sizeof(*d->buf_bus), GFP_ATOMIC);
 
         if (d->buf_cpu == NULL || d->buf_bus == NULL) {
                 PRINT(KERN_ERR, "Failed to allocate dma buffer");
                 free_dma_rcv_ctx(d);
                 return -ENOMEM;
         }
-        memset(d->buf_cpu, 0, d->num_desc * sizeof(quadlet_t*));
-        memset(d->buf_bus, 0, d->num_desc * sizeof(dma_addr_t));
 
-        d->prg_cpu = kmalloc(d->num_desc * sizeof(struct dma_cmd*),
-                                GFP_ATOMIC);
-        d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_ATOMIC);
+        d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_ATOMIC);
+        d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_ATOMIC);
 
         if (d->prg_cpu == NULL || d->prg_bus == NULL) {
                 PRINT(KERN_ERR, "Failed to allocate dma prg");
                 free_dma_rcv_ctx(d);
                 return -ENOMEM;
         }
-        memset(d->prg_cpu, 0, d->num_desc * sizeof(struct dma_cmd*));
-        memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
 
         d->spb = kmalloc(d->split_buf_size, GFP_ATOMIC);
 
@@ -3093,17 +3085,14 @@ alloc_dma_trm_ctx(struct ti_ohci *ohci, struct dma_trm_ctx *d,
         d->ctrlClear = 0;
         d->cmdPtr = 0;
 
-        d->prg_cpu = kmalloc(d->num_desc * sizeof(struct at_dma_prg*),
-                             GFP_KERNEL);
-        d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
+        d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_KERNEL);
+        d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_KERNEL);
 
         if (d->prg_cpu == NULL || d->prg_bus == NULL) {
                 PRINT(KERN_ERR, "Failed to allocate at dma prg");
                 free_dma_trm_ctx(d);
                 return -ENOMEM;
         }
-        memset(d->prg_cpu, 0, d->num_desc * sizeof(struct at_dma_prg*));
-        memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
 
         len = sprintf(pool_name, "ohci1394_trm_prg");
         sprintf(pool_name+len, "%d", num_allocs);
@@ -3201,8 +3190,6 @@ static struct hpsb_host_driver ohci1394_driver = {
         .hw_csr_reg =           ohci_hw_csr_reg,
 };
 
-
-
 /***********************************
  * PCI Driver Interface functions  *
  ***********************************/
@@ -3217,15 +3204,10 @@ do {						\
 static int __devinit ohci1394_pci_probe(struct pci_dev *dev,
                                         const struct pci_device_id *ent)
 {
-        static int version_printed = 0;
-
         struct hpsb_host *host;
         struct ti_ohci *ohci;   /* shortcut to currently handled device */
         unsigned long ohci_base;
 
-        if (version_printed++ == 0)
-                PRINT_G(KERN_INFO, "%s", version);
-
         if (pci_enable_device(dev))
                 FAIL(-ENXIO, "Failed to enable OHCI hardware");
         pci_set_master(dev);
@@ -3606,8 +3588,6 @@ static struct pci_driver ohci1394_pci_driver = {
         .suspend =      ohci1394_pci_suspend,
 };
 
-
-
 /***********************************
  * OHCI1394 Video Interface        *
  ***********************************/
@@ -3714,7 +3694,6 @@ EXPORT_SYMBOL(ohci1394_init_iso_tasklet);
 EXPORT_SYMBOL(ohci1394_register_iso_tasklet);
 EXPORT_SYMBOL(ohci1394_unregister_iso_tasklet);
 
-
 /***********************************
  * General module initialization   *
  ***********************************/
diff --git a/drivers/ieee1394/ohci1394.h b/drivers/ieee1394/ohci1394.h
index cc66c1cae250..7df0962144e3 100644
--- a/drivers/ieee1394/ohci1394.h
+++ b/drivers/ieee1394/ohci1394.h
@@ -219,8 +219,8 @@ struct ti_ohci {
 
         int self_id_errors;
 
-        /* Tasklets for iso receive and transmit, used by video1394,
-         * amdtp and dv1394 */
+        /* Tasklets for iso receive and transmit, used by video1394
+         * and dv1394 */
 
         struct list_head iso_tasklet_list;
         spinlock_t iso_tasklet_list_lock;
diff --git a/drivers/ieee1394/pcilynx.c b/drivers/ieee1394/pcilynx.c
index 6b1ab875333b..e2edc41e1b6f 100644
--- a/drivers/ieee1394/pcilynx.c
+++ b/drivers/ieee1394/pcilynx.c
@@ -1435,7 +1435,7 @@ static int __devinit add_card(struct pci_dev *dev,
                 struct i2c_algo_bit_data i2c_adapter_data;
 
                 error = -ENOMEM;
-                i2c_ad = kmalloc(sizeof(struct i2c_adapter), SLAB_KERNEL);
+                i2c_ad = kmalloc(sizeof(*i2c_ad), SLAB_KERNEL);
                 if (!i2c_ad) FAIL("failed to allocate I2C adapter memory");
 
                 memcpy(i2c_ad, &bit_ops, sizeof(struct i2c_adapter));
diff --git a/drivers/ieee1394/raw1394.c b/drivers/ieee1394/raw1394.c
index 24411e666b21..0278dc5d5ef9 100644
--- a/drivers/ieee1394/raw1394.c
+++ b/drivers/ieee1394/raw1394.c
@@ -102,12 +102,9 @@ static struct pending_request *__alloc_pending_request(gfp_t flags)
 {
         struct pending_request *req;
 
-        req = (struct pending_request *)kmalloc(sizeof(struct pending_request),
-                                                flags);
-        if (req != NULL) {
-                memset(req, 0, sizeof(struct pending_request));
+        req = kzalloc(sizeof(*req), flags);
+        if (req)
                 INIT_LIST_HEAD(&req->list);
-        }
 
         return req;
 }
@@ -192,9 +189,9 @@ static void add_host(struct hpsb_host *host)
         struct host_info *hi;
         unsigned long flags;
 
-        hi = (struct host_info *)kmalloc(sizeof(struct host_info), GFP_KERNEL);
+        hi = kmalloc(sizeof(*hi), GFP_KERNEL);
 
-        if (hi != NULL) {
+        if (hi) {
                 INIT_LIST_HEAD(&hi->list);
                 hi->host = host;
                 INIT_LIST_HEAD(&hi->file_info_list);
@@ -315,8 +312,8 @@ static void iso_receive(struct hpsb_host *host, int channel, quadlet_t * data,
                                 break;
 
                         if (!ibs) {
-                                ibs = kmalloc(sizeof(struct iso_block_store)
-                                              + length, SLAB_ATOMIC);
+                                ibs = kmalloc(sizeof(*ibs) + length,
+                                              SLAB_ATOMIC);
                                 if (!ibs) {
                                         kfree(req);
                                         break;
@@ -376,8 +373,8 @@ static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
                                 break;
 
                         if (!ibs) {
-                                ibs = kmalloc(sizeof(struct iso_block_store)
-                                              + length, SLAB_ATOMIC);
+                                ibs = kmalloc(sizeof(*ibs) + length,
+                                              SLAB_ATOMIC);
                                 if (!ibs) {
                                         kfree(req);
                                         break;
@@ -502,10 +499,9 @@ static int state_initialized(struct file_info *fi, struct pending_request *req)
         switch (req->req.type) {
         case RAW1394_REQ_LIST_CARDS:
                 spin_lock_irqsave(&host_info_lock, flags);
-                khl = kmalloc(sizeof(struct raw1394_khost_list) * host_count,
-                              SLAB_ATOMIC);
+                khl = kmalloc(sizeof(*khl) * host_count, SLAB_ATOMIC);
 
-                if (khl != NULL) {
+                if (khl) {
                         req->req.misc = host_count;
                         req->data = (quadlet_t *) khl;
 
@@ -517,7 +513,7 @@ static int state_initialized(struct file_info *fi, struct pending_request *req)
                 }
                 spin_unlock_irqrestore(&host_info_lock, flags);
 
-                if (khl != NULL) {
+                if (khl) {
                         req->req.error = RAW1394_ERROR_NONE;
                         req->req.length = min(req->req.length,
                                               (u32) (sizeof
@@ -1647,13 +1643,13 @@ static int arm_register(struct file_info *fi, struct pending_request *req)
                 return (-EINVAL);
         }
         /* addr-list-entry for fileinfo */
-        addr = (struct arm_addr *)kmalloc(sizeof(struct arm_addr), SLAB_KERNEL);
+        addr = kmalloc(sizeof(*addr), SLAB_KERNEL);
         if (!addr) {
                 req->req.length = 0;
                 return (-ENOMEM);
         }
         /* allocation of addr_space_buffer */
-        addr->addr_space_buffer = (u8 *) vmalloc(req->req.length);
+        addr->addr_space_buffer = vmalloc(req->req.length);
         if (!(addr->addr_space_buffer)) {
                 kfree(addr);
                 req->req.length = 0;
@@ -2122,8 +2118,7 @@ static int modify_config_rom(struct file_info *fi, struct pending_request *req)
                 return -ENOMEM;
         }
 
-        cache->filled_head =
-            kmalloc(sizeof(struct csr1212_cache_region), GFP_KERNEL);
+        cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL);
         if (!cache->filled_head) {
                 csr1212_release_keyval(fi->csr1212_dirs[dr]);
                 fi->csr1212_dirs[dr] = NULL;
@@ -2684,11 +2679,10 @@ static int raw1394_open(struct inode *inode, struct file *file)
 {
         struct file_info *fi;
 
-        fi = kmalloc(sizeof(struct file_info), SLAB_KERNEL);
-        if (fi == NULL)
+        fi = kzalloc(sizeof(*fi), SLAB_KERNEL);
+        if (!fi)
                 return -ENOMEM;
 
-        memset(fi, 0, sizeof(struct file_info));
         fi->notification = (u8) RAW1394_NOTIFY_ON;      /* busreset notification */
 
         INIT_LIST_HEAD(&fi->list);
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
index 12cec7c4a342..84875cd5a70d 100644
--- a/drivers/ieee1394/sbp2.c
+++ b/drivers/ieee1394/sbp2.c
@@ -80,9 +80,6 @@
 #include "ieee1394_transactions.h"
 #include "sbp2.h"
 
-static char version[] __devinitdata =
-        "$Rev: 1306 $ Ben Collins <bcollins@debian.org>";
-
 /*
  * Module load parameter definitions
  */
@@ -151,18 +148,15 @@ static int force_inquiry_hack;
 module_param(force_inquiry_hack, int, 0444);
 MODULE_PARM_DESC(force_inquiry_hack, "Force SCSI inquiry hack (default = 0)");
 
-
 /*
  * Export information about protocols/devices supported by this driver.
  */
 static struct ieee1394_device_id sbp2_id_table[] = {
         {
-                .match_flags =IEEE1394_MATCH_SPECIFIER_ID |
-                              IEEE1394_MATCH_VERSION,
-                .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
-                .version =    SBP2_SW_VERSION_ENTRY & 0xffffff
-        },
-        { }
+         .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
+         .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
+         .version = SBP2_SW_VERSION_ENTRY & 0xffffff},
+        {}
 };
 
 MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
@@ -221,7 +215,6 @@ static u32 global_outstanding_dmas = 0;
 
 #define SBP2_ERR(fmt, args...)          HPSB_ERR("sbp2: "fmt, ## args)
 
-
 /*
  * Globals
  */
@@ -254,8 +247,8 @@ static struct hpsb_address_ops sbp2_ops = {
 
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 static struct hpsb_address_ops sbp2_physdma_ops = {
-        .read = sbp2_handle_physdma_read,
-        .write = sbp2_handle_physdma_write,
+        .read = sbp2_handle_physdma_read,
+        .write = sbp2_handle_physdma_write,
 };
 #endif
 
@@ -287,7 +280,6 @@ static u32 sbp2_broken_inquiry_list[] = {
  * General utility functions
  **************************************/
 
-
 #ifndef __BIG_ENDIAN
 /*
  * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
@@ -324,7 +316,8 @@ static __inline__ void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
 /*
  * Debug packet dump routine. Length is in bytes.
  */
-static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, u32 dump_phys_addr)
+static void sbp2util_packet_dump(void *buffer, int length, char *dump_name,
+                                 u32 dump_phys_addr)
 {
         int i;
         unsigned char *dump = buffer;
@@ -345,7 +338,7 @@ static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, u32
                         printk("  ");
                 if ((i & 0xf) == 0)
                         printk("\n   ");
-                printk("%02x ", (int) dump[i]);
+                printk("%02x ", (int)dump[i]);
         }
         printk("\n");
 
@@ -364,9 +357,9 @@ static int sbp2util_down_timeout(atomic_t *done, int timeout)
 
         for (i = timeout; (i > 0 && atomic_read(done) == 0); i-= HZ/10) {
                 if (msleep_interruptible(100))  /* 100ms */
-                        return(1);
+                        return 1;
         }
-        return ((i > 0) ? 0:1);
+        return (i > 0) ? 0 : 1;
 }
 
 /* Free's an allocated packet */
@@ -380,21 +373,22 @@ static void sbp2_free_packet(struct hpsb_packet *packet)
  * subaction and returns immediately. Can be used from interrupts.
  */
 static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
-                                quadlet_t *buffer, size_t length)
+                                       quadlet_t *buffer, size_t length)
 {
         struct hpsb_packet *packet;
 
         packet = hpsb_make_writepacket(ne->host, ne->nodeid,
                                        addr, buffer, length);
-        if (!packet)
-                return -ENOMEM;
+        if (!packet)
+                return -ENOMEM;
 
-        hpsb_set_packet_complete_task(packet, (void (*)(void*))sbp2_free_packet,
+        hpsb_set_packet_complete_task(packet,
+                                      (void (*)(void *))sbp2_free_packet,
                                       packet);
 
         hpsb_node_fill_packet(ne, packet);
 
-        if (hpsb_send_packet(packet) < 0) {
+        if (hpsb_send_packet(packet) < 0) {
                 sbp2_free_packet(packet);
                 return -EIO;
         }
@@ -417,22 +411,22 @@ static int sbp2util_create_command_orb_pool(struct scsi_id_instance_data *scsi_i
 
         spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
         for (i = 0; i < orbs; i++) {
-                command = (struct sbp2_command_info *)
-                    kmalloc(sizeof(struct sbp2_command_info), GFP_ATOMIC);
+                command = kzalloc(sizeof(*command), GFP_ATOMIC);
                 if (!command) {
-                        spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
-                        return(-ENOMEM);
+                        spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock,
+                                               flags);
+                        return -ENOMEM;
                 }
-                memset(command, '\0', sizeof(struct sbp2_command_info));
                 command->command_orb_dma =
-                        pci_map_single (hi->host->pdev, &command->command_orb,
-                                        sizeof(struct sbp2_command_orb),
-                                        PCI_DMA_BIDIRECTIONAL);
+                    pci_map_single(hi->host->pdev, &command->command_orb,
+                                   sizeof(struct sbp2_command_orb),
+                                   PCI_DMA_BIDIRECTIONAL);
                 SBP2_DMA_ALLOC("single command orb DMA");
                 command->sge_dma =
-                        pci_map_single (hi->host->pdev, &command->scatter_gather_element,
-                                        sizeof(command->scatter_gather_element),
-                                        PCI_DMA_BIDIRECTIONAL);
+                    pci_map_single(hi->host->pdev,
+                                   &command->scatter_gather_element,
+                                   sizeof(command->scatter_gather_element),
+                                   PCI_DMA_BIDIRECTIONAL);
                 SBP2_DMA_ALLOC("scatter_gather_element");
                 INIT_LIST_HEAD(&command->list);
                 list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed);
@@ -488,7 +482,7 @@ static struct sbp2_command_info *sbp2util_find_command_for_orb(
                 list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
                         if (command->command_orb_dma == orb) {
                                 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
-                                return (command);
+                                return command;
                         }
                 }
         }
@@ -496,7 +490,7 @@ static struct sbp2_command_info *sbp2util_find_command_for_orb(
 
         SBP2_ORB_DEBUG("could not match command orb %x", (unsigned int)orb);
 
-        return(NULL);
+        return NULL;
 }
 
 /*
@@ -513,12 +507,12 @@ static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(struct scsi_id_
                 list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
                         if (command->Current_SCpnt == SCpnt) {
                                 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
-                                return (command);
+                                return command;
                         }
                 }
         }
         spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
-        return(NULL);
+        return NULL;
 }
 
 /*
@@ -545,7 +539,7 @@ static struct sbp2_command_info *sbp2util_allocate_command_orb(
                 SBP2_ERR("sbp2util_allocate_command_orb - No orbs available!");
         }
         spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
-        return (command);
+        return command;
 }
 
 /* Free our DMA's */
@@ -587,7 +581,8 @@ static void sbp2util_free_command_dma(struct sbp2_command_info *command)
 /*
  * This function moves a command to the completed orb list.
  */
-static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id, struct sbp2_command_info *command)
+static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id,
+                                            struct sbp2_command_info *command)
 {
         unsigned long flags;
 
@@ -606,8 +601,6 @@ static inline int sbp2util_node_is_available(struct scsi_id_instance_data *scsi_
         return scsi_id && scsi_id->ne && !scsi_id->ne->in_limbo;
 }
 
-
-
 /*********************************************
  * IEEE-1394 core driver stack related section
  *********************************************/
@@ -627,14 +620,14 @@ static int sbp2_probe(struct device *dev)
         if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
                 return -ENODEV;
 
-        scsi_id = sbp2_alloc_device(ud);
+        scsi_id = sbp2_alloc_device(ud);
 
-        if (!scsi_id)
-                return -ENOMEM;
+        if (!scsi_id)
+                return -ENOMEM;
 
-        sbp2_parse_unit_directory(scsi_id, ud);
+        sbp2_parse_unit_directory(scsi_id, ud);
 
-        return sbp2_start_device(scsi_id);
+        return sbp2_start_device(scsi_id);
 }
 
 static int sbp2_remove(struct device *dev)
@@ -719,12 +712,11 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud
 
         SBP2_DEBUG("sbp2_alloc_device");
 
-        scsi_id = kmalloc(sizeof(*scsi_id), GFP_KERNEL);
+        scsi_id = kzalloc(sizeof(*scsi_id), GFP_KERNEL);
         if (!scsi_id) {
                 SBP2_ERR("failed to create scsi_id");
                 goto failed_alloc;
         }
-        memset(scsi_id, 0, sizeof(*scsi_id));
 
         scsi_id->ne = ud->ne;
         scsi_id->ud = ud;
@@ -735,7 +727,7 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud
         INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_completed);
         INIT_LIST_HEAD(&scsi_id->scsi_list);
         spin_lock_init(&scsi_id->sbp2_command_orb_lock);
-        scsi_id->sbp2_device_type_and_lun = SBP2_DEVICE_TYPE_LUN_UNINITIALIZED;
+        scsi_id->sbp2_lun = 0;
 
         ud->device.driver_data = scsi_id;
 
@@ -769,7 +761,7 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud
 
         /* Register our host with the SCSI stack. */
         scsi_host = scsi_host_alloc(&scsi_driver_template,
-                                    sizeof (unsigned long));
+                                    sizeof(unsigned long));
         if (!scsi_host) {
                 SBP2_ERR("failed to register scsi host");
                 goto failed_alloc;
@@ -790,7 +782,6 @@ failed_alloc:
         return NULL;
 }
 
-
 static void sbp2_host_reset(struct hpsb_host *host)
 {
         struct sbp2scsi_host_info *hi;
@@ -804,7 +795,6 @@ static void sbp2_host_reset(struct hpsb_host *host)
         }
 }
 
-
 /*
  * This function is where we first pull the node unique ids, and then
  * allocate memory and register a SBP-2 device.
@@ -818,7 +808,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Login FIFO DMA */
         scsi_id->login_response =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_response),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_login_response),
                                      &scsi_id->login_response_dma);
         if (!scsi_id->login_response)
                 goto alloc_fail;
@@ -826,7 +817,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Query logins ORB DMA */
         scsi_id->query_logins_orb =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_orb),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_query_logins_orb),
                                      &scsi_id->query_logins_orb_dma);
         if (!scsi_id->query_logins_orb)
                 goto alloc_fail;
@@ -834,7 +826,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Query logins response DMA */
         scsi_id->query_logins_response =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_response),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_query_logins_response),
                                      &scsi_id->query_logins_response_dma);
         if (!scsi_id->query_logins_response)
                 goto alloc_fail;
@@ -842,7 +835,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Reconnect ORB DMA */
         scsi_id->reconnect_orb =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_reconnect_orb),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_reconnect_orb),
                                      &scsi_id->reconnect_orb_dma);
         if (!scsi_id->reconnect_orb)
                 goto alloc_fail;
@@ -850,7 +844,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Logout ORB DMA */
         scsi_id->logout_orb =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_logout_orb),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_logout_orb),
                                      &scsi_id->logout_orb_dma);
         if (!scsi_id->logout_orb)
                 goto alloc_fail;
@@ -858,7 +853,8 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 
         /* Login ORB DMA */
         scsi_id->login_orb =
-                pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_orb),
+                pci_alloc_consistent(hi->host->pdev,
+                                     sizeof(struct sbp2_login_orb),
                                      &scsi_id->login_orb_dma);
         if (!scsi_id->login_orb) {
 alloc_fail:
@@ -880,25 +876,25 @@ alloc_fail:
 
                 if (scsi_id->logout_orb) {
                         pci_free_consistent(hi->host->pdev,
-                                        sizeof(struct sbp2_logout_orb),
-                                        scsi_id->logout_orb,
-                                        scsi_id->logout_orb_dma);
+                                            sizeof(struct sbp2_logout_orb),
+                                            scsi_id->logout_orb,
+                                            scsi_id->logout_orb_dma);
                         SBP2_DMA_FREE("logout ORB DMA");
                 }
 
                 if (scsi_id->reconnect_orb) {
                         pci_free_consistent(hi->host->pdev,
-                                        sizeof(struct sbp2_reconnect_orb),
-                                        scsi_id->reconnect_orb,
-                                        scsi_id->reconnect_orb_dma);
+                                            sizeof(struct sbp2_reconnect_orb),
+                                            scsi_id->reconnect_orb,
+                                            scsi_id->reconnect_orb_dma);
                         SBP2_DMA_FREE("reconnect ORB DMA");
                 }
 
                 if (scsi_id->login_response) {
                         pci_free_consistent(hi->host->pdev,
-                                        sizeof(struct sbp2_login_response),
-                                        scsi_id->login_response,
-                                        scsi_id->login_response_dma);
+                                            sizeof(struct sbp2_login_response),
+                                            scsi_id->login_response,
+                                            scsi_id->login_response_dma);
                         SBP2_DMA_FREE("login FIFO DMA");
                 }
 
@@ -906,7 +902,7 @@ alloc_fail:
 
                 kfree(scsi_id);
 
-                SBP2_ERR ("Could not allocate memory for scsi_id");
+                SBP2_ERR("Could not allocate memory for scsi_id");
 
                 return -ENOMEM;
         }
@@ -935,7 +931,7 @@ alloc_fail:
                 sbp2_remove_device(scsi_id);
                 return -EINTR;
         }
-        
+
         /*
          * Login to the sbp-2 device
          */
@@ -1054,51 +1050,44 @@ static void sbp2_remove_device(struct scsi_id_instance_data *scsi_id)
  * This function deals with physical dma write requests (for adapters that do not support
  * physical dma in hardware). Mostly just here for debugging...
  */
-static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t *data,
-                                     u64 addr, size_t length, u16 flags)
+static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid,
+                                     int destid, quadlet_t *data, u64 addr,
+                                     size_t length, u16 flags)
 {
 
-        /*
-         * Manually put the data in the right place.
-         */
-        memcpy(bus_to_virt((u32)addr), data, length);
-        sbp2util_packet_dump(data, length, "sbp2 phys dma write by device", (u32)addr);
-        return(RCODE_COMPLETE);
+        /*
+         * Manually put the data in the right place.
+         */
+        memcpy(bus_to_virt((u32) addr), data, length);
+        sbp2util_packet_dump(data, length, "sbp2 phys dma write by device",
+                             (u32) addr);
+        return RCODE_COMPLETE;
 }
 
 /*
  * This function deals with physical dma read requests (for adapters that do not support
  * physical dma in hardware). Mostly just here for debugging...
  */
-static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid, quadlet_t *data,
-                                    u64 addr, size_t length, u16 flags)
+static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid,
+                                    quadlet_t *data, u64 addr, size_t length,
+                                    u16 flags)
 {
 
-        /*
-         * Grab data from memory and send a read response.
-         */
-        memcpy(data, bus_to_virt((u32)addr), length);
-        sbp2util_packet_dump(data, length, "sbp2 phys dma read by device", (u32)addr);
-        return(RCODE_COMPLETE);
+        /*
+         * Grab data from memory and send a read response.
+         */
+        memcpy(data, bus_to_virt((u32) addr), length);
+        sbp2util_packet_dump(data, length, "sbp2 phys dma read by device",
+                             (u32) addr);
+        return RCODE_COMPLETE;
 }
 #endif
 
-
 /**************************************
  * SBP-2 protocol related section
  **************************************/
 
 /*
- * This function determines if we should convert scsi commands for a particular sbp2 device type
- */
-static __inline__ int sbp2_command_conversion_device_type(u8 device_type)
-{
-        return (((device_type == TYPE_DISK) ||
-                 (device_type == TYPE_RBC) ||
-                 (device_type == TYPE_ROM)) ? 1:0);
-}
-
-/*
  * This function queries the device for the maximum concurrent logins it
  * supports.
  */
@@ -1120,11 +1109,7 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
 
         scsi_id->query_logins_orb->lun_misc = ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
         scsi_id->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
-        if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) {
-                scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun);
-                SBP2_DEBUG("sbp2_query_logins: set lun to %d",
-                           ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun));
-        }
+        scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun);
         SBP2_DEBUG("sbp2_query_logins: lun_misc initialized");
 
         scsi_id->query_logins_orb->reserved_resp_length =
@@ -1161,12 +1146,12 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
 
         if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 2*HZ)) {
                 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
-                return(-EIO);
+                return -EIO;
         }
 
         if (scsi_id->status_block.ORB_offset_lo != scsi_id->query_logins_orb_dma) {
                 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
-                return(-EIO);
+                return -EIO;
         }
 
         if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
@@ -1174,7 +1159,7 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
             STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
 
                 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
-                return(-EIO);
+                return -EIO;
         }
 
         sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_response, sizeof(struct sbp2_query_logins_response));
@@ -1191,7 +1176,7 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
         SBP2_DEBUG("Number of active logins: %d", active_logins);
 
         if (active_logins >= max_logins) {
-                return(-EIO);
+                return -EIO;
         }
 
         return 0;
@@ -1210,13 +1195,13 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
 
         if (!scsi_id->login_orb) {
                 SBP2_DEBUG("sbp2_login_device: login_orb not alloc'd!");
-                return(-EIO);
+                return -EIO;
         }
 
         if (!exclusive_login) {
                 if (sbp2_query_logins(scsi_id)) {
                         SBP2_INFO("Device does not support any more concurrent logins");
-                        return(-EIO);
+                        return -EIO;
                 }
         }
 
@@ -1233,12 +1218,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
         scsi_id->login_orb->lun_misc |= ORB_SET_RECONNECT(0);   /* One second reconnect time */
         scsi_id->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(exclusive_login);     /* Exclusive access to device */
         scsi_id->login_orb->lun_misc |= ORB_SET_NOTIFY(1);      /* Notify us of login complete */
-        /* Set the lun if we were able to pull it from the device's unit directory */
-        if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) {
-                scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun);
-                SBP2_DEBUG("sbp2_query_logins: set lun to %d",
-                           ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun));
-        }
+        scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun);
         SBP2_DEBUG("sbp2_login_device: lun_misc initialized");
 
         scsi_id->login_orb->passwd_resp_lengths =
@@ -1288,7 +1268,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
          */
         if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 20*HZ)) {
                 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -1296,7 +1276,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
          */
         if (scsi_id->status_block.ORB_offset_lo != scsi_id->login_orb_dma) {
                 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -1307,7 +1287,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
             STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
 
                 SBP2_ERR("Error logging into SBP-2 device - login failed");
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -1331,7 +1311,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
 
         SBP2_INFO("Logged into SBP-2 device");
 
-        return(0);
+        return 0;
 
 }
 
@@ -1385,8 +1365,7 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id)
         atomic_set(&scsi_id->sbp2_login_complete, 0);
 
         error = hpsb_node_write(scsi_id->ne,
-                                    scsi_id->sbp2_management_agent_addr,
-                                    data, 8);
+                                scsi_id->sbp2_management_agent_addr, data, 8);
         if (error)
                 return error;
 
@@ -1396,7 +1375,7 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id)
 
         SBP2_INFO("Logged out of SBP-2 device");
 
-        return(0);
+        return 0;
 
 }
 
@@ -1456,8 +1435,7 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
         atomic_set(&scsi_id->sbp2_login_complete, 0);
 
         error = hpsb_node_write(scsi_id->ne,
-                                    scsi_id->sbp2_management_agent_addr,
-                                    data, 8);
+                                scsi_id->sbp2_management_agent_addr, data, 8);
         if (error)
                 return error;
 
@@ -1466,7 +1444,7 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
          */
         if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ)) {
                 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -1474,7 +1452,7 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
          */
         if (scsi_id->status_block.ORB_offset_lo != scsi_id->reconnect_orb_dma) {
                 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -1485,12 +1463,12 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
             STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
 
                 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect failed");
-                return(-EIO);
+                return -EIO;
         }
 
         HPSB_DEBUG("Reconnected to SBP-2 device");
 
-        return(0);
+        return 0;
 
 }
 
@@ -1513,10 +1491,9 @@ static int sbp2_set_busy_timeout(struct scsi_id_instance_data *scsi_id)
                 SBP2_ERR("sbp2_set_busy_timeout error");
         }
 
-        return(0);
+        return 0;
 }
 
-
 /*
  * This function is called to parse sbp2 device's config rom unit
  * directory. Used to determine things like sbp2 management agent offset,
@@ -1529,7 +1506,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
         struct csr1212_dentry *dentry;
         u64 management_agent_addr;
         u32 command_set_spec_id, command_set, unit_characteristics,
-                firmware_revision, workarounds;
+            firmware_revision, workarounds;
         int i;
 
         SBP2_DEBUG("sbp2_parse_unit_directory");
@@ -1547,13 +1524,14 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
                         if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET) {
                                 /* Save off the management agent address */
                                 management_agent_addr =
-                                        CSR1212_REGISTER_SPACE_BASE +
-                                        (kv->value.csr_offset << 2);
+                                    CSR1212_REGISTER_SPACE_BASE +
+                                    (kv->value.csr_offset << 2);
 
                                 SBP2_DEBUG("sbp2_management_agent_addr = %x",
-                                           (unsigned int) management_agent_addr);
+                                           (unsigned int)management_agent_addr);
                         } else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
-                                scsi_id->sbp2_device_type_and_lun = kv->value.immediate;
+                                scsi_id->sbp2_lun =
+                                    ORB_SET_LUN(kv->value.immediate);
                         }
                         break;
 
@@ -1561,14 +1539,14 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
                         /* Command spec organization */
                         command_set_spec_id = kv->value.immediate;
                         SBP2_DEBUG("sbp2_command_set_spec_id = %x",
-                                   (unsigned int) command_set_spec_id);
+                                   (unsigned int)command_set_spec_id);
                         break;
 
                 case SBP2_COMMAND_SET_KEY:
                         /* Command set used by sbp2 device */
                         command_set = kv->value.immediate;
                         SBP2_DEBUG("sbp2_command_set = %x",
-                                   (unsigned int) command_set);
+                                   (unsigned int)command_set);
                         break;
 
                 case SBP2_UNIT_CHARACTERISTICS_KEY:
@@ -1578,7 +1556,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
                          */
                         unit_characteristics = kv->value.immediate;
                         SBP2_DEBUG("sbp2_unit_characteristics = %x",
-                                   (unsigned int) unit_characteristics);
+                                   (unsigned int)unit_characteristics);
                         break;
 
                 case SBP2_FIRMWARE_REVISION_KEY:
@@ -1586,9 +1564,10 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
                         firmware_revision = kv->value.immediate;
                         if (force_inquiry_hack)
                                 SBP2_INFO("sbp2_firmware_revision = %x",
-                                   (unsigned int) firmware_revision);
-                        else    SBP2_DEBUG("sbp2_firmware_revision = %x",
-                                   (unsigned int) firmware_revision);
+                                          (unsigned int)firmware_revision);
+                        else
+                                SBP2_DEBUG("sbp2_firmware_revision = %x",
+                                           (unsigned int)firmware_revision);
                         break;
 
                 default:
@@ -1646,7 +1625,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
                 scsi_id->sbp2_firmware_revision = firmware_revision;
                 scsi_id->workarounds = workarounds;
                 if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
-                        scsi_id->sbp2_device_type_and_lun = ud->lun;
+                        scsi_id->sbp2_lun = ORB_SET_LUN(ud->lun);
         }
 }
 
@@ -1666,8 +1645,9 @@ static int sbp2_max_speed_and_size(struct scsi_id_instance_data *scsi_id)
         SBP2_DEBUG("sbp2_max_speed_and_size");
 
         /* Initial setting comes from the hosts speed map */
-        scsi_id->speed_code = hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64
-                                                  + NODEID_TO_NODE(scsi_id->ne->nodeid)];
+        scsi_id->speed_code =
+            hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64 +
+                                NODEID_TO_NODE(scsi_id->ne->nodeid)];
 
         /* Bump down our speed if the user requested it */
         if (scsi_id->speed_code > max_speed) {
@@ -1678,15 +1658,16 @@ static int sbp2_max_speed_and_size(struct scsi_id_instance_data *scsi_id)
 
         /* Payload size is the lesser of what our speed supports and what
          * our host supports.  */
-        scsi_id->max_payload_size = min(sbp2_speedto_max_payload[scsi_id->speed_code],
-                                        (u8)(hi->host->csr.max_rec - 1));
+        scsi_id->max_payload_size =
+            min(sbp2_speedto_max_payload[scsi_id->speed_code],
+                (u8) (hi->host->csr.max_rec - 1));
 
         HPSB_DEBUG("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
                    NODE_BUS_ARGS(hi->host, scsi_id->ne->nodeid),
                    hpsb_speedto_str[scsi_id->speed_code],
-                   1 << ((u32)scsi_id->max_payload_size + 2));
+                   1 << ((u32) scsi_id->max_payload_size + 2));
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -1721,7 +1702,7 @@ static int sbp2_agent_reset(struct scsi_id_instance_data *scsi_id, int wait)
          */
         scsi_id->last_orb = NULL;
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -1735,10 +1716,9 @@ static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id,
                                    unsigned int scsi_request_bufflen,
                                    void *scsi_request_buffer,
                                    enum dma_data_direction dma_dir)
-
 {
         struct sbp2scsi_host_info *hi = scsi_id->hi;
-        struct scatterlist *sgpnt = (struct scatterlist *) scsi_request_buffer;
+        struct scatterlist *sgpnt = (struct scatterlist *)scsi_request_buffer;
         struct sbp2_command_orb *command_orb = &command->command_orb;
         struct sbp2_unrestricted_page_table *scatter_gather_element =
                 &command->scatter_gather_element[0];
@@ -1758,30 +1738,30 @@ static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id,
         command_orb->next_ORB_lo = 0x0;
         command_orb->misc = ORB_SET_MAX_PAYLOAD(scsi_id->max_payload_size);
         command_orb->misc |= ORB_SET_SPEED(scsi_id->speed_code);
-        command_orb->misc |= ORB_SET_NOTIFY(1);         /* Notify us when complete */
+        command_orb->misc |= ORB_SET_NOTIFY(1); /* Notify us when complete */
 
         /*
          * Get the direction of the transfer. If the direction is unknown, then use our
          * goofy table as a back-up.
          */
         switch (dma_dir) {
-                case DMA_NONE:
-                        orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
-                        break;
-                case DMA_TO_DEVICE:
-                        orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
-                        break;
-                case DMA_FROM_DEVICE:
-                        orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
-                        break;
-                case DMA_BIDIRECTIONAL:
-                default:
-                        SBP2_ERR("SCSI data transfer direction not specified. "
-                                 "Update the SBP2 direction table in sbp2.h if "
-                                 "necessary for your application");
-                        __scsi_print_command(scsi_cmd);
-                        orb_direction = sbp2scsi_direction_table[*scsi_cmd];
-                        break;
+        case DMA_NONE:
+                orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
+                break;
+        case DMA_TO_DEVICE:
+                orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
+                break;
+        case DMA_FROM_DEVICE:
+                orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
+                break;
+        case DMA_BIDIRECTIONAL:
+        default:
+                SBP2_ERR("SCSI data transfer direction not specified. "
+                         "Update the SBP2 direction table in sbp2.h if "
+                         "necessary for your application");
+                __scsi_print_command(scsi_cmd);
+                orb_direction = sbp2scsi_direction_table[*scsi_cmd];
+                break;
         }
 
         /*
@@ -1884,9 +1864,9 @@ static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id,
                 command->dma_dir = dma_dir;
                 command->dma_size = scsi_request_bufflen;
                 command->dma_type = CMD_DMA_SINGLE;
-                command->cmd_dma = pci_map_single (hi->host->pdev, scsi_request_buffer,
-                                                   command->dma_size,
-                                                   command->dma_dir);
+                command->cmd_dma =
+                    pci_map_single(hi->host->pdev, scsi_request_buffer,
+                                   command->dma_size, command->dma_dir);
                 SBP2_DMA_ALLOC("single bulk");
 
                 /*
@@ -1973,7 +1953,7 @@ static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id,
         memset(command_orb->cdb, 0, 12);
         memcpy(command_orb->cdb, scsi_cmd, COMMAND_SIZE(*scsi_cmd));
 
-        return(0);
+        return 0;
 }
 
 /*
@@ -1989,7 +1969,7 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id,
 
         outstanding_orb_incr;
         SBP2_ORB_DEBUG("sending command orb %p, total orbs = %x",
-                        command_orb, global_outstanding_command_orbs);
+                       command_orb, global_outstanding_command_orbs);
 
         pci_dma_sync_single_for_device(hi->host->pdev, command->command_orb_dma,
                                        sizeof(struct sbp2_command_orb),
@@ -2034,10 +2014,11 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id,
                  * both by the sbp2 device and us.
                  */
                 scsi_id->last_orb->next_ORB_lo =
-                        cpu_to_be32(command->command_orb_dma);
+                    cpu_to_be32(command->command_orb_dma);
                 /* Tells hardware that this pointer is valid */
                 scsi_id->last_orb->next_ORB_hi = 0x0;
-                pci_dma_sync_single_for_device(hi->host->pdev, scsi_id->last_orb_dma,
+                pci_dma_sync_single_for_device(hi->host->pdev,
+                                               scsi_id->last_orb_dma,
                                                sizeof(struct sbp2_command_orb),
                                                PCI_DMA_BIDIRECTIONAL);
 
@@ -2051,14 +2032,14 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id,
 
                 if (sbp2util_node_write_no_wait(ne, addr, &data, 4) < 0) {
                         SBP2_ERR("sbp2util_node_write_no_wait failed");
-                        return(-EIO);
+                        return -EIO;
                 }
 
                 scsi_id->last_orb = command_orb;
                 scsi_id->last_orb_dma = command->command_orb_dma;
 
         }
-        return(0);
+        return 0;
 }
 
 /*
@@ -2085,7 +2066,7 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
          */
         command = sbp2util_allocate_command_orb(scsi_id, SCpnt, done);
         if (!command) {
-                return(-EIO);
+                return -EIO;
         }
 
         /*
@@ -2106,11 +2087,6 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
         sbp2_create_command_orb(scsi_id, command, cmd, SCpnt->use_sg,
                                 request_bufflen, SCpnt->request_buffer,
                                 SCpnt->sc_data_direction);
-        /*
-         * Update our cdb if necessary (to handle sbp2 RBC command set
-         * differences). This is where the command set hacks go!   =)
-         */
-        sbp2_check_sbp2_command(scsi_id, command->command_orb.cdb);
 
         sbp2util_packet_dump(&command->command_orb, sizeof(struct sbp2_command_orb),
                              "sbp2 command orb", command->command_orb_dma);
@@ -2125,112 +2101,7 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
          */
         sbp2_link_orb_command(scsi_id, command);
 
-        return(0);
-}
-
-
-/*
- * This function deals with command set differences between Linux scsi
- * command set and sbp2 RBC command set.
- */
-static void sbp2_check_sbp2_command(struct scsi_id_instance_data *scsi_id, unchar *cmd)
-{
-        unchar new_cmd[16];
-        u8 device_type = SBP2_DEVICE_TYPE (scsi_id->sbp2_device_type_and_lun);
-
-        SBP2_DEBUG("sbp2_check_sbp2_command");
-
-        switch (*cmd) {
-
-                case READ_6:
-
-                        if (sbp2_command_conversion_device_type(device_type)) {
-
-                                SBP2_DEBUG("Convert READ_6 to READ_10");
-
-                                /*
-                                 * Need to turn read_6 into read_10
-                                 */
-                                new_cmd[0] = 0x28;
-                                new_cmd[1] = (cmd[1] & 0xe0);
-                                new_cmd[2] = 0x0;
-                                new_cmd[3] = (cmd[1] & 0x1f);
-                                new_cmd[4] = cmd[2];
-                                new_cmd[5] = cmd[3];
-                                new_cmd[6] = 0x0;
-                                new_cmd[7] = 0x0;
-                                new_cmd[8] = cmd[4];
-                                new_cmd[9] = cmd[5];
-
-                                memcpy(cmd, new_cmd, 10);
-
-                        }
-
-                        break;
-
-                case WRITE_6:
-
-                        if (sbp2_command_conversion_device_type(device_type)) {
-
-                                SBP2_DEBUG("Convert WRITE_6 to WRITE_10");
-
-                                /*
-                                 * Need to turn write_6 into write_10
-                                 */
-                                new_cmd[0] = 0x2a;
-                                new_cmd[1] = (cmd[1] & 0xe0);
-                                new_cmd[2] = 0x0;
-                                new_cmd[3] = (cmd[1] & 0x1f);
-                                new_cmd[4] = cmd[2];
-                                new_cmd[5] = cmd[3];
-                                new_cmd[6] = 0x0;
-                                new_cmd[7] = 0x0;
-                                new_cmd[8] = cmd[4];
-                                new_cmd[9] = cmd[5];
-
-                                memcpy(cmd, new_cmd, 10);
-
-                        }
-
-                        break;
-
-                case MODE_SENSE:
-
-                        if (sbp2_command_conversion_device_type(device_type)) {
-
-                                SBP2_DEBUG("Convert MODE_SENSE_6 to MODE_SENSE_10");
-
-                                /*
-                                 * Need to turn mode_sense_6 into mode_sense_10
-                                 */
-                                new_cmd[0] = 0x5a;
-                                new_cmd[1] = cmd[1];
-                                new_cmd[2] = cmd[2];
-                                new_cmd[3] = 0x0;
-                                new_cmd[4] = 0x0;
-                                new_cmd[5] = 0x0;
-                                new_cmd[6] = 0x0;
-                                new_cmd[7] = 0x0;
-                                new_cmd[8] = cmd[4];
-                                new_cmd[9] = cmd[5];
-
-                                memcpy(cmd, new_cmd, 10);
-
-                        }
-
-                        break;
-
-                case MODE_SELECT:
-
-                        /*
-                         * TODO. Probably need to change mode select to 10 byte version
-                         */
-
-                default:
-                        break;
-        }
-
-        return;
+        return 0;
 }
 
 /*
@@ -2260,80 +2131,40 @@ static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status, unchar *sense
         sense_data[14] = sbp2_status[20];
         sense_data[15] = sbp2_status[21];
 
-        return(sbp2_status[8] & 0x3f);  /* return scsi status */
+        return sbp2_status[8] & 0x3f;   /* return scsi status */
 }
 
 /*
  * This function is called after a command is completed, in order to do any necessary SBP-2
  * response data translations for the SCSI stack
  */
-static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id, 
+static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id,
                                      struct scsi_cmnd *SCpnt)
 {
         u8 *scsi_buf = SCpnt->request_buffer;
-        u8 device_type = SBP2_DEVICE_TYPE (scsi_id->sbp2_device_type_and_lun);
 
         SBP2_DEBUG("sbp2_check_sbp2_response");
 
         switch (SCpnt->cmnd[0]) {
 
-                case INQUIRY:
-
-                        /*
-                         * If scsi_id->sbp2_device_type_and_lun is uninitialized, then fill 
-                         * this information in from the inquiry response data. Lun is set to zero.
-                         */
-                        if (scsi_id->sbp2_device_type_and_lun == SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) {
-                                SBP2_DEBUG("Creating sbp2_device_type_and_lun from scsi inquiry data");
-                                scsi_id->sbp2_device_type_and_lun = (scsi_buf[0] & 0x1f) << 16;
-                        }
-
-                        /*
-                         * Make sure data length is ok. Minimum length is 36 bytes
-                         */
-                        if (scsi_buf[4] == 0) {
-                                scsi_buf[4] = 36 - 5;
-                        }
-
-                        /*
-                         * Check for Simple Direct Access Device and change it to TYPE_DISK
-                         */
-                        if ((scsi_buf[0] & 0x1f) == TYPE_RBC) {
-                                SBP2_DEBUG("Changing TYPE_RBC to TYPE_DISK");
-                                scsi_buf[0] &= 0xe0;
-                        }
-
-                        /*
-                         * Fix ansi revision and response data format
-                         */
-                        scsi_buf[2] |= 2;
-                        scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2;
-
-                        break;
-
-                case MODE_SENSE:
-
-                        if (sbp2_command_conversion_device_type(device_type)) {
-
-                                SBP2_DEBUG("Modify mode sense response (10 byte version)");
-
-                                scsi_buf[0] = scsi_buf[1];      /* Mode data length */
-                                scsi_buf[1] = scsi_buf[2];      /* Medium type */
-                                scsi_buf[2] = scsi_buf[3];      /* Device specific parameter */
-                                scsi_buf[3] = scsi_buf[7];      /* Block descriptor length */
-                                memcpy(scsi_buf + 4, scsi_buf + 8, scsi_buf[0]);
-                        }
+        case INQUIRY:
+                /*
+                 * Make sure data length is ok. Minimum length is 36 bytes
+                 */
+                if (scsi_buf[4] == 0) {
+                        scsi_buf[4] = 36 - 5;
+                }
 
-                        break;
+                /*
+                 * Fix ansi revision and response data format
+                 */
+                scsi_buf[2] |= 2;
+                scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2;
 
-                case MODE_SELECT:
+                break;
 
-                        /*
-                         * TODO. Probably need to change mode select to 10 byte version
-                         */
-
-                default:
-                        break;
+        default:
+                break;
         }
         return;
 }
@@ -2350,6 +2181,7 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
         struct scsi_cmnd *SCpnt = NULL;
         u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
         struct sbp2_command_info *command;
+        unsigned long flags;
 
         SBP2_DEBUG("sbp2_handle_status_write");
 
@@ -2357,14 +2189,14 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
 
         if (!host) {
                 SBP2_ERR("host is NULL - this is bad!");
-                return(RCODE_ADDRESS_ERROR);
+                return RCODE_ADDRESS_ERROR;
         }
 
         hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
 
         if (!hi) {
                 SBP2_ERR("host info is NULL - this is bad!");
-                return(RCODE_ADDRESS_ERROR);
+                return RCODE_ADDRESS_ERROR;
         }
 
         /*
@@ -2381,7 +2213,7 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
 
         if (!scsi_id) {
                 SBP2_ERR("scsi_id is NULL - device is gone?");
-                return(RCODE_ADDRESS_ERROR);
+                return RCODE_ADDRESS_ERROR;
         }
 
         /*
@@ -2451,9 +2283,11 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
                  * null out last orb so that next time around we write directly to the orb pointer...
                  * Quick start saves one 1394 bus transaction.
                  */
+                spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
                 if (list_empty(&scsi_id->sbp2_command_orb_inuse)) {
                         scsi_id->last_orb = NULL;
                 }
+                spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 
         } else {
 
@@ -2477,10 +2311,9 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest
                 SBP2_ORB_DEBUG("command orb completed");
         }
 
-        return(RCODE_COMPLETE);
+        return RCODE_COMPLETE;
 }
 
-
 /**************************************
  * SCSI interface related section
  **************************************/
@@ -2563,9 +2396,11 @@ static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id
         struct sbp2scsi_host_info *hi = scsi_id->hi;
         struct list_head *lh;
         struct sbp2_command_info *command;
+        unsigned long flags;
 
         SBP2_DEBUG("sbp2scsi_complete_all_commands");
 
+        spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
         while (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
                 SBP2_DEBUG("Found pending command to complete");
                 lh = scsi_id->sbp2_command_orb_inuse.next;
@@ -2582,6 +2417,7 @@ static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id
                         command->Current_done(command->Current_SCpnt);
                 }
         }
+        spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 
         return;
 }
@@ -2610,55 +2446,56 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
          * complete the command, just let it get retried at the end of the
          * bus reset.
          */
-        if (!hpsb_node_entry_valid(scsi_id->ne) && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
+        if (!hpsb_node_entry_valid(scsi_id->ne)
+            && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
                 SBP2_ERR("Bus reset in progress - retry command later");
                 return;
         }
- 
+
         /*
          * Switch on scsi status
          */
         switch (scsi_status) {
-                case SBP2_SCSI_STATUS_GOOD:
-                        SCpnt->result = DID_OK;
-                        break;
+        case SBP2_SCSI_STATUS_GOOD:
+                SCpnt->result = DID_OK;
+                break;
 
-                case SBP2_SCSI_STATUS_BUSY:
-                        SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
-                        SCpnt->result = DID_BUS_BUSY << 16;
-                        break;
+        case SBP2_SCSI_STATUS_BUSY:
+                SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
+                SCpnt->result = DID_BUS_BUSY << 16;
+                break;
 
-                case SBP2_SCSI_STATUS_CHECK_CONDITION:
-                        SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION");
-                        SCpnt->result = CHECK_CONDITION << 1;
+        case SBP2_SCSI_STATUS_CHECK_CONDITION:
+                SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION");
+                SCpnt->result = CHECK_CONDITION << 1;
 
-                        /*
-                         * Debug stuff
-                         */
+                /*
+                 * Debug stuff
+                 */
 #if CONFIG_IEEE1394_SBP2_DEBUG >= 1
-                        scsi_print_command(SCpnt);
-                        scsi_print_sense("bh", SCpnt);
+                scsi_print_command(SCpnt);
+                scsi_print_sense("bh", SCpnt);
 #endif
 
-                        break;
+                break;
 
-                case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
-                        SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
-                        SCpnt->result = DID_NO_CONNECT << 16;
-                        scsi_print_command(SCpnt);
-                        break;
+        case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
+                SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
+                SCpnt->result = DID_NO_CONNECT << 16;
+                scsi_print_command(SCpnt);
+                break;
 
-                case SBP2_SCSI_STATUS_CONDITION_MET:
-                case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
-                case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
-                        SBP2_ERR("Bad SCSI status = %x", scsi_status);
-                        SCpnt->result = DID_ERROR << 16;
-                        scsi_print_command(SCpnt);
-                        break;
+        case SBP2_SCSI_STATUS_CONDITION_MET:
+        case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
+        case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
+                SBP2_ERR("Bad SCSI status = %x", scsi_status);
+                SCpnt->result = DID_ERROR << 16;
+                scsi_print_command(SCpnt);
+                break;
 
-                default:
-                        SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
-                        SCpnt->result = DID_ERROR << 16;
+        default:
+                SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
+                SCpnt->result = DID_ERROR << 16;
         }
 
         /*
@@ -2672,7 +2509,8 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
          * If a bus reset is in progress and there was an error, complete
          * the command as busy so that it will get retried.
          */
-        if (!hpsb_node_entry_valid(scsi_id->ne) && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
+        if (!hpsb_node_entry_valid(scsi_id->ne)
+            && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
                 SBP2_ERR("Completing command with busy (bus reset)");
                 SCpnt->result = DID_BUS_BUSY << 16;
         }
@@ -2693,31 +2531,29 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
         /*
          * Tell scsi stack that we're done with this command
          */
-        done (SCpnt);
+        done(SCpnt);
 }
 
-
 static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
 {
         ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = sdev;
         return 0;
 }
 
-
 static int sbp2scsi_slave_configure(struct scsi_device *sdev)
 {
         blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
+        sdev->use_10_for_rw = 1;
+        sdev->use_10_for_ms = 1;
         return 0;
 }
 
-
 static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
 {
         ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = NULL;
         return;
 }
 
-
 /*
  * Called by scsi stack when something has really gone wrong.  Usually
  * called when a command has timed-out for some reason.
@@ -2763,7 +2599,7 @@ static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
                 sbp2scsi_complete_all_commands(scsi_id, DID_BUS_BUSY);
         }
 
-        return(SUCCESS);
+        return SUCCESS;
 }
 
 /*
@@ -2789,12 +2625,14 @@ static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
         return SUCCESS;
 }
 
-static const char *sbp2scsi_info (struct Scsi_Host *host)
+static const char *sbp2scsi_info(struct Scsi_Host *host)
 {
-        return "SCSI emulation for IEEE-1394 SBP-2 Devices";
+        return "SCSI emulation for IEEE-1394 SBP-2 Devices";
 }
 
-static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
 {
         struct scsi_device *sdev;
         struct scsi_id_instance_data *scsi_id;
@@ -2806,10 +2644,7 @@ static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_att
         if (!(scsi_id = (struct scsi_id_instance_data *)sdev->host->hostdata[0]))
                 return 0;
 
-        if (scsi_id->sbp2_device_type_and_lun == SBP2_DEVICE_TYPE_LUN_UNINITIALIZED)
-                lun = 0;
-        else
-                lun = ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun);
+        lun = ORB_SET_LUN(scsi_id->sbp2_lun);
 
         return sprintf(buf, "%016Lx:%d:%d\n", (unsigned long long)scsi_id->ne->guid,
                        scsi_id->ud->id, lun);
@@ -2855,8 +2690,6 @@ static int sbp2_module_init(void)
 
         SBP2_DEBUG("sbp2_module_init");
 
-        printk(KERN_INFO "sbp2: %s\n", version);
-
         /* Module load debug option to force one command at a time (serializing I/O) */
         if (serialize_io) {
                 SBP2_INFO("Driver forced to serialize I/O (serialize_io=1)");
@@ -2868,7 +2701,6 @@ static int sbp2_module_init(void)
         /* Set max sectors (module load option). Default is 255 sectors. */
         scsi_driver_template.max_sectors = max_sectors;
 
-
         /* Register our high level driver with 1394 stack */
         hpsb_register_highlevel(&sbp2_highlevel);
 
diff --git a/drivers/ieee1394/sbp2.h b/drivers/ieee1394/sbp2.h
index cd425be74841..abc647bae5b1 100644
--- a/drivers/ieee1394/sbp2.h
+++ b/drivers/ieee1394/sbp2.h
@@ -119,8 +119,8 @@ struct sbp2_query_logins_response {
 struct sbp2_reconnect_orb {
         u32 reserved1;
         u32 reserved2;
-        u32 reserved3;
-        u32 reserved4;
+        u32 reserved3;
+        u32 reserved4;
         u32 login_ID_misc;
         u32 reserved5;
         u32 status_FIFO_hi;
@@ -130,8 +130,8 @@ struct sbp2_reconnect_orb {
 struct sbp2_logout_orb {
         u32 reserved1;
         u32 reserved2;
-        u32 reserved3;
-        u32 reserved4;
+        u32 reserved3;
+        u32 reserved4;
         u32 login_ID_misc;
         u32 reserved5;
         u32 status_FIFO_hi;
@@ -188,7 +188,7 @@ struct sbp2_unrestricted_page_table {
 struct sbp2_status_block {
         u32 ORB_offset_hi_misc;
         u32 ORB_offset_lo;
-        u8 command_set_dependent[24];
+        u8 command_set_dependent[24];
 };
 
 /*
@@ -211,7 +211,7 @@ struct sbp2_status_block {
  * specified for write posting, where the ohci controller will
  * automatically send an ack_complete when the status is written by the
  * sbp2 device... saving a split transaction.   =)
- */ 
+ */
 #define SBP2_STATUS_FIFO_ADDRESS                                0xfffe00000000ULL
 #define SBP2_STATUS_FIFO_ADDRESS_HI                             0xfffe
 #define SBP2_STATUS_FIFO_ADDRESS_LO                             0x0
@@ -229,9 +229,6 @@ struct sbp2_status_block {
 #define SBP2_DEVICE_TYPE_AND_LUN_KEY                            0x14
 #define SBP2_FIRMWARE_REVISION_KEY                              0x3c
 
-#define SBP2_DEVICE_TYPE(q)                                     (((q) >> 16) & 0x1f)
-#define SBP2_DEVICE_LUN(q)                                      ((q) & 0xffff)
-
 #define SBP2_AGENT_STATE_OFFSET                                 0x00ULL
 #define SBP2_AGENT_RESET_OFFSET                                 0x04ULL
 #define SBP2_ORB_POINTER_OFFSET                                 0x08ULL
@@ -256,8 +253,6 @@ struct sbp2_status_block {
  */
 #define SBP2_128KB_BROKEN_FIRMWARE                              0xa0b800
 
-#define SBP2_DEVICE_TYPE_LUN_UNINITIALIZED                      0xffffffff
-
 /*
  * SCSI specific stuff
  */
@@ -338,10 +333,8 @@ struct sbp2_command_info {
 #define SBP2_BREAKAGE_128K_MAX_TRANSFER         0x1
 #define SBP2_BREAKAGE_INQUIRY_HACK              0x2
 
-
 struct sbp2scsi_host_info;
 
-
 /*
  * Information needed on a per scsi id basis (one for each sbp2 device)
  */
@@ -379,7 +372,7 @@ struct scsi_id_instance_data {
         u32 sbp2_command_set_spec_id;
         u32 sbp2_command_set;
         u32 sbp2_unit_characteristics;
-        u32 sbp2_device_type_and_lun;
+        u32 sbp2_lun;
         u32 sbp2_firmware_revision;
 
         /*
@@ -411,7 +404,6 @@ struct scsi_id_instance_data {
         u32 workarounds;
 };
 
-
 /* Sbp2 host data structure (one per IEEE1394 host) */
 struct sbp2scsi_host_info {
         struct hpsb_host *host;         /* IEEE1394 host */
@@ -469,7 +461,6 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
                              struct scsi_cmnd *SCpnt,
                              void (*done)(struct scsi_cmnd *));
 static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status, unchar *sense_data);
-static void sbp2_check_sbp2_command(struct scsi_id_instance_data *scsi_id, unchar *cmd);
 static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id,
                                      struct scsi_cmnd *SCpnt);
 static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
diff --git a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c
index 23911da50154..07050f0e4098 100644
--- a/drivers/ieee1394/video1394.c
+++ b/drivers/ieee1394/video1394.c
@@ -77,14 +77,6 @@
 
 #define ISO_CHANNELS 64
 
-#ifndef virt_to_page
-#define virt_to_page(x) MAP_NR(x)
-#endif
-
-#ifndef vmalloc_32
-#define vmalloc_32(x) vmalloc(x)
-#endif
-
 struct it_dma_prg {
         struct dma_cmd begin;
         quadlet_t data[4];
@@ -206,14 +198,12 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc,
         struct dma_iso_ctx *d;
         int i;
 
-        d = kmalloc(sizeof(struct dma_iso_ctx), GFP_KERNEL);
-        if (d == NULL) {
+        d = kzalloc(sizeof(*d), GFP_KERNEL);
+        if (!d) {
                 PRINT(KERN_ERR, ohci->host->id, "Failed to allocate dma_iso_ctx");
                 return NULL;
         }
 
-        memset(d, 0, sizeof *d);
-
         d->ohci = ohci;
         d->type = type;
         d->channel = channel;
@@ -251,9 +241,8 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc,
         }
         d->ctx = d->iso_tasklet.context;
 
-        d->prg_reg = kmalloc(d->num_desc * sizeof(struct dma_prog_region),
-                        GFP_KERNEL);
-        if (d->prg_reg == NULL) {
+        d->prg_reg = kmalloc(d->num_desc * sizeof(*d->prg_reg), GFP_KERNEL);
+        if (!d->prg_reg) {
                 PRINT(KERN_ERR, ohci->host->id, "Failed to allocate ir prg regs");
                 free_dma_iso_ctx(d);
                 return NULL;
@@ -268,15 +257,14 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc,
                 d->cmdPtr = OHCI1394_IsoRcvCommandPtr+32*d->ctx;
                 d->ctxMatch = OHCI1394_IsoRcvContextMatch+32*d->ctx;
 
-                d->ir_prg = kmalloc(d->num_desc * sizeof(struct dma_cmd *),
+                d->ir_prg = kzalloc(d->num_desc * sizeof(*d->ir_prg),
                                     GFP_KERNEL);
 
-                if (d->ir_prg == NULL) {
+                if (!d->ir_prg) {
                         PRINT(KERN_ERR, ohci->host->id, "Failed to allocate dma ir prg");
                         free_dma_iso_ctx(d);
                         return NULL;
                 }
-                memset(d->ir_prg, 0, d->num_desc * sizeof(struct dma_cmd *));
 
                 d->nb_cmd = d->buf_size / PAGE_SIZE + 1;
                 d->left_size = (d->frame_size % PAGE_SIZE) ?
@@ -297,16 +285,15 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc,
                 d->ctrlClear = OHCI1394_IsoXmitContextControlClear+16*d->ctx;
                 d->cmdPtr = OHCI1394_IsoXmitCommandPtr+16*d->ctx;
 
-                d->it_prg = kmalloc(d->num_desc * sizeof(struct it_dma_prg *),
+                d->it_prg = kzalloc(d->num_desc * sizeof(*d->it_prg),
                                     GFP_KERNEL);
 
-                if (d->it_prg == NULL) {
+                if (!d->it_prg) {
                         PRINT(KERN_ERR, ohci->host->id,
                               "Failed to allocate dma it prg");
                         free_dma_iso_ctx(d);
                         return NULL;
                 }
-                memset(d->it_prg, 0, d->num_desc*sizeof(struct it_dma_prg *));
 
                 d->packet_size = packet_size;
 
@@ -337,47 +324,24 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc,
                 }
         }
 
-        d->buffer_status = kmalloc(d->num_desc * sizeof(unsigned int),
-                                   GFP_KERNEL);
-        d->buffer_prg_assignment = kmalloc(d->num_desc * sizeof(unsigned int),
-                                   GFP_KERNEL);
-        d->buffer_time = kmalloc(d->num_desc * sizeof(struct timeval),
-                                   GFP_KERNEL);
-        d->last_used_cmd = kmalloc(d->num_desc * sizeof(unsigned int),
-                                   GFP_KERNEL);
-        d->next_buffer = kmalloc(d->num_desc * sizeof(int),
-                                 GFP_KERNEL);
-
-        if (d->buffer_status == NULL) {
-                PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_status");
-                free_dma_iso_ctx(d);
-                return NULL;
-        }
-        if (d->buffer_prg_assignment == NULL) {
-                PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_prg_assignment");
-                free_dma_iso_ctx(d);
-                return NULL;
-        }
-        if (d->buffer_time == NULL) {
-                PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_time");
-                free_dma_iso_ctx(d);
-                return NULL;
-        }
-        if (d->last_used_cmd == NULL) {
-                PRINT(KERN_ERR, ohci->host->id, "Failed to allocate last_used_cmd");
-                free_dma_iso_ctx(d);
-                return NULL;
-        }
-        if (d->next_buffer == NULL) {
-                PRINT(KERN_ERR, ohci->host->id, "Failed to allocate next_buffer");
+        d->buffer_status =
+            kzalloc(d->num_desc * sizeof(*d->buffer_status), GFP_KERNEL);
+        d->buffer_prg_assignment =
+            kzalloc(d->num_desc * sizeof(*d->buffer_prg_assignment), GFP_KERNEL);
+        d->buffer_time =
+            kzalloc(d->num_desc * sizeof(*d->buffer_time), GFP_KERNEL);
+        d->last_used_cmd =
+            kzalloc(d->num_desc * sizeof(*d->last_used_cmd), GFP_KERNEL);
+        d->next_buffer =
+            kzalloc(d->num_desc * sizeof(*d->next_buffer), GFP_KERNEL);
+
+        if (!d->buffer_status || !d->buffer_prg_assignment || !d->buffer_time ||
+            !d->last_used_cmd || !d->next_buffer) {
+                PRINT(KERN_ERR, ohci->host->id,
+                      "Failed to allocate dma_iso_ctx member");
                 free_dma_iso_ctx(d);
                 return NULL;
         }
-        memset(d->buffer_status, 0, d->num_desc * sizeof(unsigned int));
-        memset(d->buffer_prg_assignment, 0, d->num_desc * sizeof(unsigned int));
-        memset(d->buffer_time, 0, d->num_desc * sizeof(struct timeval));
-        memset(d->last_used_cmd, 0, d->num_desc * sizeof(unsigned int));
-        memset(d->next_buffer, -1, d->num_desc * sizeof(int));
 
         spin_lock_init(&d->lock);
 
@@ -1085,7 +1049,7 @@ static int __video1394_ioctl(struct file *file,
                 }
 
                 if (d->flags & VIDEO1394_VARIABLE_PACKET_SIZE) {
-                        int buf_size = d->nb_cmd * sizeof(unsigned int);
+                        int buf_size = d->nb_cmd * sizeof(*psizes);
                         struct video1394_queue_variable __user *p = argp;
                         unsigned int __user *qv;
 
@@ -1251,13 +1215,12 @@ static int video1394_open(struct inode *inode, struct file *file)
         if (ohci == NULL)
                 return -EIO;
 
-        ctx = kmalloc(sizeof(struct file_ctx), GFP_KERNEL);
-        if (ctx == NULL)  {
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+        if (!ctx)  {
                 PRINT(KERN_ERR, ohci->host->id, "Cannot malloc file_ctx");
                 return -ENOMEM;
         }
 
-        memset(ctx, 0, sizeof(struct file_ctx));
         ctx->ohci = ohci;
         INIT_LIST_HEAD(&ctx->context_list);
         ctx->current_ctx = NULL;