sbp2.c 63.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
 * sbp2.c - SBP-2 protocol driver for IEEE-1394
 *
 * Copyright (C) 2000 James Goodwin, Filanet Corporation (www.filanet.com)
 * jamesg@filanet.com (JSG)
 *
 * Copyright (C) 2003 Ben Collins <bcollins@debian.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*
 * Brief Description:
 *
 * This driver implements the Serial Bus Protocol 2 (SBP-2) over IEEE-1394
 * under Linux. The SBP-2 driver is implemented as an IEEE-1394 high-level
 * driver. It also registers as a SCSI lower-level driver in order to accept
 * SCSI commands for transport using SBP-2.
 *
32
33
 * You may access any attached SBP-2 (usually storage devices) as regular
 * SCSI devices. E.g. mount /dev/sda1, fdisk, mkfs, etc..
Linus Torvalds's avatar
Linus Torvalds committed
34
 *
35
36
 * See http://www.t10.org/drafts.htm#sbp2 for the final draft of the SBP-2
 * specification and for where to purchase the official standard.
Linus Torvalds's avatar
Linus Torvalds committed
37
 *
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 * TODO:
 *   - look into possible improvements of the SCSI error handlers
 *   - handle Unit_Characteristics.mgt_ORB_timeout and .ORB_size
 *   - handle Logical_Unit_Number.ordered
 *   - handle src == 1 in status blocks
 *   - reimplement the DMA mapping in absence of physical DMA so that
 *     bus_to_virt is no longer required
 *   - debug the handling of absent physical DMA
 *   - replace CONFIG_IEEE1394_SBP2_PHYS_DMA by automatic detection
 *     (this is easy but depends on the previous two TODO items)
 *   - make the parameter serialize_io configurable per device
 *   - move all requests to fetch agent registers into non-atomic context,
 *     replace all usages of sbp2util_node_write_no_wait by true transactions
 * Grep for inline FIXME comments below.
Linus Torvalds's avatar
Linus Torvalds committed
52
53
 */

54
#include <linux/blkdev.h>
55
56
57
58
59
#include <linux/compiler.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/init.h>
Linus Torvalds's avatar
Linus Torvalds committed
60
61
#include <linux/kernel.h>
#include <linux/list.h>
Andrew Morton's avatar
Andrew Morton committed
62
#include <linux/mm.h>
Linus Torvalds's avatar
Linus Torvalds committed
63
64
#include <linux/module.h>
#include <linux/moduleparam.h>
Andrew Morton's avatar
Andrew Morton committed
65
#include <linux/sched.h>
66
67
68
69
70
71
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/stringify.h>
#include <linux/types.h>
72
#include <linux/wait.h>
73
#include <linux/workqueue.h>
74
#include <linux/scatterlist.h>
Linus Torvalds's avatar
Linus Torvalds committed
75
76

#include <asm/byteorder.h>
77
78
79
80
81
82
83
84
#include <asm/errno.h>
#include <asm/param.h>
#include <asm/system.h>
#include <asm/types.h>

#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
#include <asm/io.h> /* for bus_to_virt */
#endif
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89
90
91
92

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>

#include "csr1212.h"
93
94
#include "highlevel.h"
#include "hosts.h"
Linus Torvalds's avatar
Linus Torvalds committed
95
96
#include "ieee1394.h"
#include "ieee1394_core.h"
97
#include "ieee1394_hotplug.h"
Linus Torvalds's avatar
Linus Torvalds committed
98
#include "ieee1394_transactions.h"
99
100
#include "ieee1394_types.h"
#include "nodemgr.h"
Linus Torvalds's avatar
Linus Torvalds committed
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include "sbp2.h"

/*
 * Module load parameter definitions
 */

/*
 * Change max_speed on module load if you have a bad IEEE-1394
 * controller that has trouble running 2KB packets at 400mb.
 *
 * NOTE: On certain OHCI parts I have seen short packets on async transmit
 * (probably due to PCI latency/throughput issues with the part). You can
 * bump down the speed if you are running into problems.
 */
115
116
static int sbp2_max_speed = IEEE1394_SPEED_MAX;
module_param_named(max_speed, sbp2_max_speed, int, 0644);
117
118
MODULE_PARM_DESC(max_speed, "Limit data transfer speed (5 <= 3200, "
		 "4 <= 1600, 3 <= 800, 2 <= 400, 1 <= 200, 0 = 100 Mb/s)");
Linus Torvalds's avatar
Linus Torvalds committed
119
120

/*
121
122
 * Set serialize_io to 0 or N to use dynamically appended lists of command ORBs.
 * This is and always has been buggy in multiple subtle ways. See above TODOs.
Linus Torvalds's avatar
Linus Torvalds committed
123
 */
124
static int sbp2_serialize_io = 1;
125
126
127
module_param_named(serialize_io, sbp2_serialize_io, bool, 0444);
MODULE_PARM_DESC(serialize_io, "Serialize requests coming from SCSI drivers "
		 "(default = Y, faster but buggy = N)");
Linus Torvalds's avatar
Linus Torvalds committed
128
129

/*
130
131
132
133
134
135
136
137
138
139
 * Adjust max_sectors if you'd like to influence how many sectors each SCSI
 * command can transfer at most. Please note that some older SBP-2 bridge
 * chips are broken for transfers greater or equal to 128KB, therefore
 * max_sectors used to be a safe 255 sectors for many years. We now have a
 * default of 0 here which means that we let the SCSI stack choose a limit.
 *
 * The SBP2_WORKAROUND_128K_MAX_TRANS flag, if set either in the workarounds
 * module parameter or in the sbp2_workarounds_table[], will override the
 * value of max_sectors. We should use sbp2_workarounds_table[] to cover any
 * bridge chip which becomes known to need the 255 sectors limit.
Linus Torvalds's avatar
Linus Torvalds committed
140
 */
