Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 5030c807907ae90ad21e9220c1a9d592558deba2

Authored by Stefan Richter 2010-06-15 08:00:11 +0800

Exists in master and in 7 other branches

ieee1394: remove unused variables

which caused gcc 4.6 to warn about
    variable 'XYZ' set but not used.

sbp2.c, unit_characteristics:

The underlying problem which was spotted here --- an incomplete
implementation --- is already 50% fixed in drivers/firewire/sbp2.c which
observes mgt_ORB_timeout but not yet ORB_size.

raw1394.c, length_conflict; dv1394.c, ts_off:

Impossible to tell why these variables are there.  We can safely remove
them though because we don't need a compiler warning to realize that we
are dealing with (at least stylistically) flawed code here.

dv1394.c, packet_time:

This was used in debug macro that is only compiled in with
DV1394_DEBUG_LEVEL >= 2 defined at compile-time.  Just drop it since
nobody debugs dv1394 anymore.  Avoids noise in regular kernel builds.

dv1394.c, ohci; eth1394.c, priv:

These variables clearly can go away.  Somebody wanted to use them but
then didn't (or not anymore).

Note, all of this code is considered to be at its end of life and is
thus not really meant to receive janitorial updates anymore.  But if we
can easily remove noisy warnings from kernel builds, we should.

Reported-by: Justin P. Mattock <justinmattock@gmail.com>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>

Showing 4 changed files with 7 additions and 24 deletions Inline Diff

drivers/ieee1394/dv1394.c
drivers/ieee1394/eth1394.c
drivers/ieee1394/raw1394.c
drivers/ieee1394/sbp2.c

drivers/ieee1394/dv1394.c

