scsi: target/sbp: remove SBP target driver
diff mbox series

Message ID 01020172acd3d10f-3964f076-a820-43fc-9494-3f3946e9b7b5-000000@eu-west-1.amazonses.com
State Deferred
Headers show
Series
  • scsi: target/sbp: remove SBP target driver
Related show

Commit Message

Chris Boot June 13, 2020, 8:37 a.m. UTC
I no longer have the time to maintain this subsystem nor the hardware to
test patches with. It also doesn't appear to have any active users so I
doubt anyone will miss it.

Signed-off-by: Chris Boot <bootc@bootc.net>
---
 MAINTAINERS                     |    9 -
 drivers/target/Kconfig          |    1 -
 drivers/target/Makefile         |    1 -
 drivers/target/sbp/Kconfig      |   12 -
 drivers/target/sbp/Makefile     |    2 -
 drivers/target/sbp/sbp_target.c | 2350 -------------------------------
 drivers/target/sbp/sbp_target.h |  243 ----
 7 files changed, 2618 deletions(-)
 delete mode 100644 drivers/target/sbp/Kconfig
 delete mode 100644 drivers/target/sbp/Makefile
 delete mode 100644 drivers/target/sbp/sbp_target.c
 delete mode 100644 drivers/target/sbp/sbp_target.h

Comments

Finn Thain June 14, 2020, 12:03 a.m. UTC | #1
On Sat, 13 Jun 2020, Chris Boot wrote:

> I no longer have the time to maintain this subsystem nor the hardware to
> test patches with. 

Then why not patch MAINTAINERS, and orphan it, as per usual practice?

$ git log --oneline MAINTAINERS | grep -i orphan

> It also doesn't appear to have any active users so I doubt anyone will 
> miss it.
> 

It's not unusual that any Linux driver written more than 5 years ago 
"doesn't appear to have any active users".

If a driver has been orphaned and broken in the past, and no-one stepped 
up to fix it within a reasonable period, removal would make sense. But 
that's not the case here.

I haven't used this driver for a long time, but I still own PowerMacs with 
firewire, and I know I'm not the only one.

> Signed-off-by: Chris Boot <bootc@bootc.net>
> ---
>  MAINTAINERS                     |    9 -
>  drivers/target/Kconfig          |    1 -
>  drivers/target/Makefile         |    1 -
>  drivers/target/sbp/Kconfig      |   12 -
>  drivers/target/sbp/Makefile     |    2 -
>  drivers/target/sbp/sbp_target.c | 2350 -------------------------------
>  drivers/target/sbp/sbp_target.h |  243 ----
>  7 files changed, 2618 deletions(-)
>  delete mode 100644 drivers/target/sbp/Kconfig
>  delete mode 100644 drivers/target/sbp/Makefile
>  delete mode 100644 drivers/target/sbp/sbp_target.c
>  delete mode 100644 drivers/target/sbp/sbp_target.h
>
Chris Boot June 14, 2020, 10:34 a.m. UTC | #2
On 14/06/2020 01:03, Finn Thain wrote:
> On Sat, 13 Jun 2020, Chris Boot wrote:
> 
>> I no longer have the time to maintain this subsystem nor the hardware to
>> test patches with. 
> 
> Then why not patch MAINTAINERS, and orphan it, as per usual practice?
> 
> $ git log --oneline MAINTAINERS | grep -i orphan

My patch to remove it was in response to:

https://lore.kernel.org/lkml/yq1img99d4k.fsf@ca-mkp.ca.oracle.com/

>> It also doesn't appear to have any active users so I doubt anyone will 
>> miss it.
>>
> 
> It's not unusual that any Linux driver written more than 5 years ago 
> "doesn't appear to have any active users".
> 
> If a driver has been orphaned and broken in the past, and no-one stepped 
> up to fix it within a reasonable period, removal would make sense. But 
> that's not the case here.
> 
> I haven't used this driver for a long time, but I still own PowerMacs with 
> firewire, and I know I'm not the only one.