141
static int sbp2_max_sectors;
142
143
module_param_named(max_sectors, sbp2_max_sectors, int, 0444);
MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported "
144
		 "(default = 0 = use SCSI stack's default)");
Linus Torvalds's avatar
Linus Torvalds committed
145
146
147
148
149
150
151

/*
 * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
 * do an exclusive login, as it's generally unsafe to have two hosts
 * talking to a single sbp2 device at the same time (filesystem coherency,
 * etc.). If you're running an sbp2 device that supports multiple logins,
 * and you're either running read-only filesystems or some sort of special
152
153
154
155
156
157
 * filesystem supporting multiple hosts, e.g. OpenGFS, Oracle Cluster
 * File System, or Lustre, then set exclusive_login to zero.
 *
 * So far only bridges from Oxford Semiconductor are known to support
 * concurrent logins. Depending on firmware, four or two concurrent logins
 * are possible on OXFW911 and newer Oxsemi bridges.
Linus Torvalds's avatar
Linus Torvalds committed
158
 */
159
static int sbp2_exclusive_login = 1;
160
module_param_named(exclusive_login, sbp2_exclusive_login, bool, 0644);
161
MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
162
		 "(default = Y, use N for concurrent initiators)");
Linus Torvalds's avatar
Linus Torvalds committed
163
164

/*
165
166
167
 * If any of the following workarounds is required for your device to work,
 * please submit the kernel messages logged by sbp2 to the linux1394-devel
 * mailing list.
Linus Torvalds's avatar
Linus Torvalds committed
168
 *
169
170
171
172
173
174
175
176
177
178
 * - 128kB max transfer
 *   Limit transfer size. Necessary for some old bridges.
 *
 * - 36 byte inquiry
 *   When scsi_mod probes the device, let the inquiry command look like that
 *   from MS Windows.
 *
 * - skip mode page 8
 *   Suppress sending of mode_sense for mode page 8 if the device pretends to
 *   support the SCSI Primary Block commands instead of Reduced Block Commands.
179
180
181
182
183
 *
 * - fix capacity
 *   Tell sd_mod to correct the last sector number reported by read_capacity.
 *   Avoids access beyond actual disk limits on devices with an off-by-one bug.
 *   Don't use this with devices which don't have this bug.
184
 *
185
186
187
 * - delay inquiry
 *   Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
 *
188
189
190
191
192
 * - power condition
 *   Set the power condition field in the START STOP UNIT commands sent by
 *   sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
 *   Some disks need this to spin down or to resume properly.
 *
193
194
195
196
 * - override internal blacklist
 *   Instead of adding to the built-in blacklist, use only the workarounds
 *   specified in the module load parameter.
 *   Useful if a blacklist entry interfered with a non-broken device.
Linus Torvalds's avatar
Linus Torvalds committed
197
 */
198
199
200
201
202
203
static int sbp2_default_workarounds;
module_param_named(workarounds, sbp2_default_workarounds, int, 0644);
MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
	", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
	", 36 byte inquiry = "    __stringify(SBP2_WORKAROUND_INQUIRY_36)
	", skip mode page 8 = "   __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
204
	", fix capacity = "       __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
205
	", delay inquiry = "      __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
206
207
	", set power condition in start stop unit = "
				  __stringify(SBP2_WORKAROUND_POWER_CONDITION)
208
	", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
209
210
	", or a combination)");

211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
/*
 * This influences the format of the sysfs attribute
 * /sys/bus/scsi/devices/.../ieee1394_id.
 *
 * The default format is like in older kernels:  %016Lx:%d:%d
 * It contains the target's EUI-64, a number given to the logical unit by
 * the ieee1394 driver's nodemgr (starting at 0), and the LUN.
 *
 * The long format is:  %016Lx:%06x:%04x
 * It contains the target's EUI-64, the unit directory's directory_ID as per
 * IEEE 1212 clause 7.7.19, and the LUN.  This format comes closest to the
 * format of SBP(-3) target port and logical unit identifier as per SAM (SCSI
 * Architecture Model) rev.2 to 4 annex A.  Therefore and because it is
 * independent of the implementation of the ieee1394 nodemgr, the longer format
 * is recommended for future use.
 */
static int sbp2_long_sysfs_ieee1394_id;
module_param_named(long_ieee1394_id, sbp2_long_sysfs_ieee1394_id, bool, 0644);
MODULE_PARM_DESC(long_ieee1394_id, "8+3+2 bytes format of ieee1394_id in sysfs "
		 "(default = backwards-compatible = N, SAM-conforming = Y)");

Linus Torvalds's avatar
Linus Torvalds committed
232

233
234
#define SBP2_INFO(fmt, args...)	HPSB_INFO("sbp2: "fmt, ## args)
#define SBP2_ERR(fmt, args...)	HPSB_ERR("sbp2: "fmt, ## args)
Linus Torvalds's avatar
Linus Torvalds committed
235
236
237
238

/*
 * Globals
 */
239
240
static void sbp2scsi_complete_all_commands(struct sbp2_lu *, u32);
static void sbp2scsi_complete_command(struct sbp2_lu *, u32, struct scsi_cmnd *,
241
				      void (*)(struct scsi_cmnd *));
242
243
244
245
246
247
static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *);
static int sbp2_start_device(struct sbp2_lu *);
static void sbp2_remove_device(struct sbp2_lu *);
static int sbp2_login_device(struct sbp2_lu *);
static int sbp2_reconnect_device(struct sbp2_lu *);
static int sbp2_logout_device(struct sbp2_lu *);
248
249
250
static void sbp2_host_reset(struct hpsb_host *);
static int sbp2_handle_status_write(struct hpsb_host *, int, int, quadlet_t *,
				    u64, size_t, u16);