Diff comments View file @ 5030c80

 /*
  * dv1394.c - DV input/output over IEEE 1394 on OHCI chips
  *   Copyright (C)2001 Daniel Maas <dmaas@dcine.com>
  *     receive by Dan Dennedy <dan@dennedy.org>
  *
  * based on:
  *  video1394.c - video driver for OHCI 1394 boards
  *  Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 /*
   OVERVIEW
   I designed dv1394 as a "pipe" that you can use to shoot DV onto a
   FireWire bus. In transmission mode, dv1394 does the following:
    1. accepts contiguous frames of DV data from user-space, via write()
       or mmap() (see dv1394.h for the complete API)
    2. wraps IEC 61883 packets around the DV data, inserting
       empty synchronization packets as necessary
    3. assigns accurate SYT timestamps to the outgoing packets
    4. shoots them out using the OHCI card's IT DMA engine
    Thanks to Dan Dennedy, we now have a receive mode that does the following:
    1. accepts raw IEC 61883 packets from the OHCI card
    2. re-assembles the DV data payloads into contiguous frames,
       discarding empty packets
    3. sends the DV data to user-space via read() or mmap()
 */
 /*
   TODO:
   - tunable frame-drop behavior: either loop last frame, or halt transmission
   - use a scatter/gather buffer for DMA programs (f->descriptor_pool)
     so that we don't rely on allocating 64KB of contiguous kernel memory
     via pci_alloc_consistent()
   DONE:
   - during reception, better handling of dropped frames and continuity errors
   - during reception, prevent DMA from bypassing the irq tasklets
   - reduce irq rate during reception (1/250 packets).
   - add many more internal buffers during reception with scatter/gather dma.
   - add dbc (continuity) checking on receive, increment status.dropped_frames
     if not continuous.
   - restart IT DMA after a bus reset
   - safely obtain and release ISO Tx channels in cooperation with OHCI driver
   - map received DIF blocks to their proper location in DV frame (ensure
     recovery if dropped packet)
   - handle bus resets gracefully (OHCI card seems to take care of this itself(!))
   - do not allow resizing the user_buf once allocated; eliminate nuke_buffer_mappings
   - eliminated #ifdef DV1394_DEBUG_LEVEL by inventing macros debug_printk and irq_printk
   - added wmb() and mb() to places where PCI read/write ordering needs to be enforced
   - set video->id correctly
   - store video_cards in an array indexed by OHCI card ID, rather than a list
   - implement DMA context allocation to cooperate with other users of the OHCI
   - fix all XXX showstoppers
   - disable IR/IT DMA interrupts on shutdown
   - flush pci writes to the card by issuing a read
   - character device dispatching
   - switch over to the new kernel DMA API (pci_map_*()) (* needs testing on platforms with IOMMU!)
   - keep all video_cards in a list (for open() via chardev), set file->private_data = video
   - dv1394_poll should indicate POLLIN when receiving buffers are available
   - add proc fs interface to set cip_n, cip_d, syt_offset, and video signal
   - expose xmit and recv as separate devices (not exclusive)
   - expose NTSC and PAL as separate devices (can be overridden)
 */
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/wait.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/mutex.h>
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 #include <asm/atomic.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <linux/delay.h>
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <linux/sched.h>
 #include <linux/types.h>
 #include <linux/vmalloc.h>
 #include <linux/string.h>
 #include <linux/compat.h>
 #include <linux/cdev.h>
 #include "dv1394.h"
 #include "dv1394-private.h"
 #include "highlevel.h"
 #include "hosts.h"
 #include "ieee1394.h"
 #include "ieee1394_core.h"
 #include "ieee1394_hotplug.h"
 #include "ieee1394_types.h"
 #include "nodemgr.h"
 #include "ohci1394.h"
 /* DEBUG LEVELS:
    0 - no debugging messages
    1 - some debugging messages, but none during DMA frame transmission
    2 - lots of messages, including during DMA frame transmission
        (will cause underflows if your machine is too slow!)
 */
 #define DV1394_DEBUG_LEVEL 0
 /* for debugging use ONLY: allow more than one open() of the device */
 /* #define DV1394_ALLOW_MORE_THAN_ONE_OPEN 1 */
 #if DV1394_DEBUG_LEVEL >= 2
 #define irq_printk( args... ) printk( args )
 #else
 #define irq_printk( args... ) do {} while (0)
 #endif
 #if DV1394_DEBUG_LEVEL >= 1
 #define debug_printk( args... ) printk( args)
 #else
 #define debug_printk( args... ) do {} while (0)
 #endif
 /* issue a dummy PCI read to force the preceding write
    to be posted to the PCI bus immediately */
 static inline void flush_pci_write(struct ti_ohci *ohci)
 {
 	mb();
 	reg_read(ohci, OHCI1394_IsochronousCycleTimer);
 }
 static void it_tasklet_func(unsigned long data);
 static void ir_tasklet_func(unsigned long data);
 #ifdef CONFIG_COMPAT
 static long dv1394_compat_ioctl(struct file *file, unsigned int cmd,
 			       unsigned long arg);
 #endif
 /* GLOBAL DATA */
 /* list of all video_cards */
 static LIST_HEAD(dv1394_cards);
 static DEFINE_SPINLOCK(dv1394_cards_lock);
 /* translate from a struct file* to the corresponding struct video_card* */
 static inline struct video_card* file_to_video_card(struct file *file)
 {
 	return (struct video_card*) file->private_data;
 }
 /*** FRAME METHODS *********************************************************/
 static void frame_reset(struct frame *f)
 {
 	f->state = FRAME_CLEAR;
 	f->done = 0;
 	f->n_packets = 0;
 	f->frame_begin_timestamp = NULL;
 	f->assigned_timestamp = 0;
 	f->cip_syt1 = NULL;
 	f->cip_syt2 = NULL;
 	f->mid_frame_timestamp = NULL;
 	f->frame_end_timestamp = NULL;
 	f->frame_end_branch = NULL;
 }
 static struct frame* frame_new(unsigned int frame_num, struct video_card *video)
 {
 	struct frame *f = kmalloc(sizeof(*f), GFP_KERNEL);
 	if (!f)
 		return NULL;
 	f->video = video;
 	f->frame_num = frame_num;
 	f->header_pool = pci_alloc_consistent(f->video->ohci->dev, PAGE_SIZE, &f->header_pool_dma);
 	if (!f->header_pool) {
 		printk(KERN_ERR "dv1394: failed to allocate CIP header pool\n");
 		kfree(f);
 		return NULL;
 	}
 	debug_printk("dv1394: frame_new: allocated CIP header pool at virt 0x%08lx (contig) dma 0x%08lx size %ld\n",
 		     (unsigned long) f->header_pool, (unsigned long) f->header_pool_dma, PAGE_SIZE);
 	f->descriptor_pool_size = MAX_PACKETS * sizeof(struct DMA_descriptor_block);
 	/* make it an even # of pages */
 	f->descriptor_pool_size += PAGE_SIZE - (f->descriptor_pool_size%PAGE_SIZE);
 	f->descriptor_pool = pci_alloc_consistent(f->video->ohci->dev,
 						  f->descriptor_pool_size,
 						  &f->descriptor_pool_dma);
 	if (!f->descriptor_pool) {
 		pci_free_consistent(f->video->ohci->dev, PAGE_SIZE, f->header_pool, f->header_pool_dma);
 		kfree(f);
 		return NULL;
 	}
 	debug_printk("dv1394: frame_new: allocated DMA program memory at virt 0x%08lx (contig) dma 0x%08lx size %ld\n",
 		     (unsigned long) f->descriptor_pool, (unsigned long) f->descriptor_pool_dma, f->descriptor_pool_size);
 	f->data = 0;
 	frame_reset(f);
 	return f;
 }
 static void frame_delete(struct frame *f)
 {
 	pci_free_consistent(f->video->ohci->dev, PAGE_SIZE, f->header_pool, f->header_pool_dma);
 	pci_free_consistent(f->video->ohci->dev, f->descriptor_pool_size, f->descriptor_pool, f->descriptor_pool_dma);
 	kfree(f);
 }
 /*
    frame_prepare() - build the DMA program for transmitting
    Frame_prepare() must be called OUTSIDE the video->spinlock.
    However, frame_prepare() must still be serialized, so
    it should be called WITH the video->mtx taken.
  */
 static void frame_prepare(struct video_card *video, unsigned int this_frame)
 {
 	struct frame *f = video->frames[this_frame];
 	int last_frame;
 	struct DMA_descriptor_block *block;
 	dma_addr_t block_dma;
 	struct CIP_header *cip;
 	dma_addr_t cip_dma;
 	unsigned int n_descriptors, full_packets, packets_per_frame, payload_size;
 	/* these flags denote packets that need special attention */
 	int empty_packet, first_packet, last_packet, mid_packet;
 	__le32 *branch_address, *last_branch_address = NULL;
 	unsigned long data_p;
 	int first_packet_empty = 0;
 	u32 cycleTimer, ct_sec, ct_cyc, ct_off;
 	unsigned long irq_flags;
 	irq_printk("frame_prepare( %d ) ---------------------\n", this_frame);
 	full_packets = 0;
 	if (video->pal_or_ntsc == DV1394_PAL)
 		packets_per_frame = DV1394_PAL_PACKETS_PER_FRAME;
 	else
 		packets_per_frame = DV1394_NTSC_PACKETS_PER_FRAME;
 	while ( full_packets < packets_per_frame ) {
 		empty_packet = first_packet = last_packet = mid_packet = 0;
 		data_p = f->data + full_packets * 480;
 		/************************************************/
 		/* allocate a descriptor block and a CIP header */
 		/************************************************/
 		/* note: these should NOT cross a page boundary (DMA restriction) */
 		if (f->n_packets >= MAX_PACKETS) {
 			printk(KERN_ERR "dv1394: FATAL ERROR: max packet count exceeded\n");
 			return;
 		}
 		/* the block surely won't cross a page boundary,
 		   since an even number of descriptor_blocks fit on a page */
 		block = &(f->descriptor_pool[f->n_packets]);
 		/* DMA address of the block = offset of block relative
 		    to the kernel base address of the descriptor pool
 		    + DMA base address of the descriptor pool */
 		block_dma = ((unsigned long) block - (unsigned long) f->descriptor_pool) + f->descriptor_pool_dma;
 		/* the whole CIP pool fits on one page, so no worries about boundaries */
 		if ( ((unsigned long) &(f->header_pool[f->n_packets]) - (unsigned long) f->header_pool)
 		    > PAGE_SIZE) {
 			printk(KERN_ERR "dv1394: FATAL ERROR: no room to allocate CIP header\n");
 			return;
 		}
 		cip = &(f->header_pool[f->n_packets]);
 		/* DMA address of the CIP header = offset of cip
 		   relative to kernel base address of the header pool
 		   + DMA base address of the header pool */
 		cip_dma = (unsigned long) cip % PAGE_SIZE + f->header_pool_dma;
 		/* is this an empty packet? */
 		if (video->cip_accum > (video->cip_d - video->cip_n)) {
 			empty_packet = 1;
 			payload_size = 8;
 			video->cip_accum -= (video->cip_d - video->cip_n);
 		} else {
 			payload_size = 488;
 			video->cip_accum += video->cip_n;
 		}
 		/* there are three important packets each frame:
 		   the first packet in the frame - we ask the card to record the timestamp when
 		                                   this packet is actually sent, so we can monitor
 						   how accurate our timestamps are. Also, the first
 						   packet serves as a semaphore to let us know that
 						   it's OK to free the *previous* frame's DMA buffer
 		   the last packet in the frame -  this packet is used to detect buffer underflows.
 		                                   if this is the last ready frame, the last DMA block
 						   will have a branch back to the beginning of the frame
 						   (so that the card will re-send the frame on underflow).
 						   if this branch gets taken, we know that at least one
 						   frame has been dropped. When the next frame is ready,
 						   the branch is pointed to its first packet, and the
 						   semaphore is disabled.
 		   a "mid" packet slightly before the end of the frame - this packet should trigger
 		                   an interrupt so we can go and assign a timestamp to the first packet
 				   in the next frame. We don't use the very last packet in the frame
 				   for this purpose, because that would leave very little time to set
 				   the timestamp before DMA starts on the next frame.
 		*/
 		if (f->n_packets == 0) {
 			first_packet = 1;
 		} else if ( full_packets == (packets_per_frame-1) ) {
 			last_packet = 1;
 		} else if (f->n_packets == packets_per_frame) {
 			mid_packet = 1;
 		}
 		/********************/
 		/* setup CIP header */
 		/********************/
 		/* the timestamp will be written later from the
 		   mid-frame interrupt handler. For now we just
 		   store the address of the CIP header(s) that
 		   need a timestamp. */
 		/* first packet in the frame needs a timestamp */
 		if (first_packet) {
 			f->cip_syt1 = cip;
 			if (empty_packet)
 				first_packet_empty = 1;
 		} else if (first_packet_empty && (f->n_packets == 1) ) {
 			/* if the first packet was empty, the second
 			   packet's CIP header also needs a timestamp */
 			f->cip_syt2 = cip;
 		}
 		fill_cip_header(cip,
 				/* the node ID number of the OHCI card */
 				reg_read(video->ohci, OHCI1394_NodeID) & 0x3F,
 				video->continuity_counter,
 				video->pal_or_ntsc,
 				0xFFFF /* the timestamp is filled in later */);
 		/* advance counter, only for full packets */
 		if ( ! empty_packet )
 			video->continuity_counter++;
 		/******************************/
 		/* setup DMA descriptor block */
 		/******************************/
 		/* first descriptor - OUTPUT_MORE_IMMEDIATE, for the controller's IT header */
 		fill_output_more_immediate( &(block->u.out.omi), 1, video->channel, 0, payload_size);
 		if (empty_packet) {
 			/* second descriptor - OUTPUT_LAST for CIP header */
 			fill_output_last( &(block->u.out.u.empty.ol),
 					  /* want completion status on all interesting packets */
 					  (first_packet || mid_packet || last_packet) ? 1 : 0,
 					  /* want interrupts on all interesting packets */
 					  (first_packet || mid_packet || last_packet) ? 1 : 0,
 					  sizeof(struct CIP_header), /* data size */
 					  cip_dma);
 			if (first_packet)
 				f->frame_begin_timestamp = &(block->u.out.u.empty.ol.q[3]);
 			else if (mid_packet)
 				f->mid_frame_timestamp = &(block->u.out.u.empty.ol.q[3]);
 			else if (last_packet) {
 				f->frame_end_timestamp = &(block->u.out.u.empty.ol.q[3]);
 				f->frame_end_branch = &(block->u.out.u.empty.ol.q[2]);
 			}
 			branch_address = &(block->u.out.u.empty.ol.q[2]);
 			n_descriptors = 3;
 			if (first_packet)
 				f->first_n_descriptors = n_descriptors;
 		} else { /* full packet */
 			/* second descriptor - OUTPUT_MORE for CIP header */
 			fill_output_more( &(block->u.out.u.full.om),
 					  sizeof(struct CIP_header), /* data size */
 					  cip_dma);
 			/* third (and possibly fourth) descriptor - for DV data */
 			/* the 480-byte payload can cross a page boundary; if so,
 			   we need to split it into two DMA descriptors */
 			/* does the 480-byte data payload cross a page boundary? */
 			if ( (PAGE_SIZE- ((unsigned long)data_p % PAGE_SIZE) ) < 480 ) {
 				/* page boundary crossed */
 				fill_output_more( &(block->u.out.u.full.u.cross.om),
 						  /* data size - how much of data_p fits on the first page */
 						  PAGE_SIZE - (data_p % PAGE_SIZE),
 						  /* DMA address of data_p */
 						  dma_region_offset_to_bus(&video->dv_buf,
 									   data_p - (unsigned long) video->dv_buf.kvirt));
 				fill_output_last( &(block->u.out.u.full.u.cross.ol),
 						  /* want completion status on all interesting packets */
 						  (first_packet || mid_packet || last_packet) ? 1 : 0,
 						  /* want interrupt on all interesting packets */
 						  (first_packet || mid_packet || last_packet) ? 1 : 0,
 						  /* data size - remaining portion of data_p */
 						  480 - (PAGE_SIZE - (data_p % PAGE_SIZE)),
 						  /* DMA address of data_p + PAGE_SIZE - (data_p % PAGE_SIZE) */
 						  dma_region_offset_to_bus(&video->dv_buf,
 									   data_p + PAGE_SIZE - (data_p % PAGE_SIZE) - (unsigned long) video->dv_buf.kvirt));
 				if (first_packet)
 					f->frame_begin_timestamp = &(block->u.out.u.full.u.cross.ol.q[3]);
 				else if (mid_packet)
 					f->mid_frame_timestamp = &(block->u.out.u.full.u.cross.ol.q[3]);
 				else if (last_packet) {
 					f->frame_end_timestamp = &(block->u.out.u.full.u.cross.ol.q[3]);
 					f->frame_end_branch = &(block->u.out.u.full.u.cross.ol.q[2]);
 				}
 				branch_address = &(block->u.out.u.full.u.cross.ol.q[2]);
 				n_descriptors = 5;
 				if (first_packet)
 					f->first_n_descriptors = n_descriptors;
 				full_packets++;
 			} else {
 				/* fits on one page */
 				fill_output_last( &(block->u.out.u.full.u.nocross.ol),
 						  /* want completion status on all interesting packets */
 						  (first_packet || mid_packet || last_packet) ? 1 : 0,
 						  /* want interrupt on all interesting packets */
 						  (first_packet || mid_packet || last_packet) ? 1 : 0,
 						  480, /* data size (480 bytes of DV data) */
 						  /* DMA address of data_p */
 						  dma_region_offset_to_bus(&video->dv_buf,
 									   data_p - (unsigned long) video->dv_buf.kvirt));
 				if (first_packet)
 					f->frame_begin_timestamp = &(block->u.out.u.full.u.nocross.ol.q[3]);
 				else if (mid_packet)
 					f->mid_frame_timestamp = &(block->u.out.u.full.u.nocross.ol.q[3]);
 				else if (last_packet) {
 					f->frame_end_timestamp = &(block->u.out.u.full.u.nocross.ol.q[3]);
 					f->frame_end_branch = &(block->u.out.u.full.u.nocross.ol.q[2]);
 				}
 				branch_address = &(block->u.out.u.full.u.nocross.ol.q[2]);
 				n_descriptors = 4;
 				if (first_packet)
 					f->first_n_descriptors = n_descriptors;
 				full_packets++;
 			}
 		}
 		/* link this descriptor block into the DMA program by filling in
 		   the branch address of the previous block */
 		/* note: we are not linked into the active DMA chain yet */
 		if (last_branch_address) {
 			*(last_branch_address) = cpu_to_le32(block_dma | n_descriptors);
 		}
 		last_branch_address = branch_address;
 		f->n_packets++;
 	}
 	/* when we first assemble a new frame, set the final branch
 	   to loop back up to the top */
 	*(f->frame_end_branch) = cpu_to_le32(f->descriptor_pool_dma | f->first_n_descriptors);
 	/* make the latest version of this frame visible to the PCI card */
 	dma_region_sync_for_device(&video->dv_buf, f->data - (unsigned long) video->dv_buf.kvirt, video->frame_size);
 	/* lock against DMA interrupt */
 	spin_lock_irqsave(&video->spinlock, irq_flags);
 	f->state = FRAME_READY;
 	video->n_clear_frames--;
 	last_frame = video->first_clear_frame - 1;
 	if (last_frame == -1)
 		last_frame = video->n_frames-1;
 	video->first_clear_frame = (video->first_clear_frame + 1) % video->n_frames;
 	irq_printk("   frame %d prepared, active_frame = %d, n_clear_frames = %d, first_clear_frame = %d\n last=%d\n",
 		   this_frame, video->active_frame, video->n_clear_frames, video->first_clear_frame, last_frame);
 	irq_printk("   begin_ts %08lx mid_ts %08lx end_ts %08lx end_br %08lx\n",
 		   (unsigned long) f->frame_begin_timestamp,
 		   (unsigned long) f->mid_frame_timestamp,
 		   (unsigned long) f->frame_end_timestamp,
 		   (unsigned long) f->frame_end_branch);
 	if (video->active_frame != -1) {
 		/* if DMA is already active, we are almost done */
 		/* just link us onto the active DMA chain */
 		if (video->frames[last_frame]->frame_end_branch) {
 			u32 temp;
 			/* point the previous frame's tail to this frame's head */
 			*(video->frames[last_frame]->frame_end_branch) = cpu_to_le32(f->descriptor_pool_dma | f->first_n_descriptors);
 			/* this write MUST precede the next one, or we could silently drop frames */
 			wmb();
 			/* disable the want_status semaphore on the last packet */
 			temp = le32_to_cpu(*(video->frames[last_frame]->frame_end_branch - 2));
 			temp &= 0xF7CFFFFF;
 			*(video->frames[last_frame]->frame_end_branch - 2) = cpu_to_le32(temp);
 			/* flush these writes to memory ASAP */
 			flush_pci_write(video->ohci);
 			/* NOTE:
 			   ideally the writes should be "atomic": if
 			   the OHCI card reads the want_status flag in
 			   between them, we'll falsely report a
 			   dropped frame. Hopefully this window is too
 			   small to really matter, and the consequence
 			   is rather harmless. */
 			irq_printk("     new frame %d linked onto DMA chain\n", this_frame);
 		} else {
 			printk(KERN_ERR "dv1394: last frame not ready???\n");
 		}
 	} else {
 		u32 transmit_sec, transmit_cyc;
-		u32 ts_cyc, ts_off;
+		u32 ts_cyc;
 		/* DMA is stopped, so this is the very first frame */
 		video->active_frame = this_frame;
 	        /* set CommandPtr to address and size of first descriptor block */
 		reg_write(video->ohci, video->ohci_IsoXmitCommandPtr,
 			  video->frames[video->active_frame]->descriptor_pool_dma |
 			  f->first_n_descriptors);
 		/* assign a timestamp based on the current cycle time...
 		   We'll tell the card to begin DMA 100 cycles from now,
 		   and assign a timestamp 103 cycles from now */
 		cycleTimer = reg_read(video->ohci, OHCI1394_IsochronousCycleTimer);
 		ct_sec = cycleTimer >> 25;
 		ct_cyc = (cycleTimer >> 12) & 0x1FFF;
 		ct_off = cycleTimer & 0xFFF;
 		transmit_sec = ct_sec;
 		transmit_cyc = ct_cyc + 100;
 		transmit_sec += transmit_cyc/8000;
 		transmit_cyc %= 8000;
-		ts_off = ct_off;
 		ts_cyc = transmit_cyc + 3;
 		ts_cyc %= 8000;
 		f->assigned_timestamp = (ts_cyc&0xF) << 12;
 		/* now actually write the timestamp into the appropriate CIP headers */
 		if (f->cip_syt1) {
 			f->cip_syt1->b[6] = f->assigned_timestamp >> 8;
 			f->cip_syt1->b[7] = f->assigned_timestamp & 0xFF;
 		}
 		if (f->cip_syt2) {
 			f->cip_syt2->b[6] = f->assigned_timestamp >> 8;
 			f->cip_syt2->b[7] = f->assigned_timestamp & 0xFF;
 		}
 		/* --- start DMA --- */
 		/* clear all bits in ContextControl register */
 		reg_write(video->ohci, video->ohci_IsoXmitContextControlClear, 0xFFFFFFFF);
 		wmb();
 		/* the OHCI card has the ability to start ISO transmission on a
 		   particular cycle (start-on-cycle). This way we can ensure that
 		   the first DV frame will have an accurate timestamp.
 		   However, start-on-cycle only appears to work if the OHCI card
 		   is cycle master! Since the consequences of messing up the first
 		   timestamp are minimal*, just disable start-on-cycle for now.
 		   * my DV deck drops the first few frames before it "locks in;"
 		     so the first frame having an incorrect timestamp is inconsequential.
 		*/
 #if 0
 		reg_write(video->ohci, video->ohci_IsoXmitContextControlSet,
 			  (1 << 31) /* enable start-on-cycle */
 			  | ( (transmit_sec & 0x3) << 29)
 			  | (transmit_cyc << 16));
 		wmb();
 #endif
 		video->dma_running = 1;
 		/* set the 'run' bit */
 		reg_write(video->ohci, video->ohci_IsoXmitContextControlSet, 0x8000);
 		flush_pci_write(video->ohci);
 		/* --- DMA should be running now --- */
 		debug_printk("    Cycle = %4u ContextControl = %08x CmdPtr = %08x\n",
 			     (reg_read(video->ohci, OHCI1394_IsochronousCycleTimer) >> 12) & 0x1FFF,
 			     reg_read(video->ohci, video->ohci_IsoXmitContextControlSet),
 			     reg_read(video->ohci, video->ohci_IsoXmitCommandPtr));
 		debug_printk("    DMA start - current cycle %4u, transmit cycle %4u (%2u), assigning ts cycle %2u\n",
 			     ct_cyc, transmit_cyc, transmit_cyc & 0xF, ts_cyc & 0xF);
 #if DV1394_DEBUG_LEVEL >= 2
 		{
 			/* check if DMA is really running */
 			int i = 0;
 			while (i < 20) {
 				mb();
 				mdelay(1);
 				if (reg_read(video->ohci, video->ohci_IsoXmitContextControlSet) & (1 << 10)) {
 					printk("DMA ACTIVE after %d msec\n", i);
 					break;
 				}
 				i++;
 			}
 			printk("set = %08x, cmdPtr = %08x\n",
 			       reg_read(video->ohci, video->ohci_IsoXmitContextControlSet),
 			       reg_read(video->ohci, video->ohci_IsoXmitCommandPtr)
 			       );
 			if ( ! (reg_read(video->ohci, video->ohci_IsoXmitContextControlSet) &  (1 << 10)) ) {
 				printk("DMA did NOT go active after 20ms, event = %x\n",
 				       reg_read(video->ohci, video->ohci_IsoXmitContextControlSet) & 0x1F);
 			} else
 				printk("DMA is RUNNING!\n");
 		}
 #endif
 	}
 	spin_unlock_irqrestore(&video->spinlock, irq_flags);
 }
 /*** RECEIVE FUNCTIONS *****************************************************/
 /*
 	frame method put_packet
 	map and copy the packet data to its location in the frame
 	based upon DIF section and sequence
 */
 static void inline
 frame_put_packet (struct frame *f, struct packet *p)
 {
 	int section_type = p->data[0] >> 5;           /* section type is in bits 5 - 7 */
 	int dif_sequence = p->data[1] >> 4;           /* dif sequence number is in bits 4 - 7 */
 	int dif_block = p->data[2];
 	/* sanity check */
 	if (dif_sequence > 11 || dif_block > 149) return;
 	switch (section_type) {
 	case 0:           /* 1 Header block */
 	        memcpy( (void *) f->data + dif_sequence * 150 * 80, p->data, 480);
 	        break;
 	case 1:           /* 2 Subcode blocks */
 	        memcpy( (void *) f->data + dif_sequence * 150 * 80 + (1 + dif_block) * 80, p->data, 480);
 	        break;
 	case 2:           /* 3 VAUX blocks */
 	        memcpy( (void *) f->data + dif_sequence * 150 * 80 + (3 + dif_block) * 80, p->data, 480);
 	        break;
 	case 3:           /* 9 Audio blocks interleaved with video */
 	        memcpy( (void *) f->data + dif_sequence * 150 * 80 + (6 + dif_block * 16) * 80, p->data, 480);
 	        break;
 	case 4:           /* 135 Video blocks interleaved with audio */
 	        memcpy( (void *) f->data + dif_sequence * 150 * 80 + (7 + (dif_block / 15) + dif_block) * 80, p->data, 480);
 	        break;
 	default:           /* we can not handle any other data */
 	        break;
 	}
 }
 static void start_dma_receive(struct video_card *video)
 {
 	if (video->first_run == 1) {
 		video->first_run = 0;
 		/* start DMA once all of the frames are READY */
 		video->n_clear_frames = 0;
 		video->first_clear_frame = -1;
 		video->current_packet = 0;
 		video->active_frame = 0;
 		/* reset iso recv control register */
 		reg_write(video->ohci, video->ohci_IsoRcvContextControlClear, 0xFFFFFFFF);
 		wmb();
 		/* clear bufferFill, set isochHeader and speed (0=100) */
 		reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, 0x40000000);
 		/* match on all tags, listen on channel */
 		reg_write(video->ohci, video->ohci_IsoRcvContextMatch, 0xf0000000 | video->channel);
 		/* address and first descriptor block + Z=1 */
 		reg_write(video->ohci, video->ohci_IsoRcvCommandPtr,
 			  video->frames[0]->descriptor_pool_dma | 1); /* Z=1 */
 		wmb();
 		video->dma_running = 1;
 		/* run */
 		reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, 0x8000);
 		flush_pci_write(video->ohci);
 		debug_printk("dv1394: DMA started\n");
 #if DV1394_DEBUG_LEVEL >= 2
 		{
 			int i;
 			for (i = 0; i < 1000; ++i) {
 				mdelay(1);
 				if (reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) & (1 << 10)) {
 					printk("DMA ACTIVE after %d msec\n", i);
 					break;
 				}
 			}
 			if ( reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) &  (1 << 11) ) {
 				printk("DEAD, event = %x\n",
 					   reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) & 0x1F);
 			} else
 				printk("RUNNING!\n");
 		}
 #endif
 	} else if ( reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) &  (1 << 11) ) {
 		debug_printk("DEAD, event = %x\n",
 			     reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) & 0x1F);
 		/* wake */
 		reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, (1 << 12));
 	}
 }
 /*
    receive_packets() - build the DMA program for receiving
 */
 static void receive_packets(struct video_card *video)
 {
 	struct DMA_descriptor_block *block = NULL;
 	dma_addr_t block_dma = 0;
 	struct packet *data = NULL;
 	dma_addr_t data_dma = 0;
 	__le32 *last_branch_address = NULL;
 	unsigned long irq_flags;
 	int want_interrupt = 0;
 	struct frame *f = NULL;
 	int i, j;
 	spin_lock_irqsave(&video->spinlock, irq_flags);
 	for (j = 0; j < video->n_frames; j++) {
 		/* connect frames */
 		if (j > 0 && f != NULL && f->frame_end_branch != NULL)
 			*(f->frame_end_branch) = cpu_to_le32(video->frames[j]->descriptor_pool_dma | 1); /* set Z=1 */
 		f = video->frames[j];
 		for (i = 0; i < MAX_PACKETS; i++) {
 			/* locate a descriptor block and packet from the buffer */
 			block = &(f->descriptor_pool[i]);
 			block_dma = ((unsigned long) block - (unsigned long) f->descriptor_pool) + f->descriptor_pool_dma;
 			data = ((struct packet*)video->packet_buf.kvirt) + f->frame_num * MAX_PACKETS + i;
 			data_dma = dma_region_offset_to_bus( &video->packet_buf,
 							     ((unsigned long) data - (unsigned long) video->packet_buf.kvirt) );
 			/* setup DMA descriptor block */
 			want_interrupt = ((i % (MAX_PACKETS/2)) == 0 || i == (MAX_PACKETS-1));
 			fill_input_last( &(block->u.in.il), want_interrupt, 512, data_dma);
 			/* link descriptors */
 			last_branch_address = f->frame_end_branch;
 			if (last_branch_address != NULL)
 				*(last_branch_address) = cpu_to_le32(block_dma | 1); /* set Z=1 */
 			f->frame_end_branch = &(block->u.in.il.q[2]);
 		}
 	} /* next j */
 	spin_unlock_irqrestore(&video->spinlock, irq_flags);
 }
 /*** MANAGEMENT FUNCTIONS **************************************************/
 static int do_dv1394_init(struct video_card *video, struct dv1394_init *init)
 {
 	unsigned long flags, new_buf_size;
 	int i;
 	u64 chan_mask;
 	int retval = -EINVAL;
 	debug_printk("dv1394: initialising %d\n", video->id);
 	if (init->api_version != DV1394_API_VERSION)
 		return -EINVAL;
 	/* first sanitize all the parameters */
 	if ( (init->n_frames < 2) || (init->n_frames > DV1394_MAX_FRAMES) )
 		return -EINVAL;
 	if ( (init->format != DV1394_NTSC) && (init->format != DV1394_PAL) )
 		return -EINVAL;
 	if ( (init->syt_offset == 0) || (init->syt_offset > 50) )
 		/* default SYT offset is 3 cycles */
 		init->syt_offset = 3;
 	if (init->channel > 63)
 		init->channel = 63;
 	chan_mask = (u64)1 << init->channel;
 	/* calculate what size DMA buffer is needed */
 	if (init->format == DV1394_NTSC)
 		new_buf_size = DV1394_NTSC_FRAME_SIZE * init->n_frames;
 	else
 		new_buf_size = DV1394_PAL_FRAME_SIZE * init->n_frames;
 	/* round up to PAGE_SIZE */
 	if (new_buf_size % PAGE_SIZE) new_buf_size += PAGE_SIZE - (new_buf_size % PAGE_SIZE);
 	/* don't allow the user to allocate the DMA buffer more than once */
 	if (video->dv_buf.kvirt && video->dv_buf_size != new_buf_size) {
 		printk("dv1394: re-sizing the DMA buffer is not allowed\n");
 		return -EINVAL;
 	}
 	/* shutdown the card if it's currently active */
 	/* (the card should not be reset if the parameters are screwy) */
 	do_dv1394_shutdown(video, 0);
 	/* try to claim the ISO channel */
 	spin_lock_irqsave(&video->ohci->IR_channel_lock, flags);
 	if (video->ohci->ISO_channel_usage & chan_mask) {
 		spin_unlock_irqrestore(&video->ohci->IR_channel_lock, flags);
 		retval = -EBUSY;
 		goto err;
 	}
 	video->ohci->ISO_channel_usage |= chan_mask;
 	spin_unlock_irqrestore(&video->ohci->IR_channel_lock, flags);
 	video->channel = init->channel;
 	/* initialize misc. fields of video */
 	video->n_frames = init->n_frames;
 	video->pal_or_ntsc = init->format;
 	video->cip_accum = 0;
 	video->continuity_counter = 0;
 	video->active_frame = -1;
 	video->first_clear_frame = 0;
 	video->n_clear_frames = video->n_frames;
 	video->dropped_frames = 0;
 	video->write_off = 0;
 	video->first_run = 1;
 	video->current_packet = -1;
 	video->first_frame = 0;
 	if (video->pal_or_ntsc == DV1394_NTSC) {
 		video->cip_n = init->cip_n != 0 ? init->cip_n : CIP_N_NTSC;
 		video->cip_d = init->cip_d != 0 ? init->cip_d : CIP_D_NTSC;
 		video->frame_size = DV1394_NTSC_FRAME_SIZE;
 	} else {
 		video->cip_n = init->cip_n != 0 ? init->cip_n : CIP_N_PAL;
 		video->cip_d = init->cip_d != 0 ? init->cip_d : CIP_D_PAL;
 		video->frame_size = DV1394_PAL_FRAME_SIZE;
 	}
 	video->syt_offset = init->syt_offset;
 	/* find and claim DMA contexts on the OHCI card */
 	if (video->ohci_it_ctx == -1) {
 		ohci1394_init_iso_tasklet(&video->it_tasklet, OHCI_ISO_TRANSMIT,
 					  it_tasklet_func, (unsigned long) video);
 		if (ohci1394_register_iso_tasklet(video->ohci, &video->it_tasklet) < 0) {
 			printk(KERN_ERR "dv1394: could not find an available IT DMA context\n");
 			retval = -EBUSY;
 			goto err;
 		}
 		video->ohci_it_ctx = video->it_tasklet.context;
 		debug_printk("dv1394: claimed IT DMA context %d\n", video->ohci_it_ctx);
 	}
 	if (video->ohci_ir_ctx == -1) {
 		ohci1394_init_iso_tasklet(&video->ir_tasklet, OHCI_ISO_RECEIVE,
 					  ir_tasklet_func, (unsigned long) video);
 		if (ohci1394_register_iso_tasklet(video->ohci, &video->ir_tasklet) < 0) {
 			printk(KERN_ERR "dv1394: could not find an available IR DMA context\n");
 			retval = -EBUSY;
 			goto err;
 		}
 		video->ohci_ir_ctx = video->ir_tasklet.context;
 		debug_printk("dv1394: claimed IR DMA context %d\n", video->ohci_ir_ctx);
 	}
 	/* allocate struct frames */
 	for (i = 0; i < init->n_frames; i++) {
 		video->frames[i] = frame_new(i, video);
 		if (!video->frames[i]) {
 			printk(KERN_ERR "dv1394: Cannot allocate frame structs\n");
 			retval = -ENOMEM;
 			goto err;
 		}
 	}
 	if (!video->dv_buf.kvirt) {
 		/* allocate the ringbuffer */
 		retval = dma_region_alloc(&video->dv_buf, new_buf_size, video->ohci->dev, PCI_DMA_TODEVICE);
 		if (retval)
 			goto err;
 		video->dv_buf_size = new_buf_size;
 		debug_printk("dv1394: Allocated %d frame buffers, total %u pages (%u DMA pages), %lu bytes\n",
 			     video->n_frames, video->dv_buf.n_pages,
 			     video->dv_buf.n_dma_pages, video->dv_buf_size);
 	}
 	/* set up the frame->data pointers */
 	for (i = 0; i < video->n_frames; i++)
 		video->frames[i]->data = (unsigned long) video->dv_buf.kvirt + i * video->frame_size;
 	if (!video->packet_buf.kvirt) {
 		/* allocate packet buffer */
 		video->packet_buf_size = sizeof(struct packet) * video->n_frames * MAX_PACKETS;
 		if (video->packet_buf_size % PAGE_SIZE)
 			video->packet_buf_size += PAGE_SIZE - (video->packet_buf_size % PAGE_SIZE);
 		retval = dma_region_alloc(&video->packet_buf, video->packet_buf_size,
 					  video->ohci->dev, PCI_DMA_FROMDEVICE);
 		if (retval)
 			goto err;
 		debug_printk("dv1394: Allocated %d packets in buffer, total %u pages (%u DMA pages), %lu bytes\n",
 				 video->n_frames*MAX_PACKETS, video->packet_buf.n_pages,
 				 video->packet_buf.n_dma_pages, video->packet_buf_size);
 	}
 	/* set up register offsets for IT context */
 	/* IT DMA context registers are spaced 16 bytes apart */
 	video->ohci_IsoXmitContextControlSet = OHCI1394_IsoXmitContextControlSet+16*video->ohci_it_ctx;
 	video->ohci_IsoXmitContextControlClear = OHCI1394_IsoXmitContextControlClear+16*video->ohci_it_ctx;
 	video->ohci_IsoXmitCommandPtr = OHCI1394_IsoXmitCommandPtr+16*video->ohci_it_ctx;
 	/* enable interrupts for IT context */
 	reg_write(video->ohci, OHCI1394_IsoXmitIntMaskSet, (1 << video->ohci_it_ctx));
 	debug_printk("dv1394: interrupts enabled for IT context %d\n", video->ohci_it_ctx);
 	/* set up register offsets for IR context */
 	/* IR DMA context registers are spaced 32 bytes apart */
 	video->ohci_IsoRcvContextControlSet = OHCI1394_IsoRcvContextControlSet+32*video->ohci_ir_ctx;
 	video->ohci_IsoRcvContextControlClear = OHCI1394_IsoRcvContextControlClear+32*video->ohci_ir_ctx;
 	video->ohci_IsoRcvCommandPtr = OHCI1394_IsoRcvCommandPtr+32*video->ohci_ir_ctx;
 	video->ohci_IsoRcvContextMatch = OHCI1394_IsoRcvContextMatch+32*video->ohci_ir_ctx;
 	/* enable interrupts for IR context */
 	reg_write(video->ohci, OHCI1394_IsoRecvIntMaskSet, (1 << video->ohci_ir_ctx) );
 	debug_printk("dv1394: interrupts enabled for IR context %d\n", video->ohci_ir_ctx);
 	return 0;
 err:
 	do_dv1394_shutdown(video, 1);
 	return retval;
 }
 /* if the user doesn't bother to call ioctl(INIT) before starting
    mmap() or read()/write(), just give him some default values */
 static int do_dv1394_init_default(struct video_card *video)
 {
 	struct dv1394_init init;
 	init.api_version = DV1394_API_VERSION;
 	init.n_frames = DV1394_MAX_FRAMES / 4;
 	init.channel = video->channel;
 	init.format = video->pal_or_ntsc;
 	init.cip_n = video->cip_n;
 	init.cip_d = video->cip_d;
 	init.syt_offset = video->syt_offset;
 	return do_dv1394_init(video, &init);
 }
 /* do NOT call from interrupt context */
 static void stop_dma(struct video_card *video)
 {
 	unsigned long flags;
 	int i;
 	/* no interrupts */
 	spin_lock_irqsave(&video->spinlock, flags);
 	video->dma_running = 0;
 	if ( (video->ohci_it_ctx == -1) && (video->ohci_ir_ctx == -1) )
 		goto out;
 	/* stop DMA if in progress */
 	if ( (video->active_frame != -1) ||
 	    (reg_read(video->ohci, video->ohci_IsoXmitContextControlClear) & (1 << 10)) ||
 	    (reg_read(video->ohci, video->ohci_IsoRcvContextControlClear) &  (1 << 10)) ) {
 		/* clear the .run bits */
 		reg_write(video->ohci, video->ohci_IsoXmitContextControlClear, (1 << 15));
 		reg_write(video->ohci, video->ohci_IsoRcvContextControlClear, (1 << 15));
 		flush_pci_write(video->ohci);
 		video->active_frame = -1;
 		video->first_run = 1;
 		/* wait until DMA really stops */
 		i = 0;
 		while (i < 1000) {
 			/* wait 0.1 millisecond */
 			udelay(100);
 			if ( (reg_read(video->ohci, video->ohci_IsoXmitContextControlClear) & (1 << 10)) ||
 			    (reg_read(video->ohci, video->ohci_IsoRcvContextControlClear)  & (1 << 10)) ) {
 				/* still active */
 				debug_printk("dv1394: stop_dma: DMA not stopped yet\n" );
 				mb();
 			} else {
 				debug_printk("dv1394: stop_dma: DMA stopped safely after %d ms\n", i/10);
 				break;
 			}
 			i++;
 		}
 		if (i == 1000) {
 			printk(KERN_ERR "dv1394: stop_dma: DMA still going after %d ms!\n", i/10);
 		}
 	}
 	else
 		debug_printk("dv1394: stop_dma: already stopped.\n");
 out:
 	spin_unlock_irqrestore(&video->spinlock, flags);
 }
 static void do_dv1394_shutdown(struct video_card *video, int free_dv_buf)
 {
 	int i;
 	debug_printk("dv1394: shutdown...\n");
 	/* stop DMA if in progress */
 	stop_dma(video);
 	/* release the DMA contexts */
 	if (video->ohci_it_ctx != -1) {
 		video->ohci_IsoXmitContextControlSet = 0;
 		video->ohci_IsoXmitContextControlClear = 0;
 		video->ohci_IsoXmitCommandPtr = 0;
 		/* disable interrupts for IT context */
 		reg_write(video->ohci, OHCI1394_IsoXmitIntMaskClear, (1 << video->ohci_it_ctx));
 		/* remove tasklet */
 		ohci1394_unregister_iso_tasklet(video->ohci, &video->it_tasklet);
 		debug_printk("dv1394: IT context %d released\n", video->ohci_it_ctx);
 		video->ohci_it_ctx = -1;
 	}
 	if (video->ohci_ir_ctx != -1) {
 		video->ohci_IsoRcvContextControlSet = 0;
 		video->ohci_IsoRcvContextControlClear = 0;
 		video->ohci_IsoRcvCommandPtr = 0;
 		video->ohci_IsoRcvContextMatch = 0;
 		/* disable interrupts for IR context */
 		reg_write(video->ohci, OHCI1394_IsoRecvIntMaskClear, (1 << video->ohci_ir_ctx));
 		/* remove tasklet */
 		ohci1394_unregister_iso_tasklet(video->ohci, &video->ir_tasklet);
 		debug_printk("dv1394: IR context %d released\n", video->ohci_ir_ctx);
 		video->ohci_ir_ctx = -1;
 	}
 	/* release the ISO channel */
 	if (video->channel != -1) {
 		u64 chan_mask;
 		unsigned long flags;
 		chan_mask = (u64)1 << video->channel;
 		spin_lock_irqsave(&video->ohci->IR_channel_lock, flags);
 		video->ohci->ISO_channel_usage &= ~(chan_mask);
 		spin_unlock_irqrestore(&video->ohci->IR_channel_lock, flags);
 		video->channel = -1;
 	}
 	/* free the frame structs */
 	for (i = 0; i < DV1394_MAX_FRAMES; i++) {
 		if (video->frames[i])
 			frame_delete(video->frames[i]);
 		video->frames[i] = NULL;
 	}
 	video->n_frames = 0;
 	/* we can't free the DMA buffer unless it is guaranteed that
 	   no more user-space mappings exist */
 	if (free_dv_buf) {
 		dma_region_free(&video->dv_buf);
 		video->dv_buf_size = 0;
 	}
 	/* free packet buffer */
 	dma_region_free(&video->packet_buf);
 	video->packet_buf_size = 0;
 	debug_printk("dv1394: shutdown OK\n");
 }
 /*
        **********************************
        *** MMAP() THEORY OF OPERATION ***
        **********************************
         The ringbuffer cannot be re-allocated or freed while
         a user program maintains a mapping of it. (note that a mapping
 	can persist even after the device fd is closed!)
 	So, only let the user process allocate the DMA buffer once.
 	To resize or deallocate it, you must close the device file
 	and open it again.
 	Previously Dan M. hacked out a scheme that allowed the DMA
 	buffer to change by forcefully unmapping it from the user's
 	address space. It was prone to error because it's very hard to
 	track all the places the buffer could have been mapped (we
 	would have had to walk the vma list of every process in the
 	system to be sure we found all the mappings!). Instead, we
 	force the user to choose one buffer size and stick with
 	it. This small sacrifice is worth the huge reduction in
 	error-prone code in dv1394.
 */
 static int dv1394_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct video_card *video = file_to_video_card(file);
 	int retval = -EINVAL;
 	/*
 	 * We cannot use the blocking variant mutex_lock here because .mmap
 	 * is called with mmap_sem held, while .ioctl, .read, .write acquire
 	 * video->mtx and subsequently call copy_to/from_user which will
 	 * grab mmap_sem in case of a page fault.
 	 */
 	if (!mutex_trylock(&video->mtx))
 		return -EAGAIN;
 	if ( ! video_card_initialized(video) ) {
 		retval = do_dv1394_init_default(video);
 		if (retval)
 			goto out;
 	}
 	retval = dma_region_mmap(&video->dv_buf, file, vma);
 out:
 	mutex_unlock(&video->mtx);
 	return retval;
 }
 /*** DEVICE FILE INTERFACE *************************************************/
 /* no need to serialize, multiple threads OK */
 static unsigned int dv1394_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct video_card *video = file_to_video_card(file);
 	unsigned int mask = 0;
 	unsigned long flags;
 	poll_wait(file, &video->waitq, wait);
 	spin_lock_irqsave(&video->spinlock, flags);
 	if ( video->n_frames == 0 ) {
 	} else if ( video->active_frame == -1 ) {
 		/* nothing going on */
 		mask |= POLLOUT;
 	} else {
 		/* any clear/ready buffers? */
 		if (video->n_clear_frames >0)
 			mask |= POLLOUT | POLLIN;
 	}
 	spin_unlock_irqrestore(&video->spinlock, flags);
 	return mask;
 }
 static int dv1394_fasync(int fd, struct file *file, int on)
 {
 	/* I just copied this code verbatim from Alan Cox's mouse driver example
 	   (Documentation/DocBook/) */
 	struct video_card *video = file_to_video_card(file);
 	return fasync_helper(fd, file, on, &video->fasync);
 }
 static ssize_t dv1394_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct video_card *video = file_to_video_card(file);
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret;
 	size_t cnt;
 	unsigned long flags;
 	int target_frame;
 	/* serialize this to prevent multi-threaded mayhem */
 	if (file->f_flags & O_NONBLOCK) {
 		if (!mutex_trylock(&video->mtx))
 			return -EAGAIN;
 	} else {
 		if (mutex_lock_interruptible(&video->mtx))
 			return -ERESTARTSYS;
 	}
 	if ( !video_card_initialized(video) ) {
 		ret = do_dv1394_init_default(video);
 		if (ret) {
 			mutex_unlock(&video->mtx);
 			return ret;
 		}
 	}
 	ret = 0;
 	add_wait_queue(&video->waitq, &wait);
 	while (count > 0) {
 		/* must set TASK_INTERRUPTIBLE *before* checking for free
 		   buffers; otherwise we could miss a wakeup if the interrupt
 		   fires between the check and the schedule() */
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&video->spinlock, flags);
 		target_frame = video->first_clear_frame;
 		spin_unlock_irqrestore(&video->spinlock, flags);
 		if (video->frames[target_frame]->state == FRAME_CLEAR) {
 			/* how much room is left in the target frame buffer */
 			cnt = video->frame_size - (video->write_off - target_frame * video->frame_size);
 		} else {
 			/* buffer is already used */
 			cnt = 0;
 		}
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			/* no room left, gotta wait */
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				break;
 			}
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				break;
 			}
 			schedule();
 			continue; /* start over from 'while(count > 0)...' */
 		}
 		if (copy_from_user(video->dv_buf.kvirt + video->write_off, buffer, cnt)) {
 			if (!ret)
 				ret = -EFAULT;
 			break;
 		}
 		video->write_off = (video->write_off + cnt) % (video->n_frames * video->frame_size);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		if (video->write_off == video->frame_size * ((target_frame + 1) % video->n_frames))
 				frame_prepare(video, target_frame);
 	}
 	remove_wait_queue(&video->waitq, &wait);
 	set_current_state(TASK_RUNNING);
 	mutex_unlock(&video->mtx);
 	return ret;
 }
 static ssize_t dv1394_read(struct file *file,  char __user *buffer, size_t count, loff_t *ppos)
 {
 	struct video_card *video = file_to_video_card(file);
 	DECLARE_WAITQUEUE(wait, current);
 	ssize_t ret;
 	size_t cnt;
 	unsigned long flags;
 	int target_frame;
 	/* serialize this to prevent multi-threaded mayhem */
 	if (file->f_flags & O_NONBLOCK) {
 		if (!mutex_trylock(&video->mtx))
 			return -EAGAIN;
 	} else {
 		if (mutex_lock_interruptible(&video->mtx))
 			return -ERESTARTSYS;
 	}
 	if ( !video_card_initialized(video) ) {
 		ret = do_dv1394_init_default(video);
 		if (ret) {
 			mutex_unlock(&video->mtx);
 			return ret;
 		}
 		video->continuity_counter = -1;
 		receive_packets(video);
 		start_dma_receive(video);
 	}
 	ret = 0;
 	add_wait_queue(&video->waitq, &wait);
 	while (count > 0) {
 		/* must set TASK_INTERRUPTIBLE *before* checking for free
 		   buffers; otherwise we could miss a wakeup if the interrupt
 		   fires between the check and the schedule() */
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&video->spinlock, flags);
 		target_frame = video->first_clear_frame;
 		spin_unlock_irqrestore(&video->spinlock, flags);
 		if (target_frame >= 0 &&
 			video->n_clear_frames > 0 &&
 			video->frames[target_frame]->state == FRAME_CLEAR) {
 			/* how much room is left in the target frame buffer */
 			cnt = video->frame_size - (video->write_off - target_frame * video->frame_size);
 		} else {
 			/* buffer is already used */
 			cnt = 0;
 		}
 		if (cnt > count)
 			cnt = count;
 		if (cnt <= 0) {
 			/* no room left, gotta wait */
 			if (file->f_flags & O_NONBLOCK) {
 				if (!ret)
 					ret = -EAGAIN;
 				break;
 			}
 			if (signal_pending(current)) {
 				if (!ret)
 					ret = -ERESTARTSYS;
 				break;
 			}
 			schedule();
 			continue; /* start over from 'while(count > 0)...' */
 		}
 		if (copy_to_user(buffer, video->dv_buf.kvirt + video->write_off, cnt)) {
 				if (!ret)
 					ret = -EFAULT;
 				break;
 		}
 		video->write_off = (video->write_off + cnt) % (video->n_frames * video->frame_size);
 		count -= cnt;
 		buffer += cnt;
 		ret += cnt;
 		if (video->write_off == video->frame_size * ((target_frame + 1) % video->n_frames)) {
 			spin_lock_irqsave(&video->spinlock, flags);
 			video->n_clear_frames--;
 			video->first_clear_frame = (video->first_clear_frame + 1) % video->n_frames;
 			spin_unlock_irqrestore(&video->spinlock, flags);
 		}
 	}
 	remove_wait_queue(&video->waitq, &wait);
 	set_current_state(TASK_RUNNING);
 	mutex_unlock(&video->mtx);
 	return ret;
 }
 /*** DEVICE IOCTL INTERFACE ************************************************/
 static long dv1394_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct video_card *video = file_to_video_card(file);
 	unsigned long flags;
 	int ret = -EINVAL;
 	void __user *argp = (void __user *)arg;
 	DECLARE_WAITQUEUE(wait, current);
 	/* serialize this to prevent multi-threaded mayhem */
 	if (file->f_flags & O_NONBLOCK) {
 		if (!mutex_trylock(&video->mtx))
 			return -EAGAIN;
 	} else {
 		if (mutex_lock_interruptible(&video->mtx))
 			return -ERESTARTSYS;
 	}
 	switch(cmd)
 	{
 	case DV1394_IOC_SUBMIT_FRAMES: {
 		unsigned int n_submit;
 		if ( !video_card_initialized(video) ) {
 			ret = do_dv1394_init_default(video);
 			if (ret)
 				goto out;
 		}
 		n_submit = (unsigned int) arg;
 		if (n_submit > video->n_frames) {
 			ret = -EINVAL;
 			goto out;
 		}
 		while (n_submit > 0) {
 			add_wait_queue(&video->waitq, &wait);
 			set_current_state(TASK_INTERRUPTIBLE);
 			spin_lock_irqsave(&video->spinlock, flags);
 			/* wait until video->first_clear_frame is really CLEAR */
 			while (video->frames[video->first_clear_frame]->state != FRAME_CLEAR) {
 				spin_unlock_irqrestore(&video->spinlock, flags);
 				if (signal_pending(current)) {
 					remove_wait_queue(&video->waitq, &wait);
 					set_current_state(TASK_RUNNING);
 					ret = -EINTR;
 					goto out;
 				}
 				schedule();
 				set_current_state(TASK_INTERRUPTIBLE);
 				spin_lock_irqsave(&video->spinlock, flags);
 			}
 			spin_unlock_irqrestore(&video->spinlock, flags);
 			remove_wait_queue(&video->waitq, &wait);
 			set_current_state(TASK_RUNNING);
 			frame_prepare(video, video->first_clear_frame);
 			n_submit--;
 		}
 		ret = 0;
 		break;
 	}
 	case DV1394_IOC_WAIT_FRAMES: {
 		unsigned int n_wait;
 		if ( !video_card_initialized(video) ) {
 			ret = -EINVAL;
 			goto out;
 		}
 		n_wait = (unsigned int) arg;
 		/* since we re-run the last frame on underflow, we will
 		   never actually have n_frames clear frames; at most only
 		   n_frames - 1 */
 		if (n_wait > (video->n_frames-1) ) {
 			ret = -EINVAL;
 			goto out;
 		}
 		add_wait_queue(&video->waitq, &wait);
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irqsave(&video->spinlock, flags);
 		while (video->n_clear_frames < n_wait) {
 			spin_unlock_irqrestore(&video->spinlock, flags);
 			if (signal_pending(current)) {
 				remove_wait_queue(&video->waitq, &wait);
 				set_current_state(TASK_RUNNING);
 				ret = -EINTR;
 				goto out;
 			}
 			schedule();
 			set_current_state(TASK_INTERRUPTIBLE);
 			spin_lock_irqsave(&video->spinlock, flags);
 		}
 		spin_unlock_irqrestore(&video->spinlock, flags);
 		remove_wait_queue(&video->waitq, &wait);
 		set_current_state(TASK_RUNNING);
 		ret = 0;
 		break;
 	}
 	case DV1394_IOC_RECEIVE_FRAMES: {
 		unsigned int n_recv;
 		if ( !video_card_initialized(video) ) {
 			ret = -EINVAL;
 			goto out;
 		}
 		n_recv = (unsigned int) arg;
 		/* at least one frame must be active */
 		if (n_recv > (video->n_frames-1) ) {
 			ret = -EINVAL;
 			goto out;
 		}
 		spin_lock_irqsave(&video->spinlock, flags);
 		/* release the clear frames */
 		video->n_clear_frames -= n_recv;
 		/* advance the clear frame cursor */
 		video->first_clear_frame = (video->first_clear_frame + n_recv) % video->n_frames;
 		/* reset dropped_frames */
 		video->dropped_frames = 0;
 		spin_unlock_irqrestore(&video->spinlock, flags);
 		ret = 0;
 		break;
 	}
 	case DV1394_IOC_START_RECEIVE: {
 		if ( !video_card_initialized(video) ) {
 			ret = do_dv1394_init_default(video);
 			if (ret)
 				goto out;
 		}
 		video->continuity_counter = -1;
 		receive_packets(video);
 		start_dma_receive(video);
 		ret = 0;
 		break;
 	}
 	case DV1394_IOC_INIT: {
 		struct dv1394_init init;
 		if (!argp) {
 			ret = do_dv1394_init_default(video);
 		} else {
 			if (copy_from_user(&init, argp, sizeof(init))) {
 				ret = -EFAULT;
 				goto out;
 			}
 			ret = do_dv1394_init(video, &init);
 		}
 		break;
 	}
 	case DV1394_IOC_SHUTDOWN:
 		do_dv1394_shutdown(video, 0);
 		ret = 0;
 		break;
         case DV1394_IOC_GET_STATUS: {
 		struct dv1394_status status;
 		if ( !video_card_initialized(video) ) {
 			ret = -EINVAL;
 			goto out;
 		}
 		status.init.api_version = DV1394_API_VERSION;
 		status.init.channel = video->channel;
 		status.init.n_frames = video->n_frames;
 		status.init.format = video->pal_or_ntsc;
 		status.init.cip_n = video->cip_n;
 		status.init.cip_d = video->cip_d;
 		status.init.syt_offset = video->syt_offset;
 		status.first_clear_frame = video->first_clear_frame;
 		/* the rest of the fields need to be locked against the interrupt */
 		spin_lock_irqsave(&video->spinlock, flags);
 		status.active_frame = video->active_frame;
 		status.n_clear_frames = video->n_clear_frames;
 		status.dropped_frames = video->dropped_frames;
 		/* reset dropped_frames */
 		video->dropped_frames = 0;
 		spin_unlock_irqrestore(&video->spinlock, flags);
 		if (copy_to_user(argp, &status, sizeof(status))) {
 			ret = -EFAULT;
 			goto out;
 		}
 		ret = 0;
 		break;
 	}
 	default:
 		break;
 	}
  out:
 	mutex_unlock(&video->mtx);
 	return ret;
 }
 /*** DEVICE FILE INTERFACE CONTINUED ***************************************/
 static int dv1394_open(struct inode *inode, struct file *file)
 {
 	struct video_card *video = NULL;
 	if (file->private_data) {
 		video = (struct video_card*) file->private_data;
 	} else {
 		/* look up the card by ID */
 		unsigned long flags;
 		int idx = ieee1394_file_to_instance(file);
 		spin_lock_irqsave(&dv1394_cards_lock, flags);
 		if (!list_empty(&dv1394_cards)) {
 			struct video_card *p;
 			list_for_each_entry(p, &dv1394_cards, list) {
 				if ((p->id) == idx) {
 					video = p;
 					break;
 				}
 			}
 		}
 		spin_unlock_irqrestore(&dv1394_cards_lock, flags);
 		if (!video) {
 			debug_printk("dv1394: OHCI card %d not found", idx);
 			return -ENODEV;
 		}
 		file->private_data = (void*) video;
 	}
 #ifndef DV1394_ALLOW_MORE_THAN_ONE_OPEN
 	if ( test_and_set_bit(0, &video->open) ) {
 		/* video is already open by someone else */
 		return -EBUSY;
  	}
 #endif
 	printk(KERN_INFO "%s: NOTE, the dv1394 interface is unsupported "
 	       "and will not be available in the new firewire driver stack. "
 	       "Try libraw1394 based programs instead.\n", current->comm);
 	return nonseekable_open(inode, file);
 }
 static int dv1394_release(struct inode *inode, struct file *file)
 {
 	struct video_card *video = file_to_video_card(file);
 	/* OK to free the DMA buffer, no more mappings can exist */
 	do_dv1394_shutdown(video, 1);
 	/* give someone else a turn */
 	clear_bit(0, &video->open);
 	return 0;
 }
 /*** DEVICE DRIVER HANDLERS ************************************************/
 static void it_tasklet_func(unsigned long data)
 {
 	int wake = 0;
 	struct video_card *video = (struct video_card*) data;
 	spin_lock(&video->spinlock);
 	if (!video->dma_running)
 		goto out;
 	irq_printk("ContextControl = %08x, CommandPtr = %08x\n",
 	       reg_read(video->ohci, video->ohci_IsoXmitContextControlSet),
 	       reg_read(video->ohci, video->ohci_IsoXmitCommandPtr)
 	       );
 	if ( (video->ohci_it_ctx != -1) &&
 	    (reg_read(video->ohci, video->ohci_IsoXmitContextControlSet) & (1 << 10)) ) {
 		struct frame *f;
 		unsigned int frame, i;
 		if (video->active_frame == -1)
 			frame = 0;
 		else
 			frame = video->active_frame;
 		/* check all the DMA-able frames */
 		for (i = 0; i < video->n_frames; i++, frame = (frame+1) % video->n_frames) {
 			irq_printk("IRQ checking frame %d...", frame);
 			f = video->frames[frame];
 			if (f->state != FRAME_READY) {
 				irq_printk("clear, skipping\n");
 				/* we don't own this frame */
 				continue;
 			}
 			irq_printk("DMA\n");
 			/* check the frame begin semaphore to see if we can free the previous frame */
 			if ( *(f->frame_begin_timestamp) ) {
 				int prev_frame;
 				struct frame *prev_f;
 				/* don't reset, need this later *(f->frame_begin_timestamp) = 0; */
 				irq_printk("  BEGIN\n");
 				prev_frame = frame - 1;
 				if (prev_frame == -1)
 					prev_frame += video->n_frames;
 				prev_f = video->frames[prev_frame];
 				/* make sure we can actually garbage collect
 				   this frame */
 				if ( (prev_f->state == FRAME_READY) &&
 				    prev_f->done && (!f->done) )
 				{
 					frame_reset(prev_f);
 					video->n_clear_frames++;
 					wake = 1;
 					video->active_frame = frame;
 					irq_printk("  BEGIN - freeing previous frame %d, new active frame is %d\n", prev_frame, frame);
 				} else {
 					irq_printk("  BEGIN - can't free yet\n");
 				}
 				f->done = 1;
 			}
 			/* see if we need to set the timestamp for the next frame */
 			if ( *(f->mid_frame_timestamp) ) {
 				struct frame *next_frame;
 				u32 begin_ts, ts_cyc, ts_off;
 				*(f->mid_frame_timestamp) = 0;
 				begin_ts = le32_to_cpu(*(f->frame_begin_timestamp));
 				irq_printk("  MIDDLE - first packet was sent at cycle %4u (%2u), assigned timestamp was (%2u) %4u\n",
 					   begin_ts & 0x1FFF, begin_ts & 0xF,
 					   f->assigned_timestamp >> 12, f->assigned_timestamp & 0xFFF);
 				/* prepare next frame and assign timestamp */
 				next_frame = video->frames[ (frame+1) % video->n_frames ];
 				if (next_frame->state == FRAME_READY) {
 					irq_printk("  MIDDLE - next frame is ready, good\n");
 				} else {
 					debug_printk("dv1394: Underflow! At least one frame has been dropped.\n");
 					next_frame = f;
 				}
 				/* set the timestamp to the timestamp of the last frame sent,
 				   plus the length of the last frame sent, plus the syt latency */
 				ts_cyc = begin_ts & 0xF;
 				/* advance one frame, plus syt latency (typically 2-3) */
 				ts_cyc += f->n_packets + video->syt_offset ;
 				ts_off = 0;
 				ts_cyc += ts_off/3072;
 				ts_off %= 3072;
 				next_frame->assigned_timestamp = ((ts_cyc&0xF) << 12) + ts_off;
 				if (next_frame->cip_syt1) {
 					next_frame->cip_syt1->b[6] = next_frame->assigned_timestamp >> 8;
 					next_frame->cip_syt1->b[7] = next_frame->assigned_timestamp & 0xFF;
 				}
 				if (next_frame->cip_syt2) {
 					next_frame->cip_syt2->b[6] = next_frame->assigned_timestamp >> 8;
 					next_frame->cip_syt2->b[7] = next_frame->assigned_timestamp & 0xFF;
 				}
 			}
 			/* see if the frame looped */
 			if ( *(f->frame_end_timestamp) ) {
 				*(f->frame_end_timestamp) = 0;
 				debug_printk("  END - the frame looped at least once\n");
 				video->dropped_frames++;
 			}
 		} /* for (each frame) */
 	}
 	if (wake) {
 		kill_fasync(&video->fasync, SIGIO, POLL_OUT);
 		/* wake readers/writers/ioctl'ers */
 		wake_up_interruptible(&video->waitq);
 	}
 out:
 	spin_unlock(&video->spinlock);
 }
 static void ir_tasklet_func(unsigned long data)
 {
 	int wake = 0;
 	struct video_card *video = (struct video_card*) data;
 	spin_lock(&video->spinlock);
 	if (!video->dma_running)
 		goto out;
 	if ( (video->ohci_ir_ctx != -1) &&
 	    (reg_read(video->ohci, video->ohci_IsoRcvContextControlSet) & (1 << 10)) ) {
 		int sof=0; /* start-of-frame flag */
 		struct frame *f;
-		u16 packet_length, packet_time;
+		u16 packet_length;
 		int i, dbc=0;
 		struct DMA_descriptor_block *block = NULL;
 		u16 xferstatus;
 		int next_i, prev_i;
 		struct DMA_descriptor_block *next = NULL;
 		dma_addr_t next_dma = 0;
 		struct DMA_descriptor_block *prev = NULL;
 		/* loop over all descriptors in all frames */
 		for (i = 0; i < video->n_frames*MAX_PACKETS; i++) {
 			struct packet *p = dma_region_i(&video->packet_buf, struct packet, video->current_packet);
 			/* make sure we are seeing the latest changes to p */
 			dma_region_sync_for_cpu(&video->packet_buf,
 						(unsigned long) p - (unsigned long) video->packet_buf.kvirt,
 						sizeof(struct packet));
 			packet_length = le16_to_cpu(p->data_length);
-			packet_time   = le16_to_cpu(p->timestamp);
-			irq_printk("received packet %02d, timestamp=%04x, length=%04x, sof=%02x%02x\n", video->current_packet,
-				   packet_time, packet_length,
-				   p->data[0], p->data[1]);
 			/* get the descriptor based on packet_buffer cursor */
 			f = video->frames[video->current_packet / MAX_PACKETS];
 			block = &(f->descriptor_pool[video->current_packet % MAX_PACKETS]);
 			xferstatus = le32_to_cpu(block->u.in.il.q[3]) >> 16;
 			xferstatus &= 0x1F;
 			irq_printk("ir_tasklet_func: xferStatus/resCount [%d] = 0x%08x\n", i, le32_to_cpu(block->u.in.il.q[3]) );
 			/* get the current frame */
 			f = video->frames[video->active_frame];
 			/* exclude empty packet */
 			if (packet_length > 8 && xferstatus == 0x11) {
 				/* check for start of frame */
 				/* DRD> Changed to check section type ([0]>>5==0)
 				   and dif sequence ([1]>>4==0) */
 				sof = ( (p->data[0] >> 5) == 0 && (p->data[1] >> 4) == 0);
 				dbc = (int) (p->cip_h1 >> 24);
 				if ( video->continuity_counter != -1 && dbc > ((video->continuity_counter + 1) % 256) )
 				{
 					printk(KERN_WARNING "dv1394: discontinuity detected, dropping all frames\n" );
 					video->dropped_frames += video->n_clear_frames + 1;
 					video->first_frame = 0;
 					video->n_clear_frames = 0;
 					video->first_clear_frame = -1;
 				}
 				video->continuity_counter = dbc;
 				if (!video->first_frame) {
 					if (sof) {
 						video->first_frame = 1;
 					}
 				} else if (sof) {
 					/* close current frame */
 					frame_reset(f);  /* f->state = STATE_CLEAR */
 					video->n_clear_frames++;
 					if (video->n_clear_frames > video->n_frames) {
 						video->dropped_frames++;
 						printk(KERN_WARNING "dv1394: dropped a frame during reception\n" );
 						video->n_clear_frames = video->n_frames-1;
 						video->first_clear_frame = (video->first_clear_frame + 1) % video->n_frames;
 					}
 					if (video->first_clear_frame == -1)
 						video->first_clear_frame = video->active_frame;
 					/* get the next frame */
 					video->active_frame = (video->active_frame + 1) % video->n_frames;
 					f = video->frames[video->active_frame];
 					irq_printk("   frame received, active_frame = %d, n_clear_frames = %d, first_clear_frame = %d\n",
 						   video->active_frame, video->n_clear_frames, video->first_clear_frame);
 				}
 				if (video->first_frame) {
 					if (sof) {
 						/* open next frame */
 						f->state = FRAME_READY;
 					}
 					/* copy to buffer */
 					if (f->n_packets > (video->frame_size / 480)) {
 						printk(KERN_ERR "frame buffer overflow during receive\n");
 					}
 					frame_put_packet(f, p);
 				} /* first_frame */
 			}
 			/* stop, end of ready packets */
 			else if (xferstatus == 0) {
 				break;
 			}
 			/* reset xferStatus & resCount */
 			block->u.in.il.q[3] = cpu_to_le32(512);
 			/* terminate dma chain at this (next) packet */
 			next_i = video->current_packet;
 			f = video->frames[next_i / MAX_PACKETS];
 			next = &(f->descriptor_pool[next_i % MAX_PACKETS]);
 			next_dma = ((unsigned long) block - (unsigned long) f->descriptor_pool) + f->descriptor_pool_dma;
 			next->u.in.il.q[0] |= cpu_to_le32(3 << 20); /* enable interrupt */
 			next->u.in.il.q[2] = cpu_to_le32(0); /* disable branch */
 			/* link previous to next */
 			prev_i = (next_i == 0) ? (MAX_PACKETS * video->n_frames - 1) : (next_i - 1);
 			f = video->frames[prev_i / MAX_PACKETS];
 			prev = &(f->descriptor_pool[prev_i % MAX_PACKETS]);
 			if (prev_i % (MAX_PACKETS/2)) {
 				prev->u.in.il.q[0] &= ~cpu_to_le32(3 << 20); /* no interrupt */
 			} else {
 				prev->u.in.il.q[0] |= cpu_to_le32(3 << 20); /* enable interrupt */
 			}
 			prev->u.in.il.q[2] = cpu_to_le32(next_dma | 1); /* set Z=1 */
 			wmb();
 			/* wake up DMA in case it fell asleep */
 			reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, (1 << 12));
 			/* advance packet_buffer cursor */
 			video->current_packet = (video->current_packet + 1) % (MAX_PACKETS * video->n_frames);
 		} /* for all packets */
 		wake = 1; /* why the hell not? */
 	} /* receive interrupt */
 	if (wake) {
 		kill_fasync(&video->fasync, SIGIO, POLL_IN);
 		/* wake readers/writers/ioctl'ers */
 		wake_up_interruptible(&video->waitq);
 	}
 out:
 	spin_unlock(&video->spinlock);
 }
 static struct cdev dv1394_cdev;
 static const struct file_operations dv1394_fops=
 {
 	.owner =	THIS_MODULE,
 	.poll =		dv1394_poll,
 	.unlocked_ioctl = dv1394_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = dv1394_compat_ioctl,
 #endif
 	.mmap =		dv1394_mmap,
 	.open =		dv1394_open,
 	.write =	dv1394_write,
 	.read =		dv1394_read,
 	.release =	dv1394_release,
 	.fasync =	dv1394_fasync,
 	.llseek =	no_llseek,
 };
 /*** HOTPLUG STUFF **********************************************************/
 /*
  * Export information about protocols/devices supported by this driver.
  */
 #ifdef MODULE
 static const struct ieee1394_device_id dv1394_id_table[] = {
 	{
 		.match_flags	= IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
 		.specifier_id	= AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
 		.version	= AVC_SW_VERSION_ENTRY & 0xffffff
 	},
 	{ }
 };
 MODULE_DEVICE_TABLE(ieee1394, dv1394_id_table);
 #endif /* MODULE */
 static struct hpsb_protocol_driver dv1394_driver = {
 	.name = "dv1394",
 };
 /*** IEEE1394 HPSB CALLBACKS ***********************************************/
 static int dv1394_init(struct ti_ohci *ohci, enum pal_or_ntsc format, enum modes mode)
 {
 	struct video_card *video;
 	unsigned long flags;
 	int i;
 	video = kzalloc(sizeof(*video), GFP_KERNEL);
 	if (!video) {
 		printk(KERN_ERR "dv1394: cannot allocate video_card\n");
 		return -1;
 	}
 	video->ohci = ohci;
 	/* lower 2 bits of id indicate which of four "plugs"
 	   per host */
 	video->id = ohci->host->id << 2;
 	if (format == DV1394_NTSC)
 		video->id |= mode;
 	else
 		video->id |= 2 + mode;
 	video->ohci_it_ctx = -1;
 	video->ohci_ir_ctx = -1;
 	video->ohci_IsoXmitContextControlSet = 0;
 	video->ohci_IsoXmitContextControlClear = 0;
 	video->ohci_IsoXmitCommandPtr = 0;
 	video->ohci_IsoRcvContextControlSet = 0;
 	video->ohci_IsoRcvContextControlClear = 0;
 	video->ohci_IsoRcvCommandPtr = 0;
 	video->ohci_IsoRcvContextMatch = 0;
 	video->n_frames = 0; /* flag that video is not initialized */
 	video->channel = 63; /* default to broadcast channel */
 	video->active_frame = -1;
 	/* initialize the following */
 	video->pal_or_ntsc = format;
 	video->cip_n = 0; /* 0 = use builtin default */
 	video->cip_d = 0;
 	video->syt_offset = 0;
 	video->mode = mode;
 	for (i = 0; i < DV1394_MAX_FRAMES; i++)
 		video->frames[i] = NULL;
 	dma_region_init(&video->dv_buf);
 	video->dv_buf_size = 0;
 	dma_region_init(&video->packet_buf);
 	video->packet_buf_size = 0;
 	clear_bit(0, &video->open);
 	spin_lock_init(&video->spinlock);
 	video->dma_running = 0;
 	mutex_init(&video->mtx);
 	init_waitqueue_head(&video->waitq);
 	video->fasync = NULL;
 	spin_lock_irqsave(&dv1394_cards_lock, flags);
 	INIT_LIST_HEAD(&video->list);
 	list_add_tail(&video->list, &dv1394_cards);
 	spin_unlock_irqrestore(&dv1394_cards_lock, flags);
 	debug_printk("dv1394: dv1394_init() OK on ID %d\n", video->id);
 	return 0;
 }
 static void dv1394_remove_host(struct hpsb_host *host)
 {
 	struct video_card *video, *tmp_video;
 	unsigned long flags;
 	int found_ohci_card = 0;
 	do {
 		video = NULL;
 		spin_lock_irqsave(&dv1394_cards_lock, flags);
 		list_for_each_entry(tmp_video, &dv1394_cards, list) {
 			if ((tmp_video->id >> 2) == host->id) {
 				list_del(&tmp_video->list);
 				video = tmp_video;
 				found_ohci_card = 1;
 				break;
 			}
 		}
 		spin_unlock_irqrestore(&dv1394_cards_lock, flags);
 		if (video) {
 			do_dv1394_shutdown(video, 1);
 			kfree(video);
 		}
 	} while (video);
 	if (found_ohci_card)
 		device_destroy(hpsb_protocol_class, MKDEV(IEEE1394_MAJOR,
 			   IEEE1394_MINOR_BLOCK_DV1394 * 16 + (host->id << 2)));
 }
 static void dv1394_add_host(struct hpsb_host *host)
 {
 	struct ti_ohci *ohci;
 	int id = host->id;
 	/* We only work with the OHCI-1394 driver */
 	if (strcmp(host->driver->name, OHCI1394_DRIVER_NAME))
 		return;
 	ohci = (struct ti_ohci *)host->hostdata;
 	device_create(hpsb_protocol_class, NULL,
 		      MKDEV(IEEE1394_MAJOR,
 			    IEEE1394_MINOR_BLOCK_DV1394 * 16 + (id<<2)),
 		      NULL, "dv1394-%d", id);
 	dv1394_init(ohci, DV1394_NTSC, MODE_RECEIVE);
 	dv1394_init(ohci, DV1394_NTSC, MODE_TRANSMIT);
 	dv1394_init(ohci, DV1394_PAL, MODE_RECEIVE);
 	dv1394_init(ohci, DV1394_PAL, MODE_TRANSMIT);
 }
 /* Bus reset handler. In the event of a bus reset, we may need to
    re-start the DMA contexts - otherwise the user program would
    end up waiting forever.
 */
 static void dv1394_host_reset(struct hpsb_host *host)
 {
-	struct ti_ohci *ohci;
 	struct video_card *video = NULL, *tmp_vid;
 	unsigned long flags;
 	/* We only work with the OHCI-1394 driver */
 	if (strcmp(host->driver->name, OHCI1394_DRIVER_NAME))
 		return;
-	ohci = (struct ti_ohci *)host->hostdata;
 	/* find the corresponding video_cards */
 	spin_lock_irqsave(&dv1394_cards_lock, flags);
 	list_for_each_entry(tmp_vid, &dv1394_cards, list) {
 		if ((tmp_vid->id >> 2) == host->id) {
 			video = tmp_vid;
 			break;
 		}
 	}
 	spin_unlock_irqrestore(&dv1394_cards_lock, flags);
 	if (!video)
 		return;
 	spin_lock_irqsave(&video->spinlock, flags);
 	if (!video->dma_running)
 		goto out;
 	/* check IT context */
 	if (video->ohci_it_ctx != -1) {
 		u32 ctx;
 		ctx = reg_read(video->ohci, video->ohci_IsoXmitContextControlSet);
 		/* if (RUN but not ACTIVE) */
 		if ( (ctx & (1<<15)) &&
 		    !(ctx & (1<<10)) ) {
 			debug_printk("dv1394: IT context stopped due to bus reset; waking it up\n");
 			/* to be safe, assume a frame has been dropped. User-space programs
 			   should handle this condition like an underflow. */
 			video->dropped_frames++;
 			/* for some reason you must clear, then re-set the RUN bit to restart DMA */
 			/* clear RUN */
 			reg_write(video->ohci, video->ohci_IsoXmitContextControlClear, (1 << 15));
 			flush_pci_write(video->ohci);
 			/* set RUN */
 			reg_write(video->ohci, video->ohci_IsoXmitContextControlSet, (1 << 15));
 			flush_pci_write(video->ohci);
 			/* set the WAKE bit (just in case; this isn't strictly necessary) */
 			reg_write(video->ohci, video->ohci_IsoXmitContextControlSet, (1 << 12));
 			flush_pci_write(video->ohci);
 			irq_printk("dv1394: AFTER IT restart ctx 0x%08x ptr 0x%08x\n",
 				   reg_read(video->ohci, video->ohci_IsoXmitContextControlSet),
 				   reg_read(video->ohci, video->ohci_IsoXmitCommandPtr));
 		}
 	}
 	/* check IR context */
 	if (video->ohci_ir_ctx != -1) {
 		u32 ctx;
 		ctx = reg_read(video->ohci, video->ohci_IsoRcvContextControlSet);
 		/* if (RUN but not ACTIVE) */
 		if ( (ctx & (1<<15)) &&
 		    !(ctx & (1<<10)) ) {
 			debug_printk("dv1394: IR context stopped due to bus reset; waking it up\n");
 			/* to be safe, assume a frame has been dropped. User-space programs
 			   should handle this condition like an overflow. */
 			video->dropped_frames++;
 			/* for some reason you must clear, then re-set the RUN bit to restart DMA */
 			/* XXX this doesn't work for me, I can't get IR DMA to restart :[ */
 			/* clear RUN */
 			reg_write(video->ohci, video->ohci_IsoRcvContextControlClear, (1 << 15));
 			flush_pci_write(video->ohci);
 			/* set RUN */
 			reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, (1 << 15));
 			flush_pci_write(video->ohci);
 			/* set the WAKE bit (just in case; this isn't strictly necessary) */
 			reg_write(video->ohci, video->ohci_IsoRcvContextControlSet, (1 << 12));
 			flush_pci_write(video->ohci);
 			irq_printk("dv1394: AFTER IR restart ctx 0x%08x ptr 0x%08x\n",
 				   reg_read(video->ohci, video->ohci_IsoRcvContextControlSet),
 				   reg_read(video->ohci, video->ohci_IsoRcvCommandPtr));
 		}
 	}
 out:
 	spin_unlock_irqrestore(&video->spinlock, flags);
 	/* wake readers/writers/ioctl'ers */
 	wake_up_interruptible(&video->waitq);
 }
 static struct hpsb_highlevel dv1394_highlevel = {
 	.name =		"dv1394",
 	.add_host =	dv1394_add_host,
 	.remove_host =	dv1394_remove_host,
 	.host_reset =   dv1394_host_reset,
 };
 #ifdef CONFIG_COMPAT
 #define DV1394_IOC32_INIT       _IOW('#', 0x06, struct dv1394_init32)
 #define DV1394_IOC32_GET_STATUS _IOR('#', 0x0c, struct dv1394_status32)
 struct dv1394_init32 {
 	u32 api_version;
 	u32 channel;
 	u32 n_frames;
 	u32 format;
 	u32 cip_n;
 	u32 cip_d;
 	u32 syt_offset;
 };
 struct dv1394_status32 {
 	struct dv1394_init32 init;
 	s32 active_frame;
 	u32 first_clear_frame;
 	u32 n_clear_frames;
 	u32 dropped_frames;
 };
 /* RED-PEN: this should use compat_alloc_userspace instead */
 static int handle_dv1394_init(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct dv1394_init32 dv32;
 	struct dv1394_init dv;
 	mm_segment_t old_fs;
 	int ret;
 	if (file->f_op->unlocked_ioctl != dv1394_ioctl)
 		return -EFAULT;
 	if (copy_from_user(&dv32, (void __user *)arg, sizeof(dv32)))
 		return -EFAULT;
 	dv.api_version = dv32.api_version;
 	dv.channel = dv32.channel;
 	dv.n_frames = dv32.n_frames;
 	dv.format = dv32.format;
 	dv.cip_n = (unsigned long)dv32.cip_n;
 	dv.cip_d = (unsigned long)dv32.cip_d;
 	dv.syt_offset = dv32.syt_offset;
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = dv1394_ioctl(file, DV1394_IOC_INIT, (unsigned long)&dv);
 	set_fs(old_fs);
 	return ret;
 }
 static int handle_dv1394_get_status(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct dv1394_status32 dv32;
 	struct dv1394_status dv;
 	mm_segment_t old_fs;
 	int ret;
 	if (file->f_op->unlocked_ioctl != dv1394_ioctl)
 		return -EFAULT;
 	old_fs = get_fs();
 	set_fs(KERNEL_DS);
 	ret = dv1394_ioctl(file, DV1394_IOC_GET_STATUS, (unsigned long)&dv);
 	set_fs(old_fs);
 	if (!ret) {
 		dv32.init.api_version = dv.init.api_version;
 		dv32.init.channel = dv.init.channel;
 		dv32.init.n_frames = dv.init.n_frames;
 		dv32.init.format = dv.init.format;
 		dv32.init.cip_n = (u32)dv.init.cip_n;
 		dv32.init.cip_d = (u32)dv.init.cip_d;
 		dv32.init.syt_offset = dv.init.syt_offset;
 		dv32.active_frame = dv.active_frame;
 		dv32.first_clear_frame = dv.first_clear_frame;
 		dv32.n_clear_frames = dv.n_clear_frames;
 		dv32.dropped_frames = dv.dropped_frames;
 		if (copy_to_user((struct dv1394_status32 __user *)arg, &dv32, sizeof(dv32)))
 			ret = -EFAULT;
 	}
 	return ret;
 }
 static long dv1394_compat_ioctl(struct file *file, unsigned int cmd,
 			       unsigned long arg)
 {
 	switch (cmd) {
 	case DV1394_IOC_SHUTDOWN:
 	case DV1394_IOC_SUBMIT_FRAMES:
 	case DV1394_IOC_WAIT_FRAMES:
 	case DV1394_IOC_RECEIVE_FRAMES:
 	case DV1394_IOC_START_RECEIVE:
 		return dv1394_ioctl(file, cmd, arg);
 	case DV1394_IOC32_INIT:
 		return handle_dv1394_init(file, cmd, arg);
 	case DV1394_IOC32_GET_STATUS:
 		return handle_dv1394_get_status(file, cmd, arg);
 	default:
 		return -ENOIOCTLCMD;
 	}
 }
 #endif /* CONFIG_COMPAT */
 /*** KERNEL MODULE HANDLERS ************************************************/
 MODULE_AUTHOR("Dan Maas <dmaas@dcine.com>, Dan Dennedy <dan@dennedy.org>");
 MODULE_DESCRIPTION("driver for DV input/output on OHCI board");
 MODULE_SUPPORTED_DEVICE("dv1394");
 MODULE_LICENSE("GPL");
 static void __exit dv1394_exit_module(void)
 {
 	hpsb_unregister_protocol(&dv1394_driver);
 	hpsb_unregister_highlevel(&dv1394_highlevel);
 	cdev_del(&dv1394_cdev);
 }
 static int __init dv1394_init_module(void)
 {
 	int ret;
 	cdev_init(&dv1394_cdev, &dv1394_fops);
 	dv1394_cdev.owner = THIS_MODULE;
 	ret = cdev_add(&dv1394_cdev, IEEE1394_DV1394_DEV, 16);
 	if (ret) {
 		printk(KERN_ERR "dv1394: unable to register character device\n");
 		return ret;
 	}
 	hpsb_register_highlevel(&dv1394_highlevel);
 	ret = hpsb_register_protocol(&dv1394_driver);
 	if (ret) {
 		printk(KERN_ERR "dv1394: failed to register protocol\n");
 		hpsb_unregister_highlevel(&dv1394_highlevel);
 		cdev_del(&dv1394_cdev);
 		return ret;
 	}
 	return 0;
 }
 module_init(dv1394_init_module);
 module_exit(dv1394_exit_module);