I expect that if someone finds this useful it can stick around (but
that's not my call). I just don't have the time or inclination or
hardware to be able to maintain it anymore, so someone else would have
to pick it up.

Cheers,
Chris
Finn Thain June 14, 2020, 11:28 p.m. UTC | #3
On Sun, 14 Jun 2020, Chris Boot wrote:

> I expect that if someone finds this useful it can stick around (but 
> that's not my call).

Who's call is that? If the patch had said "From: Martin K. Petersen" and 
"This driver is being removed because it has the following defects..." 
that would be some indication of a good-faith willingness to accept users 
as developers in the spirit of the GPL, which is what you seem to be 
alluding to (?).

> I just don't have the time or inclination or hardware to be able to 
> maintain it anymore, so someone else would have to pick it up.
> 

Which is why most drivers get orphaned, right?
Chris Boot June 15, 2020, 3 p.m. UTC | #4
On 15/06/2020 00:28, Finn Thain wrote:
> On Sun, 14 Jun 2020, Chris Boot wrote:
> 
>> I expect that if someone finds this useful it can stick around (but 
>> that's not my call).
> 
> Who's call is that? If the patch had said "From: Martin K. Petersen" and 
> "This driver is being removed because it has the following defects..." 
> that would be some indication of a good-faith willingness to accept users 
> as developers in the spirit of the GPL, which is what you seem to be 
> alluding to (?).

If you're asking me, I'd say it was martin's call:

> SCSI TARGET SUBSYSTEM                                                          
> M:      "Martin K. Petersen" <martin.petersen@oracle.com>                      
[...]
> F:      drivers/target/                                                        
> F:      include/target/                                                        

>> I just don't have the time or inclination or hardware to be able to 
>> maintain it anymore, so someone else would have to pick it up.
>>
> 
> Which is why most drivers get orphaned, right?

Sure, but that's not what Martin asked me to do, hence this patch.
Finn Thain June 16, 2020, 9:42 a.m. UTC | #5
On Mon, 15 Jun 2020, Chris Boot wrote:

> On 15/06/2020 00:28, Finn Thain wrote:
> > On Sun, 14 Jun 2020, Chris Boot wrote:
> > 
> >> I expect that if someone finds this useful it can stick around (but 
> >> that's not my call).
> > 
> > Who's call is that? If the patch had said "From: Martin K. Petersen" 
> > and "This driver is being removed because it has the following 
> > defects..." that would be some indication of a good-faith willingness 
> > to accept users as developers in the spirit of the GPL, which is what 
> > you seem to be alluding to (?).
> 
> If you're asking me, I'd say it was martin's call:
> 
> > SCSI TARGET SUBSYSTEM                                                          
> > M:      "Martin K. Petersen" <martin.petersen@oracle.com>                      
> [...]
> > F:      drivers/target/                                                        
> > F:      include/target/                                                        
> 

The question I asked you was intended to make you think. I wasn't asking 
you to search MAINTAINERS for "drivers/target" (I had already done so).

Chris, you can find my name in that file too. That's because I see my role 
as custodian of that particular code. That code lives in the kernel.org 
tree because others put it there and because users find it useful -- not 
merely because it happens to please the official glorious MAINTAINER of 
said code.

If you would ask, "who's call is it to delete drivers/nubus? or 
drivers/scsi/NCR5380.c?" my answer is, I have no idea.

> >> I just don't have the time or inclination or hardware to be able to 
> >> maintain it anymore, so someone else would have to pick it up.
> >>
> > 
> > Which is why most drivers get orphaned, right?
> 
> Sure, but that's not what Martin asked me to do, hence this patch.
> 

Martin said, "I'd appreciate a patch to remove it"

And Bart said, "do you want to keep this driver in the kernel tree?"

AFAICT both comments are quite ambiguous. I don't see an actionable 
request, just an expression of interest from people doing their jobs.

Note well: there is no pay check associated with having a MAINTAINERS file 
entry.
Bart Van Assche June 16, 2020, 2:08 p.m. UTC | #6
On 2020-06-16 02:42, Finn Thain wrote:
> Martin said, "I'd appreciate a patch to remove it"
> 
> And Bart said, "do you want to keep this driver in the kernel tree?"
> 
> AFAICT both comments are quite ambiguous. I don't see an actionable 
> request, just an expression of interest from people doing their jobs.
> 
> Note well: there is no pay check associated with having a MAINTAINERS file 
> entry.

Hi Finn,

As far as I know the sbp driver only has had one user ever and that user
is no longer user the sbp driver. So why to keep it in the kernel tree?
Restoring a kernel driver can be easy - the first step is a "git revert".

Thanks,

Bart.
Johannes Thumshirn June 16, 2020, 2:13 p.m. UTC | #7
On 16/06/2020 16:09, Bart Van Assche wrote:
> On 2020-06-16 02:42, Finn Thain wrote:
>> Martin said, "I'd appreciate a patch to remove it"
>>
>> And Bart said, "do you want to keep this driver in the kernel tree?"
>>
>> AFAICT both comments are quite ambiguous. I don't see an actionable 
>> request, just an expression of interest from people doing their jobs.
>>
>> Note well: there is no pay check associated with having a MAINTAINERS file 
>> entry.
> 
> Hi Finn,
> 
> As far as I know the sbp driver only has had one user ever and that user
> is no longer user the sbp driver. So why to keep it in the kernel tree?
> Restoring a kernel driver can be easy - the first step is a "git revert".

Why not move the driver to drivers/staging for 2 or 3 kernel releases and if
noone steps up, delete it?

Just my 2 Cents,
	Johannes
James Bottomley June 16, 2020, 3:34 p.m. UTC | #8
On Tue, 2020-06-16 at 14:13 +0000, Johannes Thumshirn wrote:
> On 16/06/2020 16:09, Bart Van Assche wrote:
> > On 2020-06-16 02:42, Finn Thain wrote:
> > > Martin said, "I'd appreciate a patch to remove it"
> > > 
> > > And Bart said, "do you want to keep this driver in the kernel
> > > tree?"
> > > 
> > > AFAICT both comments are quite ambiguous. I don't see an
> > > actionable request, just an expression of interest from people
> > > doing their jobs.
> > > 
> > > Note well: there is no pay check associated with having a
> > > MAINTAINERS file 
> > > entry.
> > 
> > Hi Finn,
> > 
> > As far as I know the sbp driver only has had one user ever and that
> > user is no longer user the sbp driver. So why to keep it in the
> > kernel tree? Restoring a kernel driver can be easy - the first step
> > is a "git revert".
> 
> Why not move the driver to drivers/staging for 2 or 3 kernel releases
> and if noone steps up, delete it?

Because that's pretty much the worst of all worlds: If the driver is
simply going orphaned it can stay where it is to avoid confusion.  If
it's being removed, it's better to remove it from where it is because
that makes the patch to restore it easy to find.

Chris, the thing is this: if this driver has just one user on a stable
distro who complains about its removal six months to two years from
now, Linus will descend on us from a great height (which won't matter
to you, since you'll be long gone).  This makes everyone very wary of
outright removal.  If you're really, really sure it has no users, it
can be deleted, but if there's the slightest chance it has just one, it
should get orphaned.

James
Chris Boot June 16, 2020, 5:59 p.m. UTC | #9
On 16/06/2020 16:34, James Bottomley wrote:
> On Tue, 2020-06-16 at 14:13 +0000, Johannes Thumshirn wrote:
>> On 16/06/2020 16:09, Bart Van Assche wrote:
>>> On 2020-06-16 02:42, Finn Thain wrote:
>>>> Martin said, "I'd appreciate a patch to remove it"
>>>>
>>>> And Bart said, "do you want to keep this driver in the kernel
>>>> tree?"
>>>>
>>>> AFAICT both comments are quite ambiguous. I don't see an
>>>> actionable request, just an expression of interest from people
>>>> doing their jobs.
>>>>
>>>> Note well: there is no pay check associated with having a
>>>> MAINTAINERS file 
>>>> entry.
>>>
>>> Hi Finn,
>>>
>>> As far as I know the sbp driver only has had one user ever and that
>>> user is no longer user the sbp driver. So why to keep it in the
>>> kernel tree? Restoring a kernel driver can be easy - the first step
>>> is a "git revert".
>>
>> Why not move the driver to drivers/staging for 2 or 3 kernel releases
>> and if noone steps up, delete it?
> 
> Because that's pretty much the worst of all worlds: If the driver is
> simply going orphaned it can stay where it is to avoid confusion.  If
> it's being removed, it's better to remove it from where it is because
> that makes the patch to restore it easy to find.
> 
> Chris, the thing is this: if this driver has just one user on a stable
> distro who complains about its removal six months to two years from
> now, Linus will descend on us from a great height (which won't matter
> to you, since you'll be long gone).  This makes everyone very wary of
> outright removal.  If you're really, really sure it has no users, it
> can be deleted, but if there's the slightest chance it has just one, it
> should get orphaned.

My patch to delete the driver was based on Martin's original request:
https://lore.kernel.org/lkml/yq1img99d4k.fsf@ca-mkp.ca.oracle.com/

I don't especially want it to be gone, nor can I be sure there are no
users of what is as far as I can tell a working piece of code. I can
tell you that I never hear about it (other than the odd patch), whereas
I do get emails out of the blue for some of my other (much smaller)
stuff which clearly has users. I'd be just as happy for this to be
orphaned or for nothing to happen to it.

Honestly, I am totally ambivalent as to what happens to this code.
Martin, however, clearly cares enough to have asked me to supply a patch
to remove it.

Cheers,
Chris
Finn Thain June 17, 2020, 2:07 a.m. UTC | #10
On Tue, 16 Jun 2020, Bart Van Assche wrote:

> 
> As far as I know the sbp driver only has had one user ever and that user 
> is no longer user the sbp driver.

So, you estimate the userbase at zero. Can you give a confidence level? 
Actual measurement is hard because when end users encounter breakage, they 
look for quick workarounds before they undertake post mortem, log 
collection, bug reporting, mailing list discussions, analysis etc.

> So why to keep it in the kernel tree?

Answer: for the same reason it was added to the tree.

Here's a different question: "Why remove it from the kernel tree?"

If maintaining this code is a burden, is it not the kind of tax that all 
developers/users pay to all developers/users? Does this driver impose an 
unreasonably high burden for some reason?

The growth of a maintenance burden in general has lead to the invention of 
design patterns and tooling to minize it. So a good argument for removal 
would describe the nature of the problem, because some driver deficiencies 
can be fixed automatically, and some tooling deficiencies can compound an 
otherwise insignificant or common driver deficiency.

There are spin-off benefits from legacy code besides process improvements. 
Building and testing this sort of code has regularly revealed erroneous 
corner cases in commits elsewhere like API changes and refactoring.

Also, legacy code is used by new developers get experience in code 
modernization. And it provides more training material for neural networks 
that need to be taught to recognize patches that raise quality.

Ten or twenty years ago, I doubt that anyone predicted these (and other) 
spin-off benefits. If we can't predict the benefit, how will we project 
the cost, and use that to justify deletion?

Please see also,
http://www.mac.linux-m68k.org/docs/obsolete.php
Martin K. Petersen June 17, 2020, 2:35 a.m. UTC | #11
Finn,

> I haven't used this driver for a long time, but I still own PowerMacs
> with firewire, and I know I'm not the only one.

I also have old 1394 hardware kicking around in the basement. But having
worked with FireWire shared storage targets in the past, I have zero
desire to ever touch any of that again.

I could understand an objection if we were to entertain removing
sbp2. But really, how many people are setting up FireWire targets?
Martin K. Petersen June 17, 2020, 3:09 a.m. UTC | #12
Chris,

> I don't especially want it to be gone, nor can I be sure there are no
> users of what is as far as I can tell a working piece of code. I can
> tell you that I never hear about it (other than the odd patch),
> whereas I do get emails out of the blue for some of my other (much
> smaller) stuff which clearly has users. I'd be just as happy for this
> to be orphaned or for nothing to happen to it.
>
> Honestly, I am totally ambivalent as to what happens to this code.
> Martin, however, clearly cares enough to have asked me to supply a
> patch to remove it.

I love it when people take ownership of old drivers. I think it's
wonderful that Finn and others are on the ball when it comes to the 5380
family. I don't care how old things are as long as they are being
actively used.

I am also very happy to keep things in the tree as long as there is a
healthy community around them. However, keeping code around is not
free. Core interfaces change frequently. Nobody enjoys having to tweak
host templates for 50 devices they have never even heard about. Also, we
now live in a reality where there is a constant barrage of build bots
and code analyzers sending mail. So the effective cost of keeping code
around in the tree is going up. I get a substantial amount of code
analysis mail about drivers nobody have touched in a decade or more.

Consequently, I am much more inclined to remove drivers than I have been
in the past. But I am also very happy to bring them back if somebody
uses them or - even better - are willing to step up and maintain them.

I don't particularly like the notion of a driver being orphaned because
all that really means is that the driver transitions from being (at
least partially) somebody else's problem to being mine and mine alone.
Finn Thain June 17, 2020, 4:21 a.m. UTC | #13
On Tue, 16 Jun 2020, Martin K. Petersen wrote:

> > I haven't used this driver for a long time, but I still own PowerMacs 
> > with firewire, and I know I'm not the only one.
> 

I need to correct what I wrote above. I recall that years ago, when I 
needed to share storage from my Linux box to my PowerBook pismo, I used 
ethernet and the globalSAN iSCSI initiator for Mac OS X (which is no 
longer freely available AFAICS). When I said that I had used the SBP 
target driver before, I misremembered that iSCSI target setup. I've 
actually never used the SBP target driver.

> I also have old 1394 hardware kicking around in the basement. But having 
> worked with FireWire shared storage targets in the past, I have zero 
> desire to ever touch any of that again.
> 
> I could understand an objection if we were to entertain removing sbp2. 
> But really, how many people are setting up FireWire targets?
> 

It's a good question. I don't know the answer.

I have successfully used the Linux sbp2 host driver in the past, and will 
probably need to use it again. Likewise, I can see myself using the sbp 
target driver in the future because that might interoperate with MacOS 9, 
and might provide a bootable device to the PowerMac ROM. iSCSI cannot do 
those things.
Finn Thain June 18, 2020, 12:40 a.m. UTC | #14
On Tue, 16 Jun 2020, Martin K. Petersen wrote:

> 
> However, keeping code around is not free.

Right. And removing code isn't free either, if it forces people to find 
workarounds.

> Core interfaces change frequently.  Nobody enjoys having to tweak host 
> templates for 50 devices they have never even heard about.

And yet some people seem to enjoy writing patches that are as trivial as 
they are invasive...

You seem to be making an argument for more automation here, not an 
argument for less code. Or is there some upper bound to the size of the 
kernel, that might be lifted by adding maintainers? (Can you deliver a 
better product by adding more developers to your project?)

> Also, we now live in a reality where there is a constant barrage of 
> build bots and code analyzers sending mail. So the effective cost of 
> keeping code around in the tree is going up.

But if maintenance cost rises due to good analysis, the value of the code 
should rise too. So what's the problem? It seems to me that the real 
problem is too many analyses that generate pedantic noise and no tangible 
improvement in code quality or value.

> I get a substantial amount of code analysis mail about drivers nobody 
> have touched in a decade or more.
> 

When stable, mature code fails analysis, the analysis is also questionable 
(in the absence of real examples).

> Consequently, I am much more inclined to remove drivers than I have been 
> in the past. But I am also very happy to bring them back if somebody 
> uses them or - even better - are willing to step up and maintain them.
> 

You seem to be saying that 1) a driver should be removed when it no longer 
meets the present threshold for code quality and 2) that a low quality 
driver is eligible for re-addition because someone wants to use it.
I don't think you can have it both ways.

> I don't particularly like the notion of a driver being orphaned because 
> all that really means is that the driver transitions from being (at 
> least partially) somebody else's problem to being mine and mine alone.
> 

Yes it's your problem but only on a best-effort basis.

Many issues detected by automatic analyzers can be fixed with automatic 
code transformation tools. This kind of solution works tree-wide, so even 
if some defect in your driver is "yours and yours alone", the solution 
will probably come from others.

This email, like yours, is just hand-waving. So feel free to ignore it or 
(preferably) provide evidence of real defects.

Patch
diff mbox series

diff --git a/MAINTAINERS b/MAINTAINERS
index 56d7d27fc114..81b7db7d68a8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -6669,15 +6669,6 @@  S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media.git
 F:	drivers/media/firewire/
 
-FIREWIRE SBP-2 TARGET
-M:	Chris Boot <bootc@bootc.net>
-L:	linux-scsi@vger.kernel.org
-L:	target-devel@vger.kernel.org
-L:	linux1394-devel@lists.sourceforge.net
-S:	Maintained
-T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/lio-core-2.6.git master
-F:	drivers/target/sbp/
-
 FIREWIRE SUBSYSTEM
 M:	Stefan Richter <stefanr@s5r6.in-berlin.de>
 L:	linux1394-devel@lists.sourceforge.net
diff --git a/drivers/target/Kconfig b/drivers/target/Kconfig
index c163b14774d7..4a5682745ada 100644
--- a/drivers/target/Kconfig
+++ b/drivers/target/Kconfig
@@ -46,6 +46,5 @@  config TCM_USER2
 source "drivers/target/loopback/Kconfig"
 source "drivers/target/tcm_fc/Kconfig"
 source "drivers/target/iscsi/Kconfig"
-source "drivers/target/sbp/Kconfig"
 
 endif
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 45634747377e..c13da05af2e2 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -29,4 +29,3 @@  obj-$(CONFIG_TCM_USER2)		+= target_core_user.o
 obj-$(CONFIG_LOOPBACK_TARGET)	+= loopback/
 obj-$(CONFIG_TCM_FC)		+= tcm_fc/
 obj-$(CONFIG_ISCSI_TARGET)	+= iscsi/
-obj-$(CONFIG_SBP_TARGET)	+= sbp/
diff --git a/drivers/target/sbp/Kconfig b/drivers/target/sbp/Kconfig
deleted file mode 100644
index 53a1c75f5660..000000000000
--- a/drivers/target/sbp/Kconfig
+++ /dev/null
@@ -1,12 +0,0 @@ 
-# SPDX-License-Identifier: GPL-2.0-only
-config SBP_TARGET
-	tristate "FireWire SBP-2 fabric module"
-	depends on FIREWIRE
-	help
-	  Say Y or M here to enable SCSI target functionality over FireWire.
-	  This enables you to expose SCSI devices to other nodes on the FireWire
-	  bus, for example hard disks. Similar to FireWire Target Disk mode on
-	  many Apple computers.
-
-	  To compile this driver as a module, say M here: The module will be
-	  called sbp-target.
diff --git a/drivers/target/sbp/Makefile b/drivers/target/sbp/Makefile
deleted file mode 100644
index 766f23690013..000000000000
--- a/drivers/target/sbp/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@ 
-# SPDX-License-Identifier: GPL-2.0-only
-obj-$(CONFIG_SBP_TARGET) += sbp_target.o
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
deleted file mode 100644
index e4a9b9fe3dfb..000000000000
--- a/drivers/target/sbp/sbp_target.c
+++ /dev/null
@@ -1,2350 +0,0 @@ 
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * SBP2 target driver (SCSI over IEEE1394 in target mode)
- *
- * Copyright (C) 2011  Chris Boot <bootc@bootc.net>
- */
-
-#define KMSG_COMPONENT "sbp_target"
-#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/configfs.h>
-#include <linux/ctype.h>
-#include <linux/delay.h>
-#include <linux/firewire.h>
-#include <linux/firewire-constants.h>
-#include <scsi/scsi_proto.h>
-#include <scsi/scsi_tcq.h>
-#include <target/target_core_base.h>
-#include <target/target_core_backend.h>
-#include <target/target_core_fabric.h>
-#include <asm/unaligned.h>
-
-#include "sbp_target.h"
-
-/* FireWire address region for management and command block address handlers */
-static const struct fw_address_region sbp_register_region = {
-	.start	= CSR_REGISTER_BASE + 0x10000,
-	.end	= 0x1000000000000ULL,
-};
-
-static const u32 sbp_unit_directory_template[] = {
-	0x1200609e, /* unit_specifier_id: NCITS/T10 */
-	0x13010483, /* unit_sw_version: 1155D Rev 4 */
-	0x3800609e, /* command_set_specifier_id: NCITS/T10 */
-	0x390104d8, /* command_set: SPC-2 */
-	0x3b000000, /* command_set_revision: 0 */
-	0x3c000001, /* firmware_revision: 1 */
-};
-
-#define SESSION_MAINTENANCE_INTERVAL HZ
-
-static atomic_t login_id = ATOMIC_INIT(0);
-
-static void session_maintenance_work(struct work_struct *);
-static int sbp_run_transaction(struct fw_card *, int, int, int, int,
-		unsigned long long, void *, size_t);
-
-static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
-{
-	int ret;
-	__be32 high, low;
-
-	ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
-			req->node_addr, req->generation, req->speed,
-			(CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4,
-			&high, sizeof(high));
-	if (ret != RCODE_COMPLETE)
-		return ret;
-
-	ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
-			req->node_addr, req->generation, req->speed,
-			(CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4,
-			&low, sizeof(low));
-	if (ret != RCODE_COMPLETE)
-		return ret;
-
-	*guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low);
-
-	return RCODE_COMPLETE;
-}
-
-static struct sbp_session *sbp_session_find_by_guid(
-	struct sbp_tpg *tpg, u64 guid)
-{
-	struct se_session *se_sess;
-	struct sbp_session *sess, *found = NULL;
-
-	spin_lock_bh(&tpg->se_tpg.session_lock);
-	list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
-		sess = se_sess->fabric_sess_ptr;
-		if (sess->guid == guid)
-			found = sess;
-	}
-	spin_unlock_bh(&tpg->se_tpg.session_lock);
-
-	return found;
-}
-
-static struct sbp_login_descriptor *sbp_login_find_by_lun(
-		struct sbp_session *session, u32 unpacked_lun)
-{
-	struct sbp_login_descriptor *login, *found = NULL;
-
-	spin_lock_bh(&session->lock);
-	list_for_each_entry(login, &session->login_list, link) {
-		if (login->login_lun == unpacked_lun)
-			found = login;
-	}
-	spin_unlock_bh(&session->lock);
-
-	return found;
-}
-
-static int sbp_login_count_all_by_lun(
-		struct sbp_tpg *tpg,
-		u32 unpacked_lun,
-		int exclusive)
-{
-	struct se_session *se_sess;
-	struct sbp_session *sess;
-	struct sbp_login_descriptor *login;
-	int count = 0;
-
-	spin_lock_bh(&tpg->se_tpg.session_lock);
-	list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
-		sess = se_sess->fabric_sess_ptr;
-
-		spin_lock_bh(&sess->lock);
-		list_for_each_entry(login, &sess->login_list, link) {
-			if (login->login_lun != unpacked_lun)
-				continue;
-
-			if (!exclusive || login->exclusive)
-				count++;
-		}
-		spin_unlock_bh(&sess->lock);
-	}
-	spin_unlock_bh(&tpg->se_tpg.session_lock);
-
-	return count;
-}
-
-static struct sbp_login_descriptor *sbp_login_find_by_id(
-	struct sbp_tpg *tpg, int login_id)
-{
-	struct se_session *se_sess;
-	struct sbp_session *sess;
-	struct sbp_login_descriptor *login, *found = NULL;
-
-	spin_lock_bh(&tpg->se_tpg.session_lock);
-	list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
-		sess = se_sess->fabric_sess_ptr;
-
-		spin_lock_bh(&sess->lock);
-		list_for_each_entry(login, &sess->login_list, link) {
-			if (login->login_id == login_id)
-				found = login;
-		}
-		spin_unlock_bh(&sess->lock);
-	}
-	spin_unlock_bh(&tpg->se_tpg.session_lock);
-
-	return found;
-}
-
-static u32 sbp_get_lun_from_tpg(struct sbp_tpg *tpg, u32 login_lun, int *err)
-{
-	struct se_portal_group *se_tpg = &tpg->se_tpg;
-	struct se_lun *se_lun;
-
-	rcu_read_lock();
-	hlist_for_each_entry_rcu(se_lun, &se_tpg->tpg_lun_hlist, link) {
-		if (se_lun->unpacked_lun == login_lun) {
-			rcu_read_unlock();
-			*err = 0;
-			return login_lun;
-		}
-	}
-	rcu_read_unlock();
-
-	*err = -ENODEV;
-	return login_lun;
-}
-
-static struct sbp_session *sbp_session_create(
-		struct sbp_tpg *tpg,
-		u64 guid)
-{
-	struct sbp_session *sess;
-	int ret;
-	char guid_str[17];
-
-	snprintf(guid_str, sizeof(guid_str), "%016llx", guid);
-
-	sess = kmalloc(sizeof(*sess), GFP_KERNEL);
-	if (!sess)
-		return ERR_PTR(-ENOMEM);
-
-	spin_lock_init(&sess->lock);
-	INIT_LIST_HEAD(&sess->login_list);
-	INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work);
-	sess->guid = guid;
-
-	sess->se_sess = target_setup_session(&tpg->se_tpg, 128,
-					     sizeof(struct sbp_target_request),
-					     TARGET_PROT_NORMAL, guid_str,
-					     sess, NULL);
-	if (IS_ERR(sess->se_sess)) {
-		pr_err("failed to init se_session\n");
-		ret = PTR_ERR(sess->se_sess);
-		kfree(sess);
-		return ERR_PTR(ret);
-	}
-
-	return sess;
-}
-
-static void sbp_session_release(struct sbp_session *sess, bool cancel_work)
-{
-	spin_lock_bh(&sess->lock);
-	if (!list_empty(&sess->login_list)) {
-		spin_unlock_bh(&sess->lock);
-		return;
-	}
-	spin_unlock_bh(&sess->lock);
-
-	if (cancel_work)
-		cancel_delayed_work_sync(&sess->maint_work);
-
-	target_remove_session(sess->se_sess);
-
-	if (sess->card)
-		fw_card_put(sess->card);
-
-	kfree(sess);
-}
-
-static void sbp_target_agent_unregister(struct sbp_target_agent *);
-
-static void sbp_login_release(struct sbp_login_descriptor *login,
-	bool cancel_work)
-{
-	struct sbp_session *sess = login->sess;
-
-	/* FIXME: abort/wait on tasks */
-
-	sbp_target_agent_unregister(login->tgt_agt);
-
-	if (sess) {
-		spin_lock_bh(&sess->lock);
-		list_del(&login->link);
-		spin_unlock_bh(&sess->lock);
-
-		sbp_session_release(sess, cancel_work);
-	}
-
-	kfree(login);
-}
-
-static struct sbp_target_agent *sbp_target_agent_register(
-	struct sbp_login_descriptor *);
-
-static void sbp_management_request_login(
-	struct sbp_management_agent *agent, struct sbp_management_request *req,
-	int *status_data_size)
-{
-	struct sbp_tport *tport = agent->tport;
-	struct sbp_tpg *tpg = tport->tpg;
-	struct sbp_session *sess;
-	struct sbp_login_descriptor *login;
-	struct sbp_login_response_block *response;
-	u64 guid;
-	u32 unpacked_lun;
-	int login_response_len, ret;
-
-	unpacked_lun = sbp_get_lun_from_tpg(tpg,
-			LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
-	if (ret) {
-		pr_notice("login to unknown LUN: %d\n",
-			LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP));
-		return;
-	}
-
-	ret = read_peer_guid(&guid, req);
-	if (ret != RCODE_COMPLETE) {
-		pr_warn("failed to read peer GUID: %d\n", ret);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-		return;
-	}
-
-	pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
-		unpacked_lun, guid);
-
-	sess = sbp_session_find_by_guid(tpg, guid);
-	if (sess) {
-		login = sbp_login_find_by_lun(sess, unpacked_lun);
-		if (login) {
-			pr_notice("initiator already logged-in\n");
-
-			/*
-			 * SBP-2 R4 says we should return access denied, but
-			 * that can confuse initiators. Instead we need to
-			 * treat this like a reconnect, but send the login
-			 * response block like a fresh login.
-			 *
-			 * This is required particularly in the case of Apple
-			 * devices booting off the FireWire target, where
-			 * the firmware has an active login to the target. When
-			 * the OS takes control of the session it issues its own
-			 * LOGIN rather than a RECONNECT. To avoid the machine
-			 * waiting until the reconnect_hold expires, we can skip
-			 * the ACCESS_DENIED errors to speed things up.
-			 */
-
-			goto already_logged_in;
-		}
-	}
-
-	/*
-	 * check exclusive bit in login request
-	 * reject with access_denied if any logins present
-	 */
-	if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
-			sbp_login_count_all_by_lun(tpg, unpacked_lun, 0)) {
-		pr_warn("refusing exclusive login with other active logins\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
-		return;
-	}
-
-	/*
-	 * check exclusive bit in any existing login descriptor
-	 * reject with access_denied if any exclusive logins present
-	 */
-	if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 1)) {
-		pr_warn("refusing login while another exclusive login present\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
-		return;
-	}
-
-	/*
-	 * check we haven't exceeded the number of allowed logins
-	 * reject with resources_unavailable if we have
-	 */
-	if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 0) >=
-			tport->max_logins_per_lun) {
-		pr_warn("max number of logins reached\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
-		return;
-	}
-
-	if (!sess) {
-		sess = sbp_session_create(tpg, guid);
-		if (IS_ERR(sess)) {
-			switch (PTR_ERR(sess)) {
-			case -EPERM:
-				ret = SBP_STATUS_ACCESS_DENIED;
-				break;
-			default:
-				ret = SBP_STATUS_RESOURCES_UNAVAIL;
-				break;
-			}
-
-			req->status.status = cpu_to_be32(
-				STATUS_BLOCK_RESP(
-					STATUS_RESP_REQUEST_COMPLETE) |
-				STATUS_BLOCK_SBP_STATUS(ret));
-			return;
-		}
-
-		sess->node_id = req->node_addr;
-		sess->card = fw_card_get(req->card);
-		sess->generation = req->generation;
-		sess->speed = req->speed;
-
-		schedule_delayed_work(&sess->maint_work,
-				SESSION_MAINTENANCE_INTERVAL);
-	}
-
-	/* only take the latest reconnect_hold into account */
-	sess->reconnect_hold = min(
-		1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
-		tport->max_reconnect_timeout) - 1;
-
-	login = kmalloc(sizeof(*login), GFP_KERNEL);
-	if (!login) {
-		pr_err("failed to allocate login descriptor\n");
-
-		sbp_session_release(sess, true);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
-		return;
-	}
-
-	login->sess = sess;
-	login->login_lun = unpacked_lun;
-	login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
-	login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
-	login->login_id = atomic_inc_return(&login_id);
-
-	login->tgt_agt = sbp_target_agent_register(login);
-	if (IS_ERR(login->tgt_agt)) {
-		ret = PTR_ERR(login->tgt_agt);
-		pr_err("failed to map command block handler: %d\n", ret);
-
-		sbp_session_release(sess, true);
-		kfree(login);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
-		return;
-	}
-
-	spin_lock_bh(&sess->lock);
-	list_add_tail(&login->link, &sess->login_list);
-	spin_unlock_bh(&sess->lock);
-
-already_logged_in:
-	response = kzalloc(sizeof(*response), GFP_KERNEL);
-	if (!response) {
-		pr_err("failed to allocate login response block\n");
-
-		sbp_login_release(login, true);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
-		return;
-	}
-
-	login_response_len = clamp_val(
-			LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
-			12, sizeof(*response));
-	response->misc = cpu_to_be32(
-		((login_response_len & 0xffff) << 16) |
-		(login->login_id & 0xffff));
-	response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff);
-	addr_to_sbp2_pointer(login->tgt_agt->handler.offset,
-		&response->command_block_agent);
-
-	ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST,
-		sess->node_id, sess->generation, sess->speed,
-		sbp2_pointer_to_addr(&req->orb.ptr2), response,
-		login_response_len);
-	if (ret != RCODE_COMPLETE) {
-		pr_debug("failed to write login response block: %x\n", ret);
-
-		kfree(response);
-		sbp_login_release(login, true);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-		return;
-	}
-
-	kfree(response);
-
-	req->status.status = cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void sbp_management_request_query_logins(
-	struct sbp_management_agent *agent, struct sbp_management_request *req,
-	int *status_data_size)
-{
-	pr_notice("QUERY LOGINS not implemented\n");
-	/* FIXME: implement */
-
-	req->status.status = cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-}
-
-static void sbp_management_request_reconnect(
-	struct sbp_management_agent *agent, struct sbp_management_request *req,
-	int *status_data_size)
-{
-	struct sbp_tport *tport = agent->tport;
-	struct sbp_tpg *tpg = tport->tpg;
-	int ret;
-	u64 guid;
-	struct sbp_login_descriptor *login;
-
-	ret = read_peer_guid(&guid, req);
-	if (ret != RCODE_COMPLETE) {
-		pr_warn("failed to read peer GUID: %d\n", ret);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-		return;
-	}
-
-	pr_notice("mgt_agent RECONNECT from %016llx\n", guid);
-
-	login = sbp_login_find_by_id(tpg,
-		RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
-
-	if (!login) {
-		pr_err("mgt_agent RECONNECT unknown login ID\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
-		return;
-	}
-
-	if (login->sess->guid != guid) {
-		pr_err("mgt_agent RECONNECT login GUID doesn't match\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
-		return;
-	}
-
-	spin_lock_bh(&login->sess->lock);
-	if (login->sess->card)
-		fw_card_put(login->sess->card);
-
-	/* update the node details */
-	login->sess->generation = req->generation;
-	login->sess->node_id = req->node_addr;
-	login->sess->card = fw_card_get(req->card);
-	login->sess->speed = req->speed;
-	spin_unlock_bh(&login->sess->lock);
-
-	req->status.status = cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void sbp_management_request_logout(
-	struct sbp_management_agent *agent, struct sbp_management_request *req,
-	int *status_data_size)
-{
-	struct sbp_tport *tport = agent->tport;
-	struct sbp_tpg *tpg = tport->tpg;
-	int id;
-	struct sbp_login_descriptor *login;
-
-	id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
-
-	login = sbp_login_find_by_id(tpg, id);
-	if (!login) {
-		pr_warn("cannot find login: %d\n", id);
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN));
-		return;
-	}
-
-	pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
-		login->login_lun, login->login_id);
-
-	if (req->node_addr != login->sess->node_id) {
-		pr_warn("logout from different node ID\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
-		return;
-	}
-
-	sbp_login_release(login, true);
-
-	req->status.status = cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void session_check_for_reset(struct sbp_session *sess)
-{
-	bool card_valid = false;
-
-	spin_lock_bh(&sess->lock);
-
-	if (sess->card) {
-		spin_lock_irq(&sess->card->lock);
-		card_valid = (sess->card->local_node != NULL);
-		spin_unlock_irq(&sess->card->lock);
-
-		if (!card_valid) {
-			fw_card_put(sess->card);
-			sess->card = NULL;
-		}
-	}
-
-	if (!card_valid || (sess->generation != sess->card->generation)) {
-		pr_info("Waiting for reconnect from node: %016llx\n",
-				sess->guid);
-
-		sess->node_id = -1;
-		sess->reconnect_expires = get_jiffies_64() +
-			((sess->reconnect_hold + 1) * HZ);
-	}
-
-	spin_unlock_bh(&sess->lock);
-}
-
-static void session_reconnect_expired(struct sbp_session *sess)
-{
-	struct sbp_login_descriptor *login, *temp;
-	LIST_HEAD(login_list);
-
-	pr_info("Reconnect timer expired for node: %016llx\n", sess->guid);
-
-	spin_lock_bh(&sess->lock);
-	list_for_each_entry_safe(login, temp, &sess->login_list, link) {
-		login->sess = NULL;
-		list_move_tail(&login->link, &login_list);
-	}
-	spin_unlock_bh(&sess->lock);
-
-	list_for_each_entry_safe(login, temp, &login_list, link) {
-		list_del(&login->link);
-		sbp_login_release(login, false);
-	}
-
-	sbp_session_release(sess, false);
-}
-
-static void session_maintenance_work(struct work_struct *work)
-{
-	struct sbp_session *sess = container_of(work, struct sbp_session,
-			maint_work.work);
-
-	/* could be called while tearing down the session */
-	spin_lock_bh(&sess->lock);
-	if (list_empty(&sess->login_list)) {
-		spin_unlock_bh(&sess->lock);
-		return;
-	}
-	spin_unlock_bh(&sess->lock);
-
-	if (sess->node_id != -1) {
-		/* check for bus reset and make node_id invalid */
-		session_check_for_reset(sess);
-
-		schedule_delayed_work(&sess->maint_work,
-				SESSION_MAINTENANCE_INTERVAL);
-	} else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) {
-		/* still waiting for reconnect */
-		schedule_delayed_work(&sess->maint_work,
-				SESSION_MAINTENANCE_INTERVAL);
-	} else {
-		/* reconnect timeout has expired */
-		session_reconnect_expired(sess);
-	}
-}
-
-static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data,
-		struct sbp_target_agent *agent)
-{
-	int state;
-
-	switch (tcode) {
-	case TCODE_READ_QUADLET_REQUEST:
-		pr_debug("tgt_agent AGENT_STATE READ\n");
-
-		spin_lock_bh(&agent->lock);
-		state = agent->state;
-		spin_unlock_bh(&agent->lock);
-
-		*(__be32 *)data = cpu_to_be32(state);
-
-		return RCODE_COMPLETE;
-
-	case TCODE_WRITE_QUADLET_REQUEST:
-		/* ignored */
-		return RCODE_COMPLETE;
-
-	default:
-		return RCODE_TYPE_ERROR;
-	}
-}
-
-static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data,
-		struct sbp_target_agent *agent)
-{
-	switch (tcode) {
-	case TCODE_WRITE_QUADLET_REQUEST:
-		pr_debug("tgt_agent AGENT_RESET\n");
-		spin_lock_bh(&agent->lock);
-		agent->state = AGENT_STATE_RESET;
-		spin_unlock_bh(&agent->lock);
-		return RCODE_COMPLETE;
-
-	default:
-		return RCODE_TYPE_ERROR;
-	}
-}
-
-static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data,
-		struct sbp_target_agent *agent)
-{
-	struct sbp2_pointer *ptr = data;
-
-	switch (tcode) {
-	case TCODE_WRITE_BLOCK_REQUEST:
-		spin_lock_bh(&agent->lock);
-		if (agent->state != AGENT_STATE_SUSPENDED &&
-				agent->state != AGENT_STATE_RESET) {
-			spin_unlock_bh(&agent->lock);
-			pr_notice("Ignoring ORB_POINTER write while active.\n");
-			return RCODE_CONFLICT_ERROR;
-		}
-		agent->state = AGENT_STATE_ACTIVE;
-		spin_unlock_bh(&agent->lock);
-
-		agent->orb_pointer = sbp2_pointer_to_addr(ptr);
-		agent->doorbell = false;
-
-		pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n",
-				agent->orb_pointer);
-
-		queue_work(system_unbound_wq, &agent->work);
-
-		return RCODE_COMPLETE;
-
-	case TCODE_READ_BLOCK_REQUEST:
-		pr_debug("tgt_agent ORB_POINTER READ\n");
-		spin_lock_bh(&agent->lock);
-		addr_to_sbp2_pointer(agent->orb_pointer, ptr);
-		spin_unlock_bh(&agent->lock);
-		return RCODE_COMPLETE;
-
-	default:
-		return RCODE_TYPE_ERROR;
-	}
-}
-
-static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data,
-		struct sbp_target_agent *agent)
-{
-	switch (tcode) {
-	case TCODE_WRITE_QUADLET_REQUEST:
-		spin_lock_bh(&agent->lock);
-		if (agent->state != AGENT_STATE_SUSPENDED) {
-			spin_unlock_bh(&agent->lock);
-			pr_debug("Ignoring DOORBELL while active.\n");
-			return RCODE_CONFLICT_ERROR;
-		}
-		agent->state = AGENT_STATE_ACTIVE;
-		spin_unlock_bh(&agent->lock);
-
-		agent->doorbell = true;
-
-		pr_debug("tgt_agent DOORBELL\n");
-
-		queue_work(system_unbound_wq, &agent->work);
-
-		return RCODE_COMPLETE;
-
-	case TCODE_READ_QUADLET_REQUEST:
-		return RCODE_COMPLETE;
-
-	default:
-		return RCODE_TYPE_ERROR;
-	}
-}
-
-static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card,
-		int tcode, void *data, struct sbp_target_agent *agent)
-{
-	switch (tcode) {
-	case TCODE_WRITE_QUADLET_REQUEST:
-		pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n");
-		/* ignored as we don't send unsolicited status */
-		return RCODE_COMPLETE;
-
-	case TCODE_READ_QUADLET_REQUEST:
-		return RCODE_COMPLETE;
-
-	default:
-		return RCODE_TYPE_ERROR;
-	}
-}
-
-static void tgt_agent_rw(struct fw_card *card, struct fw_request *request,
-		int tcode, int destination, int source, int generation,
-		unsigned long long offset, void *data, size_t length,
-		void *callback_data)
-{
-	struct sbp_target_agent *agent = callback_data;
-	struct sbp_session *sess = agent->login->sess;
-	int sess_gen, sess_node, rcode;
-
-	spin_lock_bh(&sess->lock);
-	sess_gen = sess->generation;
-	sess_node = sess->node_id;
-	spin_unlock_bh(&sess->lock);
-
-	if (generation != sess_gen) {
-		pr_notice("ignoring request with wrong generation\n");
-		rcode = RCODE_TYPE_ERROR;
-		goto out;
-	}
-
-	if (source != sess_node) {
-		pr_notice("ignoring request from foreign node (%x != %x)\n",
-				source, sess_node);
-		rcode = RCODE_TYPE_ERROR;
-		goto out;
-	}
-
-	/* turn offset into the offset from the start of the block */
-	offset -= agent->handler.offset;
-
-	if (offset == 0x00 && length == 4) {
-		/* AGENT_STATE */
-		rcode = tgt_agent_rw_agent_state(card, tcode, data, agent);
-	} else if (offset == 0x04 && length == 4) {
-		/* AGENT_RESET */
-		rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent);
-	} else if (offset == 0x08 && length == 8) {
-		/* ORB_POINTER */
-		rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent);
-	} else if (offset == 0x10 && length == 4) {
-		/* DOORBELL */
-		rcode = tgt_agent_rw_doorbell(card, tcode, data, agent);
-	} else if (offset == 0x14 && length == 4) {
-		/* UNSOLICITED_STATUS_ENABLE */
-		rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode,
-				data, agent);
-	} else {
-		rcode = RCODE_ADDRESS_ERROR;
-	}
-
-out:
-	fw_send_response(card, request, rcode);
-}
-
-static void sbp_handle_command(struct sbp_target_request *);
-static int sbp_send_status(struct sbp_target_request *);
-static void sbp_free_request(struct sbp_target_request *);
-
-static void tgt_agent_process_work(struct work_struct *work)
-{
-	struct sbp_target_request *req =
-		container_of(work, struct sbp_target_request, work);
-
-	pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n",
-			req->orb_pointer,
-			sbp2_pointer_to_addr(&req->orb.next_orb),
-			sbp2_pointer_to_addr(&req->orb.data_descriptor),
-			be32_to_cpu(req->orb.misc));
-
-	if (req->orb_pointer >> 32)
-		pr_debug("ORB with high bits set\n");
-
-	switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
-		case 0:/* Format specified by this standard */
-			sbp_handle_command(req);
-			return;
-		case 1: /* Reserved for future standardization */
-		case 2: /* Vendor-dependent */
-			req->status.status |= cpu_to_be32(
-					STATUS_BLOCK_RESP(
-						STATUS_RESP_REQUEST_COMPLETE) |
-					STATUS_BLOCK_DEAD(0) |
-					STATUS_BLOCK_LEN(1) |
-					STATUS_BLOCK_SBP_STATUS(
-						SBP_STATUS_REQ_TYPE_NOTSUPP));
-			sbp_send_status(req);
-			return;
-		case 3: /* Dummy ORB */
-			req->status.status |= cpu_to_be32(
-					STATUS_BLOCK_RESP(
-						STATUS_RESP_REQUEST_COMPLETE) |
-					STATUS_BLOCK_DEAD(0) |
-					STATUS_BLOCK_LEN(1) |
-					STATUS_BLOCK_SBP_STATUS(
-						SBP_STATUS_DUMMY_ORB_COMPLETE));
-			sbp_send_status(req);
-			return;
-		default:
-			BUG();
-	}
-}
-
-/* used to double-check we haven't been issued an AGENT_RESET */
-static inline bool tgt_agent_check_active(struct sbp_target_agent *agent)
-{
-	bool active;
-
-	spin_lock_bh(&agent->lock);
-	active = (agent->state == AGENT_STATE_ACTIVE);
-	spin_unlock_bh(&agent->lock);
-
-	return active;
-}
-
-static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess,
-	struct fw_card *card, u64 next_orb)
-{
-	struct se_session *se_sess = sess->se_sess;
-	struct sbp_target_request *req;
-	int tag, cpu;
-
-	tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
-	if (tag < 0)
-		return ERR_PTR(-ENOMEM);
-
-	req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag];
-	memset(req, 0, sizeof(*req));
-	req->se_cmd.map_tag = tag;
-	req->se_cmd.map_cpu = cpu;
-	req->se_cmd.tag = next_orb;
-
-	return req;
-}
-
-static void tgt_agent_fetch_work(struct work_struct *work)
-{
-	struct sbp_target_agent *agent =
-		container_of(work, struct sbp_target_agent, work);
-	struct sbp_session *sess = agent->login->sess;
-	struct sbp_target_request *req;
-	int ret;
-	bool doorbell = agent->doorbell;
-	u64 next_orb = agent->orb_pointer;
-
-	while (next_orb && tgt_agent_check_active(agent)) {
-		req = sbp_mgt_get_req(sess, sess->card, next_orb);
-		if (IS_ERR(req)) {
-			spin_lock_bh(&agent->lock);
-			agent->state = AGENT_STATE_DEAD;
-			spin_unlock_bh(&agent->lock);
-			return;
-		}
-
-		req->login = agent->login;
-		req->orb_pointer = next_orb;
-
-		req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
-					req->orb_pointer >> 32));
-		req->status.orb_low = cpu_to_be32(
-				req->orb_pointer & 0xfffffffc);
-
-		/* read in the ORB */
-		ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST,
-				sess->node_id, sess->generation, sess->speed,
-				req->orb_pointer, &req->orb, sizeof(req->orb));
-		if (ret != RCODE_COMPLETE) {
-			pr_debug("tgt_orb fetch failed: %x\n", ret);
-			req->status.status |= cpu_to_be32(
-					STATUS_BLOCK_SRC(
-						STATUS_SRC_ORB_FINISHED) |
-					STATUS_BLOCK_RESP(
-						STATUS_RESP_TRANSPORT_FAILURE) |
-					STATUS_BLOCK_DEAD(1) |
-					STATUS_BLOCK_LEN(1) |
-					STATUS_BLOCK_SBP_STATUS(
-						SBP_STATUS_UNSPECIFIED_ERROR));
-			spin_lock_bh(&agent->lock);
-			agent->state = AGENT_STATE_DEAD;
-			spin_unlock_bh(&agent->lock);
-
-			sbp_send_status(req);
-			return;
-		}
-
-		/* check the next_ORB field */
-		if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
-			next_orb = 0;
-			req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
-						STATUS_SRC_ORB_FINISHED));
-		} else {
-			next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
-			req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
-						STATUS_SRC_ORB_CONTINUING));
-		}
-
-		if (tgt_agent_check_active(agent) && !doorbell) {
-			INIT_WORK(&req->work, tgt_agent_process_work);
-			queue_work(system_unbound_wq, &req->work);
-		} else {
-			/* don't process this request, just check next_ORB */
-			sbp_free_request(req);
-		}
-
-		spin_lock_bh(&agent->lock);
-		doorbell = agent->doorbell = false;
-
-		/* check if we should carry on processing */
-		if (next_orb)
-			agent->orb_pointer = next_orb;
-		else
-			agent->state = AGENT_STATE_SUSPENDED;
-
-		spin_unlock_bh(&agent->lock);
-	};
-}
-
-static struct sbp_target_agent *sbp_target_agent_register(
-		struct sbp_login_descriptor *login)
-{
-	struct sbp_target_agent *agent;
-	int ret;
-
-	agent = kmalloc(sizeof(*agent), GFP_KERNEL);
-	if (!agent)
-		return ERR_PTR(-ENOMEM);
-
-	spin_lock_init(&agent->lock);
-
-	agent->handler.length = 0x20;
-	agent->handler.address_callback = tgt_agent_rw;
-	agent->handler.callback_data = agent;
-
-	agent->login = login;
-	agent->state = AGENT_STATE_RESET;
-	INIT_WORK(&agent->work, tgt_agent_fetch_work);
-	agent->orb_pointer = 0;
-	agent->doorbell = false;
-
-	ret = fw_core_add_address_handler(&agent->handler,
-			&sbp_register_region);
-	if (ret < 0) {
-		kfree(agent);
-		return ERR_PTR(ret);
-	}
-
-	return agent;
-}
-
-static void sbp_target_agent_unregister(struct sbp_target_agent *agent)
-{
-	fw_core_remove_address_handler(&agent->handler);
-	cancel_work_sync(&agent->work);
-	kfree(agent);
-}
-
-/*
- * Simple wrapper around fw_run_transaction that retries the transaction several
- * times in case of failure, with an exponential backoff.
- */
-static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id,
-		int generation, int speed, unsigned long long offset,
-		void *payload, size_t length)
-{
-	int attempt, ret, delay;
-
-	for (attempt = 1; attempt <= 5; attempt++) {
-		ret = fw_run_transaction(card, tcode, destination_id,
-				generation, speed, offset, payload, length);
-
-		switch (ret) {
-		case RCODE_COMPLETE:
-		case RCODE_TYPE_ERROR:
-		case RCODE_ADDRESS_ERROR:
-		case RCODE_GENERATION:
-			return ret;
-
-		default:
-			delay = 5 * attempt * attempt;
-			usleep_range(delay, delay * 2);
-		}
-	}
-
-	return ret;
-}
-
-/*
- * Wrapper around sbp_run_transaction that gets the card, destination,
- * generation and speed out of the request's session.
- */
-static int sbp_run_request_transaction(struct sbp_target_request *req,
-		int tcode, unsigned long long offset, void *payload,
-		size_t length)
-{
-	struct sbp_login_descriptor *login = req->login;
-	struct sbp_session *sess = login->sess;
-	struct fw_card *card;
-	int node_id, generation, speed, ret;
-
-	spin_lock_bh(&sess->lock);
-	card = fw_card_get(sess->card);
-	node_id = sess->node_id;
-	generation = sess->generation;
-	speed = sess->speed;
-	spin_unlock_bh(&sess->lock);
-
-	ret = sbp_run_transaction(card, tcode, node_id, generation, speed,
-			offset, payload, length);
-
-	fw_card_put(card);
-
-	return ret;
-}
-
-static int sbp_fetch_command(struct sbp_target_request *req)
-{
-	int ret, cmd_len, copy_len;
-
-	cmd_len = scsi_command_size(req->orb.command_block);
-
-	req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
-	if (!req->cmd_buf)
-		return -ENOMEM;
-
-	memcpy(req->cmd_buf, req->orb.command_block,
-		min_t(int, cmd_len, sizeof(req->orb.command_block)));
-
-	if (cmd_len > sizeof(req->orb.command_block)) {
-		pr_debug("sbp_fetch_command: filling in long command\n");
-		copy_len = cmd_len - sizeof(req->orb.command_block);
-
-		ret = sbp_run_request_transaction(req,
-				TCODE_READ_BLOCK_REQUEST,
-				req->orb_pointer + sizeof(req->orb),
-				req->cmd_buf + sizeof(req->orb.command_block),
-				copy_len);
-		if (ret != RCODE_COMPLETE)
-			return -EIO;
-	}
-
-	return 0;
-}
-
-static int sbp_fetch_page_table(struct sbp_target_request *req)
-{
-	int pg_tbl_sz, ret;
-	struct sbp_page_table_entry *pg_tbl;
-
-	if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
-		return 0;
-
-	pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
-		sizeof(struct sbp_page_table_entry);
-
-	pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL);
-	if (!pg_tbl)
-		return -ENOMEM;
-
-	ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
-			sbp2_pointer_to_addr(&req->orb.data_descriptor),
-			pg_tbl, pg_tbl_sz);
-	if (ret != RCODE_COMPLETE) {
-		kfree(pg_tbl);
-		return -EIO;
-	}
-
-	req->pg_tbl = pg_tbl;
-	return 0;
-}
-
-static void sbp_calc_data_length_direction(struct sbp_target_request *req,
-	u32 *data_len, enum dma_data_direction *data_dir)
-{
-	int data_size, direction, idx;
-
-	data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
-	direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
-
-	if (!data_size) {
-		*data_len = 0;
-		*data_dir = DMA_NONE;
-		return;
-	}
-
-	*data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
-	if (req->pg_tbl) {
-		*data_len = 0;
-		for (idx = 0; idx < data_size; idx++) {
-			*data_len += be16_to_cpu(
-					req->pg_tbl[idx].segment_length);
-		}
-	} else {
-		*data_len = data_size;
-	}
-}
-
-static void sbp_handle_command(struct sbp_target_request *req)
-{
-	struct sbp_login_descriptor *login = req->login;
-	struct sbp_session *sess = login->sess;
-	int ret, unpacked_lun;
-	u32 data_length;
-	enum dma_data_direction data_dir;
-
-	ret = sbp_fetch_command(req);
-	if (ret) {
-		pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
-		goto err;
-	}
-
-	ret = sbp_fetch_page_table(req);
-	if (ret) {
-		pr_debug("sbp_handle_command: fetch page table failed: %d\n",
-			ret);
-		goto err;
-	}
-
-	unpacked_lun = req->login->login_lun;
-	sbp_calc_data_length_direction(req, &data_length, &data_dir);
-
-	pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
-			req->orb_pointer, unpacked_lun, data_length, data_dir);
-
-	/* only used for printk until we do TMRs */
-	req->se_cmd.tag = req->orb_pointer;
-	if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
-			      req->sense_buf, unpacked_lun, data_length,
-			      TCM_SIMPLE_TAG, data_dir, TARGET_SCF_ACK_KREF))
-		goto err;
-
-	return;
-
-err:
-	req->status.status |= cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-		STATUS_BLOCK_DEAD(0) |
-		STATUS_BLOCK_LEN(1) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-	sbp_send_status(req);
-}
-
-/*
- * DMA_TO_DEVICE = read from initiator (SCSI WRITE)
- * DMA_FROM_DEVICE = write to initiator (SCSI READ)
- */
-static int sbp_rw_data(struct sbp_target_request *req)
-{
-	struct sbp_session *sess = req->login->sess;
-	int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id,
-		generation, num_pte, length, tfr_length,
-		rcode = RCODE_COMPLETE;
-	struct sbp_page_table_entry *pte;
-	unsigned long long offset;
-	struct fw_card *card;
-	struct sg_mapping_iter iter;
-
-	if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
-		tcode = TCODE_WRITE_BLOCK_REQUEST;
-		sg_miter_flags = SG_MITER_FROM_SG;
-	} else {
-		tcode = TCODE_READ_BLOCK_REQUEST;
-		sg_miter_flags = SG_MITER_TO_SG;
-	}
-
-	max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
-	speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
-
-	pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
-	if (pg_size) {
-		pr_err("sbp_run_transaction: page size ignored\n");
-		pg_size = 0x100 << pg_size;
-	}
-
-	spin_lock_bh(&sess->lock);
-	card = fw_card_get(sess->card);
-	node_id = sess->node_id;
-	generation = sess->generation;
-	spin_unlock_bh(&sess->lock);
-
-	if (req->pg_tbl) {
-		pte = req->pg_tbl;
-		num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
-
-		offset = 0;
-		length = 0;
-	} else {
-		pte = NULL;
-		num_pte = 0;
-
-		offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
-		length = req->se_cmd.data_length;
-	}
-
-	sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
-		sg_miter_flags);
-
-	while (length || num_pte) {
-		if (!length) {
-			offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 |
-				be32_to_cpu(pte->segment_base_lo);
-			length = be16_to_cpu(pte->segment_length);
-
-			pte++;
-			num_pte--;
-		}
-
-		sg_miter_next(&iter);
-
-		tfr_length = min3(length, max_payload, (int)iter.length);
-
-		/* FIXME: take page_size into account */
-
-		rcode = sbp_run_transaction(card, tcode, node_id,
-				generation, speed,
-				offset, iter.addr, tfr_length);
-
-		if (rcode != RCODE_COMPLETE)
-			break;
-
-		length -= tfr_length;
-		offset += tfr_length;
-		iter.consumed = tfr_length;
-	}
-
-	sg_miter_stop(&iter);
-	fw_card_put(card);
-
-	if (rcode == RCODE_COMPLETE) {
-		WARN_ON(length != 0);
-		return 0;
-	} else {
-		return -EIO;
-	}
-}
-
-static int sbp_send_status(struct sbp_target_request *req)
-{
-	int rc, ret = 0, length;
-	struct sbp_login_descriptor *login = req->login;
-
-	length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
-
-	rc = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
-			login->status_fifo_addr, &req->status, length);
-	if (rc != RCODE_COMPLETE) {
-		pr_debug("sbp_send_status: write failed: 0x%x\n", rc);
-		ret = -EIO;
-		goto put_ref;
-	}
-
-	pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n",
-			req->orb_pointer);
-	/*
-	 * Drop the extra ACK_KREF reference taken by target_submit_cmd()
-	 * ahead of sbp_check_stop_free() -> transport_generic_free_cmd()
-	 * final se_cmd->cmd_kref put.
-	 */
-put_ref:
-	target_put_sess_cmd(&req->se_cmd);
-	return ret;
-}
-
-static void sbp_sense_mangle(struct sbp_target_request *req)
-{
-	struct se_cmd *se_cmd = &req->se_cmd;
-	u8 *sense = req->sense_buf;
-	u8 *status = req->status.data;
-
-	WARN_ON(se_cmd->scsi_sense_length < 18);
-
-	switch (sense[0] & 0x7f) { 		/* sfmt */
-	case 0x70: /* current, fixed */
-		status[0] = 0 << 6;
-		break;
-	case 0x71: /* deferred, fixed */
-		status[0] = 1 << 6;
-		break;
-	case 0x72: /* current, descriptor */
-	case 0x73: /* deferred, descriptor */
-	default:
-		/*
-		 * TODO: SBP-3 specifies what we should do with descriptor
-		 * format sense data
-		 */
-		pr_err("sbp_send_sense: unknown sense format: 0x%x\n",
-			sense[0]);
-		req->status.status |= cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_DEAD(0) |
-			STATUS_BLOCK_LEN(1) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED));
-		return;
-	}
-
-	status[0] |= se_cmd->scsi_status & 0x3f;/* status */
-	status[1] =
-		(sense[0] & 0x80) |		/* valid */
-		((sense[2] & 0xe0) >> 1) |	/* mark, eom, ili */
-		(sense[2] & 0x0f);		/* sense_key */
-	status[2] = se_cmd->scsi_asc;		/* sense_code */
-	status[3] = se_cmd->scsi_ascq;		/* sense_qualifier */
-
-	/* information */
-	status[4] = sense[3];
-	status[5] = sense[4];
-	status[6] = sense[5];
-	status[7] = sense[6];
-
-	/* CDB-dependent */
-	status[8] = sense[8];
-	status[9] = sense[9];
-	status[10] = sense[10];
-	status[11] = sense[11];
-
-	/* fru */
-	status[12] = sense[14];
-
-	/* sense_key-dependent */
-	status[13] = sense[15];
-	status[14] = sense[16];
-	status[15] = sense[17];
-
-	req->status.status |= cpu_to_be32(
-		STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-		STATUS_BLOCK_DEAD(0) |
-		STATUS_BLOCK_LEN(5) |
-		STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static int sbp_send_sense(struct sbp_target_request *req)
-{
-	struct se_cmd *se_cmd = &req->se_cmd;
-
-	if (se_cmd->scsi_sense_length) {
-		sbp_sense_mangle(req);
-	} else {
-		req->status.status |= cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_DEAD(0) |
-			STATUS_BLOCK_LEN(1) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-	}
-
-	return sbp_send_status(req);
-}
-
-static void sbp_free_request(struct sbp_target_request *req)
-{
-	struct se_cmd *se_cmd = &req->se_cmd;
-	struct se_session *se_sess = se_cmd->se_sess;
-
-	kfree(req->pg_tbl);
-	kfree(req->cmd_buf);
-
-	target_free_tag(se_sess, se_cmd);
-}
-
-static void sbp_mgt_agent_process(struct work_struct *work)
-{
-	struct sbp_management_agent *agent =
-		container_of(work, struct sbp_management_agent, work);
-	struct sbp_management_request *req = agent->request;
-	int ret;
-	int status_data_len = 0;
-
-	/* fetch the ORB from the initiator */
-	ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
-		req->node_addr, req->generation, req->speed,
-		agent->orb_offset, &req->orb, sizeof(req->orb));
-	if (ret != RCODE_COMPLETE) {
-		pr_debug("mgt_orb fetch failed: %x\n", ret);
-		goto out;
-	}
-
-	pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n",
-		sbp2_pointer_to_addr(&req->orb.ptr1),
-		sbp2_pointer_to_addr(&req->orb.ptr2),
-		be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
-		sbp2_pointer_to_addr(&req->orb.status_fifo));
-
-	if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
-		ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
-		pr_err("mgt_orb bad request\n");
-		goto out;
-	}
-
-	switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
-	case MANAGEMENT_ORB_FUNCTION_LOGIN:
-		sbp_management_request_login(agent, req, &status_data_len);
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS:
-		sbp_management_request_query_logins(agent, req,
-				&status_data_len);
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_RECONNECT:
-		sbp_management_request_reconnect(agent, req, &status_data_len);
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD:
-		pr_notice("SET PASSWORD not implemented\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_LOGOUT:
-		sbp_management_request_logout(agent, req, &status_data_len);
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_ABORT_TASK:
-		pr_notice("ABORT TASK not implemented\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET:
-		pr_notice("ABORT TASK SET not implemented\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET:
-		pr_notice("LOGICAL UNIT RESET not implemented\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-
-	case MANAGEMENT_ORB_FUNCTION_TARGET_RESET:
-		pr_notice("TARGET RESET not implemented\n");
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-
-	default:
-		pr_notice("unknown management function 0x%x\n",
-			MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
-
-		req->status.status = cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
-		break;
-	}
-
-	req->status.status |= cpu_to_be32(
-		STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */
-		STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |
-		STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32));
-	req->status.orb_low = cpu_to_be32(agent->orb_offset);
-
-	/* write the status block back to the initiator */
-	ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
-		req->node_addr, req->generation, req->speed,
-		sbp2_pointer_to_addr(&req->orb.status_fifo),
-		&req->status, 8 + status_data_len);
-	if (ret != RCODE_COMPLETE) {
-		pr_debug("mgt_orb status write failed: %x\n", ret);
-		goto out;
-	}
-
-out:
-	fw_card_put(req->card);
-	kfree(req);
-
-	spin_lock_bh(&agent->lock);
-	agent->state = MANAGEMENT_AGENT_STATE_IDLE;
-	spin_unlock_bh(&agent->lock);
-}
-
-static void sbp_mgt_agent_rw(struct fw_card *card,
-	struct fw_request *request, int tcode, int destination, int source,
-	int generation, unsigned long long offset, void *data, size_t length,
-	void *callback_data)
-{
-	struct sbp_management_agent *agent = callback_data;
-	struct sbp2_pointer *ptr = data;
-	int rcode = RCODE_ADDRESS_ERROR;
-
-	if (!agent->tport->enable)
-		goto out;
-
-	if ((offset != agent->handler.offset) || (length != 8))
-		goto out;
-
-	if (tcode == TCODE_WRITE_BLOCK_REQUEST) {
-		struct sbp_management_request *req;
-		int prev_state;
-
-		spin_lock_bh(&agent->lock);
-		prev_state = agent->state;
-		agent->state = MANAGEMENT_AGENT_STATE_BUSY;
-		spin_unlock_bh(&agent->lock);
-
-		if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) {
-			pr_notice("ignoring management request while busy\n");
-			rcode = RCODE_CONFLICT_ERROR;
-			goto out;
-		}
-		req = kzalloc(sizeof(*req), GFP_ATOMIC);
-		if (!req) {
-			rcode = RCODE_CONFLICT_ERROR;
-			goto out;
-		}
-
-		req->card = fw_card_get(card);
-		req->generation = generation;
-		req->node_addr = source;
-		req->speed = fw_get_request_speed(request);
-
-		agent->orb_offset = sbp2_pointer_to_addr(ptr);
-		agent->request = req;
-
-		queue_work(system_unbound_wq, &agent->work);
-		rcode = RCODE_COMPLETE;
-	} else if (tcode == TCODE_READ_BLOCK_REQUEST) {
-		addr_to_sbp2_pointer(agent->orb_offset, ptr);
-		rcode = RCODE_COMPLETE;
-	} else {
-		rcode = RCODE_TYPE_ERROR;
-	}
-
-out:
-	fw_send_response(card, request, rcode);
-}
-
-static struct sbp_management_agent *sbp_management_agent_register(
-		struct sbp_tport *tport)
-{
-	int ret;
-	struct sbp_management_agent *agent;
-
-	agent = kmalloc(sizeof(*agent), GFP_KERNEL);
-	if (!agent)
-		return ERR_PTR(-ENOMEM);
-
-	spin_lock_init(&agent->lock);
-	agent->tport = tport;
-	agent->handler.length = 0x08;
-	agent->handler.address_callback = sbp_mgt_agent_rw;
-	agent->handler.callback_data = agent;
-	agent->state = MANAGEMENT_AGENT_STATE_IDLE;
-	INIT_WORK(&agent->work, sbp_mgt_agent_process);
-	agent->orb_offset = 0;
-	agent->request = NULL;
-
-	ret = fw_core_add_address_handler(&agent->handler,
-			&sbp_register_region);
-	if (ret < 0) {
-		kfree(agent);
-		return ERR_PTR(ret);
-	}
-
-	return agent;
-}
-
-static void sbp_management_agent_unregister(struct sbp_management_agent *agent)
-{
-	fw_core_remove_address_handler(&agent->handler);
-	cancel_work_sync(&agent->work);
-	kfree(agent);
-}
-
-static int sbp_check_true(struct se_portal_group *se_tpg)
-{
-	return 1;
-}
-
-static int sbp_check_false(struct se_portal_group *se_tpg)
-{
-	return 0;
-}
-
-static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg)
-{
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-
-	return &tport->tport_name[0];
-}
-
-static u16 sbp_get_tag(struct se_portal_group *se_tpg)
-{
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	return tpg->tport_tpgt;
-}
-
-static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
-{
-	return 1;
-}
-
-static void sbp_release_cmd(struct se_cmd *se_cmd)
-{
-	struct sbp_target_request *req = container_of(se_cmd,
-			struct sbp_target_request, se_cmd);
-
-	sbp_free_request(req);
-}
-
-static u32 sbp_sess_get_index(struct se_session *se_sess)
-{
-	return 0;
-}
-
-static int sbp_write_pending(struct se_cmd *se_cmd)
-{
-	struct sbp_target_request *req = container_of(se_cmd,
-			struct sbp_target_request, se_cmd);
-	int ret;
-
-	ret = sbp_rw_data(req);
-	if (ret) {
-		req->status.status |= cpu_to_be32(
-			STATUS_BLOCK_RESP(
-				STATUS_RESP_TRANSPORT_FAILURE) |
-			STATUS_BLOCK_DEAD(0) |
-			STATUS_BLOCK_LEN(1) |
-			STATUS_BLOCK_SBP_STATUS(
-				SBP_STATUS_UNSPECIFIED_ERROR));
-		sbp_send_status(req);
-		return ret;
-	}
-
-	target_execute_cmd(se_cmd);
-	return 0;
-}
-
-static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
-{
-	return;
-}
-
-static int sbp_get_cmd_state(struct se_cmd *se_cmd)
-{
-	return 0;
-}
-
-static int sbp_queue_data_in(struct se_cmd *se_cmd)
-{
-	struct sbp_target_request *req = container_of(se_cmd,
-			struct sbp_target_request, se_cmd);
-	int ret;
-
-	ret = sbp_rw_data(req);
-	if (ret) {
-		req->status.status |= cpu_to_be32(
-			STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-			STATUS_BLOCK_DEAD(0) |
-			STATUS_BLOCK_LEN(1) |
-			STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-		sbp_send_status(req);
-		return ret;
-	}
-
-	return sbp_send_sense(req);
-}
-
-/*
- * Called after command (no data transfer) or after the write (to device)
- * operation is completed
- */
-static int sbp_queue_status(struct se_cmd *se_cmd)
-{
-	struct sbp_target_request *req = container_of(se_cmd,
-			struct sbp_target_request, se_cmd);
-
-	return sbp_send_sense(req);
-}
-
-static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
-{
-}
-
-static void sbp_aborted_task(struct se_cmd *se_cmd)
-{
-	return;
-}
-
-static int sbp_check_stop_free(struct se_cmd *se_cmd)
-{
-	struct sbp_target_request *req = container_of(se_cmd,
-			struct sbp_target_request, se_cmd);
-
-	return transport_generic_free_cmd(&req->se_cmd, 0);
-}
-
-static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
-{
-	struct se_lun *lun;
-	int count = 0;
-
-	rcu_read_lock();
-	hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link)
-		count++;
-	rcu_read_unlock();
-
-	return count;
-}
-
-static int sbp_update_unit_directory(struct sbp_tport *tport)
-{
-	struct se_lun *lun;
-	int num_luns, num_entries, idx = 0, mgt_agt_addr, ret;
-	u32 *data;
-
-	if (tport->unit_directory.data) {
-		fw_core_remove_descriptor(&tport->unit_directory);
-		kfree(tport->unit_directory.data);
-		tport->unit_directory.data = NULL;
-	}
-
-	if (!tport->enable || !tport->tpg)
-		return 0;
-
-	num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg);
-
-	/*
-	 * Number of entries in the final unit directory:
-	 *  - all of those in the template
-	 *  - management_agent
-	 *  - unit_characteristics
-	 *  - reconnect_timeout
-	 *  - unit unique ID
-	 *  - one for each LUN
-	 *
-	 *  MUST NOT include leaf or sub-directory entries
-	 */
-	num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns;
-
-	if (tport->directory_id != -1)
-		num_entries++;
-
-	/* allocate num_entries + 4 for the header and unique ID leaf */
-	data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL);
-	if (!data)
-		return -ENOMEM;
-
-	/* directory_length */
-	data[idx++] = num_entries << 16;
-
-	/* directory_id */
-	if (tport->directory_id != -1)
-		data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id;
-
-	/* unit directory template */
-	memcpy(&data[idx], sbp_unit_directory_template,
-			sizeof(sbp_unit_directory_template));
-	idx += ARRAY_SIZE(sbp_unit_directory_template);
-
-	/* management_agent */
-	mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4;
-	data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff);
-
-	/* unit_characteristics */
-	data[idx++] = 0x3a000000 |
-		(((tport->mgt_orb_timeout * 2) << 8) & 0xff00) |
-		SBP_ORB_FETCH_SIZE;
-
-	/* reconnect_timeout */
-	data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff);
-
-	/* unit unique ID (leaf is just after LUNs) */
-	data[idx++] = 0x8d000000 | (num_luns + 1);
-
-	rcu_read_lock();
-	hlist_for_each_entry_rcu(lun, &tport->tpg->se_tpg.tpg_lun_hlist, link) {
-		struct se_device *dev;
-		int type;
-		/*
-		 * rcu_dereference_raw protected by se_lun->lun_group symlink
-		 * reference to se_device->dev_group.
-		 */
-		dev = rcu_dereference_raw(lun->lun_se_dev);
-		type = dev->transport->get_device_type(dev);
-
-		/* logical_unit_number */
-		data[idx++] = 0x14000000 |
-			((type << 16) & 0x1f0000) |
-			(lun->unpacked_lun & 0xffff);
-	}
-	rcu_read_unlock();
-
-	/* unit unique ID leaf */
-	data[idx++] = 2 << 16;
-	data[idx++] = tport->guid >> 32;
-	data[idx++] = tport->guid;
-
-	tport->unit_directory.length = idx;
-	tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24;
-	tport->unit_directory.data = data;
-
-	ret = fw_core_add_descriptor(&tport->unit_directory);
-	if (ret < 0) {
-		kfree(tport->unit_directory.data);
-		tport->unit_directory.data = NULL;
-	}
-
-	return ret;
-}
-
-static ssize_t sbp_parse_wwn(const char *name, u64 *wwn)
-{
-	const char *cp;
-	char c, nibble;
-	int pos = 0, err;
-
-	*wwn = 0;
-	for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) {
-		c = *cp;
-		if (c == '\n' && cp[1] == '\0')
-			continue;
-		if (c == '\0') {
-			err = 2;
-			if (pos != 16)
-				goto fail;
-			return cp - name;
-		}
-		err = 3;
-		if (isdigit(c))
-			nibble = c - '0';
-		else if (isxdigit(c))
-			nibble = tolower(c) - 'a' + 10;
-		else
-			goto fail;
-		*wwn = (*wwn << 4) | nibble;
-		pos++;
-	}
-	err = 4;
-fail:
-	printk(KERN_INFO "err %u len %zu pos %u\n",
-			err, cp - name, pos);
-	return -1;
-}
-
-static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
-{
-	return snprintf(buf, len, "%016llx", wwn);
-}
-
-static int sbp_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
-{
-	u64 guid = 0;
-
-	if (sbp_parse_wwn(name, &guid) < 0)
-		return -EINVAL;
-	return 0;
-}
-
-static int sbp_post_link_lun(
-		struct se_portal_group *se_tpg,
-		struct se_lun *se_lun)
-{
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-
-	return sbp_update_unit_directory(tpg->tport);
-}
-
-static void sbp_pre_unlink_lun(
-		struct se_portal_group *se_tpg,
-		struct se_lun *se_lun)
-{
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	int ret;
-
-	if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0)
-		tport->enable = 0;
-
-	ret = sbp_update_unit_directory(tport);
-	if (ret < 0)
-		pr_err("unlink LUN: failed to update unit directory\n");
-}
-
-static struct se_portal_group *sbp_make_tpg(struct se_wwn *wwn,
-					    const char *name)
-{
-	struct sbp_tport *tport =
-		container_of(wwn, struct sbp_tport, tport_wwn);
-
-	struct sbp_tpg *tpg;
-	unsigned long tpgt;
-	int ret;
-
-	if (strstr(name, "tpgt_") != name)
-		return ERR_PTR(-EINVAL);
-	if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
-		return ERR_PTR(-EINVAL);
-
-	if (tport->tpg) {
-		pr_err("Only one TPG per Unit is possible.\n");
-		return ERR_PTR(-EBUSY);
-	}
-
-	tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
-	if (!tpg)
-		return ERR_PTR(-ENOMEM);
-
-	tpg->tport = tport;
-	tpg->tport_tpgt = tpgt;
-	tport->tpg = tpg;
-
-	/* default attribute values */
-	tport->enable = 0;
-	tport->directory_id = -1;
-	tport->mgt_orb_timeout = 15;
-	tport->max_reconnect_timeout = 5;
-	tport->max_logins_per_lun = 1;
-
-	tport->mgt_agt = sbp_management_agent_register(tport);
-	if (IS_ERR(tport->mgt_agt)) {
-		ret = PTR_ERR(tport->mgt_agt);
-		goto out_free_tpg;
-	}
-
-	ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SBP);
-	if (ret < 0)
-		goto out_unreg_mgt_agt;
-
-	return &tpg->se_tpg;
-
-out_unreg_mgt_agt:
-	sbp_management_agent_unregister(tport->mgt_agt);
-out_free_tpg:
-	tport->tpg = NULL;
-	kfree(tpg);
-	return ERR_PTR(ret);
-}
-
-static void sbp_drop_tpg(struct se_portal_group *se_tpg)
-{
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-
-	core_tpg_deregister(se_tpg);
-	sbp_management_agent_unregister(tport->mgt_agt);
-	tport->tpg = NULL;
-	kfree(tpg);
-}
-
-static struct se_wwn *sbp_make_tport(
-		struct target_fabric_configfs *tf,
-		struct config_group *group,
-		const char *name)
-{
-	struct sbp_tport *tport;
-	u64 guid = 0;
-
-	if (sbp_parse_wwn(name, &guid) < 0)
-		return ERR_PTR(-EINVAL);
-
-	tport = kzalloc(sizeof(*tport), GFP_KERNEL);
-	if (!tport)
-		return ERR_PTR(-ENOMEM);
-
-	tport->guid = guid;
-	sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid);
-
-	return &tport->tport_wwn;
-}
-
-static void sbp_drop_tport(struct se_wwn *wwn)
-{
-	struct sbp_tport *tport =
-		container_of(wwn, struct sbp_tport, tport_wwn);
-
-	kfree(tport);
-}
-
-static ssize_t sbp_wwn_version_show(struct config_item *item, char *page)
-{
-	return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION);
-}
-
-CONFIGFS_ATTR_RO(sbp_wwn_, version);
-
-static struct configfs_attribute *sbp_wwn_attrs[] = {
-	&sbp_wwn_attr_version,
-	NULL,
-};
-
-static ssize_t sbp_tpg_directory_id_show(struct config_item *item, char *page)
-{
-	struct se_portal_group *se_tpg = to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-
-	if (tport->directory_id == -1)
-		return sprintf(page, "implicit\n");
-	else
-		return sprintf(page, "%06x\n", tport->directory_id);
-}
-
-static ssize_t sbp_tpg_directory_id_store(struct config_item *item,
-		const char *page, size_t count)
-{
-	struct se_portal_group *se_tpg = to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	unsigned long val;
-
-	if (tport->enable) {
-		pr_err("Cannot change the directory_id on an active target.\n");
-		return -EBUSY;
-	}
-
-	if (strstr(page, "implicit") == page) {
-		tport->directory_id = -1;
-	} else {
-		if (kstrtoul(page, 16, &val) < 0)
-			return -EINVAL;
-		if (val > 0xffffff)
-			return -EINVAL;
-
-		tport->directory_id = val;
-	}
-
-	return count;
-}
-
-static ssize_t sbp_tpg_enable_show(struct config_item *item, char *page)
-{
-	struct se_portal_group *se_tpg = to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	return sprintf(page, "%d\n", tport->enable);
-}
-
-static ssize_t sbp_tpg_enable_store(struct config_item *item,
-		const char *page, size_t count)
-{
-	struct se_portal_group *se_tpg = to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	unsigned long val;
-	int ret;
-
-	if (kstrtoul(page, 0, &val) < 0)
-		return -EINVAL;
-	if ((val != 0) && (val != 1))
-		return -EINVAL;
-
-	if (tport->enable == val)
-		return count;
-
-	if (val) {
-		if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) {
-			pr_err("Cannot enable a target with no LUNs!\n");
-			return -EINVAL;
-		}
-	} else {
-		/* XXX: force-shutdown sessions instead? */
-		spin_lock_bh(&se_tpg->session_lock);
-		if (!list_empty(&se_tpg->tpg_sess_list)) {
-			spin_unlock_bh(&se_tpg->session_lock);
-			return -EBUSY;
-		}
-		spin_unlock_bh(&se_tpg->session_lock);
-	}
-
-	tport->enable = val;
-
-	ret = sbp_update_unit_directory(tport);
-	if (ret < 0) {
-		pr_err("Could not update Config ROM\n");
-		return ret;
-	}
-
-	return count;
-}
-
-CONFIGFS_ATTR(sbp_tpg_, directory_id);
-CONFIGFS_ATTR(sbp_tpg_, enable);
-
-static struct configfs_attribute *sbp_tpg_base_attrs[] = {
-	&sbp_tpg_attr_directory_id,
-	&sbp_tpg_attr_enable,
-	NULL,
-};
-
-static ssize_t sbp_tpg_attrib_mgt_orb_timeout_show(struct config_item *item,
-		char *page)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	return sprintf(page, "%d\n", tport->mgt_orb_timeout);
-}
-
-static ssize_t sbp_tpg_attrib_mgt_orb_timeout_store(struct config_item *item,
-		const char *page, size_t count)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	unsigned long val;
-	int ret;
-
-	if (kstrtoul(page, 0, &val) < 0)
-		return -EINVAL;
-	if ((val < 1) || (val > 127))
-		return -EINVAL;
-
-	if (tport->mgt_orb_timeout == val)
-		return count;
-
-	tport->mgt_orb_timeout = val;
-
-	ret = sbp_update_unit_directory(tport);
-	if (ret < 0)
-		return ret;
-
-	return count;
-}
-
-static ssize_t sbp_tpg_attrib_max_reconnect_timeout_show(struct config_item *item,
-		char *page)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	return sprintf(page, "%d\n", tport->max_reconnect_timeout);
-}
-
-static ssize_t sbp_tpg_attrib_max_reconnect_timeout_store(struct config_item *item,
-		const char *page, size_t count)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	unsigned long val;
-	int ret;
-
-	if (kstrtoul(page, 0, &val) < 0)
-		return -EINVAL;
-	if ((val < 1) || (val > 32767))
-		return -EINVAL;
-
-	if (tport->max_reconnect_timeout == val)
-		return count;
-
-	tport->max_reconnect_timeout = val;
-
-	ret = sbp_update_unit_directory(tport);
-	if (ret < 0)
-		return ret;
-
-	return count;
-}
-
-static ssize_t sbp_tpg_attrib_max_logins_per_lun_show(struct config_item *item,
-		char *page)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	return sprintf(page, "%d\n", tport->max_logins_per_lun);
-}
-
-static ssize_t sbp_tpg_attrib_max_logins_per_lun_store(struct config_item *item,
-		const char *page, size_t count)
-{
-	struct se_portal_group *se_tpg = attrib_to_tpg(item);
-	struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-	struct sbp_tport *tport = tpg->tport;
-	unsigned long val;
-
-	if (kstrtoul(page, 0, &val) < 0)
-		return -EINVAL;
-	if ((val < 1) || (val > 127))
-		return -EINVAL;
-
-	/* XXX: also check against current count? */
-
-	tport->max_logins_per_lun = val;
-
-	return count;
-}
-
-CONFIGFS_ATTR(sbp_tpg_attrib_, mgt_orb_timeout);
-CONFIGFS_ATTR(sbp_tpg_attrib_, max_reconnect_timeout);
-CONFIGFS_ATTR(sbp_tpg_attrib_, max_logins_per_lun);
-
-static struct configfs_attribute *sbp_tpg_attrib_attrs[] = {
-	&sbp_tpg_attrib_attr_mgt_orb_timeout,
-	&sbp_tpg_attrib_attr_max_reconnect_timeout,
-	&sbp_tpg_attrib_attr_max_logins_per_lun,
-	NULL,
-};
-
-static const struct target_core_fabric_ops sbp_ops = {
-	.module				= THIS_MODULE,
-	.fabric_name			= "sbp",
-	.tpg_get_wwn			= sbp_get_fabric_wwn,
-	.tpg_get_tag			= sbp_get_tag,
-	.tpg_check_demo_mode		= sbp_check_true,
-	.tpg_check_demo_mode_cache	= sbp_check_true,
-	.tpg_check_demo_mode_write_protect = sbp_check_false,
-	.tpg_check_prod_mode_write_protect = sbp_check_false,
-	.tpg_get_inst_index		= sbp_tpg_get_inst_index,
-	.release_cmd			= sbp_release_cmd,
-	.sess_get_index			= sbp_sess_get_index,
-	.write_pending			= sbp_write_pending,
-	.set_default_node_attributes	= sbp_set_default_node_attrs,
-	.get_cmd_state			= sbp_get_cmd_state,
-	.queue_data_in			= sbp_queue_data_in,
-	.queue_status			= sbp_queue_status,
-	.queue_tm_rsp			= sbp_queue_tm_rsp,
-	.aborted_task			= sbp_aborted_task,
-	.check_stop_free		= sbp_check_stop_free,
-
-	.fabric_make_wwn		= sbp_make_tport,
-	.fabric_drop_wwn		= sbp_drop_tport,
-	.fabric_make_tpg		= sbp_make_tpg,
-	.fabric_drop_tpg		= sbp_drop_tpg,
-	.fabric_post_link		= sbp_post_link_lun,
-	.fabric_pre_unlink		= sbp_pre_unlink_lun,
-	.fabric_make_np			= NULL,
-	.fabric_drop_np			= NULL,
-	.fabric_init_nodeacl		= sbp_init_nodeacl,
-
-	.tfc_wwn_attrs			= sbp_wwn_attrs,
-	.tfc_tpg_base_attrs		= sbp_tpg_base_attrs,
-	.tfc_tpg_attrib_attrs		= sbp_tpg_attrib_attrs,
-};
-
-static int __init sbp_init(void)
-{
-	return target_register_template(&sbp_ops);
-};
-
-static void __exit sbp_exit(void)
-{
-	target_unregister_template(&sbp_ops);
-};
-
-MODULE_DESCRIPTION("FireWire SBP fabric driver");
-MODULE_LICENSE("GPL");
-module_init(sbp_init);
-module_exit(sbp_exit);
diff --git a/drivers/target/sbp/sbp_target.h b/drivers/target/sbp/sbp_target.h
deleted file mode 100644
index 1d101ac86527..000000000000
--- a/drivers/target/sbp/sbp_target.h
+++ /dev/null
@@ -1,243 +0,0 @@ 
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _SBP_BASE_H
-#define _SBP_BASE_H
-
-#include <linux/firewire.h>
-#include <linux/spinlock.h>
-#include <linux/types.h>
-#include <linux/workqueue.h>
-#include <target/target_core_base.h>
-
-#define SBP_VERSION  "v0.1"
-#define SBP_NAMELEN 32
-
-#define SBP_ORB_FETCH_SIZE	8
-
-#define MANAGEMENT_AGENT_STATE_IDLE	0
-#define MANAGEMENT_AGENT_STATE_BUSY	1
-
-#define ORB_NOTIFY(v)			(((v) >> 31) & 0x01)
-#define ORB_REQUEST_FORMAT(v)		(((v) >> 29) & 0x03)
-
-#define MANAGEMENT_ORB_FUNCTION(v)	(((v) >> 16) & 0x0f)
-
-#define MANAGEMENT_ORB_FUNCTION_LOGIN			0x0
-#define MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS		0x1
-#define MANAGEMENT_ORB_FUNCTION_RECONNECT		0x3
-#define MANAGEMENT_ORB_FUNCTION_SET_PASSWORD		0x4
-#define MANAGEMENT_ORB_FUNCTION_LOGOUT			0x7
-#define MANAGEMENT_ORB_FUNCTION_ABORT_TASK		0xb
-#define MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET		0xc
-#define MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET	0xe
-#define MANAGEMENT_ORB_FUNCTION_TARGET_RESET		0xf
-
-#define LOGIN_ORB_EXCLUSIVE(v)		(((v) >> 28) &   0x01)
-#define LOGIN_ORB_RESERVED(v)		(((v) >> 24) &   0x0f)
-#define LOGIN_ORB_RECONNECT(v)		(((v) >> 20) &   0x0f)
-#define LOGIN_ORB_LUN(v)		(((v) >>  0) & 0xffff)
-#define LOGIN_ORB_PASSWORD_LENGTH(v)	(((v) >> 16) & 0xffff)
-#define LOGIN_ORB_RESPONSE_LENGTH(v)	(((v) >>  0) & 0xffff)
-
-#define RECONNECT_ORB_LOGIN_ID(v)	(((v) >>  0) & 0xffff)
-#define LOGOUT_ORB_LOGIN_ID(v)		(((v) >>  0) & 0xffff)
-
-#define CMDBLK_ORB_DIRECTION(v)		(((v) >> 27) &   0x01)
-#define CMDBLK_ORB_SPEED(v)		(((v) >> 24) &   0x07)
-#define CMDBLK_ORB_MAX_PAYLOAD(v)	(((v) >> 20) &   0x0f)
-#define CMDBLK_ORB_PG_TBL_PRESENT(v)	(((v) >> 19) &   0x01)
-#define CMDBLK_ORB_PG_SIZE(v)		(((v) >> 16) &   0x07)
-#define CMDBLK_ORB_DATA_SIZE(v)		(((v) >>  0) & 0xffff)
-
-#define STATUS_BLOCK_SRC(v)		(((v) &   0x03) << 30)
-#define STATUS_BLOCK_RESP(v)		(((v) &   0x03) << 28)
-#define STATUS_BLOCK_DEAD(v)		(((v) ? 1 : 0)  << 27)
-#define STATUS_BLOCK_LEN(v)		(((v) &   0x07) << 24)
-#define STATUS_BLOCK_SBP_STATUS(v)	(((v) &   0xff) << 16)
-#define STATUS_BLOCK_ORB_OFFSET_HIGH(v)	(((v) & 0xffff) <<  0)
-
-#define STATUS_SRC_ORB_CONTINUING	0
-#define STATUS_SRC_ORB_FINISHED		1
-#define STATUS_SRC_UNSOLICITED		2
-
-#define STATUS_RESP_REQUEST_COMPLETE	0
-#define STATUS_RESP_TRANSPORT_FAILURE	1
-#define STATUS_RESP_ILLEGAL_REQUEST	2
-#define STATUS_RESP_VENDOR_DEPENDENT	3
-
-#define SBP_STATUS_OK			0
-#define SBP_STATUS_REQ_TYPE_NOTSUPP	1
-#define SBP_STATUS_SPEED_NOTSUPP	2
-#define SBP_STATUS_PAGE_SIZE_NOTSUPP	3
-#define SBP_STATUS_ACCESS_DENIED	4
-#define SBP_STATUS_LUN_NOTSUPP		5
-#define SBP_STATUS_PAYLOAD_TOO_SMALL	6
-/* 7 is reserved */
-#define SBP_STATUS_RESOURCES_UNAVAIL	8
-#define SBP_STATUS_FUNCTION_REJECTED	9
-#define SBP_STATUS_LOGIN_ID_UNKNOWN	10
-#define SBP_STATUS_DUMMY_ORB_COMPLETE	11
-#define SBP_STATUS_REQUEST_ABORTED	12
-#define SBP_STATUS_UNSPECIFIED_ERROR	0xff
-
-#define AGENT_STATE_RESET	0
-#define AGENT_STATE_ACTIVE	1
-#define AGENT_STATE_SUSPENDED	2
-#define AGENT_STATE_DEAD	3
-
-struct sbp2_pointer {
-	__be32 high;
-	__be32 low;
-};
-
-struct sbp_command_block_orb {
-	struct sbp2_pointer next_orb;
-	struct sbp2_pointer data_descriptor;
-	__be32 misc;
-	u8 command_block[12];
-};
-
-struct sbp_page_table_entry {
-	__be16 segment_length;
-	__be16 segment_base_hi;
-	__be32 segment_base_lo;
-};
-
-struct sbp_management_orb {
-	struct sbp2_pointer ptr1;
-	struct sbp2_pointer ptr2;
-	__be32 misc;
-	__be32 length;
-	struct sbp2_pointer status_fifo;
-};
-
-struct sbp_status_block {
-	__be32 status;
-	__be32 orb_low;
-	u8 data[24];
-};
-
-struct sbp_login_response_block {
-	__be32 misc;
-	struct sbp2_pointer command_block_agent;
-	__be32 reconnect_hold;
-};
-
-struct sbp_login_descriptor {
-	struct sbp_session *sess;
-	struct list_head link;
-
-	u32 login_lun;
-
-	u64 status_fifo_addr;
-	int exclusive;
-	u16 login_id;
-
-	struct sbp_target_agent *tgt_agt;
-};
-
-struct sbp_session {
-	spinlock_t lock;
-	struct se_session *se_sess;
-	struct list_head login_list;
-	struct delayed_work maint_work;
-
-	u64 guid; /* login_owner_EUI_64 */
-	int node_id; /* login_owner_ID */
-
-	struct fw_card *card;
-	int generation;
-	int speed;
-
-	int reconnect_hold;
-	u64 reconnect_expires;
-};
-
-struct sbp_tpg {
-	/* Target portal group tag for TCM */
-	u16 tport_tpgt;
-	/* Pointer back to sbp_tport */
-	struct sbp_tport *tport;
-	/* Returned by sbp_make_tpg() */
-	struct se_portal_group se_tpg;
-};
-
-struct sbp_tport {
-	/* Target Unit Identifier (EUI-64) */
-	u64 guid;
-	/* Target port name */
-	char tport_name[SBP_NAMELEN];
-	/* Returned by sbp_make_tport() */
-	struct se_wwn tport_wwn;
-
-	struct sbp_tpg *tpg;
-
-	/* FireWire unit directory */
-	struct fw_descriptor unit_directory;
-
-	/* SBP Management Agent */
-	struct sbp_management_agent *mgt_agt;
-
-	/* Parameters */
-	int enable;
-	s32 directory_id;
-	int mgt_orb_timeout;
-	int max_reconnect_timeout;
-	int max_logins_per_lun;
-};
-
-static inline u64 sbp2_pointer_to_addr(const struct sbp2_pointer *ptr)
-{
-	return (u64)(be32_to_cpu(ptr->high) & 0x0000ffff) << 32 |
-		(be32_to_cpu(ptr->low) & 0xfffffffc);
-}
-
-static inline void addr_to_sbp2_pointer(u64 addr, struct sbp2_pointer *ptr)
-{
-	ptr->high = cpu_to_be32(addr >> 32);
-	ptr->low = cpu_to_be32(addr);
-}
-
-struct sbp_target_agent {
-	spinlock_t lock;
-	struct fw_address_handler handler;
-	struct sbp_login_descriptor *login;
-	int state;
-	struct work_struct work;
-	u64 orb_pointer;
-	bool doorbell;
-};
-
-struct sbp_target_request {
-	struct sbp_login_descriptor *login;
-	u64 orb_pointer;
-	struct sbp_command_block_orb orb;
-	struct sbp_status_block status;
-	struct work_struct work;
-
-	struct se_cmd se_cmd;
-	struct sbp_page_table_entry *pg_tbl;
-	void *cmd_buf;
-
-	unsigned char sense_buf[TRANSPORT_SENSE_BUFFER];
-};
-
-struct sbp_management_agent {
-	spinlock_t lock;
-	struct sbp_tport *tport;
-	struct fw_address_handler handler;
-	int state;
-	struct work_struct work;
-	u64 orb_offset;
-	struct sbp_management_request *request;
-};
-
-struct sbp_management_request {
-	struct sbp_management_orb orb;
-	struct sbp_status_block status;
-	struct fw_card *card;
-	int generation;
-	int node_addr;
-	int speed;
-};
-
-#endif