251
252
static int sbp2_agent_reset(struct sbp2_lu *, int);
static void sbp2_parse_unit_directory(struct sbp2_lu *,
253
				      struct unit_directory *);
254
255
static int sbp2_set_busy_timeout(struct sbp2_lu *);
static int sbp2_max_speed_and_size(struct sbp2_lu *);
Linus Torvalds's avatar
Linus Torvalds committed
256
257


258
static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xa, 0xa, 0xa };
Linus Torvalds's avatar
Linus Torvalds committed
259

260
261
static DEFINE_RWLOCK(sbp2_hi_logical_units_lock);

Linus Torvalds's avatar
Linus Torvalds committed
262
static struct hpsb_highlevel sbp2_highlevel = {
263
264
	.name		= SBP2_DEVICE_NAME,
	.host_reset	= sbp2_host_reset,
Linus Torvalds's avatar
Linus Torvalds committed
265
266
};

267
static const struct hpsb_address_ops sbp2_ops = {
268
	.write		= sbp2_handle_status_write
Linus Torvalds's avatar
Linus Torvalds committed
269
270
271
};

#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
272
273
274
275
276
static int sbp2_handle_physdma_write(struct hpsb_host *, int, int, quadlet_t *,
				     u64, size_t, u16);
static int sbp2_handle_physdma_read(struct hpsb_host *, int, quadlet_t *, u64,
				    size_t, u16);

277
static const struct hpsb_address_ops sbp2_physdma_ops = {
278
279
	.read		= sbp2_handle_physdma_read,
	.write		= sbp2_handle_physdma_write,
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
};
#endif

283
284
285
286

/*
 * Interface to driver core and IEEE 1394 core
 */
287
static const struct ieee1394_device_id sbp2_id_table[] = {
288
289
290
291
292
293
294
295
296
297
298
299
	{
	 .match_flags	= IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
	 .specifier_id	= SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
	 .version	= SBP2_SW_VERSION_ENTRY & 0xffffff},
	{}
};
MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);

static int sbp2_probe(struct device *);
static int sbp2_remove(struct device *);
static int sbp2_update(struct unit_directory *);

Linus Torvalds's avatar
Linus Torvalds committed
300
static struct hpsb_protocol_driver sbp2_driver = {
301
	.name		= SBP2_DEVICE_NAME,
Linus Torvalds's avatar
Linus Torvalds committed
302
303
304
305
306
307
308
309
	.id_table	= sbp2_id_table,
	.update		= sbp2_update,
	.driver		= {
		.probe		= sbp2_probe,
		.remove		= sbp2_remove,
	},
};

310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330

/*
 * Interface to SCSI core
 */
static int sbp2scsi_queuecommand(struct scsi_cmnd *,
				 void (*)(struct scsi_cmnd *));
static int sbp2scsi_abort(struct scsi_cmnd *);
static int sbp2scsi_reset(struct scsi_cmnd *);
static int sbp2scsi_slave_alloc(struct scsi_device *);
static int sbp2scsi_slave_configure(struct scsi_device *);
static void sbp2scsi_slave_destroy(struct scsi_device *);
static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *,
					   struct device_attribute *, char *);

static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);

static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
	&dev_attr_ieee1394_id,
	NULL
};

331
static struct scsi_host_template sbp2_shost_template = {
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
	.module			 = THIS_MODULE,
	.name			 = "SBP-2 IEEE-1394",
	.proc_name		 = SBP2_DEVICE_NAME,
	.queuecommand		 = sbp2scsi_queuecommand,
	.eh_abort_handler	 = sbp2scsi_abort,
	.eh_device_reset_handler = sbp2scsi_reset,
	.slave_alloc		 = sbp2scsi_slave_alloc,
	.slave_configure	 = sbp2scsi_slave_configure,
	.slave_destroy		 = sbp2scsi_slave_destroy,
	.this_id		 = -1,
	.sg_tablesize		 = SG_ALL,
	.use_clustering		 = ENABLE_CLUSTERING,
	.cmd_per_lun		 = SBP2_MAX_CMDS,
	.can_queue		 = SBP2_MAX_CMDS,
	.sdev_attrs		 = sbp2_sysfs_sdev_attrs,
};

349
350
#define SBP2_ROM_VALUE_WILDCARD ~0         /* match all */
#define SBP2_ROM_VALUE_MISSING  0xff000000 /* not present in the unit dir. */
351

352
/*
353
354
355
356
357
 * List of devices with known bugs.
 *
 * The firmware_revision field, masked with 0xffff00, is the best indicator
 * for the type of bridge chip of a device.  It yields a few false positives
 * but this did not break correctly behaving devices so far.
358
 */