drivers/ieee1394/eth1394.c

Diff comments View file @ 5030c80

 /*
  * eth1394.c -- IPv4 driver for Linux IEEE-1394 Subsystem
  *
  * Copyright (C) 2001-2003 Ben Collins <bcollins@debian.org>
  *               2000 Bonin Franck <boninf@free.fr>
  *               2003 Steve Kinneberg <kinnebergsteve@acmsystems.com>
  *
  * Mainly based on work by Emanuel Pirker and Andreas E. Bombe
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 /*
  * This driver intends to support RFC 2734, which describes a method for
  * transporting IPv4 datagrams over IEEE-1394 serial busses.
  *
  * TODO:
  * RFC 2734 related:
  * - Add MCAP. Limited Multicast exists only to 224.0.0.1 and 224.0.0.2.
  *
  * Non-RFC 2734 related:
  * - Handle fragmented skb's coming from the networking layer.
  * - Move generic GASP reception to core 1394 code
  * - Convert kmalloc/kfree for link fragments to use kmem_cache_* instead
  * - Stability improvements
  * - Performance enhancements
  * - Consider garbage collecting old partial datagrams after X amount of time
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/workqueue.h>
 #include <linux/netdevice.h>
 #include <linux/inetdevice.h>
 #include <linux/if_arp.h>
 #include <linux/if_ether.h>
 #include <linux/ip.h>
 #include <linux/in.h>
 #include <linux/tcp.h>
 #include <linux/skbuff.h>
 #include <linux/bitops.h>
 #include <linux/ethtool.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
 #include <asm/unaligned.h>
 #include <net/arp.h>
 #include "config_roms.h"
 #include "csr1212.h"
 #include "eth1394.h"
 #include "highlevel.h"
 #include "ieee1394.h"
 #include "ieee1394_core.h"
 #include "ieee1394_hotplug.h"
 #include "ieee1394_transactions.h"
 #include "ieee1394_types.h"
 #include "iso.h"
 #include "nodemgr.h"
 #define ETH1394_PRINT_G(level, fmt, args...) \
 	printk(level "%s: " fmt, driver_name, ## args)
 #define ETH1394_PRINT(level, dev_name, fmt, args...) \
 	printk(level "%s: %s: " fmt, driver_name, dev_name, ## args)
 struct fragment_info {
 	struct list_head list;
 	int offset;
 	int len;
 };
 struct partial_datagram {
 	struct list_head list;
 	u16 dgl;
 	u16 dg_size;
 	__be16 ether_type;
 	struct sk_buff *skb;
 	char *pbuf;
 	struct list_head frag_info;
 };
 struct pdg_list {
 	struct list_head list;	/* partial datagram list per node	*/
 	unsigned int sz;	/* partial datagram list size per node	*/
 	spinlock_t lock;	/* partial datagram lock		*/
 };
 struct eth1394_host_info {
 	struct hpsb_host *host;
 	struct net_device *dev;
 };
 struct eth1394_node_ref {
 	struct unit_directory *ud;
 	struct list_head list;
 };
 struct eth1394_node_info {
 	u16 maxpayload;		/* max payload			*/
 	u8 sspd;		/* max speed			*/
 	u64 fifo;		/* FIFO address			*/
 	struct pdg_list pdg;	/* partial RX datagram lists	*/
 	int dgl;		/* outgoing datagram label	*/
 };
 static const char driver_name[] = "eth1394";
 static struct kmem_cache *packet_task_cache;
 static struct hpsb_highlevel eth1394_highlevel;
 /* Use common.lf to determine header len */
 static const int hdr_type_len[] = {
 	sizeof(struct eth1394_uf_hdr),
 	sizeof(struct eth1394_ff_hdr),
 	sizeof(struct eth1394_sf_hdr),
 	sizeof(struct eth1394_sf_hdr)
 };
 static const u16 eth1394_speedto_maxpayload[] = {
 /*     S100, S200, S400, S800, S1600, S3200 */
 	512, 1024, 2048, 4096,  4096,  4096
 };
 MODULE_AUTHOR("Ben Collins (bcollins@debian.org)");
 MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)");
 MODULE_LICENSE("GPL");
 /*
  * The max_partial_datagrams parameter is the maximum number of fragmented
  * datagrams per node that eth1394 will keep in memory.  Providing an upper
  * bound allows us to limit the amount of memory that partial datagrams
  * consume in the event that some partial datagrams are never completed.
  */
 static int max_partial_datagrams = 25;
 module_param(max_partial_datagrams, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(max_partial_datagrams,
 		 "Maximum number of partially received fragmented datagrams "
 		 "(default = 25).");
 static int ether1394_header(struct sk_buff *skb, struct net_device *dev,
 			    unsigned short type, const void *daddr,
 			    const void *saddr, unsigned len);
 static int ether1394_rebuild_header(struct sk_buff *skb);
 static int ether1394_header_parse(const struct sk_buff *skb,
 				  unsigned char *haddr);
 static int ether1394_header_cache(const struct neighbour *neigh,
 				  struct hh_cache *hh);
 static void ether1394_header_cache_update(struct hh_cache *hh,
 					  const struct net_device *dev,
 					  const unsigned char *haddr);
 static netdev_tx_t ether1394_tx(struct sk_buff *skb,
 				struct net_device *dev);
 static void ether1394_iso(struct hpsb_iso *iso);
 static const struct ethtool_ops ethtool_ops;
 static int ether1394_write(struct hpsb_host *host, int srcid, int destid,
 			   quadlet_t *data, u64 addr, size_t len, u16 flags);
 static void ether1394_add_host(struct hpsb_host *host);
 static void ether1394_remove_host(struct hpsb_host *host);
 static void ether1394_host_reset(struct hpsb_host *host);
 /* Function for incoming 1394 packets */
 static const struct hpsb_address_ops addr_ops = {
 	.write =	ether1394_write,
 };
 /* Ieee1394 highlevel driver functions */
 static struct hpsb_highlevel eth1394_highlevel = {
 	.name =		driver_name,
 	.add_host =	ether1394_add_host,
 	.remove_host =	ether1394_remove_host,
 	.host_reset =	ether1394_host_reset,
 };
 static int ether1394_recv_init(struct eth1394_priv *priv)
 {
 	unsigned int iso_buf_size;
 	/* FIXME: rawiso limits us to PAGE_SIZE */
 	iso_buf_size = min((unsigned int)PAGE_SIZE,
 			   2 * (1U << (priv->host->csr.max_rec + 1)));
 	priv->iso = hpsb_iso_recv_init(priv->host,
 				       ETHER1394_GASP_BUFFERS * iso_buf_size,
 				       ETHER1394_GASP_BUFFERS,
 				       priv->broadcast_channel,
 				       HPSB_ISO_DMA_PACKET_PER_BUFFER,
 				       1, ether1394_iso);
 	if (priv->iso == NULL) {
 		ETH1394_PRINT_G(KERN_ERR, "Failed to allocate IR context\n");
 		priv->bc_state = ETHER1394_BC_ERROR;
 		return -EAGAIN;
 	}
 	if (hpsb_iso_recv_start(priv->iso, -1, (1 << 3), -1) < 0)
 		priv->bc_state = ETHER1394_BC_STOPPED;
 	else
 		priv->bc_state = ETHER1394_BC_RUNNING;
 	return 0;
 }
 /* This is called after an "ifup" */
 static int ether1394_open(struct net_device *dev)
 {
 	struct eth1394_priv *priv = netdev_priv(dev);
 	int ret;
 	if (priv->bc_state == ETHER1394_BC_ERROR) {
 		ret = ether1394_recv_init(priv);
 		if (ret)
 			return ret;
 	}
 	netif_start_queue(dev);
 	return 0;
 }
 /* This is called after an "ifdown" */
 static int ether1394_stop(struct net_device *dev)
 {
 	/* flush priv->wake */
 	flush_scheduled_work();
 	netif_stop_queue(dev);
 	return 0;
 }
 /* FIXME: What to do if we timeout? I think a host reset is probably in order,
  * so that's what we do. Should we increment the stat counters too?  */
 static void ether1394_tx_timeout(struct net_device *dev)
 {
 	struct hpsb_host *host =
 			((struct eth1394_priv *)netdev_priv(dev))->host;
 	ETH1394_PRINT(KERN_ERR, dev->name, "Timeout, resetting host\n");
 	ether1394_host_reset(host);
 }
 static inline int ether1394_max_mtu(struct hpsb_host* host)
 {
 	return (1 << (host->csr.max_rec + 1))
 			- sizeof(union eth1394_hdr) - ETHER1394_GASP_OVERHEAD;
 }
 static int ether1394_change_mtu(struct net_device *dev, int new_mtu)
 {
 	int max_mtu;
 	if (new_mtu < 68)
 		return -EINVAL;
 	max_mtu = ether1394_max_mtu(
 			((struct eth1394_priv *)netdev_priv(dev))->host);
 	if (new_mtu > max_mtu) {
 		ETH1394_PRINT(KERN_INFO, dev->name,
 			      "Local node constrains MTU to %d\n", max_mtu);
 		return -ERANGE;
 	}
 	dev->mtu = new_mtu;
 	return 0;
 }
 static void purge_partial_datagram(struct list_head *old)
 {
 	struct partial_datagram *pd;
 	struct list_head *lh, *n;
 	struct fragment_info *fi;
 	pd = list_entry(old, struct partial_datagram, list);
 	list_for_each_safe(lh, n, &pd->frag_info) {
 		fi = list_entry(lh, struct fragment_info, list);
 		list_del(lh);
 		kfree(fi);
 	}
 	list_del(old);
 	kfree_skb(pd->skb);
 	kfree(pd);
 }
 /******************************************
  * 1394 bus activity functions
  ******************************************/
 static struct eth1394_node_ref *eth1394_find_node(struct list_head *inl,
 						  struct unit_directory *ud)
 {
 	struct eth1394_node_ref *node;
 	list_for_each_entry(node, inl, list)
 		if (node->ud == ud)
 			return node;
 	return NULL;
 }
 static struct eth1394_node_ref *eth1394_find_node_guid(struct list_head *inl,
 						       u64 guid)
 {
 	struct eth1394_node_ref *node;
 	list_for_each_entry(node, inl, list)
 		if (node->ud->ne->guid == guid)
 			return node;
 	return NULL;
 }
 static struct eth1394_node_ref *eth1394_find_node_nodeid(struct list_head *inl,
 							 nodeid_t nodeid)
 {
 	struct eth1394_node_ref *node;
 	list_for_each_entry(node, inl, list)
 		if (node->ud->ne->nodeid == nodeid)
 			return node;
 	return NULL;
 }
 static int eth1394_new_node(struct eth1394_host_info *hi,
 			    struct unit_directory *ud)
 {
 	struct eth1394_priv *priv;
 	struct eth1394_node_ref *new_node;
 	struct eth1394_node_info *node_info;
 	new_node = kmalloc(sizeof(*new_node), GFP_KERNEL);
 	if (!new_node)
 		return -ENOMEM;
 	node_info = kmalloc(sizeof(*node_info), GFP_KERNEL);
 	if (!node_info) {
 		kfree(new_node);
 		return -ENOMEM;
 	}
 	spin_lock_init(&node_info->pdg.lock);
 	INIT_LIST_HEAD(&node_info->pdg.list);
 	node_info->pdg.sz = 0;
 	node_info->fifo = CSR1212_INVALID_ADDR_SPACE;
 	dev_set_drvdata(&ud->device, node_info);
 	new_node->ud = ud;
 	priv = netdev_priv(hi->dev);
 	list_add_tail(&new_node->list, &priv->ip_node_list);
 	return 0;
 }
 static int eth1394_probe(struct device *dev)
 {
 	struct unit_directory *ud;
 	struct eth1394_host_info *hi;
 	ud = container_of(dev, struct unit_directory, device);
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
 	if (!hi)
 		return -ENOENT;
 	return eth1394_new_node(hi, ud);
 }
 static int eth1394_remove(struct device *dev)
 {
 	struct unit_directory *ud;
 	struct eth1394_host_info *hi;
 	struct eth1394_priv *priv;
 	struct eth1394_node_ref *old_node;
 	struct eth1394_node_info *node_info;
 	struct list_head *lh, *n;
 	unsigned long flags;
 	ud = container_of(dev, struct unit_directory, device);
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
 	if (!hi)
 		return -ENOENT;
 	priv = netdev_priv(hi->dev);
 	old_node = eth1394_find_node(&priv->ip_node_list, ud);
 	if (!old_node)
 		return 0;
 	list_del(&old_node->list);
 	kfree(old_node);
 	node_info = dev_get_drvdata(&ud->device);
 	spin_lock_irqsave(&node_info->pdg.lock, flags);
 	/* The partial datagram list should be empty, but we'll just
 	 * make sure anyway... */
 	list_for_each_safe(lh, n, &node_info->pdg.list)
 		purge_partial_datagram(lh);
 	spin_unlock_irqrestore(&node_info->pdg.lock, flags);
 	kfree(node_info);
 	dev_set_drvdata(&ud->device, NULL);
 	return 0;
 }
 static int eth1394_update(struct unit_directory *ud)
 {
 	struct eth1394_host_info *hi;
 	struct eth1394_priv *priv;
 	struct eth1394_node_ref *node;
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
 	if (!hi)
 		return -ENOENT;
 	priv = netdev_priv(hi->dev);
 	node = eth1394_find_node(&priv->ip_node_list, ud);
 	if (node)
 		return 0;
 	return eth1394_new_node(hi, ud);
 }
 static const struct ieee1394_device_id eth1394_id_table[] = {
 	{
 		.match_flags = (IEEE1394_MATCH_SPECIFIER_ID |
 				IEEE1394_MATCH_VERSION),
 		.specifier_id =	ETHER1394_GASP_SPECIFIER_ID,
 		.version = ETHER1394_GASP_VERSION,
 	},
 	{}
 };
 MODULE_DEVICE_TABLE(ieee1394, eth1394_id_table);
 static struct hpsb_protocol_driver eth1394_proto_driver = {
 	.name		= driver_name,
 	.id_table	= eth1394_id_table,
 	.update		= eth1394_update,
 	.driver		= {
 		.probe		= eth1394_probe,
 		.remove		= eth1394_remove,
 	},
 };
 static void ether1394_reset_priv(struct net_device *dev, int set_mtu)
 {
 	unsigned long flags;
 	int i;
 	struct eth1394_priv *priv = netdev_priv(dev);
 	struct hpsb_host *host = priv->host;
 	u64 guid = get_unaligned((u64 *)&(host->csr.rom->bus_info_data[3]));
 	int max_speed = IEEE1394_SPEED_MAX;
 	spin_lock_irqsave(&priv->lock, flags);
 	memset(priv->ud_list, 0, sizeof(priv->ud_list));
 	priv->bc_maxpayload = 512;
 	/* Determine speed limit */
 	/* FIXME: This is broken for nodes with link speed < PHY speed,
 	 * and it is suboptimal for S200B...S800B hardware.
 	 * The result of nodemgr's speed probe should be used somehow. */
 	for (i = 0; i < host->node_count; i++) {
 		/* take care of S100B...S400B PHY ports */
 		if (host->speed[i] == SELFID_SPEED_UNKNOWN) {
 			max_speed = IEEE1394_SPEED_100;
 			break;
 		}
 		if (max_speed > host->speed[i])
 			max_speed = host->speed[i];
 	}
 	priv->bc_sspd = max_speed;
 	if (set_mtu) {
 		/* Use the RFC 2734 default 1500 octets or the maximum payload
 		 * as initial MTU */
 		dev->mtu = min(1500, ether1394_max_mtu(host));
 		/* Set our hardware address while we're at it */
 		memcpy(dev->dev_addr, &guid, sizeof(u64));
 		memset(dev->broadcast, 0xff, sizeof(u64));
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
 }
 static const struct header_ops ether1394_header_ops = {
 	.create		= ether1394_header,
 	.rebuild	= ether1394_rebuild_header,
 	.cache  	= ether1394_header_cache,
 	.cache_update	= ether1394_header_cache_update,
 	.parse		= ether1394_header_parse,
 };
 static const struct net_device_ops ether1394_netdev_ops = {
 	.ndo_open	= ether1394_open,
 	.ndo_stop	= ether1394_stop,
 	.ndo_start_xmit	= ether1394_tx,
 	.ndo_tx_timeout	= ether1394_tx_timeout,
 	.ndo_change_mtu	= ether1394_change_mtu,
 };
 static void ether1394_init_dev(struct net_device *dev)
 {
 	dev->header_ops		= &ether1394_header_ops;
 	dev->netdev_ops		= &ether1394_netdev_ops;
 	SET_ETHTOOL_OPS(dev, &ethtool_ops);
 	dev->watchdog_timeo	= ETHER1394_TIMEOUT;
 	dev->flags		= IFF_BROADCAST | IFF_MULTICAST;
 	dev->features		= NETIF_F_HIGHDMA;
 	dev->addr_len		= ETH1394_ALEN;
 	dev->hard_header_len 	= ETH1394_HLEN;
 	dev->type		= ARPHRD_IEEE1394;
 	/* FIXME: This value was copied from ether_setup(). Is it too much? */
 	dev->tx_queue_len	= 1000;
 }
 /*
  * Wake the queue up after commonly encountered transmit failure conditions are
  * hopefully over.  Currently only tlabel exhaustion is accounted for.
  */
 static void ether1394_wake_queue(struct work_struct *work)
 {
 	struct eth1394_priv *priv;
 	struct hpsb_packet *packet;
 	priv = container_of(work, struct eth1394_priv, wake);
 	packet = hpsb_alloc_packet(0);
 	/* This is really bad, but unjam the queue anyway. */
 	if (!packet)
 		goto out;
 	packet->host = priv->host;
 	packet->node_id = priv->wake_node;
 	/*
 	 * A transaction label is all we really want.  If we get one, it almost
 	 * always means we can get a lot more because the ieee1394 core recycled
 	 * a whole batch of tlabels, at last.
 	 */
 	if (hpsb_get_tlabel(packet) == 0)
 		hpsb_free_tlabel(packet);
 	hpsb_free_packet(packet);
 out:
 	netif_wake_queue(priv->wake_dev);
 }
 /*
  * This function is called every time a card is found. It is generally called
  * when the module is installed. This is where we add all of our ethernet
  * devices. One for each host.
  */
 static void ether1394_add_host(struct hpsb_host *host)
 {
 	struct eth1394_host_info *hi = NULL;
 	struct net_device *dev = NULL;
 	struct eth1394_priv *priv;
 	u64 fifo_addr;
 	if (hpsb_config_rom_ip1394_add(host) != 0) {
 		ETH1394_PRINT_G(KERN_ERR, "Can't add IP-over-1394 ROM entry\n");
 		return;
 	}
 	fifo_addr = hpsb_allocate_and_register_addrspace(
 			&eth1394_highlevel, host, &addr_ops,
 			ETHER1394_REGION_ADDR_LEN, ETHER1394_REGION_ADDR_LEN,
 			CSR1212_INVALID_ADDR_SPACE, CSR1212_INVALID_ADDR_SPACE);
 	if (fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
 		ETH1394_PRINT_G(KERN_ERR, "Cannot register CSR space\n");
 		hpsb_config_rom_ip1394_remove(host);
 		return;
 	}
 	dev = alloc_netdev(sizeof(*priv), "eth%d", ether1394_init_dev);
 	if (dev == NULL) {
 		ETH1394_PRINT_G(KERN_ERR, "Out of memory\n");
 		goto out;
 	}
 	SET_NETDEV_DEV(dev, &host->device);
 	priv = netdev_priv(dev);
 	INIT_LIST_HEAD(&priv->ip_node_list);
 	spin_lock_init(&priv->lock);
 	priv->host = host;
 	priv->local_fifo = fifo_addr;
 	INIT_WORK(&priv->wake, ether1394_wake_queue);
 	priv->wake_dev = dev;
 	hi = hpsb_create_hostinfo(&eth1394_highlevel, host, sizeof(*hi));
 	if (hi == NULL) {
 		ETH1394_PRINT_G(KERN_ERR, "Out of memory\n");
 		goto out;
 	}
 	ether1394_reset_priv(dev, 1);
 	if (register_netdev(dev)) {
 		ETH1394_PRINT_G(KERN_ERR, "Cannot register the driver\n");
 		goto out;
 	}
 	ETH1394_PRINT(KERN_INFO, dev->name, "IPv4 over IEEE 1394 (fw-host%d)\n",
 		      host->id);
 	hi->host = host;
 	hi->dev = dev;
 	/* Ignore validity in hopes that it will be set in the future.  It'll
 	 * be checked when the eth device is opened. */
 	priv->broadcast_channel = host->csr.broadcast_channel & 0x3f;
 	ether1394_recv_init(priv);
 	return;
 out:
 	if (dev)
 		free_netdev(dev);
 	if (hi)
 		hpsb_destroy_hostinfo(&eth1394_highlevel, host);
 	hpsb_unregister_addrspace(&eth1394_highlevel, host, fifo_addr);
 	hpsb_config_rom_ip1394_remove(host);
 }
 /* Remove a card from our list */
 static void ether1394_remove_host(struct hpsb_host *host)
 {
 	struct eth1394_host_info *hi;
 	struct eth1394_priv *priv;
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
 	if (!hi)
 		return;
 	priv = netdev_priv(hi->dev);
 	hpsb_unregister_addrspace(&eth1394_highlevel, host, priv->local_fifo);
 	hpsb_config_rom_ip1394_remove(host);
 	if (priv->iso)
 		hpsb_iso_shutdown(priv->iso);
 	unregister_netdev(hi->dev);
 	free_netdev(hi->dev);
 }
 /* A bus reset happened */
 static void ether1394_host_reset(struct hpsb_host *host)
 {
 	struct eth1394_host_info *hi;
 	struct eth1394_priv *priv;
 	struct net_device *dev;
 	struct list_head *lh, *n;
 	struct eth1394_node_ref *node;
 	struct eth1394_node_info *node_info;
 	unsigned long flags;
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
 	/* This can happen for hosts that we don't use */
 	if (!hi)
 		return;
 	dev = hi->dev;
 	priv = netdev_priv(dev);
 	/* Reset our private host data, but not our MTU */
 	netif_stop_queue(dev);
 	ether1394_reset_priv(dev, 0);
 	list_for_each_entry(node, &priv->ip_node_list, list) {
 		node_info = dev_get_drvdata(&node->ud->device);
 		spin_lock_irqsave(&node_info->pdg.lock, flags);
 		list_for_each_safe(lh, n, &node_info->pdg.list)
 			purge_partial_datagram(lh);
 		INIT_LIST_HEAD(&(node_info->pdg.list));
 		node_info->pdg.sz = 0;
 		spin_unlock_irqrestore(&node_info->pdg.lock, flags);
 	}
 	netif_wake_queue(dev);
 }
 /******************************************
  * HW Header net device functions
  ******************************************/
 /* These functions have been adapted from net/ethernet/eth.c */
 /* Create a fake MAC header for an arbitrary protocol layer.
  * saddr=NULL means use device source address
  * daddr=NULL means leave destination address (eg unresolved arp). */
 static int ether1394_header(struct sk_buff *skb, struct net_device *dev,
 			    unsigned short type, const void *daddr,
 			    const void *saddr, unsigned len)
 {
 	struct eth1394hdr *eth =
 			(struct eth1394hdr *)skb_push(skb, ETH1394_HLEN);
 	eth->h_proto = htons(type);
 	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {
 		memset(eth->h_dest, 0, dev->addr_len);
 		return dev->hard_header_len;
 	}
 	if (daddr) {
 		memcpy(eth->h_dest, daddr, dev->addr_len);
 		return dev->hard_header_len;
 	}
 	return -dev->hard_header_len;
 }
 /* Rebuild the faked MAC header. This is called after an ARP
  * (or in future other address resolution) has completed on this
  * sk_buff. We now let ARP fill in the other fields.
  *
  * This routine CANNOT use cached dst->neigh!
  * Really, it is used only when dst->neigh is wrong.
  */
 static int ether1394_rebuild_header(struct sk_buff *skb)
 {
 	struct eth1394hdr *eth = (struct eth1394hdr *)skb->data;
 	if (eth->h_proto == htons(ETH_P_IP))
 		return arp_find((unsigned char *)&eth->h_dest, skb);
 	ETH1394_PRINT(KERN_DEBUG, skb->dev->name,
 		      "unable to resolve type %04x addresses\n",
 		      ntohs(eth->h_proto));
 	return 0;
 }
 static int ether1394_header_parse(const struct sk_buff *skb,
 				  unsigned char *haddr)
 {
 	memcpy(haddr, skb->dev->dev_addr, ETH1394_ALEN);
 	return ETH1394_ALEN;
 }
 static int ether1394_header_cache(const struct neighbour *neigh,
 				  struct hh_cache *hh)
 {
 	__be16 type = hh->hh_type;
 	struct net_device *dev = neigh->dev;
 	struct eth1394hdr *eth =
 		(struct eth1394hdr *)((u8 *)hh->hh_data + 16 - ETH1394_HLEN);
 	if (type == htons(ETH_P_802_3))
 		return -1;
 	eth->h_proto = type;
 	memcpy(eth->h_dest, neigh->ha, dev->addr_len);
 	hh->hh_len = ETH1394_HLEN;
 	return 0;
 }
 /* Called by Address Resolution module to notify changes in address. */
 static void ether1394_header_cache_update(struct hh_cache *hh,
 					  const struct net_device *dev,
 					  const unsigned char * haddr)
 {
 	memcpy((u8 *)hh->hh_data + 16 - ETH1394_HLEN, haddr, dev->addr_len);
 }
 /******************************************
  * Datagram reception code
  ******************************************/
 /* Copied from net/ethernet/eth.c */
 static __be16 ether1394_type_trans(struct sk_buff *skb, struct net_device *dev)
 {
 	struct eth1394hdr *eth;
 	unsigned char *rawp;
 	skb_reset_mac_header(skb);
 	skb_pull(skb, ETH1394_HLEN);
 	eth = eth1394_hdr(skb);
 	if (*eth->h_dest & 1) {
 		if (memcmp(eth->h_dest, dev->broadcast, dev->addr_len) == 0)
 			skb->pkt_type = PACKET_BROADCAST;
 #if 0
 		else
 			skb->pkt_type = PACKET_MULTICAST;
 #endif
 	} else {
 		if (memcmp(eth->h_dest, dev->dev_addr, dev->addr_len))
 			skb->pkt_type = PACKET_OTHERHOST;
 	}
 	if (ntohs(eth->h_proto) >= 1536)
 		return eth->h_proto;
 	rawp = skb->data;
 	if (*(unsigned short *)rawp == 0xFFFF)
 		return htons(ETH_P_802_3);
 	return htons(ETH_P_802_2);
 }
 /* Parse an encapsulated IP1394 header into an ethernet frame packet.
  * We also perform ARP translation here, if need be.  */
 static __be16 ether1394_parse_encap(struct sk_buff *skb, struct net_device *dev,
 				 nodeid_t srcid, nodeid_t destid,
 				 __be16 ether_type)
 {
 	struct eth1394_priv *priv = netdev_priv(dev);
 	__be64 dest_hw;
 	__be16 ret = 0;
 	/* Setup our hw addresses. We use these to build the ethernet header. */
 	if (destid == (LOCAL_BUS | ALL_NODES))
 		dest_hw = ~cpu_to_be64(0);  /* broadcast */
 	else
 		dest_hw = cpu_to_be64((u64)priv->host->csr.guid_hi << 32 |
 				      priv->host->csr.guid_lo);
 	/* If this is an ARP packet, convert it. First, we want to make
 	 * use of some of the fields, since they tell us a little bit
 	 * about the sending machine.  */
 	if (ether_type == htons(ETH_P_ARP)) {
 		struct eth1394_arp *arp1394 = (struct eth1394_arp *)skb->data;
 		struct arphdr *arp = (struct arphdr *)skb->data;
 		unsigned char *arp_ptr = (unsigned char *)(arp + 1);
 		u64 fifo_addr = (u64)ntohs(arp1394->fifo_hi) << 32 |
 					   ntohl(arp1394->fifo_lo);
 		u8 max_rec = min(priv->host->csr.max_rec,
 				 (u8)(arp1394->max_rec));
 		int sspd = arp1394->sspd;
 		u16 maxpayload;
 		struct eth1394_node_ref *node;
 		struct eth1394_node_info *node_info;
 		__be64 guid;
 		/* Sanity check. MacOSX seems to be sending us 131 in this
 		 * field (atleast on my Panther G5). Not sure why. */
 		if (sspd > 5 || sspd < 0)
 			sspd = 0;
 		maxpayload = min(eth1394_speedto_maxpayload[sspd],
 				 (u16)(1 << (max_rec + 1)));
 		guid = get_unaligned(&arp1394->s_uniq_id);
 		node = eth1394_find_node_guid(&priv->ip_node_list,
 					      be64_to_cpu(guid));
 		if (!node)
 			return cpu_to_be16(0);
 		node_info = dev_get_drvdata(&node->ud->device);
 		/* Update our speed/payload/fifo_offset table */
 		node_info->maxpayload =	maxpayload;
 		node_info->sspd =	sspd;
 		node_info->fifo =	fifo_addr;
 		/* Now that we're done with the 1394 specific stuff, we'll
 		 * need to alter some of the data.  Believe it or not, all
 		 * that needs to be done is sender_IP_address needs to be
 		 * moved, the destination hardware address get stuffed
 		 * in and the hardware address length set to 8.
 		 *
 		 * IMPORTANT: The code below overwrites 1394 specific data
 		 * needed above so keep the munging of the data for the
 		 * higher level IP stack last. */
 		arp->ar_hln = 8;
 		arp_ptr += arp->ar_hln;		/* skip over sender unique id */
 		*(u32 *)arp_ptr = arp1394->sip;	/* move sender IP addr */
 		arp_ptr += arp->ar_pln;		/* skip over sender IP addr */
 		if (arp->ar_op == htons(ARPOP_REQUEST))
 			memset(arp_ptr, 0, sizeof(u64));
 		else
 			memcpy(arp_ptr, dev->dev_addr, sizeof(u64));
 	}
 	/* Now add the ethernet header. */
 	if (dev_hard_header(skb, dev, ntohs(ether_type), &dest_hw, NULL,
 			    skb->len) >= 0)
 		ret = ether1394_type_trans(skb, dev);
 	return ret;
 }
 static int fragment_overlap(struct list_head *frag_list, int offset, int len)
 {
 	struct fragment_info *fi;
 	int end = offset + len;
 	list_for_each_entry(fi, frag_list, list)
 		if (offset < fi->offset + fi->len && end > fi->offset)
 			return 1;
 	return 0;
 }
 static struct list_head *find_partial_datagram(struct list_head *pdgl, int dgl)
 {
 	struct partial_datagram *pd;
 	list_for_each_entry(pd, pdgl, list)
 		if (pd->dgl == dgl)
 			return &pd->list;
 	return NULL;
 }
 /* Assumes that new fragment does not overlap any existing fragments */
 static int new_fragment(struct list_head *frag_info, int offset, int len)
 {
 	struct list_head *lh;
 	struct fragment_info *fi, *fi2, *new;
 	list_for_each(lh, frag_info) {
 		fi = list_entry(lh, struct fragment_info, list);
 		if (fi->offset + fi->len == offset) {
 			/* The new fragment can be tacked on to the end */
 			fi->len += len;
 			/* Did the new fragment plug a hole? */
 			fi2 = list_entry(lh->next, struct fragment_info, list);
 			if (fi->offset + fi->len == fi2->offset) {
 				/* glue fragments together */
 				fi->len += fi2->len;
 				list_del(lh->next);
 				kfree(fi2);
 			}
 			return 0;
 		} else if (offset + len == fi->offset) {
 			/* The new fragment can be tacked on to the beginning */
 			fi->offset = offset;
 			fi->len += len;
 			/* Did the new fragment plug a hole? */
 			fi2 = list_entry(lh->prev, struct fragment_info, list);
 			if (fi2->offset + fi2->len == fi->offset) {
 				/* glue fragments together */
 				fi2->len += fi->len;
 				list_del(lh);
 				kfree(fi);
 			}
 			return 0;
 		} else if (offset > fi->offset + fi->len) {
 			break;
 		} else if (offset + len < fi->offset) {
 			lh = lh->prev;
 			break;
 		}
 	}
 	new = kmalloc(sizeof(*new), GFP_ATOMIC);
 	if (!new)
 		return -ENOMEM;
 	new->offset = offset;
 	new->len = len;
 	list_add(&new->list, lh);
 	return 0;
 }
 static int new_partial_datagram(struct net_device *dev, struct list_head *pdgl,
 				int dgl, int dg_size, char *frag_buf,
 				int frag_off, int frag_len)
 {
 	struct partial_datagram *new;
 	new = kmalloc(sizeof(*new), GFP_ATOMIC);
 	if (!new)
 		return -ENOMEM;
 	INIT_LIST_HEAD(&new->frag_info);
 	if (new_fragment(&new->frag_info, frag_off, frag_len) < 0) {
 		kfree(new);
 		return -ENOMEM;
 	}
 	new->dgl = dgl;
 	new->dg_size = dg_size;
 	new->skb = dev_alloc_skb(dg_size + dev->hard_header_len + 15);
 	if (!new->skb) {
 		struct fragment_info *fi = list_entry(new->frag_info.next,
 						      struct fragment_info,
 						      list);
 		kfree(fi);
 		kfree(new);
 		return -ENOMEM;
 	}
 	skb_reserve(new->skb, (dev->hard_header_len + 15) & ~15);
 	new->pbuf = skb_put(new->skb, dg_size);
 	memcpy(new->pbuf + frag_off, frag_buf, frag_len);
 	list_add(&new->list, pdgl);
 	return 0;
 }
 static int update_partial_datagram(struct list_head *pdgl, struct list_head *lh,
 				   char *frag_buf, int frag_off, int frag_len)
 {
 	struct partial_datagram *pd =
 			list_entry(lh, struct partial_datagram, list);
 	if (new_fragment(&pd->frag_info, frag_off, frag_len) < 0)
 		return -ENOMEM;
 	memcpy(pd->pbuf + frag_off, frag_buf, frag_len);
 	/* Move list entry to beginnig of list so that oldest partial
 	 * datagrams percolate to the end of the list */
 	list_move(lh, pdgl);
 	return 0;
 }
 static int is_datagram_complete(struct list_head *lh, int dg_size)
 {
 	struct partial_datagram *pd;
 	struct fragment_info *fi;
 	pd = list_entry(lh, struct partial_datagram, list);
 	fi = list_entry(pd->frag_info.next, struct fragment_info, list);
 	return (fi->len == dg_size);
 }
 /* Packet reception. We convert the IP1394 encapsulation header to an
  * ethernet header, and fill it with some of our other fields. This is
  * an incoming packet from the 1394 bus.  */
 static int ether1394_data_handler(struct net_device *dev, int srcid, int destid,
 				  char *buf, int len)
 {
 	struct sk_buff *skb;
 	unsigned long flags;
 	struct eth1394_priv *priv = netdev_priv(dev);
 	union eth1394_hdr *hdr = (union eth1394_hdr *)buf;
 	__be16 ether_type = cpu_to_be16(0);  /* initialized to clear warning */
 	int hdr_len;
 	struct unit_directory *ud = priv->ud_list[NODEID_TO_NODE(srcid)];
 	struct eth1394_node_info *node_info;
 	if (!ud) {
 		struct eth1394_node_ref *node;
 		node = eth1394_find_node_nodeid(&priv->ip_node_list, srcid);
 		if (unlikely(!node)) {
 			HPSB_PRINT(KERN_ERR, "ether1394 rx: sender nodeid "
 				   "lookup failure: " NODE_BUS_FMT,
 				   NODE_BUS_ARGS(priv->host, srcid));
 			dev->stats.rx_dropped++;
 			return -1;
 		}
 		ud = node->ud;
 		priv->ud_list[NODEID_TO_NODE(srcid)] = ud;
 	}
 	node_info = dev_get_drvdata(&ud->device);
 	/* First, did we receive a fragmented or unfragmented datagram? */
 	hdr->words.word1 = ntohs(hdr->words.word1);
 	hdr_len = hdr_type_len[hdr->common.lf];
 	if (hdr->common.lf == ETH1394_HDR_LF_UF) {
 		/* An unfragmented datagram has been received by the ieee1394
 		 * bus. Build an skbuff around it so we can pass it to the
 		 * high level network layer. */
 		skb = dev_alloc_skb(len + dev->hard_header_len + 15);
 		if (unlikely(!skb)) {
 			ETH1394_PRINT_G(KERN_ERR, "Out of memory\n");
 			dev->stats.rx_dropped++;
 			return -1;
 		}
 		skb_reserve(skb, (dev->hard_header_len + 15) & ~15);
 		memcpy(skb_put(skb, len - hdr_len), buf + hdr_len,
 		       len - hdr_len);
 		ether_type = hdr->uf.ether_type;
 	} else {
 		/* A datagram fragment has been received, now the fun begins. */
 		struct list_head *pdgl, *lh;
 		struct partial_datagram *pd;
 		int fg_off;
 		int fg_len = len - hdr_len;
 		int dg_size;
 		int dgl;
 		int retval;
 		struct pdg_list *pdg = &(node_info->pdg);
 		hdr->words.word3 = ntohs(hdr->words.word3);
 		/* The 4th header word is reserved so no need to do ntohs() */
 		if (hdr->common.lf == ETH1394_HDR_LF_FF) {
 			ether_type = hdr->ff.ether_type;
 			dgl = hdr->ff.dgl;
 			dg_size = hdr->ff.dg_size + 1;
 			fg_off = 0;
 		} else {
 			hdr->words.word2 = ntohs(hdr->words.word2);
 			dgl = hdr->sf.dgl;
 			dg_size = hdr->sf.dg_size + 1;
 			fg_off = hdr->sf.fg_off;
 		}
 		spin_lock_irqsave(&pdg->lock, flags);
 		pdgl = &(pdg->list);
 		lh = find_partial_datagram(pdgl, dgl);
 		if (lh == NULL) {
 			while (pdg->sz >= max_partial_datagrams) {
 				/* remove the oldest */
 				purge_partial_datagram(pdgl->prev);
 				pdg->sz--;
 			}
 			retval = new_partial_datagram(dev, pdgl, dgl, dg_size,
 						      buf + hdr_len, fg_off,
 						      fg_len);
 			if (retval < 0) {
 				spin_unlock_irqrestore(&pdg->lock, flags);
 				goto bad_proto;
 			}
 			pdg->sz++;
 			lh = find_partial_datagram(pdgl, dgl);
 		} else {
 			pd = list_entry(lh, struct partial_datagram, list);
 			if (fragment_overlap(&pd->frag_info, fg_off, fg_len)) {
 				/* Overlapping fragments, obliterate old
 				 * datagram and start new one. */
 				purge_partial_datagram(lh);
 				retval = new_partial_datagram(dev, pdgl, dgl,
 							      dg_size,
 							      buf + hdr_len,
 							      fg_off, fg_len);
 				if (retval < 0) {
 					pdg->sz--;
 					spin_unlock_irqrestore(&pdg->lock, flags);
 					goto bad_proto;
 				}
 			} else {
 				retval = update_partial_datagram(pdgl, lh,
 								 buf + hdr_len,
 								 fg_off, fg_len);
 				if (retval < 0) {
 					/* Couldn't save off fragment anyway
 					 * so might as well obliterate the
 					 * datagram now. */
 					purge_partial_datagram(lh);
 					pdg->sz--;
 					spin_unlock_irqrestore(&pdg->lock, flags);
 					goto bad_proto;
 				}
 			} /* fragment overlap */
 		} /* new datagram or add to existing one */
 		pd = list_entry(lh, struct partial_datagram, list);
 		if (hdr->common.lf == ETH1394_HDR_LF_FF)
 			pd->ether_type = ether_type;
 		if (is_datagram_complete(lh, dg_size)) {
 			ether_type = pd->ether_type;
 			pdg->sz--;
 			skb = skb_get(pd->skb);
 			purge_partial_datagram(lh);
 			spin_unlock_irqrestore(&pdg->lock, flags);
 		} else {
 			/* Datagram is not complete, we're done for the
 			 * moment. */
 			spin_unlock_irqrestore(&pdg->lock, flags);
 			return 0;
 		}
 	} /* unframgented datagram or fragmented one */
 	/* Write metadata, and then pass to the receive level */
 	skb->dev = dev;
 	skb->ip_summed = CHECKSUM_UNNECESSARY;	/* don't check it */
 	/* Parse the encapsulation header. This actually does the job of
 	 * converting to an ethernet frame header, aswell as arp
 	 * conversion if needed. ARP conversion is easier in this
 	 * direction, since we are using ethernet as our backend.  */
 	skb->protocol = ether1394_parse_encap(skb, dev, srcid, destid,
 					      ether_type);
 	spin_lock_irqsave(&priv->lock, flags);
 	if (!skb->protocol) {
 		dev->stats.rx_errors++;
 		dev->stats.rx_dropped++;
 		dev_kfree_skb_any(skb);
 	} else if (netif_rx(skb) == NET_RX_DROP) {
 		dev->stats.rx_errors++;
 		dev->stats.rx_dropped++;
 	} else {
 		dev->stats.rx_packets++;
 		dev->stats.rx_bytes += skb->len;
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
 bad_proto:
 	if (netif_queue_stopped(dev))
 		netif_wake_queue(dev);
 	return 0;
 }
 static int ether1394_write(struct hpsb_host *host, int srcid, int destid,
 			   quadlet_t *data, u64 addr, size_t len, u16 flags)
 {
 	struct eth1394_host_info *hi;
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
 	if (unlikely(!hi)) {
 		ETH1394_PRINT_G(KERN_ERR, "No net device at fw-host%d\n",
 				host->id);
 		return RCODE_ADDRESS_ERROR;
 	}
 	if (ether1394_data_handler(hi->dev, srcid, destid, (char*)data, len))
 		return RCODE_ADDRESS_ERROR;
 	else
 		return RCODE_COMPLETE;
 }
 static void ether1394_iso(struct hpsb_iso *iso)
 {
 	__be32 *data;
 	char *buf;
 	struct eth1394_host_info *hi;
 	struct net_device *dev;
-	struct eth1394_priv *priv;
 	unsigned int len;
 	u32 specifier_id;
 	u16 source_id;
 	int i;
 	int nready;
 	hi = hpsb_get_hostinfo(&eth1394_highlevel, iso->host);
 	if (unlikely(!hi)) {
 		ETH1394_PRINT_G(KERN_ERR, "No net device at fw-host%d\n",
 				iso->host->id);
 		return;
 	}
 	dev = hi->dev;
 	nready = hpsb_iso_n_ready(iso);
 	for (i = 0; i < nready; i++) {
 		struct hpsb_iso_packet_info *info =
 			&iso->infos[(iso->first_packet + i) % iso->buf_packets];
 		data = (__be32 *)(iso->data_buf.kvirt + info->offset);
 		/* skip over GASP header */
 		buf = (char *)data + 8;
 		len = info->len - 8;
 		specifier_id = (be32_to_cpu(data[0]) & 0xffff) << 8 |
 			       (be32_to_cpu(data[1]) & 0xff000000) >> 24;
 		source_id = be32_to_cpu(data[0]) >> 16;
-		priv = netdev_priv(dev);
 		if (info->channel != (iso->host->csr.broadcast_channel & 0x3f)
 		    || specifier_id != ETHER1394_GASP_SPECIFIER_ID) {
 			/* This packet is not for us */
 			continue;
 		}
 		ether1394_data_handler(dev, source_id, LOCAL_BUS | ALL_NODES,
 				       buf, len);
 	}
 	hpsb_iso_recv_release_packets(iso, i);
 }
 /******************************************
  * Datagram transmission code
  ******************************************/
 /* Convert a standard ARP packet to 1394 ARP. The first 8 bytes (the entire
  * arphdr) is the same format as the ip1394 header, so they overlap.  The rest
  * needs to be munged a bit.  The remainder of the arphdr is formatted based
  * on hwaddr len and ipaddr len.  We know what they'll be, so it's easy to
  * judge.
  *
  * Now that the EUI is used for the hardware address all we need to do to make
  * this work for 1394 is to insert 2 quadlets that contain max_rec size,
  * speed, and unicast FIFO address information between the sender_unique_id
  * and the IP addresses.
  */
 static void ether1394_arp_to_1394arp(struct sk_buff *skb,
 				     struct net_device *dev)
 {
 	struct eth1394_priv *priv = netdev_priv(dev);
 	struct arphdr *arp = (struct arphdr *)skb->data;
 	unsigned char *arp_ptr = (unsigned char *)(arp + 1);
 	struct eth1394_arp *arp1394 = (struct eth1394_arp *)skb->data;
 	arp1394->hw_addr_len	= 16;
 	arp1394->sip		= *(u32*)(arp_ptr + ETH1394_ALEN);
 	arp1394->max_rec	= priv->host->csr.max_rec;
 	arp1394->sspd		= priv->host->csr.lnk_spd;
 	arp1394->fifo_hi	= htons(priv->local_fifo >> 32);
 	arp1394->fifo_lo	= htonl(priv->local_fifo & ~0x0);
 }
 /* We need to encapsulate the standard header with our own. We use the
  * ethernet header's proto for our own. */
 static unsigned int ether1394_encapsulate_prep(unsigned int max_payload,
 					       __be16 proto,
 					       union eth1394_hdr *hdr,
 					       u16 dg_size, u16 dgl)
 {
 	unsigned int adj_max_payload =
 				max_payload - hdr_type_len[ETH1394_HDR_LF_UF];
 	/* Does it all fit in one packet? */
 	if (dg_size <= adj_max_payload) {
 		hdr->uf.lf = ETH1394_HDR_LF_UF;
 		hdr->uf.ether_type = proto;
 	} else {
 		hdr->ff.lf = ETH1394_HDR_LF_FF;
 		hdr->ff.ether_type = proto;
 		hdr->ff.dg_size = dg_size - 1;
 		hdr->ff.dgl = dgl;
 		adj_max_payload = max_payload - hdr_type_len[ETH1394_HDR_LF_FF];
 	}
 	return DIV_ROUND_UP(dg_size, adj_max_payload);
 }
 static unsigned int ether1394_encapsulate(struct sk_buff *skb,
 					  unsigned int max_payload,
 					  union eth1394_hdr *hdr)
 {
 	union eth1394_hdr *bufhdr;
 	int ftype = hdr->common.lf;
 	int hdrsz = hdr_type_len[ftype];
 	unsigned int adj_max_payload = max_payload - hdrsz;
 	switch (ftype) {
 	case ETH1394_HDR_LF_UF:
 		bufhdr = (union eth1394_hdr *)skb_push(skb, hdrsz);
 		bufhdr->words.word1 = htons(hdr->words.word1);
 		bufhdr->words.word2 = hdr->words.word2;
 		break;
 	case ETH1394_HDR_LF_FF:
 		bufhdr = (union eth1394_hdr *)skb_push(skb, hdrsz);
 		bufhdr->words.word1 = htons(hdr->words.word1);
 		bufhdr->words.word2 = hdr->words.word2;
 		bufhdr->words.word3 = htons(hdr->words.word3);
 		bufhdr->words.word4 = 0;
 		/* Set frag type here for future interior fragments */
 		hdr->common.lf = ETH1394_HDR_LF_IF;
 		hdr->sf.fg_off = 0;
 		break;
 	default:
 		hdr->sf.fg_off += adj_max_payload;
 		bufhdr = (union eth1394_hdr *)skb_pull(skb, adj_max_payload);
 		if (max_payload >= skb->len)
 			hdr->common.lf = ETH1394_HDR_LF_LF;
 		bufhdr->words.word1 = htons(hdr->words.word1);
 		bufhdr->words.word2 = htons(hdr->words.word2);
 		bufhdr->words.word3 = htons(hdr->words.word3);
 		bufhdr->words.word4 = 0;
 	}
 	return min(max_payload, skb->len);
 }
 static struct hpsb_packet *ether1394_alloc_common_packet(struct hpsb_host *host)
 {
 	struct hpsb_packet *p;
 	p = hpsb_alloc_packet(0);
 	if (p) {
 		p->host = host;
 		p->generation = get_hpsb_generation(host);
 		p->type = hpsb_async;
 	}
 	return p;
 }
 static int ether1394_prep_write_packet(struct hpsb_packet *p,
 				       struct hpsb_host *host, nodeid_t node,
 				       u64 addr, void *data, int tx_len)
 {
 	p->node_id = node;
 	if (hpsb_get_tlabel(p))
 		return -EAGAIN;
 	p->tcode = TCODE_WRITEB;
 	p->header_size = 16;
 	p->expect_response = 1;
 	p->header[0] =
 		p->node_id << 16 | p->tlabel << 10 | 1 << 8 | TCODE_WRITEB << 4;
 	p->header[1] = host->node_id << 16 | addr >> 32;
 	p->header[2] = addr & 0xffffffff;
 	p->header[3] = tx_len << 16;
 	p->data_size = (tx_len + 3) & ~3;
 	p->data = data;
 	return 0;
 }
 static void ether1394_prep_gasp_packet(struct hpsb_packet *p,
 				       struct eth1394_priv *priv,
 				       struct sk_buff *skb, int length)
 {
 	p->header_size = 4;
 	p->tcode = TCODE_STREAM_DATA;
 	p->header[0] = length << 16 | 3 << 14 | priv->broadcast_channel << 8 |
 		       TCODE_STREAM_DATA << 4;
 	p->data_size = length;
 	p->data = (quadlet_t *)skb->data - 2;
 	p->data[0] = cpu_to_be32(priv->host->node_id << 16 |
 				 ETHER1394_GASP_SPECIFIER_ID_HI);
 	p->data[1] = cpu_to_be32(ETHER1394_GASP_SPECIFIER_ID_LO << 24 |
 				 ETHER1394_GASP_VERSION);
 	p->speed_code = priv->bc_sspd;
 	/* prevent hpsb_send_packet() from overriding our speed code */
 	p->node_id = LOCAL_BUS | ALL_NODES;
 }
 static void ether1394_free_packet(struct hpsb_packet *packet)
 {
 	if (packet->tcode != TCODE_STREAM_DATA)
 		hpsb_free_tlabel(packet);
 	hpsb_free_packet(packet);
 }
 static void ether1394_complete_cb(void *__ptask);
 static int ether1394_send_packet(struct packet_task *ptask, unsigned int tx_len)
 {
 	struct eth1394_priv *priv = ptask->priv;
 	struct hpsb_packet *packet = NULL;
 	packet = ether1394_alloc_common_packet(priv->host);
 	if (!packet)
 		return -ENOMEM;
 	if (ptask->tx_type == ETH1394_GASP) {
 		int length = tx_len + 2 * sizeof(quadlet_t);
 		ether1394_prep_gasp_packet(packet, priv, ptask->skb, length);
 	} else if (ether1394_prep_write_packet(packet, priv->host,
 					       ptask->dest_node,
 					       ptask->addr, ptask->skb->data,
 					       tx_len)) {
 		hpsb_free_packet(packet);
 		return -EAGAIN;
 	}
 	ptask->packet = packet;
 	hpsb_set_packet_complete_task(ptask->packet, ether1394_complete_cb,
 				      ptask);
 	if (hpsb_send_packet(packet) < 0) {
 		ether1394_free_packet(packet);
 		return -EIO;
 	}
 	return 0;
 }
 /* Task function to be run when a datagram transmission is completed */
 static void ether1394_dg_complete(struct packet_task *ptask, int fail)
 {
 	struct sk_buff *skb = ptask->skb;
 	struct net_device *dev = skb->dev;
 	struct eth1394_priv *priv = netdev_priv(dev);
 	unsigned long flags;
 	/* Statistics */
 	spin_lock_irqsave(&priv->lock, flags);
 	if (fail) {
 		dev->stats.tx_dropped++;
 		dev->stats.tx_errors++;
 	} else {
 		dev->stats.tx_bytes += skb->len;
 		dev->stats.tx_packets++;
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
 	dev_kfree_skb_any(skb);
 	kmem_cache_free(packet_task_cache, ptask);
 }
 /* Callback for when a packet has been sent and the status of that packet is
  * known */
 static void ether1394_complete_cb(void *__ptask)
 {
 	struct packet_task *ptask = (struct packet_task *)__ptask;
 	struct hpsb_packet *packet = ptask->packet;
 	int fail = 0;
 	if (packet->tcode != TCODE_STREAM_DATA)
 		fail = hpsb_packet_success(packet);
 	ether1394_free_packet(packet);
 	ptask->outstanding_pkts--;
 	if (ptask->outstanding_pkts > 0 && !fail) {
 		int tx_len, err;
 		/* Add the encapsulation header to the fragment */
 		tx_len = ether1394_encapsulate(ptask->skb, ptask->max_payload,
 					       &ptask->hdr);
 		err = ether1394_send_packet(ptask, tx_len);
 		if (err) {
 			if (err == -EAGAIN)
 				ETH1394_PRINT_G(KERN_ERR, "Out of tlabels\n");
 			ether1394_dg_complete(ptask, 1);
 		}
 	} else {
 		ether1394_dg_complete(ptask, fail);
 	}
 }
 /* Transmit a packet (called by kernel) */
 static netdev_tx_t ether1394_tx(struct sk_buff *skb,
 				struct net_device *dev)
 {
 	struct eth1394hdr hdr_buf;
 	struct eth1394_priv *priv = netdev_priv(dev);
 	__be16 proto;
 	unsigned long flags;
 	nodeid_t dest_node;
 	eth1394_tx_type tx_type;
 	unsigned int tx_len;
 	unsigned int max_payload;
 	u16 dg_size;
 	u16 dgl;
 	struct packet_task *ptask;
 	struct eth1394_node_ref *node;
 	struct eth1394_node_info *node_info = NULL;
 	ptask = kmem_cache_alloc(packet_task_cache, GFP_ATOMIC);
 	if (ptask == NULL)
 		goto fail;
 	/* XXX Ignore this for now. Noticed that when MacOSX is the IRM,
 	 * it does not set our validity bit. We need to compensate for
 	 * that somewhere else, but not in eth1394. */
 #if 0
 	if ((priv->host->csr.broadcast_channel & 0xc0000000) != 0xc0000000)
 		goto fail;
 #endif
 	skb = skb_share_check(skb, GFP_ATOMIC);
 	if (!skb)
 		goto fail;
 	/* Get rid of the fake eth1394 header, but first make a copy.
 	 * We might need to rebuild the header on tx failure. */
 	memcpy(&hdr_buf, skb->data, sizeof(hdr_buf));
 	skb_pull(skb, ETH1394_HLEN);
 	proto = hdr_buf.h_proto;
 	dg_size = skb->len;
 	/* Set the transmission type for the packet.  ARP packets and IP
 	 * broadcast packets are sent via GASP. */
 	if (memcmp(hdr_buf.h_dest, dev->broadcast, ETH1394_ALEN) == 0 ||
 	    proto == htons(ETH_P_ARP) ||
 	    (proto == htons(ETH_P_IP) &&
 	     IN_MULTICAST(ntohl(ip_hdr(skb)->daddr)))) {
 		tx_type = ETH1394_GASP;
 		dest_node = LOCAL_BUS | ALL_NODES;
 		max_payload = priv->bc_maxpayload - ETHER1394_GASP_OVERHEAD;
 		BUG_ON(max_payload < 512 - ETHER1394_GASP_OVERHEAD);
 		dgl = priv->bc_dgl;
 		if (max_payload < dg_size + hdr_type_len[ETH1394_HDR_LF_UF])
 			priv->bc_dgl++;
 	} else {
 		__be64 guid = get_unaligned((__be64 *)hdr_buf.h_dest);
 		node = eth1394_find_node_guid(&priv->ip_node_list,
 					      be64_to_cpu(guid));
 		if (!node)
 			goto fail;
 		node_info = dev_get_drvdata(&node->ud->device);
 		if (node_info->fifo == CSR1212_INVALID_ADDR_SPACE)
 			goto fail;
 		dest_node = node->ud->ne->nodeid;
 		max_payload = node_info->maxpayload;
 		BUG_ON(max_payload < 512 - ETHER1394_GASP_OVERHEAD);
 		dgl = node_info->dgl;
 		if (max_payload < dg_size + hdr_type_len[ETH1394_HDR_LF_UF])
 			node_info->dgl++;
 		tx_type = ETH1394_WRREQ;
 	}
 	/* If this is an ARP packet, convert it */
 	if (proto == htons(ETH_P_ARP))
 		ether1394_arp_to_1394arp(skb, dev);
 	ptask->hdr.words.word1 = 0;
 	ptask->hdr.words.word2 = 0;
 	ptask->hdr.words.word3 = 0;
 	ptask->hdr.words.word4 = 0;
 	ptask->skb = skb;
 	ptask->priv = priv;
 	ptask->tx_type = tx_type;
 	if (tx_type != ETH1394_GASP) {
 		u64 addr;
 		spin_lock_irqsave(&priv->lock, flags);
 		addr = node_info->fifo;
 		spin_unlock_irqrestore(&priv->lock, flags);
 		ptask->addr = addr;
 		ptask->dest_node = dest_node;
 	}
 	ptask->tx_type = tx_type;
 	ptask->max_payload = max_payload;
 	ptask->outstanding_pkts = ether1394_encapsulate_prep(max_payload,
 					proto, &ptask->hdr, dg_size, dgl);
 	/* Add the encapsulation header to the fragment */
 	tx_len = ether1394_encapsulate(skb, max_payload, &ptask->hdr);
 	dev->trans_start = jiffies;
 	if (ether1394_send_packet(ptask, tx_len)) {
 		if (dest_node == (LOCAL_BUS | ALL_NODES))
 			goto fail;
 		/* At this point we want to restore the packet.  When we return
 		 * here with NETDEV_TX_BUSY we will get another entrance in this
 		 * routine with the same skb and we need it to look the same.
 		 * So we pull 4 more bytes, then build the header again. */
 		skb_pull(skb, 4);
 		ether1394_header(skb, dev, ntohs(hdr_buf.h_proto),
 				 hdr_buf.h_dest, NULL, 0);
 		/* Most failures of ether1394_send_packet are recoverable. */
 		netif_stop_queue(dev);
 		priv->wake_node = dest_node;
 		schedule_work(&priv->wake);
 		kmem_cache_free(packet_task_cache, ptask);
 		return NETDEV_TX_BUSY;
 	}
 	return NETDEV_TX_OK;
 fail:
 	if (ptask)
 		kmem_cache_free(packet_task_cache, ptask);
 	if (skb != NULL)
 		dev_kfree_skb(skb);
 	spin_lock_irqsave(&priv->lock, flags);
 	dev->stats.tx_dropped++;
 	dev->stats.tx_errors++;
 	spin_unlock_irqrestore(&priv->lock, flags);
 	return NETDEV_TX_OK;
 }
 static void ether1394_get_drvinfo(struct net_device *dev,
 				  struct ethtool_drvinfo *info)
 {
 	strcpy(info->driver, driver_name);
 	strcpy(info->bus_info, "ieee1394"); /* FIXME provide more detail? */
 }
 static const struct ethtool_ops ethtool_ops = {
 	.get_drvinfo = ether1394_get_drvinfo
 };
 static int __init ether1394_init_module(void)
 {
 	int err;
 	packet_task_cache = kmem_cache_create("packet_task",
 					      sizeof(struct packet_task),
 					      0, 0, NULL);
 	if (!packet_task_cache)
 		return -ENOMEM;
 	hpsb_register_highlevel(&eth1394_highlevel);
 	err = hpsb_register_protocol(&eth1394_proto_driver);
 	if (err) {
 		hpsb_unregister_highlevel(&eth1394_highlevel);
 		kmem_cache_destroy(packet_task_cache);
 	}
 	return err;
 }
 static void __exit ether1394_exit_module(void)
 {
 	hpsb_unregister_protocol(&eth1394_proto_driver);
 	hpsb_unregister_highlevel(&eth1394_highlevel);
 	kmem_cache_destroy(packet_task_cache);
 }
 module_init(ether1394_init_module);
 module_exit(ether1394_exit_module);

drivers/ieee1394/raw1394.c

Diff comments View file @ 5030c80

 /*
  * IEEE 1394 for Linux
  *
  * Raw interface to the bus
  *
  * Copyright (C) 1999, 2000 Andreas E. Bombe
  *               2001, 2002 Manfred Weihs <weihs@ict.tuwien.ac.at>
  *                     2002 Christian Toegel <christian.toegel@gmx.at>
  *
  * This code is licensed under the GPL.  See the file COPYING in the root
  * directory of the kernel sources for details.
  *
  *
  * Contributions:
  *
  * Manfred Weihs <weihs@ict.tuwien.ac.at>
  *        configuration ROM manipulation
  *        address range mapping
  *        adaptation for new (transparent) loopback mechanism
  *        sending of arbitrary async packets
  * Christian Toegel <christian.toegel@gmx.at>
  *        address range mapping
  *        lock64 request
  *        transmit physical packet
  *        busreset notification control (switch on/off)
  *        busreset with selection of type (short/long)
  *        request_reply
  */
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
 #include <linux/cdev.h>
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
 #include <linux/compat.h>
 #include "csr1212.h"
 #include "highlevel.h"
 #include "hosts.h"
 #include "ieee1394.h"
 #include "ieee1394_core.h"
 #include "ieee1394_hotplug.h"
 #include "ieee1394_transactions.h"
 #include "ieee1394_types.h"
 #include "iso.h"
 #include "nodemgr.h"
 #include "raw1394.h"
 #include "raw1394-private.h"
 #define int2ptr(x) ((void __user *)(unsigned long)x)
 #define ptr2int(x) ((u64)(unsigned long)(void __user *)x)
 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
 #define RAW1394_DEBUG
 #endif
 #ifdef RAW1394_DEBUG
 #define DBGMSG(fmt, args...) \
 printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
 #else
 #define DBGMSG(fmt, args...) do {} while (0)
 #endif
 static LIST_HEAD(host_info_list);
 static int host_count;
 static DEFINE_SPINLOCK(host_info_lock);
 static atomic_t internal_generation = ATOMIC_INIT(0);
 static atomic_t iso_buffer_size;
 static const int iso_buffer_max = 4 * 1024 * 1024;	/* 4 MB */
 static struct hpsb_highlevel raw1394_highlevel;
 static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
 		    u64 addr, size_t length, u16 flags);
 static int arm_write(struct hpsb_host *host, int nodeid, int destid,
 		     quadlet_t * data, u64 addr, size_t length, u16 flags);
 static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
 		    u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
 		    u16 flags);
 static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
 		      u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
 		      u16 flags);
 static const struct hpsb_address_ops arm_ops = {
 	.read = arm_read,
 	.write = arm_write,
 	.lock = arm_lock,
 	.lock64 = arm_lock64,
 };
 static void queue_complete_cb(struct pending_request *req);
 static struct pending_request *__alloc_pending_request(gfp_t flags)
 {
 	struct pending_request *req;
 	req = kzalloc(sizeof(*req), flags);
 	if (req)
 		INIT_LIST_HEAD(&req->list);
 	return req;
 }
 static inline struct pending_request *alloc_pending_request(void)
 {
 	return __alloc_pending_request(GFP_KERNEL);
 }
 static void free_pending_request(struct pending_request *req)
 {
 	if (req->ibs) {
 		if (atomic_dec_and_test(&req->ibs->refcount)) {
 			atomic_sub(req->ibs->data_size, &iso_buffer_size);
 			kfree(req->ibs);
 		}
 	} else if (req->free_data) {
 		kfree(req->data);
 	}
 	hpsb_free_packet(req->packet);
 	kfree(req);
 }
 /* fi->reqlists_lock must be taken */
 static void __queue_complete_req(struct pending_request *req)
 {
 	struct file_info *fi = req->file_info;
 	list_move_tail(&req->list, &fi->req_complete);
  	wake_up(&fi->wait_complete);
 }
 static void queue_complete_req(struct pending_request *req)
 {
 	unsigned long flags;
 	struct file_info *fi = req->file_info;
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	__queue_complete_req(req);
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 }
 static void queue_complete_cb(struct pending_request *req)
 {
 	struct hpsb_packet *packet = req->packet;
 	int rcode = (packet->header[1] >> 12) & 0xf;
 	switch (packet->ack_code) {
 	case ACKX_NONE:
 	case ACKX_SEND_ERROR:
 		req->req.error = RAW1394_ERROR_SEND_ERROR;
 		break;
 	case ACKX_ABORTED:
 		req->req.error = RAW1394_ERROR_ABORTED;
 		break;
 	case ACKX_TIMEOUT:
 		req->req.error = RAW1394_ERROR_TIMEOUT;
 		break;
 	default:
 		req->req.error = (packet->ack_code << 16) | rcode;
 		break;
 	}
 	if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
 		req->req.length = 0;
 	}
 	if ((req->req.type == RAW1394_REQ_ASYNC_READ) ||
 	    (req->req.type == RAW1394_REQ_ASYNC_WRITE) ||
 	    (req->req.type == RAW1394_REQ_ASYNC_STREAM) ||
 	    (req->req.type == RAW1394_REQ_LOCK) ||
 	    (req->req.type == RAW1394_REQ_LOCK64))
 		hpsb_free_tlabel(packet);
 	queue_complete_req(req);
 }
 static void add_host(struct hpsb_host *host)
 {
 	struct host_info *hi;
 	unsigned long flags;
 	hi = kmalloc(sizeof(*hi), GFP_KERNEL);
 	if (hi) {
 		INIT_LIST_HEAD(&hi->list);
 		hi->host = host;
 		INIT_LIST_HEAD(&hi->file_info_list);
 		spin_lock_irqsave(&host_info_lock, flags);
 		list_add_tail(&hi->list, &host_info_list);
 		host_count++;
 		spin_unlock_irqrestore(&host_info_lock, flags);
 	}
 	atomic_inc(&internal_generation);
 }
 static struct host_info *find_host_info(struct hpsb_host *host)
 {
 	struct host_info *hi;
 	list_for_each_entry(hi, &host_info_list, list)
 	    if (hi->host == host)
 		return hi;
 	return NULL;
 }
 static void remove_host(struct hpsb_host *host)
 {
 	struct host_info *hi;
 	unsigned long flags;
 	spin_lock_irqsave(&host_info_lock, flags);
 	hi = find_host_info(host);
 	if (hi != NULL) {
 		list_del(&hi->list);
 		host_count--;
 		/*
 		   FIXME: address ranges should be removed
 		   and fileinfo states should be initialized
 		   (including setting generation to
 		   internal-generation ...)
 		 */
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	if (hi == NULL) {
 		printk(KERN_ERR "raw1394: attempt to remove unknown host "
 		       "0x%p\n", host);
 		return;
 	}
 	kfree(hi);
 	atomic_inc(&internal_generation);
 }
 static void host_reset(struct hpsb_host *host)
 {
 	unsigned long flags;
 	struct host_info *hi;
 	struct file_info *fi;
 	struct pending_request *req;
 	spin_lock_irqsave(&host_info_lock, flags);
 	hi = find_host_info(host);
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			if (fi->notification == RAW1394_NOTIFY_ON) {
 				req = __alloc_pending_request(GFP_ATOMIC);
 				if (req != NULL) {
 					req->file_info = fi;
 					req->req.type = RAW1394_REQ_BUS_RESET;
 					req->req.generation =
 					    get_hpsb_generation(host);
 					req->req.misc = (host->node_id << 16)
 					    | host->node_count;
 					if (fi->protocol_version > 3) {
 						req->req.misc |=
 						    (NODEID_TO_NODE
 						     (host->irm_id)
 						     << 8);
 					}
 					queue_complete_req(req);
 				}
 			}
 		}
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 }
 static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
 			int cts, u8 * data, size_t length)
 {
 	unsigned long flags;
 	struct host_info *hi;
 	struct file_info *fi;
 	struct pending_request *req, *req_next;
 	struct iso_block_store *ibs = NULL;
 	LIST_HEAD(reqs);
 	if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
 		HPSB_INFO("dropped fcp request");
 		return;
 	}
 	spin_lock_irqsave(&host_info_lock, flags);
 	hi = find_host_info(host);
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			if (!fi->fcp_buffer)
 				continue;
 			req = __alloc_pending_request(GFP_ATOMIC);
 			if (!req)
 				break;
 			if (!ibs) {
 				ibs = kmalloc(sizeof(*ibs) + length,
 					      GFP_ATOMIC);
 				if (!ibs) {
 					kfree(req);
 					break;
 				}
 				atomic_add(length, &iso_buffer_size);
 				atomic_set(&ibs->refcount, 0);
 				ibs->data_size = length;
 				memcpy(ibs->data, data, length);
 			}
 			atomic_inc(&ibs->refcount);
 			req->file_info = fi;
 			req->ibs = ibs;
 			req->data = ibs->data;
 			req->req.type = RAW1394_REQ_FCP_REQUEST;
 			req->req.generation = get_hpsb_generation(host);
 			req->req.misc = nodeid | (direction << 16);
 			req->req.recvb = ptr2int(fi->fcp_buffer);
 			req->req.length = length;
 			list_add_tail(&req->list, &reqs);
 		}
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	list_for_each_entry_safe(req, req_next, &reqs, list)
 	    queue_complete_req(req);
 }
 #ifdef CONFIG_COMPAT
 struct compat_raw1394_req {
 	__u32 type;
 	__s32 error;
 	__u32 misc;
 	__u32 generation;
 	__u32 length;
 	__u64 address;
 	__u64 tag;
 	__u64 sendb;
 	__u64 recvb;
 }
 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
 __attribute__((packed))
 #endif
 ;
 static const char __user *raw1394_compat_write(const char __user *buf)
 {
 	struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
 	struct raw1394_request __user *r;
 	r = compat_alloc_user_space(sizeof(struct raw1394_request));
 #define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x))
 	if (copy_in_user(r, cr, sizeof(struct compat_raw1394_req)) ||
 	    C(address) ||
 	    C(tag) ||
 	    C(sendb) ||
 	    C(recvb))
 		return (__force const char __user *)ERR_PTR(-EFAULT);
 	return (const char __user *)r;
 }
 #undef C
 #define P(x) __put_user(r->x, &cr->x)
 static int
 raw1394_compat_read(const char __user *buf, struct raw1394_request *r)
 {
 	struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
 	if (!access_ok(VERIFY_WRITE, cr, sizeof(struct compat_raw1394_req)) ||
 	    P(type) ||
 	    P(error) ||
 	    P(misc) ||
 	    P(generation) ||
 	    P(length) ||
 	    P(address) ||
 	    P(tag) ||
 	    P(sendb) ||
 	    P(recvb))
 		return -EFAULT;
 	return sizeof(struct compat_raw1394_req);
 }
 #undef P
 #endif
 /* get next completed request  (caller must hold fi->reqlists_lock) */
 static inline struct pending_request *__next_complete_req(struct file_info *fi)
 {
 	struct list_head *lh;
 	struct pending_request *req = NULL;
 	if (!list_empty(&fi->req_complete)) {
 		lh = fi->req_complete.next;
 		list_del(lh);
 		req = list_entry(lh, struct pending_request, list);
 	}
 	return req;
 }
 /* atomically get next completed request */
 static struct pending_request *next_complete_req(struct file_info *fi)
 {
 	unsigned long flags;
 	struct pending_request *req;
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	req = __next_complete_req(fi);
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 	return req;
 }
 static ssize_t raw1394_read(struct file *file, char __user * buffer,
 			    size_t count, loff_t * offset_is_ignored)
 {
 	struct file_info *fi = (struct file_info *)file->private_data;
 	struct pending_request *req;
 	ssize_t ret;
 #ifdef CONFIG_COMPAT
 	if (count == sizeof(struct compat_raw1394_req)) {
 		/* ok */
 	} else
 #endif
 	if (count != sizeof(struct raw1394_request)) {
 		return -EINVAL;
 	}
 	if (!access_ok(VERIFY_WRITE, buffer, count)) {
 		return -EFAULT;
 	}
 	if (file->f_flags & O_NONBLOCK) {
 		if (!(req = next_complete_req(fi)))
 			return -EAGAIN;
 	} else {
 		/*
 		 * NB: We call the macro wait_event_interruptible() with a
 		 * condition argument with side effect.  This is only possible
 		 * because the side effect does not occur until the condition
 		 * became true, and wait_event_interruptible() won't evaluate
 		 * the condition again after that.
 		 */
 		if (wait_event_interruptible(fi->wait_complete,
 					     (req = next_complete_req(fi))))
 			return -ERESTARTSYS;
 	}
 	if (req->req.length) {
 		if (copy_to_user(int2ptr(req->req.recvb), req->data,
 				 req->req.length)) {
 			req->req.error = RAW1394_ERROR_MEMFAULT;
 		}
 	}
 #ifdef CONFIG_COMPAT
 	if (count == sizeof(struct compat_raw1394_req) &&
    	    sizeof(struct compat_raw1394_req) !=
 			sizeof(struct raw1394_request)) {
 		ret = raw1394_compat_read(buffer, &req->req);
 	} else
 #endif
 	{
 		if (copy_to_user(buffer, &req->req, sizeof(req->req))) {
 			ret = -EFAULT;
 			goto out;
 		}
 		ret = (ssize_t) sizeof(struct raw1394_request);
 	}
       out:
 	free_pending_request(req);
 	return ret;
 }
 static int state_opened(struct file_info *fi, struct pending_request *req)
 {
 	if (req->req.type == RAW1394_REQ_INITIALIZE) {
 		switch (req->req.misc) {
 		case RAW1394_KERNELAPI_VERSION:
 		case 3:
 			fi->state = initialized;
 			fi->protocol_version = req->req.misc;
 			req->req.error = RAW1394_ERROR_NONE;
 			req->req.generation = atomic_read(&internal_generation);
 			break;
 		default:
 			req->req.error = RAW1394_ERROR_COMPAT;
 			req->req.misc = RAW1394_KERNELAPI_VERSION;
 		}
 	} else {
 		req->req.error = RAW1394_ERROR_STATE_ORDER;
 	}
 	req->req.length = 0;
 	queue_complete_req(req);
 	return 0;
 }
 static int state_initialized(struct file_info *fi, struct pending_request *req)
 {
 	unsigned long flags;
 	struct host_info *hi;
 	struct raw1394_khost_list *khl;
 	if (req->req.generation != atomic_read(&internal_generation)) {
 		req->req.error = RAW1394_ERROR_GENERATION;
 		req->req.generation = atomic_read(&internal_generation);
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	switch (req->req.type) {
 	case RAW1394_REQ_LIST_CARDS:
 		spin_lock_irqsave(&host_info_lock, flags);
 		khl = kmalloc(sizeof(*khl) * host_count, GFP_ATOMIC);
 		if (khl) {
 			req->req.misc = host_count;
 			req->data = (quadlet_t *) khl;
 			list_for_each_entry(hi, &host_info_list, list) {
 				khl->nodes = hi->host->node_count;
 				strcpy(khl->name, hi->host->driver->name);
 				khl++;
 			}
 		}
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		if (khl) {
 			req->req.error = RAW1394_ERROR_NONE;
 			req->req.length = min(req->req.length,
 					      (u32) (sizeof
 						     (struct raw1394_khost_list)
 						     * req->req.misc));
 			req->free_data = 1;
 		} else {
 			return -ENOMEM;
 		}
 		break;
 	case RAW1394_REQ_SET_CARD:
 		spin_lock_irqsave(&host_info_lock, flags);
 		if (req->req.misc >= host_count) {
 			req->req.error = RAW1394_ERROR_INVALID_ARG;
 			goto out_set_card;
 		}
 		list_for_each_entry(hi, &host_info_list, list)
 			if (!req->req.misc--)
 				break;
 		get_device(&hi->host->device); /* FIXME handle failure case */
 		list_add_tail(&fi->list, &hi->file_info_list);
 		/* prevent unloading of the host's low-level driver */
 		if (!try_module_get(hi->host->driver->owner)) {
 			req->req.error = RAW1394_ERROR_ABORTED;
 			goto out_set_card;
 		}
 		WARN_ON(fi->host);
 		fi->host = hi->host;
 		fi->state = connected;
 		req->req.error = RAW1394_ERROR_NONE;
 		req->req.generation = get_hpsb_generation(fi->host);
 		req->req.misc = (fi->host->node_id << 16)
 				| fi->host->node_count;
 		if (fi->protocol_version > 3)
 			req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8;
 out_set_card:
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		req->req.length = 0;
 		break;
 	default:
 		req->req.error = RAW1394_ERROR_STATE_ORDER;
 		req->req.length = 0;
 		break;
 	}
 	queue_complete_req(req);
 	return 0;
 }
 static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
 {
 	if (req->req.misc) {
 		if (fi->fcp_buffer) {
 			req->req.error = RAW1394_ERROR_ALREADY;
 		} else {
 			fi->fcp_buffer = int2ptr(req->req.recvb);
 		}
 	} else {
 		if (!fi->fcp_buffer) {
 			req->req.error = RAW1394_ERROR_ALREADY;
 		} else {
 			fi->fcp_buffer = NULL;
 		}
 	}
 	req->req.length = 0;
 	queue_complete_req(req);
 }
 static int handle_async_request(struct file_info *fi,
 				struct pending_request *req, int node)
 {
 	unsigned long flags;
 	struct hpsb_packet *packet = NULL;
 	u64 addr = req->req.address & 0xffffffffffffULL;
 	switch (req->req.type) {
 	case RAW1394_REQ_ASYNC_READ:
 		DBGMSG("read_request called");
 		packet =
 		    hpsb_make_readpacket(fi->host, node, addr, req->req.length);
 		if (!packet)
 			return -ENOMEM;
 		if (req->req.length == 4)
 			req->data = &packet->header[3];
 		else
 			req->data = packet->data;
 		break;
 	case RAW1394_REQ_ASYNC_WRITE:
 		DBGMSG("write_request called");
 		packet = hpsb_make_writepacket(fi->host, node, addr, NULL,
 					       req->req.length);
 		if (!packet)
 			return -ENOMEM;
 		if (req->req.length == 4) {
 			if (copy_from_user
 			    (&packet->header[3], int2ptr(req->req.sendb),
 			     req->req.length))
 				req->req.error = RAW1394_ERROR_MEMFAULT;
 		} else {
 			if (copy_from_user
 			    (packet->data, int2ptr(req->req.sendb),
 			     req->req.length))
 				req->req.error = RAW1394_ERROR_MEMFAULT;
 		}
 		req->req.length = 0;
 		break;
 	case RAW1394_REQ_ASYNC_STREAM:
 		DBGMSG("stream_request called");
 		packet =
 		    hpsb_make_streampacket(fi->host, NULL, req->req.length,
 					   node & 0x3f /*channel */ ,
 					   (req->req.misc >> 16) & 0x3,
 					   req->req.misc & 0xf);
 		if (!packet)
 			return -ENOMEM;
 		if (copy_from_user(packet->data, int2ptr(req->req.sendb),
 				   req->req.length))
 			req->req.error = RAW1394_ERROR_MEMFAULT;
 		req->req.length = 0;
 		break;
 	case RAW1394_REQ_LOCK:
 		DBGMSG("lock_request called");
 		if ((req->req.misc == EXTCODE_FETCH_ADD)
 		    || (req->req.misc == EXTCODE_LITTLE_ADD)) {
 			if (req->req.length != 4) {
 				req->req.error = RAW1394_ERROR_INVALID_ARG;
 				break;
 			}
 		} else {
 			if (req->req.length != 8) {
 				req->req.error = RAW1394_ERROR_INVALID_ARG;
 				break;
 			}
 		}
 		packet = hpsb_make_lockpacket(fi->host, node, addr,
 					      req->req.misc, NULL, 0);
 		if (!packet)
 			return -ENOMEM;
 		if (copy_from_user(packet->data, int2ptr(req->req.sendb),
 				   req->req.length)) {
 			req->req.error = RAW1394_ERROR_MEMFAULT;
 			break;
 		}
 		req->data = packet->data;
 		req->req.length = 4;
 		break;
 	case RAW1394_REQ_LOCK64:
 		DBGMSG("lock64_request called");
 		if ((req->req.misc == EXTCODE_FETCH_ADD)
 		    || (req->req.misc == EXTCODE_LITTLE_ADD)) {
 			if (req->req.length != 8) {
 				req->req.error = RAW1394_ERROR_INVALID_ARG;
 				break;
 			}
 		} else {
 			if (req->req.length != 16) {
 				req->req.error = RAW1394_ERROR_INVALID_ARG;
 				break;
 			}
 		}
 		packet = hpsb_make_lock64packet(fi->host, node, addr,
 						req->req.misc, NULL, 0);
 		if (!packet)
 			return -ENOMEM;
 		if (copy_from_user(packet->data, int2ptr(req->req.sendb),
 				   req->req.length)) {
 			req->req.error = RAW1394_ERROR_MEMFAULT;
 			break;
 		}
 		req->data = packet->data;
 		req->req.length = 8;
 		break;
 	default:
 		req->req.error = RAW1394_ERROR_STATE_ORDER;
 	}
 	req->packet = packet;
 	if (req->req.error) {
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	hpsb_set_packet_complete_task(packet,
 				      (void (*)(void *))queue_complete_cb, req);
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	list_add_tail(&req->list, &fi->req_pending);
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 	packet->generation = req->req.generation;
 	if (hpsb_send_packet(packet) < 0) {
 		req->req.error = RAW1394_ERROR_SEND_ERROR;
 		req->req.length = 0;
 		hpsb_free_tlabel(packet);
 		queue_complete_req(req);
 	}
 	return 0;
 }
 static int handle_async_send(struct file_info *fi, struct pending_request *req)
 {
 	unsigned long flags;
 	struct hpsb_packet *packet;
 	int header_length = req->req.misc & 0xffff;
 	int expect_response = req->req.misc >> 16;
 	size_t data_size;
 	if (header_length > req->req.length || header_length < 12 ||
 	    header_length > FIELD_SIZEOF(struct hpsb_packet, header)) {
 		req->req.error = RAW1394_ERROR_INVALID_ARG;
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	data_size = req->req.length - header_length;
 	packet = hpsb_alloc_packet(data_size);
 	req->packet = packet;
 	if (!packet)
 		return -ENOMEM;
 	if (copy_from_user(packet->header, int2ptr(req->req.sendb),
 			   header_length)) {
 		req->req.error = RAW1394_ERROR_MEMFAULT;
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	if (copy_from_user
 	    (packet->data, int2ptr(req->req.sendb) + header_length,
 	     data_size)) {
 		req->req.error = RAW1394_ERROR_MEMFAULT;
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	packet->type = hpsb_async;
 	packet->node_id = packet->header[0] >> 16;
 	packet->tcode = (packet->header[0] >> 4) & 0xf;
 	packet->tlabel = (packet->header[0] >> 10) & 0x3f;
 	packet->host = fi->host;
 	packet->expect_response = expect_response;
 	packet->header_size = header_length;
 	packet->data_size = data_size;
 	req->req.length = 0;
 	hpsb_set_packet_complete_task(packet,
 				      (void (*)(void *))queue_complete_cb, req);
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	list_add_tail(&req->list, &fi->req_pending);
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 	/* Update the generation of the packet just before sending. */
 	packet->generation = req->req.generation;
 	if (hpsb_send_packet(packet) < 0) {
 		req->req.error = RAW1394_ERROR_SEND_ERROR;
 		queue_complete_req(req);
 	}
 	return 0;
 }
 static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
 		    u64 addr, size_t length, u16 flags)
 {
 	unsigned long irqflags;
 	struct pending_request *req;
 	struct host_info *hi;
 	struct file_info *fi = NULL;
 	struct list_head *entry;
 	struct arm_addr *arm_addr = NULL;
 	struct arm_request *arm_req = NULL;
 	struct arm_response *arm_resp = NULL;
 	int found = 0, size = 0, rcode = -1;
 	struct arm_request_response *arm_req_resp = NULL;
 	DBGMSG("arm_read  called by node: %X "
 	       "addr: %4.4x %8.8x length: %Zu", nodeid,
 	       (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
 	       length);
 	spin_lock_irqsave(&host_info_lock, irqflags);
 	hi = find_host_info(host);	/* search address-entry */
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			entry = fi->addr_list.next;
 			while (entry != &(fi->addr_list)) {
 				arm_addr =
 				    list_entry(entry, struct arm_addr,
 					       addr_list);
 				if (((arm_addr->start) <= (addr))
 				    && ((arm_addr->end) >= (addr + length))) {
 					found = 1;
 					break;
 				}
 				entry = entry->next;
 			}
 			if (found) {
 				break;
 			}
 		}
 	}
 	rcode = -1;
 	if (!found) {
 		printk(KERN_ERR "raw1394: arm_read FAILED addr_entry not found"
 		       " -> rcode_address_error\n");
 		spin_unlock_irqrestore(&host_info_lock, irqflags);
 		return (RCODE_ADDRESS_ERROR);
 	} else {
 		DBGMSG("arm_read addr_entry FOUND");
 	}
 	if (arm_addr->rec_length < length) {
 		DBGMSG("arm_read blocklength too big -> rcode_data_error");
 		rcode = RCODE_DATA_ERROR;	/* hardware error, data is unavailable */
 	}
 	if (rcode == -1) {
 		if (arm_addr->access_rights & ARM_READ) {
 			if (!(arm_addr->client_transactions & ARM_READ)) {
 				memcpy(buffer,
 				       (arm_addr->addr_space_buffer) + (addr -
 									(arm_addr->
 									 start)),
 				       length);
 				DBGMSG("arm_read -> (rcode_complete)");
 				rcode = RCODE_COMPLETE;
 			}
 		} else {
 			rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 			DBGMSG("arm_read -> rcode_type_error (access denied)");
 		}
 	}
 	if (arm_addr->notification_options & ARM_READ) {
 		DBGMSG("arm_read -> entering notification-section");
 		req = __alloc_pending_request(GFP_ATOMIC);
 		if (!req) {
 			DBGMSG("arm_read -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		if (rcode == RCODE_COMPLETE) {
 			size =
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response) +
 			    length * sizeof(byte_t) +
 			    sizeof(struct arm_request_response);
 		} else {
 			size =
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response) +
 			    sizeof(struct arm_request_response);
 		}
 		req->data = kmalloc(size, GFP_ATOMIC);
 		if (!(req->data)) {
 			free_pending_request(req);
 			DBGMSG("arm_read -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		req->free_data = 1;
 		req->file_info = fi;
 		req->req.type = RAW1394_REQ_ARM;
 		req->req.generation = get_hpsb_generation(host);
 		req->req.misc =
 		    (((length << 16) & (0xFFFF0000)) | (ARM_READ & 0xFF));
 		req->req.tag = arm_addr->arm_tag;
 		req->req.recvb = arm_addr->recvb;
 		req->req.length = size;
 		arm_req_resp = (struct arm_request_response *)(req->data);
 		arm_req = (struct arm_request *)((byte_t *) (req->data) +
 						 (sizeof
 						  (struct
 						   arm_request_response)));
 		arm_resp =
 		    (struct arm_response *)((byte_t *) (arm_req) +
 					    (sizeof(struct arm_request)));
 		arm_req->buffer = NULL;
 		arm_resp->buffer = NULL;
 		if (rcode == RCODE_COMPLETE) {
 			byte_t *buf =
 			    (byte_t *) arm_resp + sizeof(struct arm_response);
 			memcpy(buf,
 			       (arm_addr->addr_space_buffer) + (addr -
 								(arm_addr->
 								 start)),
 			       length);
 			arm_resp->buffer =
 			    int2ptr((arm_addr->recvb) +
 				    sizeof(struct arm_request_response) +
 				    sizeof(struct arm_request) +
 				    sizeof(struct arm_response));
 		}
 		arm_resp->buffer_length =
 		    (rcode == RCODE_COMPLETE) ? length : 0;
 		arm_resp->response_code = rcode;
 		arm_req->buffer_length = 0;
 		arm_req->generation = req->req.generation;
 		arm_req->extended_transaction_code = 0;
 		arm_req->destination_offset = addr;
 		arm_req->source_nodeid = nodeid;
 		arm_req->destination_nodeid = host->node_id;
 		arm_req->tlabel = (flags >> 10) & 0x3f;
 		arm_req->tcode = (flags >> 4) & 0x0f;
 		arm_req_resp->request = int2ptr((arm_addr->recvb) +
 						sizeof(struct
 						       arm_request_response));
 		arm_req_resp->response =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request));
 		queue_complete_req(req);
 	}
 	spin_unlock_irqrestore(&host_info_lock, irqflags);
 	return (rcode);
 }
 static int arm_write(struct hpsb_host *host, int nodeid, int destid,
 		     quadlet_t * data, u64 addr, size_t length, u16 flags)
 {
 	unsigned long irqflags;
 	struct pending_request *req;
 	struct host_info *hi;
 	struct file_info *fi = NULL;
 	struct list_head *entry;
 	struct arm_addr *arm_addr = NULL;
 	struct arm_request *arm_req = NULL;
 	struct arm_response *arm_resp = NULL;
-	int found = 0, size = 0, rcode = -1, length_conflict = 0;
+	int found = 0, size = 0, rcode = -1;
 	struct arm_request_response *arm_req_resp = NULL;
 	DBGMSG("arm_write called by node: %X "
 	       "addr: %4.4x %8.8x length: %Zu", nodeid,
 	       (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
 	       length);
 	spin_lock_irqsave(&host_info_lock, irqflags);
 	hi = find_host_info(host);	/* search address-entry */
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			entry = fi->addr_list.next;
 			while (entry != &(fi->addr_list)) {
 				arm_addr =
 				    list_entry(entry, struct arm_addr,
 					       addr_list);
 				if (((arm_addr->start) <= (addr))
 				    && ((arm_addr->end) >= (addr + length))) {
 					found = 1;
 					break;
 				}
 				entry = entry->next;
 			}
 			if (found) {
 				break;
 			}
 		}
 	}
 	rcode = -1;
 	if (!found) {
 		printk(KERN_ERR "raw1394: arm_write FAILED addr_entry not found"
 		       " -> rcode_address_error\n");
 		spin_unlock_irqrestore(&host_info_lock, irqflags);
 		return (RCODE_ADDRESS_ERROR);
 	} else {
 		DBGMSG("arm_write addr_entry FOUND");
 	}
 	if (arm_addr->rec_length < length) {
 		DBGMSG("arm_write blocklength too big -> rcode_data_error");
-		length_conflict = 1;
 		rcode = RCODE_DATA_ERROR;	/* hardware error, data is unavailable */
 	}
 	if (rcode == -1) {
 		if (arm_addr->access_rights & ARM_WRITE) {
 			if (!(arm_addr->client_transactions & ARM_WRITE)) {
 				memcpy((arm_addr->addr_space_buffer) +
 				       (addr - (arm_addr->start)), data,
 				       length);
 				DBGMSG("arm_write -> (rcode_complete)");
 				rcode = RCODE_COMPLETE;
 			}
 		} else {
 			rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 			DBGMSG("arm_write -> rcode_type_error (access denied)");
 		}
 	}
 	if (arm_addr->notification_options & ARM_WRITE) {
 		DBGMSG("arm_write -> entering notification-section");
 		req = __alloc_pending_request(GFP_ATOMIC);
 		if (!req) {
 			DBGMSG("arm_write -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request my be retried */
 		}
 		size =
 		    sizeof(struct arm_request) + sizeof(struct arm_response) +
 		    (length) * sizeof(byte_t) +
 		    sizeof(struct arm_request_response);
 		req->data = kmalloc(size, GFP_ATOMIC);
 		if (!(req->data)) {
 			free_pending_request(req);
 			DBGMSG("arm_write -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		req->free_data = 1;
 		req->file_info = fi;
 		req->req.type = RAW1394_REQ_ARM;
 		req->req.generation = get_hpsb_generation(host);
 		req->req.misc =
 		    (((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF));
 		req->req.tag = arm_addr->arm_tag;
 		req->req.recvb = arm_addr->recvb;
 		req->req.length = size;
 		arm_req_resp = (struct arm_request_response *)(req->data);
 		arm_req = (struct arm_request *)((byte_t *) (req->data) +
 						 (sizeof
 						  (struct
 						   arm_request_response)));
 		arm_resp =
 		    (struct arm_response *)((byte_t *) (arm_req) +
 					    (sizeof(struct arm_request)));
 		arm_resp->buffer = NULL;
 		memcpy((byte_t *) arm_resp + sizeof(struct arm_response),
 		       data, length);
 		arm_req->buffer = int2ptr((arm_addr->recvb) +
 					  sizeof(struct arm_request_response) +
 					  sizeof(struct arm_request) +
 					  sizeof(struct arm_response));
 		arm_req->buffer_length = length;
 		arm_req->generation = req->req.generation;
 		arm_req->extended_transaction_code = 0;
 		arm_req->destination_offset = addr;
 		arm_req->source_nodeid = nodeid;
 		arm_req->destination_nodeid = destid;
 		arm_req->tlabel = (flags >> 10) & 0x3f;
 		arm_req->tcode = (flags >> 4) & 0x0f;
 		arm_resp->buffer_length = 0;
 		arm_resp->response_code = rcode;
 		arm_req_resp->request = int2ptr((arm_addr->recvb) +
 						sizeof(struct
 						       arm_request_response));
 		arm_req_resp->response =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request));
 		queue_complete_req(req);
 	}
 	spin_unlock_irqrestore(&host_info_lock, irqflags);
 	return (rcode);
 }
 static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
 		    u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
 		    u16 flags)
 {
 	unsigned long irqflags;
 	struct pending_request *req;
 	struct host_info *hi;
 	struct file_info *fi = NULL;
 	struct list_head *entry;
 	struct arm_addr *arm_addr = NULL;
 	struct arm_request *arm_req = NULL;
 	struct arm_response *arm_resp = NULL;
 	int found = 0, size = 0, rcode = -1;
 	quadlet_t old, new;
 	struct arm_request_response *arm_req_resp = NULL;
 	if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
 	    ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
 		DBGMSG("arm_lock  called by node: %X "
 		       "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
 		       nodeid, (u16) ((addr >> 32) & 0xFFFF),
 		       (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
 		       be32_to_cpu(data));
 	} else {
 		DBGMSG("arm_lock  called by node: %X "
 		       "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
 		       nodeid, (u16) ((addr >> 32) & 0xFFFF),
 		       (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
 		       be32_to_cpu(data), be32_to_cpu(arg));
 	}
 	spin_lock_irqsave(&host_info_lock, irqflags);
 	hi = find_host_info(host);	/* search address-entry */
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			entry = fi->addr_list.next;
 			while (entry != &(fi->addr_list)) {
 				arm_addr =
 				    list_entry(entry, struct arm_addr,
 					       addr_list);
 				if (((arm_addr->start) <= (addr))
 				    && ((arm_addr->end) >=
 					(addr + sizeof(*store)))) {
 					found = 1;
 					break;
 				}
 				entry = entry->next;
 			}
 			if (found) {
 				break;
 			}
 		}
 	}
 	rcode = -1;
 	if (!found) {
 		printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found"
 		       " -> rcode_address_error\n");
 		spin_unlock_irqrestore(&host_info_lock, irqflags);
 		return (RCODE_ADDRESS_ERROR);
 	} else {
 		DBGMSG("arm_lock addr_entry FOUND");
 	}
 	if (rcode == -1) {
 		if (arm_addr->access_rights & ARM_LOCK) {
 			if (!(arm_addr->client_transactions & ARM_LOCK)) {
 				memcpy(&old,
 				       (arm_addr->addr_space_buffer) + (addr -
 									(arm_addr->
 									 start)),
 				       sizeof(old));
 				switch (ext_tcode) {
 				case (EXTCODE_MASK_SWAP):
 					new = data | (old & ~arg);
 					break;
 				case (EXTCODE_COMPARE_SWAP):
 					if (old == arg) {
 						new = data;
 					} else {
 						new = old;
 					}
 					break;
 				case (EXTCODE_FETCH_ADD):
 					new =
 					    cpu_to_be32(be32_to_cpu(data) +
 							be32_to_cpu(old));
 					break;
 				case (EXTCODE_LITTLE_ADD):
 					new =
 					    cpu_to_le32(le32_to_cpu(data) +
 							le32_to_cpu(old));
 					break;
 				case (EXTCODE_BOUNDED_ADD):
 					if (old != arg) {
 						new =
 						    cpu_to_be32(be32_to_cpu
 								(data) +
 								be32_to_cpu
 								(old));
 					} else {
 						new = old;
 					}
 					break;
 				case (EXTCODE_WRAP_ADD):
 					if (old != arg) {
 						new =
 						    cpu_to_be32(be32_to_cpu
 								(data) +
 								be32_to_cpu
 								(old));
 					} else {
 						new = data;
 					}
 					break;
 				default:
 					rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 					printk(KERN_ERR
 					       "raw1394: arm_lock FAILED "
 					       "ext_tcode not allowed -> rcode_type_error\n");
 					break;
 				}	/*switch */
 				if (rcode == -1) {
 					DBGMSG("arm_lock -> (rcode_complete)");
 					rcode = RCODE_COMPLETE;
 					memcpy(store, &old, sizeof(*store));
 					memcpy((arm_addr->addr_space_buffer) +
 					       (addr - (arm_addr->start)),
 					       &new, sizeof(*store));
 				}
 			}
 		} else {
 			rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 			DBGMSG("arm_lock -> rcode_type_error (access denied)");
 		}
 	}
 	if (arm_addr->notification_options & ARM_LOCK) {
 		byte_t *buf1, *buf2;
 		DBGMSG("arm_lock -> entering notification-section");
 		req = __alloc_pending_request(GFP_ATOMIC);
 		if (!req) {
 			DBGMSG("arm_lock -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response);	/* maximum */
 		req->data = kmalloc(size, GFP_ATOMIC);
 		if (!(req->data)) {
 			free_pending_request(req);
 			DBGMSG("arm_lock -> rcode_conflict_error");
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		req->free_data = 1;
 		arm_req_resp = (struct arm_request_response *)(req->data);
 		arm_req = (struct arm_request *)((byte_t *) (req->data) +
 						 (sizeof
 						  (struct
 						   arm_request_response)));
 		arm_resp =
 		    (struct arm_response *)((byte_t *) (arm_req) +
 					    (sizeof(struct arm_request)));
 		buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
 		buf2 = buf1 + 2 * sizeof(*store);
 		if ((ext_tcode == EXTCODE_FETCH_ADD) ||
 		    (ext_tcode == EXTCODE_LITTLE_ADD)) {
 			arm_req->buffer_length = sizeof(*store);
 			memcpy(buf1, &data, sizeof(*store));
 		} else {
 			arm_req->buffer_length = 2 * sizeof(*store);
 			memcpy(buf1, &arg, sizeof(*store));
 			memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
 		}
 		if (rcode == RCODE_COMPLETE) {
 			arm_resp->buffer_length = sizeof(*store);
 			memcpy(buf2, &old, sizeof(*store));
 		} else {
 			arm_resp->buffer_length = 0;
 		}
 		req->file_info = fi;
 		req->req.type = RAW1394_REQ_ARM;
 		req->req.generation = get_hpsb_generation(host);
 		req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
 				 (ARM_LOCK & 0xFF));
 		req->req.tag = arm_addr->arm_tag;
 		req->req.recvb = arm_addr->recvb;
 		req->req.length = size;
 		arm_req->generation = req->req.generation;
 		arm_req->extended_transaction_code = ext_tcode;
 		arm_req->destination_offset = addr;
 		arm_req->source_nodeid = nodeid;
 		arm_req->destination_nodeid = host->node_id;
 		arm_req->tlabel = (flags >> 10) & 0x3f;
 		arm_req->tcode = (flags >> 4) & 0x0f;
 		arm_resp->response_code = rcode;
 		arm_req_resp->request = int2ptr((arm_addr->recvb) +
 						sizeof(struct
 						       arm_request_response));
 		arm_req_resp->response =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request));
 		arm_req->buffer =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response));
 		arm_resp->buffer =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response) + 2 * sizeof(*store));
 		queue_complete_req(req);
 	}
 	spin_unlock_irqrestore(&host_info_lock, irqflags);
 	return (rcode);
 }
 static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
 		      u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
 		      u16 flags)
 {
 	unsigned long irqflags;
 	struct pending_request *req;
 	struct host_info *hi;
 	struct file_info *fi = NULL;
 	struct list_head *entry;
 	struct arm_addr *arm_addr = NULL;
 	struct arm_request *arm_req = NULL;
 	struct arm_response *arm_resp = NULL;
 	int found = 0, size = 0, rcode = -1;
 	octlet_t old, new;
 	struct arm_request_response *arm_req_resp = NULL;
 	if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
 	    ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
 		DBGMSG("arm_lock64 called by node: %X "
 		       "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
 		       nodeid, (u16) ((addr >> 32) & 0xFFFF),
 		       (u32) (addr & 0xFFFFFFFF),
 		       ext_tcode & 0xFF,
 		       (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
 		       (u32) (be64_to_cpu(data) & 0xFFFFFFFF));
 	} else {
 		DBGMSG("arm_lock64 called by node: %X "
 		       "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
 		       "%8.8X %8.8X ",
 		       nodeid, (u16) ((addr >> 32) & 0xFFFF),
 		       (u32) (addr & 0xFFFFFFFF),
 		       ext_tcode & 0xFF,
 		       (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
 		       (u32) (be64_to_cpu(data) & 0xFFFFFFFF),
 		       (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF),
 		       (u32) (be64_to_cpu(arg) & 0xFFFFFFFF));
 	}
 	spin_lock_irqsave(&host_info_lock, irqflags);
 	hi = find_host_info(host);	/* search addressentry in file_info's for host */
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			entry = fi->addr_list.next;
 			while (entry != &(fi->addr_list)) {
 				arm_addr =
 				    list_entry(entry, struct arm_addr,
 					       addr_list);
 				if (((arm_addr->start) <= (addr))
 				    && ((arm_addr->end) >=
 					(addr + sizeof(*store)))) {
 					found = 1;
 					break;
 				}
 				entry = entry->next;
 			}
 			if (found) {
 				break;
 			}
 		}
 	}
 	rcode = -1;
 	if (!found) {
 		printk(KERN_ERR
 		       "raw1394: arm_lock64 FAILED addr_entry not found"
 		       " -> rcode_address_error\n");
 		spin_unlock_irqrestore(&host_info_lock, irqflags);
 		return (RCODE_ADDRESS_ERROR);
 	} else {
 		DBGMSG("arm_lock64 addr_entry FOUND");
 	}
 	if (rcode == -1) {
 		if (arm_addr->access_rights & ARM_LOCK) {
 			if (!(arm_addr->client_transactions & ARM_LOCK)) {
 				memcpy(&old,
 				       (arm_addr->addr_space_buffer) + (addr -
 									(arm_addr->
 									 start)),
 				       sizeof(old));
 				switch (ext_tcode) {
 				case (EXTCODE_MASK_SWAP):
 					new = data | (old & ~arg);
 					break;
 				case (EXTCODE_COMPARE_SWAP):
 					if (old == arg) {
 						new = data;
 					} else {
 						new = old;
 					}
 					break;
 				case (EXTCODE_FETCH_ADD):
 					new =
 					    cpu_to_be64(be64_to_cpu(data) +
 							be64_to_cpu(old));
 					break;
 				case (EXTCODE_LITTLE_ADD):
 					new =
 					    cpu_to_le64(le64_to_cpu(data) +
 							le64_to_cpu(old));
 					break;
 				case (EXTCODE_BOUNDED_ADD):
 					if (old != arg) {
 						new =
 						    cpu_to_be64(be64_to_cpu
 								(data) +
 								be64_to_cpu
 								(old));
 					} else {
 						new = old;
 					}
 					break;
 				case (EXTCODE_WRAP_ADD):
 					if (old != arg) {
 						new =
 						    cpu_to_be64(be64_to_cpu
 								(data) +
 								be64_to_cpu
 								(old));
 					} else {
 						new = data;
 					}
 					break;
 				default:
 					printk(KERN_ERR
 					       "raw1394: arm_lock64 FAILED "
 					       "ext_tcode not allowed -> rcode_type_error\n");
 					rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 					break;
 				}	/*switch */
 				if (rcode == -1) {
 					DBGMSG
 					    ("arm_lock64 -> (rcode_complete)");
 					rcode = RCODE_COMPLETE;
 					memcpy(store, &old, sizeof(*store));
 					memcpy((arm_addr->addr_space_buffer) +
 					       (addr - (arm_addr->start)),
 					       &new, sizeof(*store));
 				}
 			}
 		} else {
 			rcode = RCODE_TYPE_ERROR;	/* function not allowed */
 			DBGMSG
 			    ("arm_lock64 -> rcode_type_error (access denied)");
 		}
 	}
 	if (arm_addr->notification_options & ARM_LOCK) {
 		byte_t *buf1, *buf2;
 		DBGMSG("arm_lock64 -> entering notification-section");
 		req = __alloc_pending_request(GFP_ATOMIC);
 		if (!req) {
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			DBGMSG("arm_lock64 -> rcode_conflict_error");
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response);	/* maximum */
 		req->data = kmalloc(size, GFP_ATOMIC);
 		if (!(req->data)) {
 			free_pending_request(req);
 			spin_unlock_irqrestore(&host_info_lock, irqflags);
 			DBGMSG("arm_lock64 -> rcode_conflict_error");
 			return (RCODE_CONFLICT_ERROR);	/* A resource conflict was detected.
 							   The request may be retried */
 		}
 		req->free_data = 1;
 		arm_req_resp = (struct arm_request_response *)(req->data);
 		arm_req = (struct arm_request *)((byte_t *) (req->data) +
 						 (sizeof
 						  (struct
 						   arm_request_response)));
 		arm_resp =
 		    (struct arm_response *)((byte_t *) (arm_req) +
 					    (sizeof(struct arm_request)));
 		buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
 		buf2 = buf1 + 2 * sizeof(*store);
 		if ((ext_tcode == EXTCODE_FETCH_ADD) ||
 		    (ext_tcode == EXTCODE_LITTLE_ADD)) {
 			arm_req->buffer_length = sizeof(*store);
 			memcpy(buf1, &data, sizeof(*store));
 		} else {
 			arm_req->buffer_length = 2 * sizeof(*store);
 			memcpy(buf1, &arg, sizeof(*store));
 			memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
 		}
 		if (rcode == RCODE_COMPLETE) {
 			arm_resp->buffer_length = sizeof(*store);
 			memcpy(buf2, &old, sizeof(*store));
 		} else {
 			arm_resp->buffer_length = 0;
 		}
 		req->file_info = fi;
 		req->req.type = RAW1394_REQ_ARM;
 		req->req.generation = get_hpsb_generation(host);
 		req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
 				 (ARM_LOCK & 0xFF));
 		req->req.tag = arm_addr->arm_tag;
 		req->req.recvb = arm_addr->recvb;
 		req->req.length = size;
 		arm_req->generation = req->req.generation;
 		arm_req->extended_transaction_code = ext_tcode;
 		arm_req->destination_offset = addr;
 		arm_req->source_nodeid = nodeid;
 		arm_req->destination_nodeid = host->node_id;
 		arm_req->tlabel = (flags >> 10) & 0x3f;
 		arm_req->tcode = (flags >> 4) & 0x0f;
 		arm_resp->response_code = rcode;
 		arm_req_resp->request = int2ptr((arm_addr->recvb) +
 						sizeof(struct
 						       arm_request_response));
 		arm_req_resp->response =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request));
 		arm_req->buffer =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response));
 		arm_resp->buffer =
 		    int2ptr((arm_addr->recvb) +
 			    sizeof(struct arm_request_response) +
 			    sizeof(struct arm_request) +
 			    sizeof(struct arm_response) + 2 * sizeof(*store));
 		queue_complete_req(req);
 	}
 	spin_unlock_irqrestore(&host_info_lock, irqflags);
 	return (rcode);
 }
 static int arm_register(struct file_info *fi, struct pending_request *req)
 {
 	int retval;
 	struct arm_addr *addr;
 	struct host_info *hi;
 	struct file_info *fi_hlp = NULL;
 	struct list_head *entry;
 	struct arm_addr *arm_addr = NULL;
 	int same_host, another_host;
 	unsigned long flags;
 	DBGMSG("arm_register called "
 	       "addr(Offset): %8.8x %8.8x length: %u "
 	       "rights: %2.2X notify: %2.2X "
 	       "max_blk_len: %4.4X",
 	       (u32) ((req->req.address >> 32) & 0xFFFF),
 	       (u32) (req->req.address & 0xFFFFFFFF),
 	       req->req.length, ((req->req.misc >> 8) & 0xFF),
 	       (req->req.misc & 0xFF), ((req->req.misc >> 16) & 0xFFFF));
 	/* check addressrange */
 	if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) ||
 	    (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) !=
 	     0)) {
 		req->req.length = 0;
 		return (-EINVAL);
 	}
 	/* addr-list-entry for fileinfo */
 	addr = kmalloc(sizeof(*addr), GFP_KERNEL);
 	if (!addr) {
 		req->req.length = 0;
 		return (-ENOMEM);
 	}
 	/* allocation of addr_space_buffer */
 	addr->addr_space_buffer = vmalloc(req->req.length);
 	if (!(addr->addr_space_buffer)) {
 		kfree(addr);
 		req->req.length = 0;
 		return (-ENOMEM);
 	}
 	/* initialization of addr_space_buffer */
 	if ((req->req.sendb) == (unsigned long)NULL) {
 		/* init: set 0 */
 		memset(addr->addr_space_buffer, 0, req->req.length);
 	} else {
 		/* init: user -> kernel */
 		if (copy_from_user
 		    (addr->addr_space_buffer, int2ptr(req->req.sendb),
 		     req->req.length)) {
 			vfree(addr->addr_space_buffer);
 			kfree(addr);
 			return (-EFAULT);
 		}
 	}
 	INIT_LIST_HEAD(&addr->addr_list);
 	addr->arm_tag = req->req.tag;
 	addr->start = req->req.address;
 	addr->end = req->req.address + req->req.length;
 	addr->access_rights = (u8) (req->req.misc & 0x0F);
 	addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F);
 	addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F);
 	addr->access_rights |= addr->client_transactions;
 	addr->notification_options |= addr->client_transactions;
 	addr->recvb = req->req.recvb;
 	addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF);
 	spin_lock_irqsave(&host_info_lock, flags);
 	hi = find_host_info(fi->host);
 	same_host = 0;
 	another_host = 0;
 	/* same host with address-entry containing same addressrange ? */
 	list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
 		entry = fi_hlp->addr_list.next;
 		while (entry != &(fi_hlp->addr_list)) {
 			arm_addr =
 			    list_entry(entry, struct arm_addr, addr_list);
 			if ((arm_addr->start == addr->start)
 			    && (arm_addr->end == addr->end)) {
 				DBGMSG("same host ownes same "
 				       "addressrange -> EALREADY");
 				same_host = 1;
 				break;
 			}
 			entry = entry->next;
 		}
 		if (same_host) {
 			break;
 		}
 	}
 	if (same_host) {
 		/* addressrange occupied by same host */
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		vfree(addr->addr_space_buffer);
 		kfree(addr);
 		return (-EALREADY);
 	}
 	/* another host with valid address-entry containing same addressrange */
 	list_for_each_entry(hi, &host_info_list, list) {
 		if (hi->host != fi->host) {
 			list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
 				entry = fi_hlp->addr_list.next;
 				while (entry != &(fi_hlp->addr_list)) {
 					arm_addr =
 					    list_entry(entry, struct arm_addr,
 						       addr_list);
 					if ((arm_addr->start == addr->start)
 					    && (arm_addr->end == addr->end)) {
 						DBGMSG
 						    ("another host ownes same "
 						     "addressrange");
 						another_host = 1;
 						break;
 					}
 					entry = entry->next;
 				}
 				if (another_host) {
 					break;
 				}
 			}
 		}
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	if (another_host) {
 		DBGMSG("another hosts entry is valid -> SUCCESS");
 		if (copy_to_user(int2ptr(req->req.recvb),
 				 &addr->start, sizeof(u64))) {
 			printk(KERN_ERR "raw1394: arm_register failed "
 			       " address-range-entry is invalid -> EFAULT !!!\n");
 			vfree(addr->addr_space_buffer);
 			kfree(addr);
 			return (-EFAULT);
 		}
 		free_pending_request(req);	/* immediate success or fail */
 		/* INSERT ENTRY */
 		spin_lock_irqsave(&host_info_lock, flags);
 		list_add_tail(&addr->addr_list, &fi->addr_list);
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		return 0;
 	}
 	retval =
 	    hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops,
 				    req->req.address,
 				    req->req.address + req->req.length);
 	if (retval) {
 		/* INSERT ENTRY */
 		spin_lock_irqsave(&host_info_lock, flags);
 		list_add_tail(&addr->addr_list, &fi->addr_list);
 		spin_unlock_irqrestore(&host_info_lock, flags);
 	} else {
 		DBGMSG("arm_register failed errno: %d \n", retval);
 		vfree(addr->addr_space_buffer);
 		kfree(addr);
 		return (-EALREADY);
 	}
 	free_pending_request(req);	/* immediate success or fail */
 	return 0;
 }
 static int arm_unregister(struct file_info *fi, struct pending_request *req)
 {
 	int found = 0;
 	int retval = 0;
 	struct list_head *entry;
 	struct arm_addr *addr = NULL;
 	struct host_info *hi;
 	struct file_info *fi_hlp = NULL;
 	struct arm_addr *arm_addr = NULL;
 	int another_host;
 	unsigned long flags;
 	DBGMSG("arm_Unregister called addr(Offset): "
 	       "%8.8x %8.8x",
 	       (u32) ((req->req.address >> 32) & 0xFFFF),
 	       (u32) (req->req.address & 0xFFFFFFFF));
 	spin_lock_irqsave(&host_info_lock, flags);
 	/* get addr */
 	entry = fi->addr_list.next;
 	while (entry != &(fi->addr_list)) {
 		addr = list_entry(entry, struct arm_addr, addr_list);
 		if (addr->start == req->req.address) {
 			found = 1;
 			break;
 		}
 		entry = entry->next;
 	}
 	if (!found) {
 		DBGMSG("arm_Unregister addr not found");
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		return (-EINVAL);
 	}
 	DBGMSG("arm_Unregister addr found");
 	another_host = 0;
 	/* another host with valid address-entry containing
 	   same addressrange */
 	list_for_each_entry(hi, &host_info_list, list) {
 		if (hi->host != fi->host) {
 			list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
 				entry = fi_hlp->addr_list.next;
 				while (entry != &(fi_hlp->addr_list)) {
 					arm_addr = list_entry(entry,
 							      struct arm_addr,
 							      addr_list);
 					if (arm_addr->start == addr->start) {
 						DBGMSG("another host ownes "
 						       "same addressrange");
 						another_host = 1;
 						break;
 					}
 					entry = entry->next;
 				}
 				if (another_host) {
 					break;
 				}
 			}
 		}
 	}
 	if (another_host) {
 		DBGMSG("delete entry from list -> success");
 		list_del(&addr->addr_list);
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		vfree(addr->addr_space_buffer);
 		kfree(addr);
 		free_pending_request(req);	/* immediate success or fail */
 		return 0;
 	}
 	retval =
 	    hpsb_unregister_addrspace(&raw1394_highlevel, fi->host,
 				      addr->start);
 	if (!retval) {
 		printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n");
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		return (-EINVAL);
 	}
 	DBGMSG("delete entry from list -> success");
 	list_del(&addr->addr_list);
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	vfree(addr->addr_space_buffer);
 	kfree(addr);
 	free_pending_request(req);	/* immediate success or fail */
 	return 0;
 }
 /* Copy data from ARM buffer(s) to user buffer. */
 static int arm_get_buf(struct file_info *fi, struct pending_request *req)
 {
 	struct arm_addr *arm_addr = NULL;
 	unsigned long flags;
 	unsigned long offset;
 	struct list_head *entry;
 	DBGMSG("arm_get_buf "
 	       "addr(Offset): %04X %08X length: %u",
 	       (u32) ((req->req.address >> 32) & 0xFFFF),
 	       (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
 	spin_lock_irqsave(&host_info_lock, flags);
 	entry = fi->addr_list.next;
 	while (entry != &(fi->addr_list)) {
 		arm_addr = list_entry(entry, struct arm_addr, addr_list);
 		if ((arm_addr->start <= req->req.address) &&
 		    (arm_addr->end > req->req.address)) {
 			if (req->req.address + req->req.length <= arm_addr->end) {
 				offset = req->req.address - arm_addr->start;
 				spin_unlock_irqrestore(&host_info_lock, flags);
 				DBGMSG
 				    ("arm_get_buf copy_to_user( %08X, %p, %u )",
 				     (u32) req->req.recvb,
 				     arm_addr->addr_space_buffer + offset,
 				     (u32) req->req.length);
 				if (copy_to_user
 				    (int2ptr(req->req.recvb),
 				     arm_addr->addr_space_buffer + offset,
 				     req->req.length))
 					return (-EFAULT);
 				/* We have to free the request, because we
 				 * queue no response, and therefore nobody
 				 * will free it. */
 				free_pending_request(req);
 				return 0;
 			} else {
 				DBGMSG("arm_get_buf request exceeded mapping");
 				spin_unlock_irqrestore(&host_info_lock, flags);
 				return (-EINVAL);
 			}
 		}
 		entry = entry->next;
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	return (-EINVAL);
 }
 /* Copy data from user buffer to ARM buffer(s). */
 static int arm_set_buf(struct file_info *fi, struct pending_request *req)
 {
 	struct arm_addr *arm_addr = NULL;
 	unsigned long flags;
 	unsigned long offset;
 	struct list_head *entry;
 	DBGMSG("arm_set_buf "
 	       "addr(Offset): %04X %08X length: %u",
 	       (u32) ((req->req.address >> 32) & 0xFFFF),
 	       (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
 	spin_lock_irqsave(&host_info_lock, flags);
 	entry = fi->addr_list.next;
 	while (entry != &(fi->addr_list)) {
 		arm_addr = list_entry(entry, struct arm_addr, addr_list);
 		if ((arm_addr->start <= req->req.address) &&
 		    (arm_addr->end > req->req.address)) {
 			if (req->req.address + req->req.length <= arm_addr->end) {
 				offset = req->req.address - arm_addr->start;
 				spin_unlock_irqrestore(&host_info_lock, flags);
 				DBGMSG
 				    ("arm_set_buf copy_from_user( %p, %08X, %u )",
 				     arm_addr->addr_space_buffer + offset,
 				     (u32) req->req.sendb,
 				     (u32) req->req.length);
 				if (copy_from_user
 				    (arm_addr->addr_space_buffer + offset,
 				     int2ptr(req->req.sendb),
 				     req->req.length))
 					return (-EFAULT);
 				/* We have to free the request, because we
 				 * queue no response, and therefore nobody
 				 * will free it. */
 				free_pending_request(req);
 				return 0;
 			} else {
 				DBGMSG("arm_set_buf request exceeded mapping");
 				spin_unlock_irqrestore(&host_info_lock, flags);
 				return (-EINVAL);
 			}
 		}
 		entry = entry->next;
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	return (-EINVAL);
 }
 static int reset_notification(struct file_info *fi, struct pending_request *req)
 {
 	DBGMSG("reset_notification called - switch %s ",
 	       (req->req.misc == RAW1394_NOTIFY_OFF) ? "OFF" : "ON");
 	if ((req->req.misc == RAW1394_NOTIFY_OFF) ||
 	    (req->req.misc == RAW1394_NOTIFY_ON)) {
 		fi->notification = (u8) req->req.misc;
 		free_pending_request(req);	/* we have to free the request, because we queue no response, and therefore nobody will free it */
 		return 0;
 	}
 	/* error EINVAL (22) invalid argument */
 	return (-EINVAL);
 }
 static int write_phypacket(struct file_info *fi, struct pending_request *req)
 {
 	struct hpsb_packet *packet = NULL;
 	int retval = 0;
 	quadlet_t data;
 	unsigned long flags;
 	data = be32_to_cpu((u32) req->req.sendb);
 	DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data);
 	packet = hpsb_make_phypacket(fi->host, data);
 	if (!packet)
 		return -ENOMEM;
 	req->req.length = 0;
 	req->packet = packet;
 	hpsb_set_packet_complete_task(packet,
 				      (void (*)(void *))queue_complete_cb, req);
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	list_add_tail(&req->list, &fi->req_pending);
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 	packet->generation = req->req.generation;
 	retval = hpsb_send_packet(packet);
 	DBGMSG("write_phypacket send_packet called => retval: %d ", retval);
 	if (retval < 0) {
 		req->req.error = RAW1394_ERROR_SEND_ERROR;
 		req->req.length = 0;
 		queue_complete_req(req);
 	}
 	return 0;
 }
 static int get_config_rom(struct file_info *fi, struct pending_request *req)
 {
 	int ret = 0;
 	quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
 	int status;
 	if (!data)
 		return -ENOMEM;
 	status =
 	    csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET,
 			 data, req->req.length);
 	if (copy_to_user(int2ptr(req->req.recvb), data, req->req.length))
 		ret = -EFAULT;
 	if (copy_to_user
 	    (int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len,
 	     sizeof(fi->host->csr.rom->cache_head->len)))
 		ret = -EFAULT;
 	if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation,
 			 sizeof(fi->host->csr.generation)))
 		ret = -EFAULT;
 	if (copy_to_user(int2ptr(req->req.sendb), &status, sizeof(status)))
 		ret = -EFAULT;
 	kfree(data);
 	if (ret >= 0) {
 		free_pending_request(req);	/* we have to free the request, because we queue no response, and therefore nobody will free it */
 	}
 	return ret;
 }
 static int update_config_rom(struct file_info *fi, struct pending_request *req)
 {
 	int ret = 0;
 	quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
 	if (copy_from_user(data, int2ptr(req->req.sendb), req->req.length)) {
 		ret = -EFAULT;
 	} else {
 		int status = hpsb_update_config_rom(fi->host,
 						    data, req->req.length,
 						    (unsigned char)req->req.
 						    misc);
 		if (copy_to_user
 		    (int2ptr(req->req.recvb), &status, sizeof(status)))
 			ret = -ENOMEM;
 	}
 	kfree(data);
 	if (ret >= 0) {
 		free_pending_request(req);	/* we have to free the request, because we queue no response, and therefore nobody will free it */
 		fi->cfgrom_upd = 1;
 	}
 	return ret;
 }
 static int modify_config_rom(struct file_info *fi, struct pending_request *req)
 {
 	struct csr1212_keyval *kv;
 	struct csr1212_csr_rom_cache *cache;
 	struct csr1212_dentry *dentry;
 	u32 dr;
 	int ret = 0;
 	if (req->req.misc == ~0) {
 		if (req->req.length == 0)
 			return -EINVAL;
 		/* Find an unused slot */
 		for (dr = 0;
 		     dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr];
 		     dr++) ;
 		if (dr == RAW1394_MAX_USER_CSR_DIRS)
 			return -ENOMEM;
 		fi->csr1212_dirs[dr] =
 		    csr1212_new_directory(CSR1212_KV_ID_VENDOR);
 		if (!fi->csr1212_dirs[dr])
 			return -ENOMEM;
 	} else {
 		dr = req->req.misc;
 		if (!fi->csr1212_dirs[dr])
 			return -EINVAL;
 		/* Delete old stuff */
 		for (dentry =
 		     fi->csr1212_dirs[dr]->value.directory.dentries_head;
 		     dentry; dentry = dentry->next) {
 			csr1212_detach_keyval_from_directory(fi->host->csr.rom->
 							     root_kv,
 							     dentry->kv);
 		}
 		if (req->req.length == 0) {
 			csr1212_release_keyval(fi->csr1212_dirs[dr]);
 			fi->csr1212_dirs[dr] = NULL;
 			hpsb_update_config_rom_image(fi->host);
 			free_pending_request(req);
 			return 0;
 		}
 	}
 	cache = csr1212_rom_cache_malloc(0, req->req.length);
 	if (!cache) {
 		csr1212_release_keyval(fi->csr1212_dirs[dr]);
 		fi->csr1212_dirs[dr] = NULL;
 		return -ENOMEM;
 	}
 	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;
 		CSR1212_FREE(cache);
 		return -ENOMEM;
 	}
 	cache->filled_tail = cache->filled_head;
 	if (copy_from_user(cache->data, int2ptr(req->req.sendb),
 			   req->req.length)) {
 		csr1212_release_keyval(fi->csr1212_dirs[dr]);
 		fi->csr1212_dirs[dr] = NULL;
 		ret = -EFAULT;
 	} else {
 		cache->len = req->req.length;
 		cache->filled_head->offset_start = 0;
 		cache->filled_head->offset_end = cache->size - 1;
 		cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr];
 		ret = CSR1212_SUCCESS;
 		/* parse all the items */
 		for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv;
 		     kv = kv->next) {
 			ret = csr1212_parse_keyval(kv, cache);
 		}
 		/* attach top level items to the root directory */
 		for (dentry =
 		     fi->csr1212_dirs[dr]->value.directory.dentries_head;
 		     ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) {
 			ret =
 			    csr1212_attach_keyval_to_directory(fi->host->csr.
 							       rom->root_kv,
 							       dentry->kv);
 		}
 		if (ret == CSR1212_SUCCESS) {
 			ret = hpsb_update_config_rom_image(fi->host);
 			if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb),
 						     &dr, sizeof(dr))) {
 				ret = -ENOMEM;
 			}
 		}
 	}
 	kfree(cache->filled_head);
 	CSR1212_FREE(cache);
 	if (ret >= 0) {
 		/* we have to free the request, because we queue no response,
 		 * and therefore nobody will free it */
 		free_pending_request(req);
 		return 0;
 	} else {
 		for (dentry =
 		     fi->csr1212_dirs[dr]->value.directory.dentries_head;
 		     dentry; dentry = dentry->next) {
 			csr1212_detach_keyval_from_directory(fi->host->csr.rom->
 							     root_kv,
 							     dentry->kv);
 		}
 		csr1212_release_keyval(fi->csr1212_dirs[dr]);
 		fi->csr1212_dirs[dr] = NULL;
 		return ret;
 	}
 }
 static int state_connected(struct file_info *fi, struct pending_request *req)
 {
 	int node = req->req.address >> 48;
 	req->req.error = RAW1394_ERROR_NONE;
 	switch (req->req.type) {
 	case RAW1394_REQ_ECHO:
 		queue_complete_req(req);
 		return 0;
 	case RAW1394_REQ_ARM_REGISTER:
 		return arm_register(fi, req);
 	case RAW1394_REQ_ARM_UNREGISTER:
 		return arm_unregister(fi, req);
 	case RAW1394_REQ_ARM_SET_BUF:
 		return arm_set_buf(fi, req);
 	case RAW1394_REQ_ARM_GET_BUF:
 		return arm_get_buf(fi, req);
 	case RAW1394_REQ_RESET_NOTIFY:
 		return reset_notification(fi, req);
 	case RAW1394_REQ_ISO_SEND:
 	case RAW1394_REQ_ISO_LISTEN:
 		printk(KERN_DEBUG "raw1394: old iso ABI has been removed\n");
 		req->req.error = RAW1394_ERROR_COMPAT;
 		req->req.misc = RAW1394_KERNELAPI_VERSION;
 		queue_complete_req(req);
 		return 0;
 	case RAW1394_REQ_FCP_LISTEN:
 		handle_fcp_listen(fi, req);
 		return 0;
 	case RAW1394_REQ_RESET_BUS:
 		if (req->req.misc == RAW1394_LONG_RESET) {
 			DBGMSG("busreset called (type: LONG)");
 			hpsb_reset_bus(fi->host, LONG_RESET);
 			free_pending_request(req);	/* we have to free the request, because we queue no response, and therefore nobody will free it */
 			return 0;
 		}
 		if (req->req.misc == RAW1394_SHORT_RESET) {
 			DBGMSG("busreset called (type: SHORT)");
 			hpsb_reset_bus(fi->host, SHORT_RESET);
 			free_pending_request(req);	/* we have to free the request, because we queue no response, and therefore nobody will free it */
 			return 0;
 		}
 		/* error EINVAL (22) invalid argument */
 		return (-EINVAL);
 	case RAW1394_REQ_GET_ROM:
 		return get_config_rom(fi, req);
 	case RAW1394_REQ_UPDATE_ROM:
 		return update_config_rom(fi, req);
 	case RAW1394_REQ_MODIFY_ROM:
 		return modify_config_rom(fi, req);
 	}
 	if (req->req.generation != get_hpsb_generation(fi->host)) {
 		req->req.error = RAW1394_ERROR_GENERATION;
 		req->req.generation = get_hpsb_generation(fi->host);
 		req->req.length = 0;
 		queue_complete_req(req);
 		return 0;
 	}
 	switch (req->req.type) {
 	case RAW1394_REQ_PHYPACKET:
 		return write_phypacket(fi, req);
 	case RAW1394_REQ_ASYNC_SEND:
 		return handle_async_send(fi, req);
 	}
 	if (req->req.length == 0) {
 		req->req.error = RAW1394_ERROR_INVALID_ARG;
 		queue_complete_req(req);
 		return 0;
 	}
 	return handle_async_request(fi, req, node);
 }
 static ssize_t raw1394_write(struct file *file, const char __user * buffer,
 			     size_t count, loff_t * offset_is_ignored)
 {
 	struct file_info *fi = (struct file_info *)file->private_data;
 	struct pending_request *req;
 	ssize_t retval = -EBADFD;
 #ifdef CONFIG_COMPAT
 	if (count == sizeof(struct compat_raw1394_req) &&
    	    sizeof(struct compat_raw1394_req) !=
 			sizeof(struct raw1394_request)) {
 		buffer = raw1394_compat_write(buffer);
 		if (IS_ERR((__force void *)buffer))
 			return PTR_ERR((__force void *)buffer);
 	} else
 #endif
 	if (count != sizeof(struct raw1394_request)) {
 		return -EINVAL;
 	}
 	req = alloc_pending_request();
 	if (req == NULL) {
 		return -ENOMEM;
 	}
 	req->file_info = fi;
 	if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
 		free_pending_request(req);
 		return -EFAULT;
 	}
 	if (!mutex_trylock(&fi->state_mutex)) {
 		free_pending_request(req);
 		return -EAGAIN;
 	}
 	switch (fi->state) {
 	case opened:
 		retval = state_opened(fi, req);
 		break;
 	case initialized:
 		retval = state_initialized(fi, req);
 		break;
 	case connected:
 		retval = state_connected(fi, req);
 		break;
 	}
 	mutex_unlock(&fi->state_mutex);
 	if (retval < 0) {
 		free_pending_request(req);
 	} else {
 		BUG_ON(retval);
 		retval = count;
 	}
 	return retval;
 }
 /* rawiso operations */
 /* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
  * completion queue (reqlists_lock must be taken) */
 static inline int __rawiso_event_in_queue(struct file_info *fi)
 {
 	struct pending_request *req;
 	list_for_each_entry(req, &fi->req_complete, list)
 	    if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY)
 		return 1;
 	return 0;
 }
 /* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
 static void queue_rawiso_event(struct file_info *fi)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	/* only one ISO activity event may be in the queue */
 	if (!__rawiso_event_in_queue(fi)) {
 		struct pending_request *req =
 		    __alloc_pending_request(GFP_ATOMIC);
 		if (req) {
 			req->file_info = fi;
 			req->req.type = RAW1394_REQ_RAWISO_ACTIVITY;
 			req->req.generation = get_hpsb_generation(fi->host);
 			__queue_complete_req(req);
 		} else {
 			/* on allocation failure, signal an overflow */
 			if (fi->iso_handle) {
 				atomic_inc(&fi->iso_handle->overflows);
 			}
 		}
 	}
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 }
 static void rawiso_activity_cb(struct hpsb_iso *iso)
 {
 	unsigned long flags;
 	struct host_info *hi;
 	struct file_info *fi;
 	spin_lock_irqsave(&host_info_lock, flags);
 	hi = find_host_info(iso->host);
 	if (hi != NULL) {
 		list_for_each_entry(fi, &hi->file_info_list, list) {
 			if (fi->iso_handle == iso)
 				queue_rawiso_event(fi);
 		}
 	}
 	spin_unlock_irqrestore(&host_info_lock, flags);
 }
 /* helper function - gather all the kernel iso status bits for returning to user-space */
 static void raw1394_iso_fill_status(struct hpsb_iso *iso,
 				    struct raw1394_iso_status *stat)
 {
 	int overflows = atomic_read(&iso->overflows);
 	int skips = atomic_read(&iso->skips);
 	stat->config.data_buf_size = iso->buf_size;
 	stat->config.buf_packets = iso->buf_packets;
 	stat->config.channel = iso->channel;
 	stat->config.speed = iso->speed;
 	stat->config.irq_interval = iso->irq_interval;
 	stat->n_packets = hpsb_iso_n_ready(iso);
 	stat->overflows = ((skips & 0xFFFF) << 16) | ((overflows & 0xFFFF));
 	stat->xmit_cycle = iso->xmit_cycle;
 }
 static int raw1394_iso_xmit_init(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_iso_status stat;
 	if (!fi->host)
 		return -EINVAL;
 	if (copy_from_user(&stat, uaddr, sizeof(stat)))
 		return -EFAULT;
 	fi->iso_handle = hpsb_iso_xmit_init(fi->host,
 					    stat.config.data_buf_size,
 					    stat.config.buf_packets,
 					    stat.config.channel,
 					    stat.config.speed,
 					    stat.config.irq_interval,
 					    rawiso_activity_cb);
 	if (!fi->iso_handle)
 		return -ENOMEM;
 	fi->iso_state = RAW1394_ISO_XMIT;
 	raw1394_iso_fill_status(fi->iso_handle, &stat);
 	if (copy_to_user(uaddr, &stat, sizeof(stat)))
 		return -EFAULT;
 	/* queue an event to get things started */
 	rawiso_activity_cb(fi->iso_handle);
 	return 0;
 }
 static int raw1394_iso_recv_init(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_iso_status stat;
 	if (!fi->host)
 		return -EINVAL;
 	if (copy_from_user(&stat, uaddr, sizeof(stat)))
 		return -EFAULT;
 	fi->iso_handle = hpsb_iso_recv_init(fi->host,
 					    stat.config.data_buf_size,
 					    stat.config.buf_packets,
 					    stat.config.channel,
 					    stat.config.dma_mode,
 					    stat.config.irq_interval,
 					    rawiso_activity_cb);
 	if (!fi->iso_handle)
 		return -ENOMEM;
 	fi->iso_state = RAW1394_ISO_RECV;
 	raw1394_iso_fill_status(fi->iso_handle, &stat);
 	if (copy_to_user(uaddr, &stat, sizeof(stat)))
 		return -EFAULT;
 	return 0;
 }
 static int raw1394_iso_get_status(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_iso_status stat;
 	struct hpsb_iso *iso = fi->iso_handle;
 	raw1394_iso_fill_status(fi->iso_handle, &stat);
 	if (copy_to_user(uaddr, &stat, sizeof(stat)))
 		return -EFAULT;
 	/* reset overflow counter */
 	atomic_set(&iso->overflows, 0);
 	/* reset skip counter */
 	atomic_set(&iso->skips, 0);
 	return 0;
 }
 /* copy N packet_infos out of the ringbuffer into user-supplied array */
 static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_iso_packets upackets;
 	unsigned int packet = fi->iso_handle->first_packet;
 	int i;
 	if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
 		return -EFAULT;
 	if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
 		return -EINVAL;
 	/* ensure user-supplied buffer is accessible and big enough */
 	if (!access_ok(VERIFY_WRITE, upackets.infos,
 		       upackets.n_packets *
 		       sizeof(struct raw1394_iso_packet_info)))
 		return -EFAULT;
 	/* copy the packet_infos out */
 	for (i = 0; i < upackets.n_packets; i++) {
 		if (__copy_to_user(&upackets.infos[i],
 				   &fi->iso_handle->infos[packet],
 				   sizeof(struct raw1394_iso_packet_info)))
 			return -EFAULT;
 		packet = (packet + 1) % fi->iso_handle->buf_packets;
 	}
 	return 0;
 }
 /* copy N packet_infos from user to ringbuffer, and queue them for transmission */
 static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_iso_packets upackets;
 	int i, rv;
 	if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
 		return -EFAULT;
 	if (upackets.n_packets >= fi->iso_handle->buf_packets)
 		return -EINVAL;
 	if (upackets.n_packets >= hpsb_iso_n_ready(fi->iso_handle))
 		return -EAGAIN;
 	/* ensure user-supplied buffer is accessible and big enough */
 	if (!access_ok(VERIFY_READ, upackets.infos,
 		       upackets.n_packets *
 		       sizeof(struct raw1394_iso_packet_info)))
 		return -EFAULT;
 	/* copy the infos structs in and queue the packets */
 	for (i = 0; i < upackets.n_packets; i++) {
 		struct raw1394_iso_packet_info info;
 		if (__copy_from_user(&info, &upackets.infos[i],
 				     sizeof(struct raw1394_iso_packet_info)))
 			return -EFAULT;
 		rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset,
 						info.len, info.tag, info.sy);
 		if (rv)
 			return rv;
 	}
 	return 0;
 }
 static void raw1394_iso_shutdown(struct file_info *fi)
 {
 	if (fi->iso_handle)
 		hpsb_iso_shutdown(fi->iso_handle);
 	fi->iso_handle = NULL;
 	fi->iso_state = RAW1394_ISO_INACTIVE;
 }
 static int raw1394_read_cycle_timer(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_cycle_timer ct;
 	int err;
 	err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
 	if (!err)
 		if (copy_to_user(uaddr, &ct, sizeof(ct)))
 			err = -EFAULT;
 	return err;
 }
 /* mmap the rawiso xmit/recv buffer */
 static int raw1394_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct file_info *fi = file->private_data;
 	int ret;
 	if (!mutex_trylock(&fi->state_mutex))
 		return -EAGAIN;
 	if (fi->iso_state == RAW1394_ISO_INACTIVE)
 		ret = -EINVAL;
 	else
 		ret = dma_region_mmap(&fi->iso_handle->data_buf, file, vma);
 	mutex_unlock(&fi->state_mutex);
 	return ret;
 }
 static long raw1394_ioctl_inactive(struct file_info *fi, unsigned int cmd,
 				   void __user *argp)
 {
 	switch (cmd) {
 	case RAW1394_IOC_ISO_XMIT_INIT:
 		return raw1394_iso_xmit_init(fi, argp);
 	case RAW1394_IOC_ISO_RECV_INIT:
 		return raw1394_iso_recv_init(fi, argp);
 	default:
 		return -EINVAL;
 	}
 }
 static long raw1394_ioctl_recv(struct file_info *fi, unsigned int cmd,
 			       unsigned long arg)
 {
 	void __user *argp = (void __user *)arg;
 	switch (cmd) {
 	case RAW1394_IOC_ISO_RECV_START:{
 			int args[3];
 			if (copy_from_user(&args[0], argp, sizeof(args)))
 				return -EFAULT;
 			return hpsb_iso_recv_start(fi->iso_handle,
 						   args[0], args[1], args[2]);
 		}
 	case RAW1394_IOC_ISO_XMIT_RECV_STOP:
 		hpsb_iso_stop(fi->iso_handle);
 		return 0;
 	case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
 		return hpsb_iso_recv_listen_channel(fi->iso_handle, arg);
 	case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
 		return hpsb_iso_recv_unlisten_channel(fi->iso_handle, arg);
 	case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:{
 			u64 mask;
 			if (copy_from_user(&mask, argp, sizeof(mask)))
 				return -EFAULT;
 			return hpsb_iso_recv_set_channel_mask(fi->iso_handle,
 							      mask);
 		}
 	case RAW1394_IOC_ISO_GET_STATUS:
 		return raw1394_iso_get_status(fi, argp);
 	case RAW1394_IOC_ISO_RECV_PACKETS:
 		return raw1394_iso_recv_packets(fi, argp);
 	case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
 		return hpsb_iso_recv_release_packets(fi->iso_handle, arg);
 	case RAW1394_IOC_ISO_RECV_FLUSH:
 		return hpsb_iso_recv_flush(fi->iso_handle);
 	case RAW1394_IOC_ISO_SHUTDOWN:
 		raw1394_iso_shutdown(fi);
 		return 0;
 	case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
 		queue_rawiso_event(fi);
 		return 0;
 	default:
 		return -EINVAL;
 	}
 }
 static long raw1394_ioctl_xmit(struct file_info *fi, unsigned int cmd,
 			       void __user *argp)
 {
 	switch (cmd) {
 	case RAW1394_IOC_ISO_XMIT_START:{
 			int args[2];
 			if (copy_from_user(&args[0], argp, sizeof(args)))
 				return -EFAULT;
 			return hpsb_iso_xmit_start(fi->iso_handle,
 						   args[0], args[1]);
 		}
 	case RAW1394_IOC_ISO_XMIT_SYNC:
 		return hpsb_iso_xmit_sync(fi->iso_handle);
 	case RAW1394_IOC_ISO_XMIT_RECV_STOP:
 		hpsb_iso_stop(fi->iso_handle);
 		return 0;
 	case RAW1394_IOC_ISO_GET_STATUS:
 		return raw1394_iso_get_status(fi, argp);
 	case RAW1394_IOC_ISO_XMIT_PACKETS:
 		return raw1394_iso_send_packets(fi, argp);
 	case RAW1394_IOC_ISO_SHUTDOWN:
 		raw1394_iso_shutdown(fi);
 		return 0;
 	case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
 		queue_rawiso_event(fi);
 		return 0;
 	default:
 		return -EINVAL;
 	}
 }
 /* ioctl is only used for rawiso operations */
 static long raw1394_ioctl(struct file *file, unsigned int cmd,
 			  unsigned long arg)
 {
 	struct file_info *fi = file->private_data;
 	void __user *argp = (void __user *)arg;
 	long ret;
 	/* state-independent commands */
 	switch(cmd) {
 	case RAW1394_IOC_GET_CYCLE_TIMER:
 		return raw1394_read_cycle_timer(fi, argp);
 	default:
 		break;
 	}
 	if (!mutex_trylock(&fi->state_mutex))
 		return -EAGAIN;
 	switch (fi->iso_state) {
 	case RAW1394_ISO_INACTIVE:
 		ret = raw1394_ioctl_inactive(fi, cmd, argp);
 		break;
 	case RAW1394_ISO_RECV:
 		ret = raw1394_ioctl_recv(fi, cmd, arg);
 		break;
 	case RAW1394_ISO_XMIT:
 		ret = raw1394_ioctl_xmit(fi, cmd, argp);
 		break;
 	default:
 		ret = -EINVAL;
 		break;
 	}
 	mutex_unlock(&fi->state_mutex);
 	return ret;
 }
 #ifdef CONFIG_COMPAT
 struct raw1394_iso_packets32 {
         __u32 n_packets;
         compat_uptr_t infos;
 } __attribute__((packed));
 struct raw1394_cycle_timer32 {
         __u32 cycle_timer;
         __u64 local_time;
 }
 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
 __attribute__((packed))
 #endif
 ;
 #define RAW1394_IOC_ISO_RECV_PACKETS32          \
         _IOW ('#', 0x25, struct raw1394_iso_packets32)
 #define RAW1394_IOC_ISO_XMIT_PACKETS32          \
         _IOW ('#', 0x27, struct raw1394_iso_packets32)
 #define RAW1394_IOC_GET_CYCLE_TIMER32           \
         _IOR ('#', 0x30, struct raw1394_cycle_timer32)
 static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd,
                                           struct raw1394_iso_packets32 __user *arg)
 {
 	compat_uptr_t infos32;
 	void __user *infos;
 	long err = -EFAULT;
 	struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets));
 	if (!copy_in_user(&dst->n_packets, &arg->n_packets, sizeof arg->n_packets) &&
 	    !copy_from_user(&infos32, &arg->infos, sizeof infos32)) {
 		infos = compat_ptr(infos32);
 		if (!copy_to_user(&dst->infos, &infos, sizeof infos))
 			err = raw1394_ioctl(file, cmd, (unsigned long)dst);
 	}
 	return err;
 }
 static long raw1394_read_cycle_timer32(struct file_info *fi, void __user * uaddr)
 {
 	struct raw1394_cycle_timer32 ct;
 	int err;
 	err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
 	if (!err)
 		if (copy_to_user(uaddr, &ct, sizeof(ct)))
 			err = -EFAULT;
 	return err;
 }
 static long raw1394_compat_ioctl(struct file *file,
 				 unsigned int cmd, unsigned long arg)
 {
 	struct file_info *fi = file->private_data;
 	void __user *argp = (void __user *)arg;
 	long err;
 	switch (cmd) {
 	/* These requests have same format as long as 'int' has same size. */
 	case RAW1394_IOC_ISO_RECV_INIT:
 	case RAW1394_IOC_ISO_RECV_START:
 	case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
 	case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
 	case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:
 	case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
 	case RAW1394_IOC_ISO_RECV_FLUSH:
 	case RAW1394_IOC_ISO_XMIT_RECV_STOP:
 	case RAW1394_IOC_ISO_XMIT_INIT:
 	case RAW1394_IOC_ISO_XMIT_START:
 	case RAW1394_IOC_ISO_XMIT_SYNC:
 	case RAW1394_IOC_ISO_GET_STATUS:
 	case RAW1394_IOC_ISO_SHUTDOWN:
 	case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
 		err = raw1394_ioctl(file, cmd, arg);
 		break;
 	/* These request have different format. */
 	case RAW1394_IOC_ISO_RECV_PACKETS32:
 		err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_RECV_PACKETS, argp);
 		break;
 	case RAW1394_IOC_ISO_XMIT_PACKETS32:
 		err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_XMIT_PACKETS, argp);
 		break;
 	case RAW1394_IOC_GET_CYCLE_TIMER32:
 		err = raw1394_read_cycle_timer32(fi, argp);
 		break;
 	default:
 		err = -EINVAL;
 		break;
 	}
 	return err;
 }
 #endif
 static unsigned int raw1394_poll(struct file *file, poll_table * pt)
 {
 	struct file_info *fi = file->private_data;
 	unsigned int mask = POLLOUT | POLLWRNORM;
 	unsigned long flags;
 	poll_wait(file, &fi->wait_complete, pt);
 	spin_lock_irqsave(&fi->reqlists_lock, flags);
 	if (!list_empty(&fi->req_complete)) {
 		mask |= POLLIN | POLLRDNORM;
 	}
 	spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 	return mask;
 }
 static int raw1394_open(struct inode *inode, struct file *file)
 {
 	struct file_info *fi;
 	fi = kzalloc(sizeof(*fi), GFP_KERNEL);
 	if (!fi)
 		return -ENOMEM;
 	fi->notification = (u8) RAW1394_NOTIFY_ON;	/* busreset notification */
 	INIT_LIST_HEAD(&fi->list);
 	mutex_init(&fi->state_mutex);
 	fi->state = opened;
 	INIT_LIST_HEAD(&fi->req_pending);
 	INIT_LIST_HEAD(&fi->req_complete);
 	spin_lock_init(&fi->reqlists_lock);
 	init_waitqueue_head(&fi->wait_complete);
 	INIT_LIST_HEAD(&fi->addr_list);
 	file->private_data = fi;
 	return nonseekable_open(inode, file);
 }
 static int raw1394_release(struct inode *inode, struct file *file)
 {
 	struct file_info *fi = file->private_data;
 	struct list_head *lh;
 	struct pending_request *req;
 	int i, fail;
 	int retval = 0;
 	struct list_head *entry;
 	struct arm_addr *addr = NULL;
 	struct host_info *hi;
 	struct file_info *fi_hlp = NULL;
 	struct arm_addr *arm_addr = NULL;
 	int another_host;
 	int csr_mod = 0;
 	unsigned long flags;
 	if (fi->iso_state != RAW1394_ISO_INACTIVE)
 		raw1394_iso_shutdown(fi);
 	spin_lock_irqsave(&host_info_lock, flags);
 	fail = 0;
 	/* set address-entries invalid */
 	while (!list_empty(&fi->addr_list)) {
 		another_host = 0;
 		lh = fi->addr_list.next;
 		addr = list_entry(lh, struct arm_addr, addr_list);
 		/* another host with valid address-entry containing
 		   same addressrange? */
 		list_for_each_entry(hi, &host_info_list, list) {
 			if (hi->host != fi->host) {
 				list_for_each_entry(fi_hlp, &hi->file_info_list,
 						    list) {
 					entry = fi_hlp->addr_list.next;
 					while (entry != &(fi_hlp->addr_list)) {
 						arm_addr = list_entry(entry, struct
 								      arm_addr,
 								      addr_list);
 						if (arm_addr->start ==
 						    addr->start) {
 							DBGMSG
 							    ("raw1394_release: "
 							     "another host ownes "
 							     "same addressrange");
 							another_host = 1;
 							break;
 						}
 						entry = entry->next;
 					}
 					if (another_host) {
 						break;
 					}
 				}
 			}
 		}
 		if (!another_host) {
 			DBGMSG("raw1394_release: call hpsb_arm_unregister");
 			retval =
 			    hpsb_unregister_addrspace(&raw1394_highlevel,
 						      fi->host, addr->start);
 			if (!retval) {
 				++fail;
 				printk(KERN_ERR
 				       "raw1394_release arm_Unregister failed\n");
 			}
 		}
 		DBGMSG("raw1394_release: delete addr_entry from list");
 		list_del(&addr->addr_list);
 		vfree(addr->addr_space_buffer);
 		kfree(addr);
 	}			/* while */
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	if (fail > 0) {
 		printk(KERN_ERR "raw1394: during addr_list-release "
 		       "error(s) occurred \n");
 	}
 	for (;;) {
 		/* This locked section guarantees that neither
 		 * complete nor pending requests exist once i!=0 */
 		spin_lock_irqsave(&fi->reqlists_lock, flags);
 		while ((req = __next_complete_req(fi)))
 			free_pending_request(req);
 		i = list_empty(&fi->req_pending);
 		spin_unlock_irqrestore(&fi->reqlists_lock, flags);
 		if (i)
 			break;
 		/*
 		 * Sleep until more requests can be freed.
 		 *
 		 * NB: We call the macro wait_event() with a condition argument
 		 * with side effect.  This is only possible because the side
 		 * effect does not occur until the condition became true, and
 		 * wait_event() won't evaluate the condition again after that.
 		 */
 		wait_event(fi->wait_complete, (req = next_complete_req(fi)));
 		free_pending_request(req);
 	}
 	/* Remove any sub-trees left by user space programs */
 	for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) {
 		struct csr1212_dentry *dentry;
 		if (!fi->csr1212_dirs[i])
 			continue;
 		for (dentry =
 		     fi->csr1212_dirs[i]->value.directory.dentries_head; dentry;
 		     dentry = dentry->next) {
 			csr1212_detach_keyval_from_directory(fi->host->csr.rom->
 							     root_kv,
 							     dentry->kv);
 		}
 		csr1212_release_keyval(fi->csr1212_dirs[i]);
 		fi->csr1212_dirs[i] = NULL;
 		csr_mod = 1;
 	}
 	if ((csr_mod || fi->cfgrom_upd)
 	    && hpsb_update_config_rom_image(fi->host) < 0)
 		HPSB_ERR
 		    ("Failed to generate Configuration ROM image for host %d",
 		     fi->host->id);
 	if (fi->state == connected) {
 		spin_lock_irqsave(&host_info_lock, flags);
 		list_del(&fi->list);
 		spin_unlock_irqrestore(&host_info_lock, flags);
 		put_device(&fi->host->device);
 	}
 	spin_lock_irqsave(&host_info_lock, flags);
 	if (fi->host)
 		module_put(fi->host->driver->owner);
 	spin_unlock_irqrestore(&host_info_lock, flags);
 	kfree(fi);
 	return 0;
 }
 /*** HOTPLUG STUFF **********************************************************/
 /*
  * Export information about protocols/devices supported by this driver.
  */
 #ifdef MODULE
 static const struct ieee1394_device_id raw1394_id_table[] = {
 	{
 	 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
 	 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
 	 .version = AVC_SW_VERSION_ENTRY & 0xffffff},
 	{
 	 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
 	 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
 	 .version = CAMERA_SW_VERSION_ENTRY & 0xffffff},
 	{
 	 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
 	 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
 	 .version = (CAMERA_SW_VERSION_ENTRY + 1) & 0xffffff},
 	{
 	 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
 	 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
 	 .version = (CAMERA_SW_VERSION_ENTRY + 2) & 0xffffff},
 	{}
 };
 MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table);
 #endif /* MODULE */
 static struct hpsb_protocol_driver raw1394_driver = {
 	.name = "raw1394",
 };
 /******************************************************************************/
 static struct hpsb_highlevel raw1394_highlevel = {
 	.name = RAW1394_DEVICE_NAME,
 	.add_host = add_host,
 	.remove_host = remove_host,
 	.host_reset = host_reset,
 	.fcp_request = fcp_request,
 };
 static struct cdev raw1394_cdev;
 static const struct file_operations raw1394_fops = {
 	.owner = THIS_MODULE,
 	.read = raw1394_read,
 	.write = raw1394_write,
 	.mmap = raw1394_mmap,
 	.unlocked_ioctl = raw1394_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl = raw1394_compat_ioctl,
 #endif
 	.poll = raw1394_poll,
 	.open = raw1394_open,
 	.release = raw1394_release,
 	.llseek = no_llseek,
 };
 static int __init init_raw1394(void)
 {
 	int ret = 0;
 	hpsb_register_highlevel(&raw1394_highlevel);
 	if (IS_ERR
 	    (device_create(hpsb_protocol_class, NULL,
 			   MKDEV(IEEE1394_MAJOR,
 				 IEEE1394_MINOR_BLOCK_RAW1394 * 16),
 			   NULL, RAW1394_DEVICE_NAME))) {
 		ret = -EFAULT;
 		goto out_unreg;
 	}
 	cdev_init(&raw1394_cdev, &raw1394_fops);
 	raw1394_cdev.owner = THIS_MODULE;
 	ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1);
 	if (ret) {
 		HPSB_ERR("raw1394 failed to register minor device block");
 		goto out_dev;
 	}
 	HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME);
 	ret = hpsb_register_protocol(&raw1394_driver);
 	if (ret) {
 		HPSB_ERR("raw1394: failed to register protocol");
 		cdev_del(&raw1394_cdev);
 		goto out_dev;
 	}
 	goto out;
       out_dev:
 	device_destroy(hpsb_protocol_class,
 		       MKDEV(IEEE1394_MAJOR,
 			     IEEE1394_MINOR_BLOCK_RAW1394 * 16));
       out_unreg:
 	hpsb_unregister_highlevel(&raw1394_highlevel);
       out:
 	return ret;
 }
 static void __exit cleanup_raw1394(void)
 {
 	device_destroy(hpsb_protocol_class,
 		       MKDEV(IEEE1394_MAJOR,
 			     IEEE1394_MINOR_BLOCK_RAW1394 * 16));
 	cdev_del(&raw1394_cdev);
 	hpsb_unregister_highlevel(&raw1394_highlevel);
 	hpsb_unregister_protocol(&raw1394_driver);
 }
 module_init(init_raw1394);
 module_exit(cleanup_raw1394);
 MODULE_LICENSE("GPL");