359
360
static const struct {
	u32 firmware_revision;
361
	u32 model;
362
363
	unsigned workarounds;
} sbp2_workarounds_table[] = {
364
	/* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
365
		.firmware_revision	= 0x002800,
366
		.model			= 0x001010,
367
		.workarounds		= SBP2_WORKAROUND_INQUIRY_36 |
368
369
					  SBP2_WORKAROUND_MODE_SENSE_8 |
					  SBP2_WORKAROUND_POWER_CONDITION,
370
	},
371
372
	/* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
		.firmware_revision	= 0x002800,
373
		.model			= 0x000000,
374
		.workarounds		= SBP2_WORKAROUND_POWER_CONDITION,
375
	},
376
377
	/* Initio bridges, actually only needed for some older ones */ {
		.firmware_revision	= 0x000200,
378
		.model			= SBP2_ROM_VALUE_WILDCARD,
379
380
		.workarounds		= SBP2_WORKAROUND_INQUIRY_36,
	},
381
382
	/* PL-3507 bridge with Prolific firmware */ {
		.firmware_revision	= 0x012800,
383
		.model			= SBP2_ROM_VALUE_WILDCARD,
384
385
		.workarounds		= SBP2_WORKAROUND_POWER_CONDITION,
	},
386
387
	/* Symbios bridge */ {
		.firmware_revision	= 0xa0b800,
388
		.model			= SBP2_ROM_VALUE_WILDCARD,
389
		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
390
	},
391
392
	/* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
		.firmware_revision	= 0x002600,
393
		.model			= SBP2_ROM_VALUE_WILDCARD,
394
395
		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
	},
396
397
398
399
400
401
402
403
404
405
	/*
	 * iPod 2nd generation: needs 128k max transfer size workaround
	 * iPod 3rd generation: needs fix capacity workaround
	 */
	{
		.firmware_revision	= 0x0a2700,
		.model			= 0x000000,
		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS |
					  SBP2_WORKAROUND_FIX_CAPACITY,
	},
406
407
	/* iPod 4th generation */ {
		.firmware_revision	= 0x0a2700,
408
		.model			= 0x000021,
409
410
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
411
412
	/* iPod mini */ {
		.firmware_revision	= 0x0a2700,
413
		.model			= 0x000022,
414
415
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
416
417
	/* iPod mini */ {
		.firmware_revision	= 0x0a2700,
418
		.model			= 0x000023,
419
420
421
422
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
	/* iPod Photo */ {
		.firmware_revision	= 0x0a2700,
423
		.model			= 0x00007e,
424
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
425
	}
Linus Torvalds's avatar
Linus Torvalds committed
426
427
428
429
430
431
432
433
434
435
};

/**************************************
 * General utility functions
 **************************************/

#ifndef __BIG_ENDIAN
/*
 * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
 */
436
static inline void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
Linus Torvalds's avatar
Linus Torvalds committed
437
438
439
440
441
442
443
444
445
446
{
	u32 *temp = buffer;

	for (length = (length >> 2); length--; )
		temp[length] = be32_to_cpu(temp[length]);
}

/*
 * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
 */
447
static inline void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
Linus Torvalds's avatar
Linus Torvalds committed
448
449
450
451
452
453
454
455
{
	u32 *temp = buffer;

	for (length = (length >> 2); length--; )
		temp[length] = cpu_to_be32(temp[length]);
}
#else /* BIG_ENDIAN */
/* Why waste the cpu cycles? */
456
457
#define sbp2util_be32_to_cpu_buffer(x,y) do {} while (0)
#define sbp2util_cpu_to_be32_buffer(x,y) do {} while (0)
Linus Torvalds's avatar
Linus Torvalds committed
458
459
#endif

460
static DECLARE_WAIT_QUEUE_HEAD(sbp2_access_wq);
461

Linus Torvalds's avatar
Linus Torvalds committed
462
/*
463
464
 * Waits for completion of an SBP-2 access request.
 * Returns nonzero if timed out or prematurely interrupted.
Linus Torvalds's avatar
Linus Torvalds committed
465
 */
466
static int sbp2util_access_timeout(struct sbp2_lu *lu, int timeout)
Linus Torvalds's avatar
Linus Torvalds committed
467
{
468
	long leftover;
Linus Torvalds's avatar
Linus Torvalds committed
469

470
	leftover = wait_event_interruptible_timeout(
471
472
			sbp2_access_wq, lu->access_complete, timeout);
	lu->access_complete = 0;
473
	return leftover <= 0;
Linus Torvalds's avatar
Linus Torvalds committed
474
475
}

476
static void sbp2_free_packet(void *packet)
Linus Torvalds's avatar
Linus Torvalds committed
477
478
479
480
481
{
	hpsb_free_tlabel(packet);
	hpsb_free_packet(packet);
}

482
483
484
/*
 * This is much like hpsb_node_write(), except it ignores the response
 * subaction and returns immediately. Can be used from atomic context.
Linus Torvalds's avatar
Linus Torvalds committed
485
486
 */
static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
487
				       quadlet_t *buf, size_t len)
Linus Torvalds's avatar
Linus Torvalds committed
488
489
490
{
	struct hpsb_packet *packet;

491
	packet = hpsb_make_writepacket(ne->host, ne->nodeid, addr, buf, len);
Stefan Richter's avatar
Stefan Richter committed
492
493
	if (!packet)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
494

495
	hpsb_set_packet_complete_task(packet, sbp2_free_packet, packet);
Linus Torvalds's avatar
Linus Torvalds committed
496
	hpsb_node_fill_packet(ne, packet);
Stefan Richter's avatar
Stefan Richter committed
497
	if (hpsb_send_packet(packet) < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
498
499
500
501
502
503
		sbp2_free_packet(packet);
		return -EIO;
	}
	return 0;
}

504
505
static void sbp2util_notify_fetch_agent(struct sbp2_lu *lu, u64 offset,
					quadlet_t *data, size_t len)
506
{
507
508
509
	/* There is a small window after a bus reset within which the node
	 * entry's generation is current but the reconnect wasn't completed. */
	if (unlikely(atomic_read(&lu->state) == SBP2LU_STATE_IN_RESET))
510
511
		return;

512
	if (hpsb_node_write(lu->ne, lu->command_block_agent_addr + offset,
513
514
			    data, len))
		SBP2_ERR("sbp2util_notify_fetch_agent failed.");
515
516
517
518
519

	/* Now accept new SCSI commands, unless a bus reset happended during
	 * hpsb_node_write. */
	if (likely(atomic_read(&lu->state) != SBP2LU_STATE_IN_RESET))
		scsi_unblock_requests(lu->shost);
520
521
}

David Howells's avatar
David Howells committed
522
static void sbp2util_write_orb_pointer(struct work_struct *work)
523
{
524
	struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
525
526
	quadlet_t data[2];

527
528
	data[0] = ORB_SET_NODE_ID(lu->hi->host->node_id);
	data[1] = lu->last_orb_dma;
529
	sbp2util_cpu_to_be32_buffer(data, 8);
530
	sbp2util_notify_fetch_agent(lu, SBP2_ORB_POINTER_OFFSET, data, 8);
531
532
}

David Howells's avatar
David Howells committed
533
static void sbp2util_write_doorbell(struct work_struct *work)
534
{
535
536
537
	struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);

	sbp2util_notify_fetch_agent(lu, SBP2_DOORBELL_OFFSET, NULL, 4);
538
539
}

540
static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
Linus Torvalds's avatar
Linus Torvalds committed
541
{
542
	struct sbp2_command_info *cmd;
543
	struct device *dmadev = lu->hi->host->device.parent;
544
	int i, orbs = sbp2_serialize_io ? 2 : SBP2_MAX_CMDS;
Linus Torvalds's avatar
Linus Torvalds committed
545
546

	for (i = 0; i < orbs; i++) {
547
548
		cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
		if (!cmd)
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
			goto failed_alloc;

		cmd->command_orb_dma =
		    dma_map_single(dmadev, &cmd->command_orb,
				   sizeof(struct sbp2_command_orb),
				   DMA_TO_DEVICE);
		if (dma_mapping_error(dmadev, cmd->command_orb_dma))
			goto failed_orb;

		cmd->sge_dma =
		    dma_map_single(dmadev, &cmd->scatter_gather_element,
				   sizeof(cmd->scatter_gather_element),
				   DMA_TO_DEVICE);
		if (dma_mapping_error(dmadev, cmd->sge_dma))
			goto failed_sge;

565
566
		INIT_LIST_HEAD(&cmd->list);
		list_add_tail(&cmd->list, &lu->cmd_orb_completed);
Linus Torvalds's avatar
Linus Torvalds committed
567
568
	}
	return 0;
569
570
571
572
573
574
575
576

failed_sge:
	dma_unmap_single(dmadev, cmd->command_orb_dma,
			 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
failed_orb:
	kfree(cmd);
failed_alloc:
	return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
577
578
}

579
580
static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu,
					     struct hpsb_host *host)
Linus Torvalds's avatar
Linus Torvalds committed
581
582
{
	struct list_head *lh, *next;
583
	struct sbp2_command_info *cmd;
Linus Torvalds's avatar
Linus Torvalds committed
584
585
	unsigned long flags;

586
587
588
589
	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
	if (!list_empty(&lu->cmd_orb_completed))
		list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
			cmd = list_entry(lh, struct sbp2_command_info, list);
590
591
			dma_unmap_single(host->device.parent,
					 cmd->command_orb_dma,
Linus Torvalds's avatar
Linus Torvalds committed
592
					 sizeof(struct sbp2_command_orb),
593
					 DMA_TO_DEVICE);
594
			dma_unmap_single(host->device.parent, cmd->sge_dma,
595
					 sizeof(cmd->scatter_gather_element),
596
					 DMA_TO_DEVICE);
597
			kfree(cmd);
Linus Torvalds's avatar
Linus Torvalds committed
598
		}
599
	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
600
601
602
603
	return;
}

/*
604
605
 * Finds the sbp2_command for a given outstanding command ORB.
 * Only looks at the in-use list.
Linus Torvalds's avatar
Linus Torvalds committed
606
607
 */
static struct sbp2_command_info *sbp2util_find_command_for_orb(
608
				struct sbp2_lu *lu, dma_addr_t orb)
Linus Torvalds's avatar
Linus Torvalds committed
609
{
610
	struct sbp2_command_info *cmd;
Linus Torvalds's avatar
Linus Torvalds committed
611
612
	unsigned long flags;

613
614
615
616
617
618
619
	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
	if (!list_empty(&lu->cmd_orb_inuse))
		list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
			if (cmd->command_orb_dma == orb) {
				spin_unlock_irqrestore(
						&lu->cmd_orb_lock, flags);
				return cmd;
Linus Torvalds's avatar
Linus Torvalds committed
620
			}
621
	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Stefan Richter's avatar
Stefan Richter committed
622
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
623
624
625
}

/*
626
627
 * Finds the sbp2_command for a given outstanding SCpnt.
 * Only looks at the in-use list.
628
 * Must be called with lu->cmd_orb_lock held.
Linus Torvalds's avatar
Linus Torvalds committed
629
 */
630
static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(
631
				struct sbp2_lu *lu, void *SCpnt)
Linus Torvalds's avatar
Linus Torvalds committed
632
{
633
	struct sbp2_command_info *cmd;
Linus Torvalds's avatar
Linus Torvalds committed
634

635
636
637
638
	if (!list_empty(&lu->cmd_orb_inuse))
		list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
			if (cmd->Current_SCpnt == SCpnt)
				return cmd;
Stefan Richter's avatar
Stefan Richter committed
639
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
640
641
642
}

static struct sbp2_command_info *sbp2util_allocate_command_orb(
643
644
645
				struct sbp2_lu *lu,
				struct scsi_cmnd *Current_SCpnt,
				void (*Current_done)(struct scsi_cmnd *))