drivers/ieee1394/sbp2.c

Diff comments View file @ 5030c80

 /*
  * sbp2.c - SBP-2 protocol driver for IEEE-1394
  *
  * Copyright (C) 2000 James Goodwin, Filanet Corporation (www.filanet.com)
  * jamesg@filanet.com (JSG)
  *
  * Copyright (C) 2003 Ben Collins <bcollins@debian.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 /*
  * Brief Description:
  *
  * This driver implements the Serial Bus Protocol 2 (SBP-2) over IEEE-1394
  * under Linux. The SBP-2 driver is implemented as an IEEE-1394 high-level
  * driver. It also registers as a SCSI lower-level driver in order to accept
  * SCSI commands for transport using SBP-2.
  *
  * You may access any attached SBP-2 (usually storage devices) as regular
  * SCSI devices. E.g. mount /dev/sda1, fdisk, mkfs, etc..
  *
  * See http://www.t10.org/drafts.htm#sbp2 for the final draft of the SBP-2
  * specification and for where to purchase the official standard.
  *
  * TODO:
  *   - look into possible improvements of the SCSI error handlers
  *   - handle Unit_Characteristics.mgt_ORB_timeout and .ORB_size
  *   - handle Logical_Unit_Number.ordered
  *   - handle src == 1 in status blocks
  *   - reimplement the DMA mapping in absence of physical DMA so that
  *     bus_to_virt is no longer required
  *   - debug the handling of absent physical DMA
  *   - replace CONFIG_IEEE1394_SBP2_PHYS_DMA by automatic detection
  *     (this is easy but depends on the previous two TODO items)
  *   - make the parameter serialize_io configurable per device
  *   - move all requests to fetch agent registers into non-atomic context,
  *     replace all usages of sbp2util_node_write_no_wait by true transactions
  * Grep for inline FIXME comments below.
  */
 #include <linux/blkdev.h>
 #include <linux/compiler.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/stringify.h>
 #include <linux/types.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
 #include <linux/scatterlist.h>
 #include <asm/byteorder.h>
 #include <asm/errno.h>
 #include <asm/param.h>
 #include <asm/system.h>
 #include <asm/types.h>
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 #include <asm/io.h> /* for bus_to_virt */
 #endif
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include "csr1212.h"
 #include "highlevel.h"
 #include "hosts.h"
 #include "ieee1394.h"
 #include "ieee1394_core.h"
 #include "ieee1394_hotplug.h"
 #include "ieee1394_transactions.h"
 #include "ieee1394_types.h"
 #include "nodemgr.h"
 #include "sbp2.h"
 /*
  * Module load parameter definitions
  */
 /*
  * Change max_speed on module load if you have a bad IEEE-1394
  * controller that has trouble running 2KB packets at 400mb.
  *
  * NOTE: On certain OHCI parts I have seen short packets on async transmit
  * (probably due to PCI latency/throughput issues with the part). You can
  * bump down the speed if you are running into problems.
  */
 static int sbp2_max_speed = IEEE1394_SPEED_MAX;
 module_param_named(max_speed, sbp2_max_speed, int, 0644);
 MODULE_PARM_DESC(max_speed, "Limit data transfer speed (5 <= 3200, "
 		 "4 <= 1600, 3 <= 800, 2 <= 400, 1 <= 200, 0 = 100 Mb/s)");
 /*
  * Set serialize_io to 0 or N to use dynamically appended lists of command ORBs.
  * This is and always has been buggy in multiple subtle ways. See above TODOs.
  */
 static int sbp2_serialize_io = 1;
 module_param_named(serialize_io, sbp2_serialize_io, bool, 0444);
 MODULE_PARM_DESC(serialize_io, "Serialize requests coming from SCSI drivers "
 		 "(default = Y, faster but buggy = N)");
 /*
  * Adjust max_sectors if you'd like to influence how many sectors each SCSI
  * command can transfer at most. Please note that some older SBP-2 bridge
  * chips are broken for transfers greater or equal to 128KB, therefore
  * max_sectors used to be a safe 255 sectors for many years. We now have a
  * default of 0 here which means that we let the SCSI stack choose a limit.
  *
  * The SBP2_WORKAROUND_128K_MAX_TRANS flag, if set either in the workarounds
  * module parameter or in the sbp2_workarounds_table[], will override the
  * value of max_sectors. We should use sbp2_workarounds_table[] to cover any
  * bridge chip which becomes known to need the 255 sectors limit.
  */
 static int sbp2_max_sectors;
 module_param_named(max_sectors, sbp2_max_sectors, int, 0444);
 MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported "
 		 "(default = 0 = use SCSI stack's default)");
 /*
  * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
  * do an exclusive login, as it's generally unsafe to have two hosts
  * talking to a single sbp2 device at the same time (filesystem coherency,
  * etc.). If you're running an sbp2 device that supports multiple logins,
  * and you're either running read-only filesystems or some sort of special
  * filesystem supporting multiple hosts, e.g. OpenGFS, Oracle Cluster
  * File System, or Lustre, then set exclusive_login to zero.
  *
  * So far only bridges from Oxford Semiconductor are known to support
  * concurrent logins. Depending on firmware, four or two concurrent logins
  * are possible on OXFW911 and newer Oxsemi bridges.
  */
 static int sbp2_exclusive_login = 1;
 module_param_named(exclusive_login, sbp2_exclusive_login, bool, 0644);
 MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
 		 "(default = Y, use N for concurrent initiators)");
 /*
  * If any of the following workarounds is required for your device to work,
  * please submit the kernel messages logged by sbp2 to the linux1394-devel
  * mailing list.
  *
  * - 128kB max transfer
  *   Limit transfer size. Necessary for some old bridges.
  *
  * - 36 byte inquiry
  *   When scsi_mod probes the device, let the inquiry command look like that
  *   from MS Windows.
  *
  * - skip mode page 8
  *   Suppress sending of mode_sense for mode page 8 if the device pretends to
  *   support the SCSI Primary Block commands instead of Reduced Block Commands.
  *
  * - fix capacity
  *   Tell sd_mod to correct the last sector number reported by read_capacity.
  *   Avoids access beyond actual disk limits on devices with an off-by-one bug.
  *   Don't use this with devices which don't have this bug.
  *
  * - delay inquiry
  *   Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
  *
  * - power condition
  *   Set the power condition field in the START STOP UNIT commands sent by
  *   sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
  *   Some disks need this to spin down or to resume properly.
  *
  * - override internal blacklist
  *   Instead of adding to the built-in blacklist, use only the workarounds
  *   specified in the module load parameter.
  *   Useful if a blacklist entry interfered with a non-broken device.
  */
 static int sbp2_default_workarounds;
 module_param_named(workarounds, sbp2_default_workarounds, int, 0644);
 MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
 	", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
 	", 36 byte inquiry = "    __stringify(SBP2_WORKAROUND_INQUIRY_36)
 	", skip mode page 8 = "   __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
 	", fix capacity = "       __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
 	", delay inquiry = "      __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
 	", set power condition in start stop unit = "
 				  __stringify(SBP2_WORKAROUND_POWER_CONDITION)
 	", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
 	", or a combination)");
 /*
  * This influences the format of the sysfs attribute
  * /sys/bus/scsi/devices/.../ieee1394_id.
  *
  * The default format is like in older kernels:  %016Lx:%d:%d
  * It contains the target's EUI-64, a number given to the logical unit by
  * the ieee1394 driver's nodemgr (starting at 0), and the LUN.
  *
  * The long format is:  %016Lx:%06x:%04x
  * It contains the target's EUI-64, the unit directory's directory_ID as per
  * IEEE 1212 clause 7.7.19, and the LUN.  This format comes closest to the
  * format of SBP(-3) target port and logical unit identifier as per SAM (SCSI
  * Architecture Model) rev.2 to 4 annex A.  Therefore and because it is
  * independent of the implementation of the ieee1394 nodemgr, the longer format
  * is recommended for future use.
  */
 static int sbp2_long_sysfs_ieee1394_id;
 module_param_named(long_ieee1394_id, sbp2_long_sysfs_ieee1394_id, bool, 0644);
 MODULE_PARM_DESC(long_ieee1394_id, "8+3+2 bytes format of ieee1394_id in sysfs "
 		 "(default = backwards-compatible = N, SAM-conforming = Y)");
 #define SBP2_INFO(fmt, args...)	HPSB_INFO("sbp2: "fmt, ## args)
 #define SBP2_ERR(fmt, args...)	HPSB_ERR("sbp2: "fmt, ## args)
 /*
  * Globals
  */
 static void sbp2scsi_complete_all_commands(struct sbp2_lu *, u32);
 static void sbp2scsi_complete_command(struct sbp2_lu *, u32, struct scsi_cmnd *,
 				      void (*)(struct scsi_cmnd *));
 static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *);
 static int sbp2_start_device(struct sbp2_lu *);
 static void sbp2_remove_device(struct sbp2_lu *);
 static int sbp2_login_device(struct sbp2_lu *);
 static int sbp2_reconnect_device(struct sbp2_lu *);
 static int sbp2_logout_device(struct sbp2_lu *);
 static void sbp2_host_reset(struct hpsb_host *);
 static int sbp2_handle_status_write(struct hpsb_host *, int, int, quadlet_t *,
 				    u64, size_t, u16);
 static int sbp2_agent_reset(struct sbp2_lu *, int);
 static void sbp2_parse_unit_directory(struct sbp2_lu *,
 				      struct unit_directory *);
 static int sbp2_set_busy_timeout(struct sbp2_lu *);
 static int sbp2_max_speed_and_size(struct sbp2_lu *);
 static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xa, 0xa, 0xa };
 static DEFINE_RWLOCK(sbp2_hi_logical_units_lock);
 static struct hpsb_highlevel sbp2_highlevel = {
 	.name		= SBP2_DEVICE_NAME,
 	.host_reset	= sbp2_host_reset,
 };
 static const struct hpsb_address_ops sbp2_ops = {
 	.write		= sbp2_handle_status_write
 };
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 static int sbp2_handle_physdma_write(struct hpsb_host *, int, int, quadlet_t *,
 				     u64, size_t, u16);
 static int sbp2_handle_physdma_read(struct hpsb_host *, int, quadlet_t *, u64,
 				    size_t, u16);
 static const struct hpsb_address_ops sbp2_physdma_ops = {
 	.read		= sbp2_handle_physdma_read,
 	.write		= sbp2_handle_physdma_write,
 };
 #endif
 /*
  * Interface to driver core and IEEE 1394 core
  */
 static const 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},
 	{}
 };
 MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
 static int sbp2_probe(struct device *);
 static int sbp2_remove(struct device *);
 static int sbp2_update(struct unit_directory *);
 static struct hpsb_protocol_driver sbp2_driver = {
 	.name		= SBP2_DEVICE_NAME,
 	.id_table	= sbp2_id_table,
 	.update		= sbp2_update,
 	.driver		= {
 		.probe		= sbp2_probe,
 		.remove		= sbp2_remove,
 	},
 };
 /*
  * Interface to SCSI core
  */
 static int sbp2scsi_queuecommand(struct scsi_cmnd *,
 				 void (*)(struct scsi_cmnd *));
 static int sbp2scsi_abort(struct scsi_cmnd *);
 static int sbp2scsi_reset(struct scsi_cmnd *);
 static int sbp2scsi_slave_alloc(struct scsi_device *);
 static int sbp2scsi_slave_configure(struct scsi_device *);
 static void sbp2scsi_slave_destroy(struct scsi_device *);
 static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *,
 					   struct device_attribute *, char *);
 static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
 static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
 	&dev_attr_ieee1394_id,
 	NULL
 };
 static struct scsi_host_template sbp2_shost_template = {
 	.module			 = THIS_MODULE,
 	.name			 = "SBP-2 IEEE-1394",
 	.proc_name		 = SBP2_DEVICE_NAME,
 	.queuecommand		 = sbp2scsi_queuecommand,
 	.eh_abort_handler	 = sbp2scsi_abort,
 	.eh_device_reset_handler = sbp2scsi_reset,
 	.slave_alloc		 = sbp2scsi_slave_alloc,
 	.slave_configure	 = sbp2scsi_slave_configure,
 	.slave_destroy		 = sbp2scsi_slave_destroy,
 	.this_id		 = -1,
 	.sg_tablesize		 = SG_ALL,
 	.use_clustering		 = ENABLE_CLUSTERING,
 	.cmd_per_lun		 = SBP2_MAX_CMDS,
 	.can_queue		 = SBP2_MAX_CMDS,
 	.sdev_attrs		 = sbp2_sysfs_sdev_attrs,
 };
 #define SBP2_ROM_VALUE_WILDCARD ~0         /* match all */
 #define SBP2_ROM_VALUE_MISSING  0xff000000 /* not present in the unit dir. */
 /*
  * List of devices with known bugs.
  *
  * The firmware_revision field, masked with 0xffff00, is the best indicator
  * for the type of bridge chip of a device.  It yields a few false positives
  * but this did not break correctly behaving devices so far.
  */
 static const struct {
 	u32 firmware_revision;
 	u32 model;
 	unsigned workarounds;
 } sbp2_workarounds_table[] = {
 	/* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
 		.firmware_revision	= 0x002800,
 		.model			= 0x001010,
 		.workarounds		= SBP2_WORKAROUND_INQUIRY_36 |
 					  SBP2_WORKAROUND_MODE_SENSE_8 |
 					  SBP2_WORKAROUND_POWER_CONDITION,
 	},
 	/* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
 		.firmware_revision	= 0x002800,
 		.model			= 0x000000,
 		.workarounds		= SBP2_WORKAROUND_POWER_CONDITION,
 	},
 	/* Initio bridges, actually only needed for some older ones */ {
 		.firmware_revision	= 0x000200,
 		.model			= SBP2_ROM_VALUE_WILDCARD,
 		.workarounds		= SBP2_WORKAROUND_INQUIRY_36,
 	},
 	/* PL-3507 bridge with Prolific firmware */ {
 		.firmware_revision	= 0x012800,
 		.model			= SBP2_ROM_VALUE_WILDCARD,
 		.workarounds		= SBP2_WORKAROUND_POWER_CONDITION,
 	},
 	/* Symbios bridge */ {
 		.firmware_revision	= 0xa0b800,
 		.model			= SBP2_ROM_VALUE_WILDCARD,
 		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
 	},
 	/* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
 		.firmware_revision	= 0x002600,
 		.model			= SBP2_ROM_VALUE_WILDCARD,
 		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
 	},
 	/*
 	 * iPod 2nd generation: needs 128k max transfer size workaround
 	 * iPod 3rd generation: needs fix capacity workaround
 	 */
 	{
 		.firmware_revision	= 0x0a2700,
 		.model			= 0x000000,
 		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS |
 					  SBP2_WORKAROUND_FIX_CAPACITY,
 	},
 	/* iPod 4th generation */ {
 		.firmware_revision	= 0x0a2700,
 		.model			= 0x000021,
 		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
 	},
 	/* iPod mini */ {
 		.firmware_revision	= 0x0a2700,
 		.model			= 0x000022,
 		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
 	},
 	/* iPod mini */ {
 		.firmware_revision	= 0x0a2700,
 		.model			= 0x000023,
 		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
 	},
 	/* iPod Photo */ {
 		.firmware_revision	= 0x0a2700,
 		.model			= 0x00007e,
 		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
 	}
 };
 /**************************************
  * General utility functions
  **************************************/
 #ifndef __BIG_ENDIAN
 /*
  * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
  */
 static inline void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
 {
 	u32 *temp = buffer;
 	for (length = (length >> 2); length--; )
 		temp[length] = be32_to_cpu(temp[length]);
 }
 /*
  * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
  */
 static inline void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
 {
 	u32 *temp = buffer;
 	for (length = (length >> 2); length--; )
 		temp[length] = cpu_to_be32(temp[length]);
 }
 #else /* BIG_ENDIAN */
 /* Why waste the cpu cycles? */
 #define sbp2util_be32_to_cpu_buffer(x,y) do {} while (0)
 #define sbp2util_cpu_to_be32_buffer(x,y) do {} while (0)
 #endif
 static DECLARE_WAIT_QUEUE_HEAD(sbp2_access_wq);
 /*
  * Waits for completion of an SBP-2 access request.
  * Returns nonzero if timed out or prematurely interrupted.
  */
 static int sbp2util_access_timeout(struct sbp2_lu *lu, int timeout)
 {
 	long leftover;
 	leftover = wait_event_interruptible_timeout(
 			sbp2_access_wq, lu->access_complete, timeout);
 	lu->access_complete = 0;
 	return leftover <= 0;
 }
 static void sbp2_free_packet(void *packet)
 {
 	hpsb_free_tlabel(packet);
 	hpsb_free_packet(packet);
 }
 /*
  * This is much like hpsb_node_write(), except it ignores the response
  * subaction and returns immediately. Can be used from atomic context.
  */
 static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
 				       quadlet_t *buf, size_t len)
 {
 	struct hpsb_packet *packet;
 	packet = hpsb_make_writepacket(ne->host, ne->nodeid, addr, buf, len);
 	if (!packet)
 		return -ENOMEM;
 	hpsb_set_packet_complete_task(packet, sbp2_free_packet, packet);
 	hpsb_node_fill_packet(ne, packet);
 	if (hpsb_send_packet(packet) < 0) {
 		sbp2_free_packet(packet);
 		return -EIO;
 	}
 	return 0;
 }
 static void sbp2util_notify_fetch_agent(struct sbp2_lu *lu, u64 offset,
 					quadlet_t *data, size_t len)
 {
 	/* There is a small window after a bus reset within which the node
 	 * entry's generation is current but the reconnect wasn't completed. */
 	if (unlikely(atomic_read(&lu->state) == SBP2LU_STATE_IN_RESET))
 		return;
 	if (hpsb_node_write(lu->ne, lu->command_block_agent_addr + offset,
 			    data, len))
 		SBP2_ERR("sbp2util_notify_fetch_agent failed.");
 	/* Now accept new SCSI commands, unless a bus reset happended during
 	 * hpsb_node_write. */
 	if (likely(atomic_read(&lu->state) != SBP2LU_STATE_IN_RESET))
 		scsi_unblock_requests(lu->shost);
 }
 static void sbp2util_write_orb_pointer(struct work_struct *work)
 {
 	struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
 	quadlet_t data[2];
 	data[0] = ORB_SET_NODE_ID(lu->hi->host->node_id);
 	data[1] = lu->last_orb_dma;
 	sbp2util_cpu_to_be32_buffer(data, 8);
 	sbp2util_notify_fetch_agent(lu, SBP2_ORB_POINTER_OFFSET, data, 8);
 }
 static void sbp2util_write_doorbell(struct work_struct *work)
 {
 	struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
 	sbp2util_notify_fetch_agent(lu, SBP2_DOORBELL_OFFSET, NULL, 4);
 }
 static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
 {
 	struct sbp2_command_info *cmd;
 	struct device *dmadev = lu->hi->host->device.parent;
 	int i, orbs = sbp2_serialize_io ? 2 : SBP2_MAX_CMDS;
 	for (i = 0; i < orbs; i++) {
 		cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 		if (!cmd)
 			goto failed_alloc;
 		cmd->command_orb_dma =
 		    dma_map_single(dmadev, &cmd->command_orb,
 				   sizeof(struct sbp2_command_orb),
 				   DMA_TO_DEVICE);
 		if (dma_mapping_error(dmadev, cmd->command_orb_dma))
 			goto failed_orb;
 		cmd->sge_dma =
 		    dma_map_single(dmadev, &cmd->scatter_gather_element,
 				   sizeof(cmd->scatter_gather_element),
 				   DMA_TO_DEVICE);
 		if (dma_mapping_error(dmadev, cmd->sge_dma))
 			goto failed_sge;
 		INIT_LIST_HEAD(&cmd->list);
 		list_add_tail(&cmd->list, &lu->cmd_orb_completed);
 	}
 	return 0;
 failed_sge:
 	dma_unmap_single(dmadev, cmd->command_orb_dma,
 			 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
 failed_orb:
 	kfree(cmd);
 failed_alloc:
 	return -ENOMEM;
 }
 static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu,
 					     struct hpsb_host *host)
 {
 	struct list_head *lh, *next;
 	struct sbp2_command_info *cmd;
 	unsigned long flags;
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	if (!list_empty(&lu->cmd_orb_completed))
 		list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
 			cmd = list_entry(lh, struct sbp2_command_info, list);
 			dma_unmap_single(host->device.parent,
 					 cmd->command_orb_dma,
 					 sizeof(struct sbp2_command_orb),
 					 DMA_TO_DEVICE);
 			dma_unmap_single(host->device.parent, cmd->sge_dma,
 					 sizeof(cmd->scatter_gather_element),
 					 DMA_TO_DEVICE);
 			kfree(cmd);
 		}
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	return;
 }
 /*
  * Finds the sbp2_command for a given outstanding command ORB.
  * Only looks at the in-use list.
  */
 static struct sbp2_command_info *sbp2util_find_command_for_orb(
 				struct sbp2_lu *lu, dma_addr_t orb)
 {
 	struct sbp2_command_info *cmd;
 	unsigned long flags;
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	if (!list_empty(&lu->cmd_orb_inuse))
 		list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
 			if (cmd->command_orb_dma == orb) {
 				spin_unlock_irqrestore(
 						&lu->cmd_orb_lock, flags);
 				return cmd;
 			}
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	return NULL;
 }
 /*
  * Finds the sbp2_command for a given outstanding SCpnt.
  * Only looks at the in-use list.
  * Must be called with lu->cmd_orb_lock held.
  */
 static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(
 				struct sbp2_lu *lu, void *SCpnt)
 {
 	struct sbp2_command_info *cmd;
 	if (!list_empty(&lu->cmd_orb_inuse))
 		list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
 			if (cmd->Current_SCpnt == SCpnt)
 				return cmd;
 	return NULL;
 }
 static struct sbp2_command_info *sbp2util_allocate_command_orb(
 				struct sbp2_lu *lu,
 				struct scsi_cmnd *Current_SCpnt,
 				void (*Current_done)(struct scsi_cmnd *))
 {
 	struct list_head *lh;
 	struct sbp2_command_info *cmd = NULL;
 	unsigned long flags;
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	if (!list_empty(&lu->cmd_orb_completed)) {
 		lh = lu->cmd_orb_completed.next;
 		list_del(lh);
 		cmd = list_entry(lh, struct sbp2_command_info, list);
 		cmd->Current_done = Current_done;
 		cmd->Current_SCpnt = Current_SCpnt;
 		list_add_tail(&cmd->list, &lu->cmd_orb_inuse);
 	} else
 		SBP2_ERR("%s: no orbs available", __func__);
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	return cmd;
 }
 /*
  * Unmaps the DMAs of a command and moves the command to the completed ORB list.
  * Must be called with lu->cmd_orb_lock held.
  */
 static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
 					    struct sbp2_command_info *cmd)
 {
 	if (scsi_sg_count(cmd->Current_SCpnt))
 		dma_unmap_sg(lu->ud->ne->host->device.parent,
 			     scsi_sglist(cmd->Current_SCpnt),
 			     scsi_sg_count(cmd->Current_SCpnt),
 			     cmd->Current_SCpnt->sc_data_direction);
 	list_move_tail(&cmd->list, &lu->cmd_orb_completed);
 }
 /*
  * Is lu valid? Is the 1394 node still present?
  */
 static inline int sbp2util_node_is_available(struct sbp2_lu *lu)
 {
 	return lu && lu->ne && !lu->ne->in_limbo;
 }
 /*********************************************
  * IEEE-1394 core driver stack related section
  *********************************************/
 static int sbp2_probe(struct device *dev)
 {
 	struct unit_directory *ud;
 	struct sbp2_lu *lu;
 	ud = container_of(dev, struct unit_directory, device);
 	/* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
 	 * instead. */
 	if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
 		return -ENODEV;
 	lu = sbp2_alloc_device(ud);
 	if (!lu)
 		return -ENOMEM;
 	sbp2_parse_unit_directory(lu, ud);
 	return sbp2_start_device(lu);
 }
 static int sbp2_remove(struct device *dev)
 {
 	struct unit_directory *ud;
 	struct sbp2_lu *lu;
 	struct scsi_device *sdev;
 	ud = container_of(dev, struct unit_directory, device);
 	lu = dev_get_drvdata(&ud->device);
 	if (!lu)
 		return 0;
 	if (lu->shost) {
 		/* Get rid of enqueued commands if there is no chance to
 		 * send them. */
 		if (!sbp2util_node_is_available(lu))
 			sbp2scsi_complete_all_commands(lu, DID_NO_CONNECT);
 		/* scsi_remove_device() may trigger shutdown functions of SCSI
 		 * highlevel drivers which would deadlock if blocked. */
 		atomic_set(&lu->state, SBP2LU_STATE_IN_SHUTDOWN);
 		scsi_unblock_requests(lu->shost);
 	}
 	sdev = lu->sdev;
 	if (sdev) {
 		lu->sdev = NULL;
 		scsi_remove_device(sdev);
 	}
 	sbp2_logout_device(lu);
 	sbp2_remove_device(lu);
 	return 0;
 }
 static int sbp2_update(struct unit_directory *ud)
 {
 	struct sbp2_lu *lu = dev_get_drvdata(&ud->device);
 	if (sbp2_reconnect_device(lu) != 0) {
 		/*
 		 * Reconnect failed.  If another bus reset happened,
 		 * let nodemgr proceed and call sbp2_update again later
 		 * (or sbp2_remove if this node went away).
 		 */
 		if (!hpsb_node_entry_valid(lu->ne))
 			return 0;
 		/*
 		 * Or the target rejected the reconnect because we weren't
 		 * fast enough.  Try a regular login, but first log out
 		 * just in case of any weirdness.
 		 */
 		sbp2_logout_device(lu);
 		if (sbp2_login_device(lu) != 0) {
 			if (!hpsb_node_entry_valid(lu->ne))
 				return 0;
 			/* Maybe another initiator won the login. */
 			SBP2_ERR("Failed to reconnect to sbp2 device!");
 			return -EBUSY;
 		}
 	}
 	sbp2_set_busy_timeout(lu);
 	sbp2_agent_reset(lu, 1);
 	sbp2_max_speed_and_size(lu);
 	/* Complete any pending commands with busy (so they get retried)
 	 * and remove them from our queue. */
 	sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
 	/* Accept new commands unless there was another bus reset in the
 	 * meantime. */
 	if (hpsb_node_entry_valid(lu->ne)) {
 		atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
 		scsi_unblock_requests(lu->shost);
 	}
 	return 0;
 }
 static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *ud)
 {
 	struct sbp2_fwhost_info *hi;
 	struct Scsi_Host *shost = NULL;
 	struct sbp2_lu *lu = NULL;
 	unsigned long flags;
 	lu = kzalloc(sizeof(*lu), GFP_KERNEL);
 	if (!lu) {
 		SBP2_ERR("failed to create lu");
 		goto failed_alloc;
 	}
 	lu->ne = ud->ne;
 	lu->ud = ud;
 	lu->speed_code = IEEE1394_SPEED_100;
 	lu->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
 	lu->status_fifo_addr = CSR1212_INVALID_ADDR_SPACE;
 	INIT_LIST_HEAD(&lu->cmd_orb_inuse);
 	INIT_LIST_HEAD(&lu->cmd_orb_completed);
 	INIT_LIST_HEAD(&lu->lu_list);
 	spin_lock_init(&lu->cmd_orb_lock);
 	atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
 	INIT_WORK(&lu->protocol_work, NULL);
 	dev_set_drvdata(&ud->device, lu);
 	hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
 	if (!hi) {
 		hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host,
 					  sizeof(*hi));
 		if (!hi) {
 			SBP2_ERR("failed to allocate hostinfo");
 			goto failed_alloc;
 		}
 		hi->host = ud->ne->host;
 		INIT_LIST_HEAD(&hi->logical_units);
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 		/* Handle data movement if physical dma is not
 		 * enabled or not supported on host controller */
 		if (!hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host,
 					     &sbp2_physdma_ops,
 					     0x0ULL, 0xfffffffcULL)) {
 			SBP2_ERR("failed to register lower 4GB address range");
 			goto failed_alloc;
 		}
 #endif
 	}
 	if (dma_get_max_seg_size(hi->host->device.parent) > SBP2_MAX_SEG_SIZE)
 		BUG_ON(dma_set_max_seg_size(hi->host->device.parent,
 					    SBP2_MAX_SEG_SIZE));
 	/* Prevent unloading of the 1394 host */
 	if (!try_module_get(hi->host->driver->owner)) {
 		SBP2_ERR("failed to get a reference on 1394 host driver");
 		goto failed_alloc;
 	}
 	lu->hi = hi;
 	write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
 	list_add_tail(&lu->lu_list, &hi->logical_units);
 	write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
 	/* Register the status FIFO address range. We could use the same FIFO
 	 * for targets at different nodes. However we need different FIFOs per
 	 * target in order to support multi-unit devices.
 	 * The FIFO is located out of the local host controller's physical range
 	 * but, if possible, within the posted write area. Status writes will
 	 * then be performed as unified transactions. This slightly reduces
 	 * bandwidth usage, and some Prolific based devices seem to require it.
 	 */
 	lu->status_fifo_addr = hpsb_allocate_and_register_addrspace(
 			&sbp2_highlevel, ud->ne->host, &sbp2_ops,
 			sizeof(struct sbp2_status_block), sizeof(quadlet_t),
 			ud->ne->host->low_addr_space, CSR1212_ALL_SPACE_END);
 	if (lu->status_fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
 		SBP2_ERR("failed to allocate status FIFO address range");
 		goto failed_alloc;
 	}
 	shost = scsi_host_alloc(&sbp2_shost_template, sizeof(unsigned long));
 	if (!shost) {
 		SBP2_ERR("failed to register scsi host");
 		goto failed_alloc;
 	}
 	shost->hostdata[0] = (unsigned long)lu;
 	shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
 	if (!scsi_add_host(shost, &ud->device)) {
 		lu->shost = shost;
 		return lu;
 	}
 	SBP2_ERR("failed to add scsi host");
 	scsi_host_put(shost);
 failed_alloc:
 	sbp2_remove_device(lu);
 	return NULL;
 }
 static void sbp2_host_reset(struct hpsb_host *host)
 {
 	struct sbp2_fwhost_info *hi;
 	struct sbp2_lu *lu;
 	unsigned long flags;
 	hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
 	if (!hi)
 		return;
 	read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
 	list_for_each_entry(lu, &hi->logical_units, lu_list)
 		if (atomic_cmpxchg(&lu->state,
 				   SBP2LU_STATE_RUNNING, SBP2LU_STATE_IN_RESET)
 		    == SBP2LU_STATE_RUNNING)
 			scsi_block_requests(lu->shost);
 	read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
 }
 static int sbp2_start_device(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	int error;
 	lu->login_response = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_login_response),
 				     &lu->login_response_dma, GFP_KERNEL);
 	if (!lu->login_response)
 		goto alloc_fail;
 	lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_query_logins_orb),
 				     &lu->query_logins_orb_dma, GFP_KERNEL);
 	if (!lu->query_logins_orb)
 		goto alloc_fail;
 	lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_query_logins_response),
 				     &lu->query_logins_response_dma, GFP_KERNEL);
 	if (!lu->query_logins_response)
 		goto alloc_fail;
 	lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_reconnect_orb),
 				     &lu->reconnect_orb_dma, GFP_KERNEL);
 	if (!lu->reconnect_orb)
 		goto alloc_fail;
 	lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_logout_orb),
 				     &lu->logout_orb_dma, GFP_KERNEL);
 	if (!lu->logout_orb)
 		goto alloc_fail;
 	lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
 				     sizeof(struct sbp2_login_orb),
 				     &lu->login_orb_dma, GFP_KERNEL);
 	if (!lu->login_orb)
 		goto alloc_fail;
 	if (sbp2util_create_command_orb_pool(lu))
 		goto alloc_fail;
 	/* Wait a second before trying to log in. Previously logged in
 	 * initiators need a chance to reconnect. */
 	if (msleep_interruptible(1000)) {
 		sbp2_remove_device(lu);
 		return -EINTR;
 	}
 	if (sbp2_login_device(lu)) {
 		sbp2_remove_device(lu);
 		return -EBUSY;
 	}
 	sbp2_set_busy_timeout(lu);
 	sbp2_agent_reset(lu, 1);
 	sbp2_max_speed_and_size(lu);
 	if (lu->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
 		ssleep(SBP2_INQUIRY_DELAY);
 	error = scsi_add_device(lu->shost, 0, lu->ud->id, 0);
 	if (error) {
 		SBP2_ERR("scsi_add_device failed");
 		sbp2_logout_device(lu);
 		sbp2_remove_device(lu);
 		return error;
 	}
 	return 0;
 alloc_fail:
 	SBP2_ERR("Could not allocate memory for lu");
 	sbp2_remove_device(lu);
 	return -ENOMEM;
 }
 static void sbp2_remove_device(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi;
 	unsigned long flags;
 	if (!lu)
 		return;
 	hi = lu->hi;
 	if (!hi)
 		goto no_hi;
 	if (lu->shost) {
 		scsi_remove_host(lu->shost);
 		scsi_host_put(lu->shost);
 	}
 	flush_scheduled_work();
 	sbp2util_remove_command_orb_pool(lu, hi->host);
 	write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
 	list_del(&lu->lu_list);
 	write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
 	if (lu->login_response)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_login_response),
 				    lu->login_response,
 				    lu->login_response_dma);
 	if (lu->login_orb)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_login_orb),
 				    lu->login_orb,
 				    lu->login_orb_dma);
 	if (lu->reconnect_orb)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_reconnect_orb),
 				    lu->reconnect_orb,
 				    lu->reconnect_orb_dma);
 	if (lu->logout_orb)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_logout_orb),
 				    lu->logout_orb,
 				    lu->logout_orb_dma);
 	if (lu->query_logins_orb)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_query_logins_orb),
 				    lu->query_logins_orb,
 				    lu->query_logins_orb_dma);
 	if (lu->query_logins_response)
 		dma_free_coherent(hi->host->device.parent,
 				    sizeof(struct sbp2_query_logins_response),
 				    lu->query_logins_response,
 				    lu->query_logins_response_dma);
 	if (lu->status_fifo_addr != CSR1212_INVALID_ADDR_SPACE)
 		hpsb_unregister_addrspace(&sbp2_highlevel, hi->host,
 					  lu->status_fifo_addr);
 	dev_set_drvdata(&lu->ud->device, NULL);
 	module_put(hi->host->driver->owner);
 no_hi:
 	kfree(lu);
 }
 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 /*
  * Deal with write requests on adapters which do not support physical DMA or
  * have it switched off.
  */
 static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid,
 				     int destid, quadlet_t *data, u64 addr,
 				     size_t length, u16 flags)
 {
 	memcpy(bus_to_virt((u32) addr), data, length);
 	return RCODE_COMPLETE;
 }
 /*
  * Deal with read requests on adapters which do not support physical DMA or
  * have it switched off.
  */
 static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid,
 				    quadlet_t *data, u64 addr, size_t length,
 				    u16 flags)
 {
 	memcpy(data, bus_to_virt((u32) addr), length);
 	return RCODE_COMPLETE;
 }
 #endif
 /**************************************
  * SBP-2 protocol related section
  **************************************/
 static int sbp2_query_logins(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	quadlet_t data[2];
 	int max_logins;
 	int active_logins;
 	lu->query_logins_orb->reserved1 = 0x0;
 	lu->query_logins_orb->reserved2 = 0x0;
 	lu->query_logins_orb->query_response_lo = lu->query_logins_response_dma;
 	lu->query_logins_orb->query_response_hi =
 			ORB_SET_NODE_ID(hi->host->node_id);
 	lu->query_logins_orb->lun_misc =
 			ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
 	lu->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
 	lu->query_logins_orb->lun_misc |= ORB_SET_LUN(lu->lun);
 	lu->query_logins_orb->reserved_resp_length =
 		ORB_SET_QUERY_LOGINS_RESP_LENGTH(
 			sizeof(struct sbp2_query_logins_response));
 	lu->query_logins_orb->status_fifo_hi =
 		ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
 	lu->query_logins_orb->status_fifo_lo =
 		ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
 	sbp2util_cpu_to_be32_buffer(lu->query_logins_orb,
 				    sizeof(struct sbp2_query_logins_orb));
 	memset(lu->query_logins_response, 0,
 	       sizeof(struct sbp2_query_logins_response));
 	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
 	data[1] = lu->query_logins_orb_dma;
 	sbp2util_cpu_to_be32_buffer(data, 8);
 	hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
 	if (sbp2util_access_timeout(lu, 2*HZ)) {
 		SBP2_INFO("Error querying logins to SBP-2 device - timed out");
 		return -EIO;
 	}
 	if (lu->status_block.ORB_offset_lo != lu->query_logins_orb_dma) {
 		SBP2_INFO("Error querying logins to SBP-2 device - timed out");
 		return -EIO;
 	}
 	if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
 		SBP2_INFO("Error querying logins to SBP-2 device - failed");
 		return -EIO;
 	}
 	sbp2util_cpu_to_be32_buffer(lu->query_logins_response,
 				    sizeof(struct sbp2_query_logins_response));
 	max_logins = RESPONSE_GET_MAX_LOGINS(
 			lu->query_logins_response->length_max_logins);
 	SBP2_INFO("Maximum concurrent logins supported: %d", max_logins);
 	active_logins = RESPONSE_GET_ACTIVE_LOGINS(
 			lu->query_logins_response->length_max_logins);
 	SBP2_INFO("Number of active logins: %d", active_logins);
 	if (active_logins >= max_logins) {
 		return -EIO;
 	}
 	return 0;
 }
 static int sbp2_login_device(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	quadlet_t data[2];
 	if (!lu->login_orb)
 		return -EIO;
 	if (!sbp2_exclusive_login && sbp2_query_logins(lu)) {
 		SBP2_INFO("Device does not support any more concurrent logins");
 		return -EIO;
 	}
 	/* assume no password */
 	lu->login_orb->password_hi = 0;
 	lu->login_orb->password_lo = 0;
 	lu->login_orb->login_response_lo = lu->login_response_dma;
 	lu->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
 	lu->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
 	/* one second reconnect time */
 	lu->login_orb->lun_misc |= ORB_SET_RECONNECT(0);
 	lu->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(sbp2_exclusive_login);
 	lu->login_orb->lun_misc |= ORB_SET_NOTIFY(1);
 	lu->login_orb->lun_misc |= ORB_SET_LUN(lu->lun);
 	lu->login_orb->passwd_resp_lengths =
 		ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
 	lu->login_orb->status_fifo_hi =
 		ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
 	lu->login_orb->status_fifo_lo =
 		ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
 	sbp2util_cpu_to_be32_buffer(lu->login_orb,
 				    sizeof(struct sbp2_login_orb));
 	memset(lu->login_response, 0, sizeof(struct sbp2_login_response));
 	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
 	data[1] = lu->login_orb_dma;
 	sbp2util_cpu_to_be32_buffer(data, 8);
 	hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
 	/* wait up to 20 seconds for login status */
 	if (sbp2util_access_timeout(lu, 20*HZ)) {
 		SBP2_ERR("Error logging into SBP-2 device - timed out");
 		return -EIO;
 	}
 	/* make sure that the returned status matches the login ORB */
 	if (lu->status_block.ORB_offset_lo != lu->login_orb_dma) {
 		SBP2_ERR("Error logging into SBP-2 device - timed out");
 		return -EIO;
 	}
 	if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
 		SBP2_ERR("Error logging into SBP-2 device - failed");
 		return -EIO;
 	}
 	sbp2util_cpu_to_be32_buffer(lu->login_response,
 				    sizeof(struct sbp2_login_response));
 	lu->command_block_agent_addr =
 			((u64)lu->login_response->command_block_agent_hi) << 32;
 	lu->command_block_agent_addr |=
 			((u64)lu->login_response->command_block_agent_lo);
 	lu->command_block_agent_addr &= 0x0000ffffffffffffULL;
 	SBP2_INFO("Logged into SBP-2 device");
 	return 0;
 }
 static int sbp2_logout_device(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	quadlet_t data[2];
 	int error;
 	lu->logout_orb->reserved1 = 0x0;
 	lu->logout_orb->reserved2 = 0x0;
 	lu->logout_orb->reserved3 = 0x0;
 	lu->logout_orb->reserved4 = 0x0;
 	lu->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
 	lu->logout_orb->login_ID_misc |=
 			ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
 	lu->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
 	lu->logout_orb->reserved5 = 0x0;
 	lu->logout_orb->status_fifo_hi =
 		ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
 	lu->logout_orb->status_fifo_lo =
 		ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
 	sbp2util_cpu_to_be32_buffer(lu->logout_orb,
 				    sizeof(struct sbp2_logout_orb));
 	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
 	data[1] = lu->logout_orb_dma;
 	sbp2util_cpu_to_be32_buffer(data, 8);
 	error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
 	if (error)
 		return error;
 	/* wait up to 1 second for the device to complete logout */
 	if (sbp2util_access_timeout(lu, HZ))
 		return -EIO;
 	SBP2_INFO("Logged out of SBP-2 device");
 	return 0;
 }
 static int sbp2_reconnect_device(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	quadlet_t data[2];
 	int error;
 	lu->reconnect_orb->reserved1 = 0x0;
 	lu->reconnect_orb->reserved2 = 0x0;
 	lu->reconnect_orb->reserved3 = 0x0;
 	lu->reconnect_orb->reserved4 = 0x0;
 	lu->reconnect_orb->login_ID_misc =
 			ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST);
 	lu->reconnect_orb->login_ID_misc |=
 			ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
 	lu->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
 	lu->reconnect_orb->reserved5 = 0x0;
 	lu->reconnect_orb->status_fifo_hi =
 		ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
 	lu->reconnect_orb->status_fifo_lo =
 		ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
 	sbp2util_cpu_to_be32_buffer(lu->reconnect_orb,
 				    sizeof(struct sbp2_reconnect_orb));
 	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
 	data[1] = lu->reconnect_orb_dma;
 	sbp2util_cpu_to_be32_buffer(data, 8);
 	error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
 	if (error)
 		return error;
 	/* wait up to 1 second for reconnect status */
 	if (sbp2util_access_timeout(lu, HZ)) {
 		SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
 		return -EIO;
 	}
 	/* make sure that the returned status matches the reconnect ORB */
 	if (lu->status_block.ORB_offset_lo != lu->reconnect_orb_dma) {
 		SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
 		return -EIO;
 	}
 	if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
 		SBP2_ERR("Error reconnecting to SBP-2 device - failed");
 		return -EIO;
 	}
 	SBP2_INFO("Reconnected to SBP-2 device");
 	return 0;
 }
 /*
  * Set the target node's Single Phase Retry limit. Affects the target's retry
  * behaviour if our node is too busy to accept requests.
  */
 static int sbp2_set_busy_timeout(struct sbp2_lu *lu)
 {
 	quadlet_t data;
 	data = cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE);
 	if (hpsb_node_write(lu->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4))
 		SBP2_ERR("%s error", __func__);
 	return 0;
 }
 static void sbp2_parse_unit_directory(struct sbp2_lu *lu,
 				      struct unit_directory *ud)
 {
 	struct csr1212_keyval *kv;
 	struct csr1212_dentry *dentry;
 	u64 management_agent_addr;
-	u32 unit_characteristics, firmware_revision, model;
+	u32 firmware_revision, model;
 	unsigned workarounds;
 	int i;
 	management_agent_addr = 0;
-	unit_characteristics = 0;
 	firmware_revision = SBP2_ROM_VALUE_MISSING;
 	model = ud->flags & UNIT_DIRECTORY_MODEL_ID ?
 				ud->model_id : SBP2_ROM_VALUE_MISSING;
 	csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
 		switch (kv->key.id) {
 		case CSR1212_KV_ID_DEPENDENT_INFO:
 			if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET)
 				management_agent_addr =
 				    CSR1212_REGISTER_SPACE_BASE +
 				    (kv->value.csr_offset << 2);
 			else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE)
 				lu->lun = ORB_SET_LUN(kv->value.immediate);
 			break;