Linus Torvalds's avatar
Linus Torvalds committed
646
647
{
	struct list_head *lh;
648
	struct sbp2_command_info *cmd = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
649
650
	unsigned long flags;

651
652
653
	spin_lock_irqsave(&lu->cmd_orb_lock, flags);
	if (!list_empty(&lu->cmd_orb_completed)) {
		lh = lu->cmd_orb_completed.next;
Linus Torvalds's avatar
Linus Torvalds committed
654
		list_del(lh);
655
656
657
658
659
		cmd = list_entry(lh, struct sbp2_command_info, list);
		cmd->Current_done = Current_done;
		cmd->Current_SCpnt = Current_SCpnt;
		list_add_tail(&cmd->list, &lu->cmd_orb_inuse);
	} else
660
		SBP2_ERR("%s: no orbs available", __func__);
661
662
	spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
	return cmd;
Linus Torvalds's avatar
Linus Torvalds committed
663
664
}

665
666
667
668
669
670
/*
 * Unmaps the DMAs of a command and moves the command to the completed ORB list.
 * Must be called with lu->cmd_orb_lock held.
 */
static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
					    struct sbp2_command_info *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
671
{
672
673
674
675
676
	if (scsi_sg_count(cmd->Current_SCpnt))
		dma_unmap_sg(lu->ud->ne->host->device.parent,
			     scsi_sglist(cmd->Current_SCpnt),
			     scsi_sg_count(cmd->Current_SCpnt),
			     cmd->Current_SCpnt->sc_data_direction);
677
	list_move_tail(&cmd->list, &lu->cmd_orb_completed);
Linus Torvalds's avatar
Linus Torvalds committed
678
679
}

680
/*
681
 * Is lu valid? Is the 1394 node still present?
682
 */
683
static inline int sbp2util_node_is_available(struct sbp2_lu *lu)
684
{
685
	return lu && lu->ne && !lu->ne->in_limbo;
686
687
}

Linus Torvalds's avatar
Linus Torvalds committed
688
689
690
691
692
693
694
/*********************************************
 * IEEE-1394 core driver stack related section
 *********************************************/

static int sbp2_probe(struct device *dev)
{
	struct unit_directory *ud;
695
	struct sbp2_lu *lu;
Linus Torvalds's avatar
Linus Torvalds committed
696
697
698
699
700
701
702
703

	ud = container_of(dev, struct unit_directory, device);

	/* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
	 * instead. */
	if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
		return -ENODEV;

704
705
	lu = sbp2_alloc_device(ud);
	if (!lu)
Stefan Richter's avatar
Stefan Richter committed
706
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
707

708
709
	sbp2_parse_unit_directory(lu, ud);
	return sbp2_start_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
710
711
712
713
714
}

static int sbp2_remove(struct device *dev)
{
	struct unit_directory *ud;
715
	struct sbp2_lu *lu;
716
	struct scsi_device *sdev;
Linus Torvalds's avatar
Linus Torvalds committed
717
718

	ud = container_of(dev, struct unit_directory, device);
719
	lu = dev_get_drvdata(&ud->device);
720
	if (!lu)
721
722
		return 0;

723
	if (lu->shost) {
724
725
		/* Get rid of enqueued commands if there is no chance to
		 * send them. */
726
727
		if (!sbp2util_node_is_available(lu))
			sbp2scsi_complete_all_commands(lu, DID_NO_CONNECT);
728
		/* scsi_remove_device() may trigger shutdown functions of SCSI
729
		 * highlevel drivers which would deadlock if blocked. */
730
731
		atomic_set(&lu->state, SBP2LU_STATE_IN_SHUTDOWN);
		scsi_unblock_requests(lu->shost);
732
	}
733
	sdev = lu->sdev;
734
	if (sdev) {
735
		lu->sdev = NULL;
736
737
		scsi_remove_device(sdev);
	}
Linus Torvalds's avatar
Linus Torvalds committed
738

739
740
	sbp2_logout_device(lu);
	sbp2_remove_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
741
742
743
744
745
746

	return 0;
}

static int sbp2_update(struct unit_directory *ud)
{
747
	struct sbp2_lu *lu = dev_get_drvdata(&ud->device);
Linus Torvalds's avatar
Linus Torvalds committed
748

749
750
751
752
753
754
755
756
757
758
759
760
761
	if (sbp2_reconnect_device(lu) != 0) {
		/*
		 * Reconnect failed.  If another bus reset happened,
		 * let nodemgr proceed and call sbp2_update again later
		 * (or sbp2_remove if this node went away).
		 */
		if (!hpsb_node_entry_valid(lu->ne))
			return 0;
		/*
		 * Or the target rejected the reconnect because we weren't
		 * fast enough.  Try a regular login, but first log out
		 * just in case of any weirdness.
		 */
762
		sbp2_logout_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
763

764
765
766
767
768
		if (sbp2_login_device(lu) != 0) {
			if (!hpsb_node_entry_valid(lu->ne))
				return 0;

			/* Maybe another initiator won the login. */
Linus Torvalds's avatar
Linus Torvalds committed
769
770
771
772
773
			SBP2_ERR("Failed to reconnect to sbp2 device!");
			return -EBUSY;
		}
	}

774
775
776
	sbp2_set_busy_timeout(lu);
	sbp2_agent_reset(lu, 1);
	sbp2_max_speed_and_size(lu);
Linus Torvalds's avatar
Linus Torvalds committed
777

778
779
	/* Complete any pending commands with busy (so they get retried)
	 * and remove them from our queue. */
780
	sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
Linus Torvalds's avatar
Linus Torvalds committed
781

782
783
	/* Accept new commands unless there was another bus reset in the
	 * meantime. */
784
785
786
	if (hpsb_node_entry_valid(lu->ne)) {
		atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
		scsi_unblock_requests(lu->shost);
787
	}
Linus Torvalds's avatar
Linus Torvalds committed
788
789
790
	return 0;
}

791
static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *ud)
Linus Torvalds's avatar
Linus Torvalds committed
792
{
793
	struct sbp2_fwhost_info *hi;
794
795
	struct Scsi_Host *shost = NULL;
	struct sbp2_lu *lu = NULL;
796
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
797

798
799
800
	lu = kzalloc(sizeof(*lu), GFP_KERNEL);
	if (!lu) {
		SBP2_ERR("failed to create lu");
Linus Torvalds's avatar
Linus Torvalds committed
801
802
803
		goto failed_alloc;
	}

804
805
806
807
808
809
810
811
812
813
814
	lu->ne = ud->ne;
	lu->ud = ud;
	lu->speed_code = IEEE1394_SPEED_100;
	lu->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
	lu->status_fifo_addr = CSR1212_INVALID_ADDR_SPACE;
	INIT_LIST_HEAD(&lu->cmd_orb_inuse);
	INIT_LIST_HEAD(&lu->cmd_orb_completed);
	INIT_LIST_HEAD(&lu->lu_list);
	spin_lock_init(&lu->cmd_orb_lock);
	atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
	INIT_WORK(&lu->protocol_work, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
815

816
	dev_set_drvdata(&ud->device, lu);
Linus Torvalds's avatar
Linus Torvalds committed
817
818
819

	hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
	if (!hi) {
820
821
		hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host,
					  sizeof(*hi));
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
825
826
		if (!hi) {
			SBP2_ERR("failed to allocate hostinfo");
			goto failed_alloc;
		}
		hi->host = ud->ne->host;
827
		INIT_LIST_HEAD(&hi->logical_units);
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830

#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
		/* Handle data movement if physical dma is not
Stefan Richter's avatar
Stefan Richter committed
831
832
833
834
835
836
837
		 * enabled or not supported on host controller */
		if (!hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host,
					     &sbp2_physdma_ops,
					     0x0ULL, 0xfffffffcULL)) {
			SBP2_ERR("failed to register lower 4GB address range");
			goto failed_alloc;
		}
Linus Torvalds's avatar
Linus Torvalds committed
838
839
840
#endif
	}

841
842
843
844
	if (dma_get_max_seg_size(hi->host->device.parent) > SBP2_MAX_SEG_SIZE)
		BUG_ON(dma_set_max_seg_size(hi->host->device.parent,
					    SBP2_MAX_SEG_SIZE));

845
846
847
848
849
850
	/* Prevent unloading of the 1394 host */
	if (!try_module_get(hi->host->driver->owner)) {
		SBP2_ERR("failed to get a reference on 1394 host driver");
		goto failed_alloc;
	}

851
	lu->hi = hi;
Linus Torvalds's avatar
Linus Torvalds committed
852

853
	write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
854
	list_add_tail(&lu->lu_list, &hi->logical_units);
855
	write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
856

857
858
	/* Register the status FIFO address range. We could use the same FIFO
	 * for targets at different nodes. However we need different FIFOs per
859
860
861
862
863
864
	 * target in order to support multi-unit devices.
	 * The FIFO is located out of the local host controller's physical range
	 * but, if possible, within the posted write area. Status writes will
	 * then be performed as unified transactions. This slightly reduces
	 * bandwidth usage, and some Prolific based devices seem to require it.
	 */
865
	lu->status_fifo_addr = hpsb_allocate_and_register_addrspace(
866
867
			&sbp2_highlevel, ud->ne->host, &sbp2_ops,
			sizeof(struct sbp2_status_block), sizeof(quadlet_t),
868
			ud->ne->host->low_addr_space, CSR1212_ALL_SPACE_END);
869
	if (lu->status_fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
870
871
872
873
		SBP2_ERR("failed to allocate status FIFO address range");
		goto failed_alloc;
	}

874
875
	shost = scsi_host_alloc(&sbp2_shost_template, sizeof(unsigned long));
	if (!shost) {
Linus Torvalds's avatar
Linus Torvalds committed
876
877
878
879
		SBP2_ERR("failed to register scsi host");
		goto failed_alloc;
	}

880
	shost->hostdata[0] = (unsigned long)lu;
881
	shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
882

883
884
885
	if (!scsi_add_host(shost, &ud->device)) {
		lu->shost = shost;
		return lu;
Linus Torvalds's avatar
Linus Torvalds committed
886
887
888
	}

	SBP2_ERR("failed to add scsi host");
889
	scsi_host_put(shost);
Linus Torvalds's avatar
Linus Torvalds committed
890
891

failed_alloc:
892
	sbp2_remove_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
893
894
895
896
897
	return NULL;
}

static void sbp2_host_reset(struct hpsb_host *host)
{
898
	struct sbp2_fwhost_info *hi;
899
	struct sbp2_lu *lu;
900
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
901
902

	hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
903
904
	if (!hi)
		return;
905
906

	read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
907

908
	list_for_each_entry(lu, &hi->logical_units, lu_list)
909
910
911
		if (atomic_cmpxchg(&lu->state,
				   SBP2LU_STATE_RUNNING, SBP2LU_STATE_IN_RESET)
		    == SBP2LU_STATE_RUNNING)
912
			scsi_block_requests(lu->shost);
913

914
	read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
915
916
}

917
static int sbp2_start_device(struct sbp2_lu *lu)
Linus Torvalds's avatar
Linus Torvalds committed
918
{
919
	struct sbp2_fwhost_info *hi = lu->hi;
920
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
921

922
	lu->login_response = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
923
				     sizeof(struct sbp2_login_response),
924
				     &lu->login_response_dma, GFP_KERNEL);