-		case SBP2_UNIT_CHARACTERISTICS_KEY:
-			/* FIXME: This is ignored so far.
-			 * See SBP-2 clause 7.4.8. */
-			unit_characteristics = kv->value.immediate;
-			break;
 		case SBP2_FIRMWARE_REVISION_KEY:
 			firmware_revision = kv->value.immediate;
 			break;
 		default:
+			/* FIXME: Check for SBP2_UNIT_CHARACTERISTICS_KEY
+			 * mgt_ORB_timeout and ORB_size, SBP-2 clause 7.4.8. */
 			/* FIXME: Check for SBP2_DEVICE_TYPE_AND_LUN_KEY.
 			 * Its "ordered" bit has consequences for command ORB
 			 * list handling. See SBP-2 clauses 4.6, 7.4.11, 10.2 */
 			break;
 		}
 	}
 	workarounds = sbp2_default_workarounds;
 	if (!(workarounds & SBP2_WORKAROUND_OVERRIDE))
 		for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
 			if (sbp2_workarounds_table[i].firmware_revision !=
 			    SBP2_ROM_VALUE_WILDCARD &&
 			    sbp2_workarounds_table[i].firmware_revision !=
 			    (firmware_revision & 0xffff00))
 				continue;
 			if (sbp2_workarounds_table[i].model !=
 			    SBP2_ROM_VALUE_WILDCARD &&
 			    sbp2_workarounds_table[i].model != model)
 				continue;
 			workarounds |= sbp2_workarounds_table[i].workarounds;
 			break;
 		}
 	if (workarounds)
 		SBP2_INFO("Workarounds for node " NODE_BUS_FMT ": 0x%x "
 			  "(firmware_revision 0x%06x, vendor_id 0x%06x,"
 			  " model_id 0x%06x)",
 			  NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
 			  workarounds, firmware_revision, ud->vendor_id,
 			  model);
 	/* We would need one SCSI host template for each target to adjust
 	 * max_sectors on the fly, therefore warn only. */
 	if (workarounds & SBP2_WORKAROUND_128K_MAX_TRANS &&
 	    (sbp2_max_sectors * 512) > (128 * 1024))
 		SBP2_INFO("Node " NODE_BUS_FMT ": Bridge only supports 128KB "
 			  "max transfer size. WARNING: Current max_sectors "
 			  "setting is larger than 128KB (%d sectors)",
 			  NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
 			  sbp2_max_sectors);
 	/* If this is a logical unit directory entry, process the parent
 	 * to get the values. */
 	if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
 		struct unit_directory *parent_ud = container_of(
 			ud->device.parent, struct unit_directory, device);
 		sbp2_parse_unit_directory(lu, parent_ud);
 	} else {
 		lu->management_agent_addr = management_agent_addr;
 		lu->workarounds = workarounds;
 		if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
 			lu->lun = ORB_SET_LUN(ud->lun);
 	}
 }
 #define SBP2_PAYLOAD_TO_BYTES(p) (1 << ((p) + 2))
 /*
  * This function is called in order to determine the max speed and packet
  * size we can use in our ORBs. Note, that we (the driver and host) only
  * initiate the transaction. The SBP-2 device actually transfers the data
  * (by reading from the DMA area we tell it). This means that the SBP-2
  * device decides the actual maximum data it can transfer. We just tell it
  * the speed that it needs to use, and the max_rec the host supports, and
  * it takes care of the rest.
  */
 static int sbp2_max_speed_and_size(struct sbp2_lu *lu)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	u8 payload;
 	lu->speed_code = hi->host->speed[NODEID_TO_NODE(lu->ne->nodeid)];
 	if (lu->speed_code > sbp2_max_speed) {
 		lu->speed_code = sbp2_max_speed;
 		SBP2_INFO("Reducing speed to %s",
 			  hpsb_speedto_str[sbp2_max_speed]);
 	}
 	/* Payload size is the lesser of what our speed supports and what
 	 * our host supports.  */
 	payload = min(sbp2_speedto_max_payload[lu->speed_code],
 		      (u8) (hi->host->csr.max_rec - 1));
 	/* If physical DMA is off, work around limitation in ohci1394:
 	 * packet size must not exceed PAGE_SIZE */
 	if (lu->ne->host->low_addr_space < (1ULL << 32))
 		while (SBP2_PAYLOAD_TO_BYTES(payload) + 24 > PAGE_SIZE &&
 		       payload)
 			payload--;
 	SBP2_INFO("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
 		  NODE_BUS_ARGS(hi->host, lu->ne->nodeid),
 		  hpsb_speedto_str[lu->speed_code],
 		  SBP2_PAYLOAD_TO_BYTES(payload));
 	lu->max_payload_size = payload;
 	return 0;
 }
 static int sbp2_agent_reset(struct sbp2_lu *lu, int wait)
 {
 	quadlet_t data;
 	u64 addr;
 	int retval;
 	unsigned long flags;
 	/* flush lu->protocol_work */
 	if (wait)
 		flush_scheduled_work();
 	data = ntohl(SBP2_AGENT_RESET_DATA);
 	addr = lu->command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
 	if (wait)
 		retval = hpsb_node_write(lu->ne, addr, &data, 4);
 	else
 		retval = sbp2util_node_write_no_wait(lu->ne, addr, &data, 4);
 	if (retval < 0) {
 		SBP2_ERR("hpsb_node_write failed.\n");
 		return -EIO;
 	}
 	/* make sure that the ORB_POINTER is written on next command */
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	lu->last_orb = NULL;
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	return 0;
 }
 static int sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
 				    struct sbp2_fwhost_info *hi,
 				    struct sbp2_command_info *cmd,
 				    unsigned int sg_count,
 				    struct scatterlist *sg,
 				    u32 orb_direction,
 				    enum dma_data_direction dma_dir)
 {
 	struct device *dmadev = hi->host->device.parent;
 	struct sbp2_unrestricted_page_table *pt;
 	int i, n;
 	n = dma_map_sg(dmadev, sg, sg_count, dma_dir);
 	if (n == 0)
 		return -ENOMEM;
 	orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
 	orb->misc |= ORB_SET_DIRECTION(orb_direction);
 	/* special case if only one element (and less than 64KB in size) */
 	if (n == 1) {
 		orb->misc |= ORB_SET_DATA_SIZE(sg_dma_len(sg));
 		orb->data_descriptor_lo = sg_dma_address(sg);
 	} else {
 		pt = &cmd->scatter_gather_element[0];
 		dma_sync_single_for_cpu(dmadev, cmd->sge_dma,
 					sizeof(cmd->scatter_gather_element),
 					DMA_TO_DEVICE);
 		for_each_sg(sg, sg, n, i) {
 			pt[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
 			pt[i].low = cpu_to_be32(sg_dma_address(sg));
 		}
 		orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1) |
 			     ORB_SET_DATA_SIZE(n);
 		orb->data_descriptor_lo = cmd->sge_dma;
 		dma_sync_single_for_device(dmadev, cmd->sge_dma,
 					   sizeof(cmd->scatter_gather_element),
 					   DMA_TO_DEVICE);
 	}
 	return 0;
 }
 static int sbp2_create_command_orb(struct sbp2_lu *lu,
 				   struct sbp2_command_info *cmd,
 				   struct scsi_cmnd *SCpnt)
 {
 	struct device *dmadev = lu->hi->host->device.parent;
 	struct sbp2_command_orb *orb = &cmd->command_orb;
 	unsigned int scsi_request_bufflen = scsi_bufflen(SCpnt);
 	enum dma_data_direction dma_dir = SCpnt->sc_data_direction;
 	u32 orb_direction;
 	int ret;
 	dma_sync_single_for_cpu(dmadev, cmd->command_orb_dma,
 				sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
 	/*
 	 * Set-up our command ORB.
 	 *
 	 * NOTE: We're doing unrestricted page tables (s/g), as this is
 	 * best performance (at least with the devices I have). This means
 	 * that data_size becomes the number of s/g elements, and
 	 * page_size should be zero (for unrestricted).
 	 */
 	orb->next_ORB_hi = ORB_SET_NULL_PTR(1);
 	orb->next_ORB_lo = 0x0;
 	orb->misc = ORB_SET_MAX_PAYLOAD(lu->max_payload_size);
 	orb->misc |= ORB_SET_SPEED(lu->speed_code);
 	orb->misc |= ORB_SET_NOTIFY(1);
 	if (dma_dir == DMA_NONE)
 		orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
 	else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen)
 		orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
 	else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen)
 		orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
 	else {
 		SBP2_INFO("Falling back to DMA_NONE");
 		orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
 	}
 	/* set up our page table stuff */
 	if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) {
 		orb->data_descriptor_hi = 0x0;
 		orb->data_descriptor_lo = 0x0;
 		orb->misc |= ORB_SET_DIRECTION(1);
 		ret = 0;
 	} else {
 		ret = sbp2_prep_command_orb_sg(orb, lu->hi, cmd,
 					       scsi_sg_count(SCpnt),
 					       scsi_sglist(SCpnt),
 					       orb_direction, dma_dir);
 	}
 	sbp2util_cpu_to_be32_buffer(orb, sizeof(*orb));
 	memset(orb->cdb, 0, sizeof(orb->cdb));
 	memcpy(orb->cdb, SCpnt->cmnd, SCpnt->cmd_len);
 	dma_sync_single_for_device(dmadev, cmd->command_orb_dma,
 			sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
 	return ret;
 }
 static void sbp2_link_orb_command(struct sbp2_lu *lu,
 				  struct sbp2_command_info *cmd)
 {
 	struct sbp2_fwhost_info *hi = lu->hi;
 	struct sbp2_command_orb *last_orb;
 	dma_addr_t last_orb_dma;
 	u64 addr = lu->command_block_agent_addr;
 	quadlet_t data[2];
 	size_t length;
 	unsigned long flags;
 	/* check to see if there are any previous orbs to use */
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	last_orb = lu->last_orb;
 	last_orb_dma = lu->last_orb_dma;
 	if (!last_orb) {
 		/*
 		 * last_orb == NULL means: We know that the target's fetch agent
 		 * is not active right now.
 		 */
 		addr += SBP2_ORB_POINTER_OFFSET;
 		data[0] = ORB_SET_NODE_ID(hi->host->node_id);
 		data[1] = cmd->command_orb_dma;
 		sbp2util_cpu_to_be32_buffer(data, 8);
 		length = 8;
 	} else {
 		/*
 		 * last_orb != NULL means: We know that the target's fetch agent
 		 * is (very probably) not dead or in reset state right now.
 		 * We have an ORB already sent that we can append a new one to.
 		 * The target's fetch agent may or may not have read this
 		 * previous ORB yet.
 		 */
 		dma_sync_single_for_cpu(hi->host->device.parent, last_orb_dma,
 					sizeof(struct sbp2_command_orb),
 					DMA_TO_DEVICE);
 		last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma);
 		wmb();
 		/* Tells hardware that this pointer is valid */
 		last_orb->next_ORB_hi = 0;
 		dma_sync_single_for_device(hi->host->device.parent,
 					   last_orb_dma,
 					   sizeof(struct sbp2_command_orb),
 					   DMA_TO_DEVICE);
 		addr += SBP2_DOORBELL_OFFSET;
 		data[0] = 0;
 		length = 4;
 	}
 	lu->last_orb = &cmd->command_orb;
 	lu->last_orb_dma = cmd->command_orb_dma;
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	if (sbp2util_node_write_no_wait(lu->ne, addr, data, length)) {
 		/*
 		 * sbp2util_node_write_no_wait failed. We certainly ran out
 		 * of transaction labels, perhaps just because there were no
 		 * context switches which gave khpsbpkt a chance to collect
 		 * free tlabels. Try again in non-atomic context. If necessary,
 		 * the workqueue job will sleep to guaranteedly get a tlabel.
 		 * We do not accept new commands until the job is over.
 		 */
 		scsi_block_requests(lu->shost);
 		PREPARE_WORK(&lu->protocol_work,
 			     last_orb ? sbp2util_write_doorbell:
 					sbp2util_write_orb_pointer);
 		schedule_work(&lu->protocol_work);
 	}
 }
 static int sbp2_send_command(struct sbp2_lu *lu, struct scsi_cmnd *SCpnt,
 			     void (*done)(struct scsi_cmnd *))
 {
 	struct sbp2_command_info *cmd;
 	cmd = sbp2util_allocate_command_orb(lu, SCpnt, done);
 	if (!cmd)
 		return -EIO;
 	if (sbp2_create_command_orb(lu, cmd, SCpnt))
 		return -ENOMEM;
 	sbp2_link_orb_command(lu, cmd);
 	return 0;
 }
 /*
  * Translates SBP-2 status into SCSI sense data for check conditions
  */
 static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status,
 					      unchar *sense_data)
 {
 	/* OK, it's pretty ugly... ;-) */
 	sense_data[0] = 0x70;
 	sense_data[1] = 0x0;
 	sense_data[2] = sbp2_status[9];
 	sense_data[3] = sbp2_status[12];
 	sense_data[4] = sbp2_status[13];
 	sense_data[5] = sbp2_status[14];
 	sense_data[6] = sbp2_status[15];
 	sense_data[7] = 10;
 	sense_data[8] = sbp2_status[16];
 	sense_data[9] = sbp2_status[17];
 	sense_data[10] = sbp2_status[18];
 	sense_data[11] = sbp2_status[19];
 	sense_data[12] = sbp2_status[10];
 	sense_data[13] = sbp2_status[11];
 	sense_data[14] = sbp2_status[20];
 	sense_data[15] = sbp2_status[21];
 	return sbp2_status[8] & 0x3f;
 }
 static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid,
 				    int destid, quadlet_t *data, u64 addr,
 				    size_t length, u16 fl)
 {
 	struct sbp2_fwhost_info *hi;
 	struct sbp2_lu *lu = NULL, *lu_tmp;
 	struct scsi_cmnd *SCpnt = NULL;
 	struct sbp2_status_block *sb;
 	u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
 	struct sbp2_command_info *cmd;
 	unsigned long flags;
 	if (unlikely(length < 8 || length > sizeof(struct sbp2_status_block))) {
 		SBP2_ERR("Wrong size of status block");
 		return RCODE_ADDRESS_ERROR;
 	}
 	if (unlikely(!host)) {
 		SBP2_ERR("host is NULL - this is bad!");
 		return RCODE_ADDRESS_ERROR;
 	}
 	hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
 	if (unlikely(!hi)) {
 		SBP2_ERR("host info is NULL - this is bad!");
 		return RCODE_ADDRESS_ERROR;
 	}
 	/* Find the unit which wrote the status. */
 	read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
 	list_for_each_entry(lu_tmp, &hi->logical_units, lu_list) {
 		if (lu_tmp->ne->nodeid == nodeid &&
 		    lu_tmp->status_fifo_addr == addr) {
 			lu = lu_tmp;
 			break;
 		}
 	}
 	read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
 	if (unlikely(!lu)) {
 		SBP2_ERR("lu is NULL - device is gone?");
 		return RCODE_ADDRESS_ERROR;
 	}
 	/* Put response into lu status fifo buffer. The first two bytes
 	 * come in big endian bit order. Often the target writes only a
 	 * truncated status block, minimally the first two quadlets. The rest
 	 * is implied to be zeros. */
 	sb = &lu->status_block;
 	memset(sb->command_set_dependent, 0, sizeof(sb->command_set_dependent));
 	memcpy(sb, data, length);
 	sbp2util_be32_to_cpu_buffer(sb, 8);
 	/* Ignore unsolicited status. Handle command ORB status. */
 	if (unlikely(STATUS_GET_SRC(sb->ORB_offset_hi_misc) == 2))
 		cmd = NULL;
 	else
 		cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
 	if (cmd) {
 		/* Grab SCSI command pointers and check status. */
 		/*
 		 * FIXME: If the src field in the status is 1, the ORB DMA must
 		 * not be reused until status for a subsequent ORB is received.
 		 */
 		SCpnt = cmd->Current_SCpnt;
 		spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 		sbp2util_mark_command_completed(lu, cmd);
 		spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 		if (SCpnt) {
 			u32 h = sb->ORB_offset_hi_misc;
 			u32 r = STATUS_GET_RESP(h);
 			if (r != RESP_STATUS_REQUEST_COMPLETE) {
 				SBP2_INFO("resp 0x%x, sbp_status 0x%x",
 					  r, STATUS_GET_SBP_STATUS(h));
 				scsi_status =
 					r == RESP_STATUS_TRANSPORT_FAILURE ?
 					SBP2_SCSI_STATUS_BUSY :
 					SBP2_SCSI_STATUS_COMMAND_TERMINATED;
 			}
 			if (STATUS_GET_LEN(h) > 1)
 				scsi_status = sbp2_status_to_sense_data(
 					(unchar *)sb, SCpnt->sense_buffer);
 			if (STATUS_TEST_DEAD(h))
                                 sbp2_agent_reset(lu, 0);
 		}
 		/* Check here to see if there are no commands in-use. If there
 		 * are none, we know that the fetch agent left the active state
 		 * _and_ that we did not reactivate it yet. Therefore clear
 		 * last_orb so that next time we write directly to the
 		 * ORB_POINTER register. That way the fetch agent does not need
 		 * to refetch the next_ORB. */
 		spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 		if (list_empty(&lu->cmd_orb_inuse))
 			lu->last_orb = NULL;
 		spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	} else {
 		/* It's probably status after a management request. */
 		if ((sb->ORB_offset_lo == lu->reconnect_orb_dma) ||
 		    (sb->ORB_offset_lo == lu->login_orb_dma) ||
 		    (sb->ORB_offset_lo == lu->query_logins_orb_dma) ||
 		    (sb->ORB_offset_lo == lu->logout_orb_dma)) {
 			lu->access_complete = 1;
 			wake_up_interruptible(&sbp2_access_wq);
 		}
 	}
 	if (SCpnt)
 		sbp2scsi_complete_command(lu, scsi_status, SCpnt,
 					  cmd->Current_done);
 	return RCODE_COMPLETE;
 }
 /**************************************
  * SCSI interface related section
  **************************************/
 static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
 				 void (*done)(struct scsi_cmnd *))
 {
 	struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
 	struct sbp2_fwhost_info *hi;
 	int result = DID_NO_CONNECT << 16;
 	if (unlikely(!sbp2util_node_is_available(lu)))
 		goto done;
 	hi = lu->hi;
 	if (unlikely(!hi)) {
 		SBP2_ERR("sbp2_fwhost_info is NULL - this is bad!");
 		goto done;
 	}
 	/* Multiple units are currently represented to the SCSI core as separate
 	 * targets, not as one target with multiple LUs. Therefore return
 	 * selection time-out to any IO directed at non-zero LUNs. */
 	if (unlikely(SCpnt->device->lun))
 		goto done;
 	if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
 		SBP2_ERR("Bus reset in progress - rejecting command");
 		result = DID_BUS_BUSY << 16;
 		goto done;
 	}
 	/* Bidirectional commands are not yet implemented,
 	 * and unknown transfer direction not handled. */
 	if (unlikely(SCpnt->sc_data_direction == DMA_BIDIRECTIONAL)) {
 		SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
 		result = DID_ERROR << 16;
 		goto done;
 	}
 	if (sbp2_send_command(lu, SCpnt, done)) {
 		SBP2_ERR("Error sending SCSI command");
 		sbp2scsi_complete_command(lu,
 					  SBP2_SCSI_STATUS_SELECTION_TIMEOUT,
 					  SCpnt, done);
 	}
 	return 0;
 done:
 	SCpnt->result = result;
 	done(SCpnt);
 	return 0;
 }
 static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
 {
 	struct list_head *lh;
 	struct sbp2_command_info *cmd;
 	unsigned long flags;
 	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 	while (!list_empty(&lu->cmd_orb_inuse)) {
 		lh = lu->cmd_orb_inuse.next;
 		cmd = list_entry(lh, struct sbp2_command_info, list);
 		sbp2util_mark_command_completed(lu, cmd);
 		if (cmd->Current_SCpnt) {
 			cmd->Current_SCpnt->result = status << 16;
 			cmd->Current_done(cmd->Current_SCpnt);
 		}
 	}
 	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 	return;
 }
 /*
  * Complete a regular SCSI command. Can be called in atomic context.
  */
 static void sbp2scsi_complete_command(struct sbp2_lu *lu, u32 scsi_status,
 				      struct scsi_cmnd *SCpnt,
 				      void (*done)(struct scsi_cmnd *))
 {
 	if (!SCpnt) {
 		SBP2_ERR("SCpnt is NULL");
 		return;
 	}
 	switch (scsi_status) {
 	case SBP2_SCSI_STATUS_GOOD:
 		SCpnt->result = DID_OK << 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:
 		SCpnt->result = CHECK_CONDITION << 1 | DID_OK << 16;
 		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;
 	default:
 		SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
 		SCpnt->result = DID_ERROR << 16;
 	}
 	/* 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(lu->ne)
 	    && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
 		SBP2_ERR("Completing command with busy (bus reset)");
 		SCpnt->result = DID_BUS_BUSY << 16;
 	}
 	/* Tell the SCSI stack that we're done with this command. */
 	done(SCpnt);
 }
 static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
 {
 	struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
 	if (sdev->lun != 0 || sdev->id != lu->ud->id || sdev->channel != 0)
 		return -ENODEV;
 	lu->sdev = sdev;
 	sdev->allow_restart = 1;
 	/* SBP-2 requires quadlet alignment of the data buffers. */
 	blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
 	if (lu->workarounds & SBP2_WORKAROUND_INQUIRY_36)
 		sdev->inquiry_len = 36;
 	return 0;
 }
 static int sbp2scsi_slave_configure(struct scsi_device *sdev)
 {
 	struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
 	sdev->use_10_for_rw = 1;
 	if (sbp2_exclusive_login)
 		sdev->manage_start_stop = 1;
 	if (sdev->type == TYPE_ROM)
 		sdev->use_10_for_ms = 1;
 	if (sdev->type == TYPE_DISK &&
 	    lu->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
 		sdev->skip_ms_page_8 = 1;
 	if (lu->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
 		sdev->fix_capacity = 1;
 	if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
 		sdev->start_stop_pwr_cond = 1;
 	if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
 		blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
 	blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
 	return 0;
 }
 static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
 {
 	((struct sbp2_lu *)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.
  */
 static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
 {
 	struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
 	struct sbp2_command_info *cmd;
 	unsigned long flags;
 	SBP2_INFO("aborting sbp2 command");
 	scsi_print_command(SCpnt);
 	if (sbp2util_node_is_available(lu)) {
 		sbp2_agent_reset(lu, 1);
 		/* Return a matching command structure to the free pool. */
 		spin_lock_irqsave(&lu->cmd_orb_lock, flags);
 		cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
 		if (cmd) {
 			sbp2util_mark_command_completed(lu, cmd);
 			if (cmd->Current_SCpnt) {
 				cmd->Current_SCpnt->result = DID_ABORT << 16;
 				cmd->Current_done(cmd->Current_SCpnt);
 			}
 		}
 		spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
 		sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
 	}
 	return SUCCESS;
 }
 /*
  * Called by scsi stack when something has really gone wrong.
  */
 static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
 {
 	struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
 	SBP2_INFO("reset requested");
 	if (sbp2util_node_is_available(lu)) {
 		SBP2_INFO("generating sbp2 fetch agent reset");
 		sbp2_agent_reset(lu, 1);
 	}
 	return SUCCESS;
 }
 static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
 					   struct device_attribute *attr,
 					   char *buf)
 {
 	struct scsi_device *sdev;
 	struct sbp2_lu *lu;
 	if (!(sdev = to_scsi_device(dev)))
 		return 0;
 	if (!(lu = (struct sbp2_lu *)sdev->host->hostdata[0]))
 		return 0;
 	if (sbp2_long_sysfs_ieee1394_id)
 		return sprintf(buf, "%016Lx:%06x:%04x\n",
 				(unsigned long long)lu->ne->guid,
 				lu->ud->directory_id, ORB_SET_LUN(lu->lun));
 	else
 		return sprintf(buf, "%016Lx:%d:%d\n",
 				(unsigned long long)lu->ne->guid,
 				lu->ud->id, ORB_SET_LUN(lu->lun));
 }
 MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
 MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
 MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME);
 MODULE_LICENSE("GPL");
 static int sbp2_module_init(void)
 {
 	int ret;
 	if (sbp2_serialize_io) {
 		sbp2_shost_template.can_queue = 1;
 		sbp2_shost_template.cmd_per_lun = 1;
 	}
 	sbp2_shost_template.max_sectors = sbp2_max_sectors;
 	hpsb_register_highlevel(&sbp2_highlevel);
 	ret = hpsb_register_protocol(&sbp2_driver);
 	if (ret) {
 		SBP2_ERR("Failed to register protocol");
 		hpsb_unregister_highlevel(&sbp2_highlevel);
 		return ret;
 	}
 	return 0;
 }
 static void __exit sbp2_module_exit(void)
 {
 	hpsb_unregister_protocol(&sbp2_driver);
 	hpsb_unregister_highlevel(&sbp2_highlevel);
 }