925
	if (!lu->login_response)
Linus Torvalds's avatar
Linus Torvalds committed
926
927
		goto alloc_fail;

928
	lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
929
				     sizeof(struct sbp2_query_logins_orb),
930
				     &lu->query_logins_orb_dma, GFP_KERNEL);
931
	if (!lu->query_logins_orb)
Linus Torvalds's avatar
Linus Torvalds committed
932
933
		goto alloc_fail;

934
	lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
935
				     sizeof(struct sbp2_query_logins_response),
936
				     &lu->query_logins_response_dma, GFP_KERNEL);
937
	if (!lu->query_logins_response)
Linus Torvalds's avatar
Linus Torvalds committed
938
939
		goto alloc_fail;

940
	lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
941
				     sizeof(struct sbp2_reconnect_orb),
942
				     &lu->reconnect_orb_dma, GFP_KERNEL);
943
	if (!lu->reconnect_orb)
Linus Torvalds's avatar
Linus Torvalds committed
944
945
		goto alloc_fail;

946
	lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
947
				     sizeof(struct sbp2_logout_orb),
948
				     &lu->logout_orb_dma, GFP_KERNEL);
949
	if (!lu->logout_orb)
Linus Torvalds's avatar
Linus Torvalds committed
950
951
		goto alloc_fail;

952
	lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richter's avatar
Stefan Richter committed
953
				     sizeof(struct sbp2_login_orb),
954
				     &lu->login_orb_dma, GFP_KERNEL);
955
	if (!lu->login_orb)
956
		goto alloc_fail;
Linus Torvalds's avatar
Linus Torvalds committed
957

958
959
	if (sbp2util_create_command_orb_pool(lu))
		goto alloc_fail;
Linus Torvalds's avatar
Linus Torvalds committed
960

961
962
	/* Wait a second before trying to log in. Previously logged in
	 * initiators need a chance to reconnect. */
963
	if (msleep_interruptible(1000)) {
964
		sbp2_remove_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
965
966
		return -EINTR;
	}
Stefan Richter's avatar
Stefan Richter committed
967

968
969
	if (sbp2_login_device(lu)) {
		sbp2_remove_device(lu);
Linus Torvalds's avatar
Linus Torvalds committed
970
971
972
		return -EBUSY;
	}

973
974
975
	sbp2_set_busy_timeout(lu);
	sbp2_agent_reset(lu, 1);
	sbp2_max_speed_and_size(lu);
Linus Torvalds's avatar
Linus Torvalds committed
976

977
978
979
	if (lu->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
		ssleep(SBP2_INQUIRY_DELAY);

980
	error = scsi_add_device(lu->shost, 0, lu->ud->id, 0);
981
	if (error) {
Linus Torvalds's avatar
Linus Torvalds committed
982
		SBP2_ERR("scsi_add_device failed");
983
984
		sbp2_logout_device(lu);
		sbp2_remove_device(lu);
985
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
986
987
988
	}

	return 0;
989
990

alloc_fail:
991
992
	SBP2_ERR("Could not allocate memory for lu");
	sbp2_remove_device(lu);
993
	return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
994
995
}

996
static void sbp2_remove_device(struct sbp2_lu *lu)
Linus Torvalds's avatar
Linus Torvalds committed
997
{
998
	struct sbp2_fwhost_info *hi;
999
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1000

1001
	if (!lu)
Linus Torvalds's avatar
Linus Torvalds committed
1002
		return;
1003
	hi = lu->hi;
1004
1005
	if (!hi)
		goto no_hi;
Linus Torvalds's avatar
Linus Torvalds committed
1006

1007
1008
1009
	if (lu->shost) {
		scsi_remove_host(lu->shost);
		scsi_host_put(lu->shost);
Linus Torvalds's avatar
Linus Torvalds committed
1010
	}
1011
	flush_scheduled_work();
1012
	sbp2util_remove_command_orb_pool(lu, hi->host);
Linus Torvalds's avatar
Linus Torvalds committed
1013

1014
	write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
1015
	list_del(&lu->lu_list);
1016
	write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1017

1018
	if (lu->login_response)
1019
		dma_free_coherent(hi->host->device.parent,
Linus Torvalds's avatar
Linus Torvalds committed
1020
				    sizeof(struct sbp2_login_response),
1021
1022
1023
				    lu->login_response,
				    lu->login_response_dma);
	if (lu->login_orb)
1024
		dma_free_coherent(hi->host->device.parent,
Linus Torvalds's avatar
Linus Torvalds committed
1025
				    sizeof(struct sbp2_login_orb),
1026
1027
1028
				    lu->login_orb,
				    lu->login_orb_dma);
	if (lu->reconnect_orb)
1029
		dma_free_coherent(hi->host->device.parent,
Linus Torvalds's avatar
Linus Torvalds committed
1030
				    sizeof(struct sbp2_reconnect_orb),
1031
1032
1033
				    lu->reconnect_orb,
				    lu->reconnect_orb_dma);
	if (lu->logout_orb)
1034
		dma_free_coherent(hi->host->device.parent,
Linus Torvalds's avatar
Linus Torvalds committed
1035
				    sizeof(struct sbp2_logout_orb),
1036
1037
1038
				    lu->logout_orb,
				    lu->logout_orb_dma);
	if (lu->query_logins_orb)
1039
		dma_free_coherent(hi->host->device.parent,
Linus Torvalds's avatar
Linus Torvalds committed
1040
				    sizeof(struct sbp2_query_logins_orb),