fw-sbp2.c 47.3 KB
Newer Older
1 2
/*
 * SBP2 driver (SCSI over IEEE1394)
3
 *
4
 * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * 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.
 */

21 22
/*
 * The basic structure of this driver is based on the old storage driver,
23 24 25 26 27 28 29 30
 * drivers/ieee1394/sbp2.c, originally written by
 *     James Goodwin <jamesg@filanet.com>
 * with later contributions and ongoing maintenance from
 *     Ben Collins <bcollins@debian.org>,
 *     Stefan Richter <stefanr@s5r6.in-berlin.de>
 * and many others.
 */

31
#include <linux/blkdev.h>
32
#include <linux/bug.h>
33 34 35
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
36
#include <linux/kernel.h>
37
#include <linux/mod_devicetable.h>
38
#include <linux/module.h>
39
#include <linux/moduleparam.h>
A
Andrew Morton 已提交
40
#include <linux/scatterlist.h>
41
#include <linux/string.h>
42
#include <linux/stringify.h>
43
#include <linux/timer.h>
44
#include <linux/workqueue.h>
45
#include <asm/system.h>
46 47 48 49 50 51 52

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

#include "fw-device.h"
53 54
#include "fw-topology.h"
#include "fw-transaction.h"
55

56 57 58 59 60 61 62 63 64 65 66 67
/*
 * 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.
 *
 * Concurrent logins are useful together with cluster filesystems.
 */
static int sbp2_param_exclusive_login = 1;
module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
		 "(default = Y, use N for concurrent initiators)");

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
/*
 * Flags for firmware oddities
 *
 * - 128kB max transfer
 *   Limit transfer size. Necessary for some old bridges.
 *
 * - 36 byte inquiry
 *   When scsi_mod probes the device, let the inquiry command look like that
 *   from MS Windows.
 *
 * - skip mode page 8
 *   Suppress sending of mode_sense for mode page 8 if the device pretends to
 *   support the SCSI Primary Block commands instead of Reduced Block Commands.
 *
 * - fix capacity
 *   Tell sd_mod to correct the last sector number reported by read_capacity.
 *   Avoids access beyond actual disk limits on devices with an off-by-one bug.
 *   Don't use this with devices which don't have this bug.
 *
87 88 89
 * - delay inquiry
 *   Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
 *
90 91 92 93 94
 * - 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.
 *
95 96 97 98 99 100 101 102 103
 * - 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.
 */
#define SBP2_WORKAROUND_128K_MAX_TRANS	0x1
#define SBP2_WORKAROUND_INQUIRY_36	0x2
#define SBP2_WORKAROUND_MODE_SENSE_8	0x4
#define SBP2_WORKAROUND_FIX_CAPACITY	0x8
104 105
#define SBP2_WORKAROUND_DELAY_INQUIRY	0x10
#define SBP2_INQUIRY_DELAY		12
106
#define SBP2_WORKAROUND_POWER_CONDITION	0x20
107 108 109 110 111 112 113 114 115
#define SBP2_WORKAROUND_OVERRIDE	0x100

static int sbp2_param_workarounds;
module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
	", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
	", 36 byte inquiry = "    __stringify(SBP2_WORKAROUND_INQUIRY_36)
	", skip mode page 8 = "   __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
	", fix capacity = "       __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
116
	", delay inquiry = "      __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
117 118
	", set power condition in start stop unit = "
				  __stringify(SBP2_WORKAROUND_POWER_CONDITION)
119 120 121
	", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
	", or a combination)");

122
/* I don't know why the SCSI stack doesn't define something like this... */
123
typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
124 125 126

static const char sbp2_driver_name[] = "sbp2";

127 128 129 130 131 132 133
/*
 * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
 * and one struct scsi_device per sbp2_logical_unit.
 */
struct sbp2_logical_unit {
	struct sbp2_target *tgt;
	struct list_head link;
134 135
	struct fw_address_handler address_handler;
	struct list_head orb_list;
136

137
	u64 command_block_agent_address;
138
	u16 lun;
139 140
	int login_id;

141
	/*
142 143 144 145
	 * The generation is updated once we've logged in or reconnected
	 * to the logical unit.  Thus, I/O to the device will automatically
	 * fail and get retried if it happens in a window where the device
	 * is not ready, e.g. after a bus reset but before we reconnect.
146
	 */
147
	int generation;
148 149
	int retries;
	struct delayed_work work;
150
	bool has_sdev;
151
	bool blocked;
152 153
};

154 155 156 157 158 159 160
/*
 * We create one struct sbp2_target per IEEE 1212 Unit Directory
 * and one struct Scsi_Host per sbp2_target.
 */
struct sbp2_target {
	struct kref kref;
	struct fw_unit *unit;
161
	const char *bus_id;
162
	struct list_head lu_list;
163 164

	u64 management_agent_address;
165
	u64 guid;
166 167 168
	int directory_id;
	int node_id;
	int address_high;
169
	unsigned int workarounds;
170
	unsigned int mgt_orb_timeout;
171
	unsigned int max_payload;
172 173 174

	int dont_block;	/* counter for each logical unit */
	int blocked;	/* ditto */
175 176
};

J
Jay Fenlason 已提交
177 178 179
/* Impossible login_id, to detect logout attempt before successful login */
#define INVALID_LOGIN_ID 0x10000

180 181
/*
 * Per section 7.4.8 of the SBP-2 spec, a mgt_ORB_timeout value can be
182 183
 * provided in the config rom. Most devices do provide a value, which
 * we'll use for login management orbs, but with some sane limits.
184
 */
185 186
#define SBP2_MIN_LOGIN_ORB_TIMEOUT	5000U	/* Timeout in ms */
#define SBP2_MAX_LOGIN_ORB_TIMEOUT	40000U	/* Timeout in ms */
187
#define SBP2_ORB_TIMEOUT		2000U	/* Timeout in ms */
188
#define SBP2_ORB_NULL			0x80000000
189 190
#define SBP2_RETRY_LIMIT		0xf		/* 15 retries */
#define SBP2_CYCLE_LIMIT		(0xc8 << 12)	/* 200 125us cycles */
191

192 193 194 195 196 197 198
/*
 * The default maximum s/g segment size of a FireWire controller is
 * usually 0x10000, but SBP-2 only allows 0xffff. Since buffers have to
 * be quadlet-aligned, we set the length limit to 0xffff & ~3.
 */
#define SBP2_MAX_SEG_SIZE		0xfffc

199
/* Unit directory keys */
200
#define SBP2_CSR_UNIT_CHARACTERISTICS	0x3a
201 202 203
#define SBP2_CSR_FIRMWARE_REVISION	0x3c
#define SBP2_CSR_LOGICAL_UNIT_NUMBER	0x14
#define SBP2_CSR_LOGICAL_UNIT_DIRECTORY	0xd4
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228

/* Management orb opcodes */
#define SBP2_LOGIN_REQUEST		0x0
#define SBP2_QUERY_LOGINS_REQUEST	0x1
#define SBP2_RECONNECT_REQUEST		0x3
#define SBP2_SET_PASSWORD_REQUEST	0x4
#define SBP2_LOGOUT_REQUEST		0x7
#define SBP2_ABORT_TASK_REQUEST		0xb
#define SBP2_ABORT_TASK_SET		0xc
#define SBP2_LOGICAL_UNIT_RESET		0xe
#define SBP2_TARGET_RESET_REQUEST	0xf

/* Offsets for command block agent registers */
#define SBP2_AGENT_STATE		0x00
#define SBP2_AGENT_RESET		0x04
#define SBP2_ORB_POINTER		0x08
#define SBP2_DOORBELL			0x10
#define SBP2_UNSOLICITED_STATUS_ENABLE	0x14

/* Status write response codes */
#define SBP2_STATUS_REQUEST_COMPLETE	0x0
#define SBP2_STATUS_TRANSPORT_FAILURE	0x1
#define SBP2_STATUS_ILLEGAL_REQUEST	0x2
#define SBP2_STATUS_VENDOR_DEPENDENT	0x3

229 230 231 232 233 234 235 236
#define STATUS_GET_ORB_HIGH(v)		((v).status & 0xffff)
#define STATUS_GET_SBP_STATUS(v)	(((v).status >> 16) & 0xff)
#define STATUS_GET_LEN(v)		(((v).status >> 24) & 0x07)
#define STATUS_GET_DEAD(v)		(((v).status >> 27) & 0x01)
#define STATUS_GET_RESPONSE(v)		(((v).status >> 28) & 0x03)
#define STATUS_GET_SOURCE(v)		(((v).status >> 30) & 0x03)
#define STATUS_GET_ORB_LOW(v)		((v).orb_low)
#define STATUS_GET_DATA(v)		((v).data)
237 238 239 240 241 242 243 244

struct sbp2_status {
	u32 status;
	u32 orb_low;
	u8 data[24];
};

struct sbp2_pointer {
245 246
	__be32 high;
	__be32 low;
247 248 249 250
};

struct sbp2_orb {
	struct fw_transaction t;
251
	struct kref kref;
252 253 254
	dma_addr_t request_bus;
	int rcode;
	struct sbp2_pointer pointer;
255
	void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
256 257 258
	struct list_head link;
};

259 260 261
#define MANAGEMENT_ORB_LUN(v)			((v))
#define MANAGEMENT_ORB_FUNCTION(v)		((v) << 16)
#define MANAGEMENT_ORB_RECONNECT(v)		((v) << 20)
262
#define MANAGEMENT_ORB_EXCLUSIVE(v)		((v) ? 1 << 28 : 0)
263 264
#define MANAGEMENT_ORB_REQUEST_FORMAT(v)	((v) << 29)
#define MANAGEMENT_ORB_NOTIFY			((1) << 31)
265

266 267
#define MANAGEMENT_ORB_RESPONSE_LENGTH(v)	((v))
#define MANAGEMENT_ORB_PASSWORD_LENGTH(v)	((v) << 16)
268 269 270 271 272 273

struct sbp2_management_orb {
	struct sbp2_orb base;
	struct {
		struct sbp2_pointer password;
		struct sbp2_pointer response;
274 275
		__be32 misc;
		__be32 length;
276 277 278 279 280 281 282 283 284
		struct sbp2_pointer status_fifo;
	} request;
	__be32 response[4];
	dma_addr_t response_bus;
	struct completion done;
	struct sbp2_status status;
};

struct sbp2_login_response {
285
	__be32 misc;
286
	struct sbp2_pointer command_block_agent;
287
	__be32 reconnect_hold;
288
};
289 290 291 292 293
#define COMMAND_ORB_DATA_SIZE(v)	((v))
#define COMMAND_ORB_PAGE_SIZE(v)	((v) << 16)
#define COMMAND_ORB_PAGE_TABLE_PRESENT	((1) << 19)
#define COMMAND_ORB_MAX_PAYLOAD(v)	((v) << 20)
#define COMMAND_ORB_SPEED(v)		((v) << 24)
294
#define COMMAND_ORB_DIRECTION		((1) << 27)
295 296
#define COMMAND_ORB_REQUEST_FORMAT(v)	((v) << 29)
#define COMMAND_ORB_NOTIFY		((1) << 31)
297 298 299 300 301 302

struct sbp2_command_orb {
	struct sbp2_orb base;
	struct {
		struct sbp2_pointer next;
		struct sbp2_pointer data_descriptor;
303
		__be32 misc;
304 305 306 307
		u8 command_block[12];
	} request;
	struct scsi_cmnd *cmd;
	scsi_done_fn_t done;
308
	struct sbp2_logical_unit *lu;
309

310
	struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
311 312 313
	dma_addr_t page_table_bus;
};

314 315 316
#define SBP2_ROM_VALUE_WILDCARD ~0         /* match all */
#define SBP2_ROM_VALUE_MISSING  0xff000000 /* not present in the unit dir. */

317 318 319 320 321 322
/*
 * 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
323
 * so far.
324 325 326 327
 */
static const struct {
	u32 firmware_revision;
	u32 model;
328
	unsigned int workarounds;
329 330 331 332 333
} sbp2_workarounds_table[] = {
	/* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
		.firmware_revision	= 0x002800,
		.model			= 0x001010,
		.workarounds		= SBP2_WORKAROUND_INQUIRY_36 |
334 335
					  SBP2_WORKAROUND_MODE_SENSE_8 |
					  SBP2_WORKAROUND_POWER_CONDITION,
336
	},
337 338 339
	/* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
		.firmware_revision	= 0x002800,
		.model			= 0x000000,
340 341
		.workarounds		= SBP2_WORKAROUND_DELAY_INQUIRY |
					  SBP2_WORKAROUND_POWER_CONDITION,
342
	},
343 344
	/* Initio bridges, actually only needed for some older ones */ {
		.firmware_revision	= 0x000200,
345
		.model			= SBP2_ROM_VALUE_WILDCARD,
346 347
		.workarounds		= SBP2_WORKAROUND_INQUIRY_36,
	},
348 349
	/* PL-3507 bridge with Prolific firmware */ {
		.firmware_revision	= 0x012800,
350
		.model			= SBP2_ROM_VALUE_WILDCARD,
351 352
		.workarounds		= SBP2_WORKAROUND_POWER_CONDITION,
	},
353 354
	/* Symbios bridge */ {
		.firmware_revision	= 0xa0b800,
355
		.model			= SBP2_ROM_VALUE_WILDCARD,
356 357
		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
	},
358 359
	/* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
		.firmware_revision	= 0x002600,
360
		.model			= SBP2_ROM_VALUE_WILDCARD,
361 362
		.workarounds		= SBP2_WORKAROUND_128K_MAX_TRANS,
	},
363 364 365

	/*
	 * There are iPods (2nd gen, 3rd gen) with model_id == 0, but
366 367
	 * these iPods do not feature the read_capacity bug according
	 * to one report.  Read_capacity behaviour as well as model_id
368 369 370
	 * could change due to Apple-supplied firmware updates though.
	 */

371 372 373 374 375
	/* iPod 4th generation. */ {
		.firmware_revision	= 0x0a2700,
		.model			= 0x000021,
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
376 377 378 379 380
	/* iPod mini */ {
		.firmware_revision	= 0x0a2700,
		.model			= 0x000022,
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
381 382 383 384 385 386 387 388 389 390 391 392
	/* iPod mini */ {
		.firmware_revision	= 0x0a2700,
		.model			= 0x000023,
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	},
	/* iPod Photo */ {
		.firmware_revision	= 0x0a2700,
		.model			= 0x00007e,
		.workarounds		= SBP2_WORKAROUND_FIX_CAPACITY,
	}
};

393 394 395 396 397 398 399 400
static void
free_orb(struct kref *kref)
{
	struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);

	kfree(orb);
}

401 402 403 404 405 406 407
static void
sbp2_status_write(struct fw_card *card, struct fw_request *request,
		  int tcode, int destination, int source,
		  int generation, int speed,
		  unsigned long long offset,
		  void *payload, size_t length, void *callback_data)
{
408
	struct sbp2_logical_unit *lu = callback_data;
409 410 411 412 413 414
	struct sbp2_orb *orb;
	struct sbp2_status status;
	size_t header_size;
	unsigned long flags;

	if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
415
	    length == 0 || length > sizeof(status)) {
416 417 418 419 420 421 422 423
		fw_send_response(card, request, RCODE_TYPE_ERROR);
		return;
	}

	header_size = min(length, 2 * sizeof(u32));
	fw_memcpy_from_be32(&status, payload, header_size);
	if (length > header_size)
		memcpy(status.data, payload + 8, length - header_size);
424
	if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
425 426 427 428 429 430 431
		fw_notify("non-orb related status write, not handled\n");
		fw_send_response(card, request, RCODE_COMPLETE);
		return;
	}

	/* Lookup the orb corresponding to this status write. */
	spin_lock_irqsave(&card->lock, flags);
432
	list_for_each_entry(orb, &lu->orb_list, link) {
433
		if (STATUS_GET_ORB_HIGH(status) == 0 &&
434 435
		    STATUS_GET_ORB_LOW(status) == orb->request_bus) {
			orb->rcode = RCODE_COMPLETE;
436 437 438 439 440 441
			list_del(&orb->link);
			break;
		}
	}
	spin_unlock_irqrestore(&card->lock, flags);

442
	if (&orb->link != &lu->orb_list)
443 444 445 446
		orb->callback(orb, &status);
	else
		fw_error("status write for unknown orb\n");

447 448
	kref_put(&orb->kref, free_orb);

449 450 451 452 453 454 455 456 457 458
	fw_send_response(card, request, RCODE_COMPLETE);
}

static void
complete_transaction(struct fw_card *card, int rcode,
		     void *payload, size_t length, void *data)
{
	struct sbp2_orb *orb = data;
	unsigned long flags;

459 460 461 462 463 464 465 466 467 468 469 470 471 472
	/*
	 * This is a little tricky.  We can get the status write for
	 * the orb before we get this callback.  The status write
	 * handler above will assume the orb pointer transaction was
	 * successful and set the rcode to RCODE_COMPLETE for the orb.
	 * So this callback only sets the rcode if it hasn't already
	 * been set and only does the cleanup if the transaction
	 * failed and we didn't already get a status write.
	 */
	spin_lock_irqsave(&card->lock, flags);

	if (orb->rcode == -1)
		orb->rcode = rcode;
	if (orb->rcode != RCODE_COMPLETE) {
473
		list_del(&orb->link);
474
		spin_unlock_irqrestore(&card->lock, flags);
475
		orb->callback(orb, NULL);
476 477
	} else {
		spin_unlock_irqrestore(&card->lock, flags);
478
	}
479 480

	kref_put(&orb->kref, free_orb);
481 482 483
}

static void
484
sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
485 486
	      int node_id, int generation, u64 offset)
{
487
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
488 489 490
	unsigned long flags;

	orb->pointer.high = 0;
491
	orb->pointer.low = cpu_to_be32(orb->request_bus);
492 493

	spin_lock_irqsave(&device->card->lock, flags);
494
	list_add_tail(&orb->link, &lu->orb_list);
495 496
	spin_unlock_irqrestore(&device->card->lock, flags);

497 498 499 500
	/* Take a ref for the orb list and for the transaction callback. */
	kref_get(&orb->kref);
	kref_get(&orb->kref);

501
	fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
502
			node_id, generation, device->max_speed, offset,
503
			&orb->pointer, sizeof(orb->pointer),
504 505 506
			complete_transaction, orb);
}

507
static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
508
{
509
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
510 511 512
	struct sbp2_orb *orb, *next;
	struct list_head list;
	unsigned long flags;
513
	int retval = -ENOENT;
514 515 516

	INIT_LIST_HEAD(&list);
	spin_lock_irqsave(&device->card->lock, flags);
517
	list_splice_init(&lu->orb_list, &list);
518 519 520
	spin_unlock_irqrestore(&device->card->lock, flags);

	list_for_each_entry_safe(orb, next, &list, link) {
521
		retval = 0;
522 523 524
		if (fw_cancel_transaction(device->card, &orb->t) == 0)
			continue;

525 526 527 528
		orb->rcode = RCODE_CANCELLED;
		orb->callback(orb, NULL);
	}

529
	return retval;
530 531
}

532 533 534 535
static void
complete_management_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
{
	struct sbp2_management_orb *orb =
536
		container_of(base_orb, struct sbp2_management_orb, base);
537 538

	if (status)
539
		memcpy(&orb->status, status, sizeof(*status));
540 541 542 543
	complete(&orb->done);
}

static int
544 545 546
sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
			 int generation, int function, int lun_or_login_id,
			 void *response)
547
{
548
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
549
	struct sbp2_management_orb *orb;
550
	unsigned int timeout;
551 552
	int retval = -ENOMEM;

553 554 555
	if (function == SBP2_LOGOUT_REQUEST && fw_device_is_shutdown(device))
		return 0;

556
	orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
557 558 559
	if (orb == NULL)
		return -ENOMEM;

560
	kref_init(&orb->base.kref);
561 562
	orb->response_bus =
		dma_map_single(device->card->device, &orb->response,
563
			       sizeof(orb->response), DMA_FROM_DEVICE);
564
	if (dma_mapping_error(device->card->device, orb->response_bus))
565
		goto fail_mapping_response;
566

567 568
	orb->request.response.high = 0;
	orb->request.response.low  = cpu_to_be32(orb->response_bus);
569

570
	orb->request.misc = cpu_to_be32(
571 572
		MANAGEMENT_ORB_NOTIFY |
		MANAGEMENT_ORB_FUNCTION(function) |
573 574 575
		MANAGEMENT_ORB_LUN(lun_or_login_id));
	orb->request.length = cpu_to_be32(
		MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response)));
576

577 578 579 580
	orb->request.status_fifo.high =
		cpu_to_be32(lu->address_handler.offset >> 32);
	orb->request.status_fifo.low  =
		cpu_to_be32(lu->address_handler.offset);
581 582

	if (function == SBP2_LOGIN_REQUEST) {
583
		/* Ask for 2^2 == 4 seconds reconnect grace period */
584
		orb->request.misc |= cpu_to_be32(
585
			MANAGEMENT_ORB_RECONNECT(2) |
586
			MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login));
587
		timeout = lu->tgt->mgt_orb_timeout;
588 589
	} else {
		timeout = SBP2_ORB_TIMEOUT;
590 591 592 593
	}

	init_completion(&orb->done);
	orb->base.callback = complete_management_orb;
594

595 596 597
	orb->base.request_bus =
		dma_map_single(device->card->device, &orb->request,
			       sizeof(orb->request), DMA_TO_DEVICE);
598
	if (dma_mapping_error(device->card->device, orb->base.request_bus))
599 600
		goto fail_mapping_request;

601 602
	sbp2_send_orb(&orb->base, lu, node_id, generation,
		      lu->tgt->management_agent_address);
603

604
	wait_for_completion_timeout(&orb->done, msecs_to_jiffies(timeout));
605 606

	retval = -EIO;
607
	if (sbp2_cancel_orbs(lu) == 0) {
608 609
		fw_error("%s: orb reply timed out, rcode=0x%02x\n",
			 lu->tgt->bus_id, orb->base.rcode);
610 611 612
		goto out;
	}

613
	if (orb->base.rcode != RCODE_COMPLETE) {
614 615
		fw_error("%s: management write failed, rcode 0x%02x\n",
			 lu->tgt->bus_id, orb->base.rcode);
616 617 618
		goto out;
	}

619 620
	if (STATUS_GET_RESPONSE(orb->status) != 0 ||
	    STATUS_GET_SBP_STATUS(orb->status) != 0) {
621
		fw_error("%s: error status: %d:%d\n", lu->tgt->bus_id,
622 623
			 STATUS_GET_RESPONSE(orb->status),
			 STATUS_GET_SBP_STATUS(orb->status));
624 625 626 627 628 629
		goto out;
	}

	retval = 0;
 out:
	dma_unmap_single(device->card->device, orb->base.request_bus,
630
			 sizeof(orb->request), DMA_TO_DEVICE);
631
 fail_mapping_request:
632
	dma_unmap_single(device->card->device, orb->response_bus,
633
			 sizeof(orb->response), DMA_FROM_DEVICE);
634
 fail_mapping_response:
635
	if (response)
636
		memcpy(response, orb->response, sizeof(orb->response));
637
	kref_put(&orb->base.kref, free_orb);
638 639 640 641

	return retval;
}

642 643 644
static void sbp2_agent_reset(struct sbp2_logical_unit *lu)
{
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
J
Jay Fenlason 已提交
645
	__be32 d = 0;
646

J
Jay Fenlason 已提交
647 648 649 650
	fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
			   lu->tgt->node_id, lu->generation, device->max_speed,
			   lu->command_block_agent_address + SBP2_AGENT_RESET,
			   &d, sizeof(d));
651 652
}

653 654 655 656 657 658 659 660
static void
complete_agent_reset_write_no_wait(struct fw_card *card, int rcode,
				   void *payload, size_t length, void *data)
{
	kfree(data);
}

static void sbp2_agent_reset_no_wait(struct sbp2_logical_unit *lu)
661
{
662
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
663
	struct fw_transaction *t;
J
Jay Fenlason 已提交
664
	static __be32 d;
665

666
	t = kmalloc(sizeof(*t), GFP_ATOMIC);
667
	if (t == NULL)
668
		return;
669 670

	fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
671 672
			lu->tgt->node_id, lu->generation, device->max_speed,
			lu->command_block_agent_address + SBP2_AGENT_RESET,
J
Jay Fenlason 已提交
673
			&d, sizeof(d), complete_agent_reset_write_no_wait, t);
674 675
}

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
static inline void sbp2_allow_block(struct sbp2_logical_unit *lu)
{
	/*
	 * We may access dont_block without taking card->lock here:
	 * All callers of sbp2_allow_block() and all callers of sbp2_unblock()
	 * are currently serialized against each other.
	 * And a wrong result in sbp2_conditionally_block()'s access of
	 * dont_block is rather harmless, it simply misses its first chance.
	 */
	--lu->tgt->dont_block;
}

/*
 * Blocks lu->tgt if all of the following conditions are met:
 *   - Login, INQUIRY, and high-level SCSI setup of all of the target's
 *     logical units have been finished (indicated by dont_block == 0).
 *   - lu->generation is stale.
 *
 * Note, scsi_block_requests() must be called while holding card->lock,
 * otherwise it might foil sbp2_[conditionally_]unblock()'s attempt to
 * unblock the target.
 */
static void sbp2_conditionally_block(struct sbp2_logical_unit *lu)
{
	struct sbp2_target *tgt = lu->tgt;
	struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
	struct Scsi_Host *shost =
		container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
	unsigned long flags;

	spin_lock_irqsave(&card->lock, flags);
	if (!tgt->dont_block && !lu->blocked &&
	    lu->generation != card->generation) {
		lu->blocked = true;
710
		if (++tgt->blocked == 1)
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
			scsi_block_requests(shost);
	}
	spin_unlock_irqrestore(&card->lock, flags);
}

/*
 * Unblocks lu->tgt as soon as all its logical units can be unblocked.
 * Note, it is harmless to run scsi_unblock_requests() outside the
 * card->lock protected section.  On the other hand, running it inside
 * the section might clash with shost->host_lock.
 */
static void sbp2_conditionally_unblock(struct sbp2_logical_unit *lu)
{
	struct sbp2_target *tgt = lu->tgt;
	struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
	struct Scsi_Host *shost =
		container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
	unsigned long flags;
	bool unblock = false;

	spin_lock_irqsave(&card->lock, flags);
	if (lu->blocked && lu->generation == card->generation) {
		lu->blocked = false;
		unblock = --tgt->blocked == 0;
	}
	spin_unlock_irqrestore(&card->lock, flags);

738
	if (unblock)
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
		scsi_unblock_requests(shost);
}

/*
 * Prevents future blocking of tgt and unblocks it.
 * Note, it is harmless to run scsi_unblock_requests() outside the
 * card->lock protected section.  On the other hand, running it inside
 * the section might clash with shost->host_lock.
 */
static void sbp2_unblock(struct sbp2_target *tgt)
{
	struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
	struct Scsi_Host *shost =
		container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
	unsigned long flags;

	spin_lock_irqsave(&card->lock, flags);
	++tgt->dont_block;
	spin_unlock_irqrestore(&card->lock, flags);

	scsi_unblock_requests(shost);
}

762 763 764 765 766 767 768 769 770 771 772
static int sbp2_lun2int(u16 lun)
{
	struct scsi_lun eight_bytes_lun;

	memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
	eight_bytes_lun.scsi_lun[0] = (lun >> 8) & 0xff;
	eight_bytes_lun.scsi_lun[1] = lun & 0xff;

	return scsilun_to_int(&eight_bytes_lun);
}

773
static void sbp2_release_target(struct kref *kref)
774
{
775 776 777 778
	struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
	struct sbp2_logical_unit *lu, *next;
	struct Scsi_Host *shost =
		container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
779
	struct scsi_device *sdev;
780
	struct fw_device *device = fw_device(tgt->unit->device.parent);
781

782 783 784
	/* prevent deadlocks */
	sbp2_unblock(tgt);

785
	list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
786 787 788 789
		sdev = scsi_device_lookup(shost, 0, 0, sbp2_lun2int(lu->lun));
		if (sdev) {
			scsi_remove_device(sdev);
			scsi_device_put(sdev);
790
		}
J
Jay Fenlason 已提交
791 792 793 794 795 796 797 798 799 800 801 802 803 804
		if (lu->login_id != INVALID_LOGIN_ID) {
			int generation, node_id;
			/*
			 * tgt->node_id may be obsolete here if we failed
			 * during initial login or after a bus reset where
			 * the topology changed.
			 */
			generation = device->generation;
			smp_rmb(); /* node_id vs. generation */
			node_id    = device->node_id;
			sbp2_send_management_orb(lu, node_id, generation,
						 SBP2_LOGOUT_REQUEST,
						 lu->login_id, NULL);
		}
805 806 807 808 809
		fw_core_remove_address_handler(&lu->address_handler);
		list_del(&lu->link);
		kfree(lu);
	}
	scsi_remove_host(shost);
810
	fw_notify("released %s, target %d:0:0\n", tgt->bus_id, shost->host_no);
811

812
	fw_unit_put(tgt->unit);
813
	scsi_host_put(shost);
814
	fw_device_put(device);
815 816
}

817 818
static struct workqueue_struct *sbp2_wq;

J
Jay Fenlason 已提交
819 820 821 822 823
static void sbp2_target_put(struct sbp2_target *tgt)
{
	kref_put(&tgt->kref, sbp2_release_target);
}

824 825 826 827 828 829
/*
 * Always get the target's kref when scheduling work on one its units.
 * Each workqueue job is responsible to call sbp2_target_put() upon return.
 */
static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
{
J
Jay Fenlason 已提交
830 831 832
	kref_get(&lu->tgt->kref);
	if (!queue_delayed_work(sbp2_wq, &lu->work, delay))
		sbp2_target_put(lu->tgt);
833 834
}

835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
/*
 * Write retransmit retry values into the BUSY_TIMEOUT register.
 * - The single-phase retry protocol is supported by all SBP-2 devices, but the
 *   default retry_limit value is 0 (i.e. never retry transmission). We write a
 *   saner value after logging into the device.
 * - The dual-phase retry protocol is optional to implement, and if not
 *   supported, writes to the dual-phase portion of the register will be
 *   ignored. We try to write the original 1394-1995 default here.
 * - In the case of devices that are also SBP-3-compliant, all writes are
 *   ignored, as the register is read-only, but contains single-phase retry of
 *   15, which is what we're trying to set for all SBP-2 device anyway, so this
 *   write attempt is safe and yields more consistent behavior for all devices.
 *
 * See section 8.3.2.3.5 of the 1394-1995 spec, section 6.2 of the SBP-2 spec,
 * and section 6.4 of the SBP-3 spec for further details.
 */
851 852 853
static void sbp2_set_busy_timeout(struct sbp2_logical_unit *lu)
{
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
J
Jay Fenlason 已提交
854
	__be32 d = cpu_to_be32(SBP2_CYCLE_LIMIT | SBP2_RETRY_LIMIT);
855

J
Jay Fenlason 已提交
856 857 858 859
	fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
			   lu->tgt->node_id, lu->generation, device->max_speed,
			   CSR_REGISTER_BASE + CSR_BUSY_TIMEOUT,
			   &d, sizeof(d));
860 861
}

862 863
static void sbp2_reconnect(struct work_struct *work);

864 865
static void sbp2_login(struct work_struct *work)
{
866 867
	struct sbp2_logical_unit *lu =
		container_of(work, struct sbp2_logical_unit, work.work);
868 869 870
	struct sbp2_target *tgt = lu->tgt;
	struct fw_device *device = fw_device(tgt->unit->device.parent);
	struct Scsi_Host *shost;
871
	struct scsi_device *sdev;
872
	struct sbp2_login_response response;
873
	int generation, node_id, local_node_id;
874

875 876 877
	if (fw_device_is_shutdown(device))
		goto out;

878
	generation    = device->generation;
879
	smp_rmb();    /* node IDs must not be older than generation */
880 881
	node_id       = device->node_id;
	local_node_id = device->card->node_id;
882

883
	/* If this is a re-login attempt, log out, or we might be rejected. */
884
	if (lu->has_sdev)
885 886 887
		sbp2_send_management_orb(lu, device->node_id, generation,
				SBP2_LOGOUT_REQUEST, lu->login_id, NULL);

888 889
	if (sbp2_send_management_orb(lu, node_id, generation,
				SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
890
		if (lu->retries++ < 5) {
891
			sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
892
		} else {
893 894
			fw_error("%s: failed to login to LUN %04x\n",
				 tgt->bus_id, lu->lun);
895 896 897
			/* Let any waiting I/O fail from now on. */
			sbp2_unblock(lu->tgt);
		}
898
		goto out;
899 900
	}

901 902
	tgt->node_id	  = node_id;
	tgt->address_high = local_node_id << 16;
903 904
	smp_wmb();	  /* node IDs must not be older than generation */
	lu->generation	  = generation;
905

906
	lu->command_block_agent_address =
907 908 909
		((u64)(be32_to_cpu(response.command_block_agent.high) & 0xffff)
		      << 32) | be32_to_cpu(response.command_block_agent.low);
	lu->login_id = be32_to_cpu(response.misc) & 0xffff;
910

911 912
	fw_notify("%s: logged in to LUN %04x (%d retries)\n",
		  tgt->bus_id, lu->lun, lu->retries);
913

914 915
	/* set appropriate retry limit(s) in BUSY_TIMEOUT register */
	sbp2_set_busy_timeout(lu);
916

917 918 919
	PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
	sbp2_agent_reset(lu);

920
	/* This was a re-login. */
921
	if (lu->has_sdev) {
922
		sbp2_cancel_orbs(lu);
923
		sbp2_conditionally_unblock(lu);
924 925 926
		goto out;
	}

927 928 929
	if (lu->tgt->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
		ssleep(SBP2_INQUIRY_DELAY);

930
	shost = container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
931
	sdev = __scsi_add_device(shost, 0, 0, sbp2_lun2int(lu->lun), lu);
932 933 934 935 936 937 938
	/*
	 * FIXME:  We are unable to perform reconnects while in sbp2_login().
	 * Therefore __scsi_add_device() will get into trouble if a bus reset
	 * happens in parallel.  It will either fail or leave us with an
	 * unusable sdev.  As a workaround we check for this and retry the
	 * whole login and SCSI probing.
	 */
939

940 941 942 943 944 945 946 947
	/* Reported error during __scsi_add_device() */
	if (IS_ERR(sdev))
		goto out_logout_login;

	/* Unreported error during __scsi_add_device() */
	smp_rmb(); /* get current card generation */
	if (generation != device->card->generation) {
		scsi_remove_device(sdev);
948
		scsi_device_put(sdev);
949
		goto out_logout_login;
950
	}
951 952

	/* No error during __scsi_add_device() */
953 954
	lu->has_sdev = true;
	scsi_device_put(sdev);
955
	sbp2_allow_block(lu);
956 957 958 959 960 961 962 963 964 965 966 967 968 969
	goto out;

 out_logout_login:
	smp_rmb(); /* generation may have changed */
	generation = device->generation;
	smp_rmb(); /* node_id must not be older than generation */

	sbp2_send_management_orb(lu, device->node_id, generation,
				 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
	/*
	 * If a bus reset happened, sbp2_update will have requeued
	 * lu->work already.  Reset the work from reconnect to login.
	 */
	PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
970
 out:
971
	sbp2_target_put(tgt);
972
}
973

974
static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
975
{
976
	struct sbp2_logical_unit *lu;
977

978 979 980
	lu = kmalloc(sizeof(*lu), GFP_KERNEL);
	if (!lu)
		return -ENOMEM;
981

982 983 984
	lu->address_handler.length           = 0x100;
	lu->address_handler.address_callback = sbp2_status_write;
	lu->address_handler.callback_data    = lu;
985

986 987 988 989 990
	if (fw_core_add_address_handler(&lu->address_handler,
					&fw_high_memory_region) < 0) {
		kfree(lu);
		return -ENOMEM;
	}
991

992 993
	lu->tgt      = tgt;
	lu->lun      = lun_entry & 0xffff;
J
Jay Fenlason 已提交
994
	lu->login_id = INVALID_LOGIN_ID;
995 996 997
	lu->retries  = 0;
	lu->has_sdev = false;
	lu->blocked  = false;
998
	++tgt->dont_block;
999 1000
	INIT_LIST_HEAD(&lu->orb_list);
	INIT_DELAYED_WORK(&lu->work, sbp2_login);
1001

1002 1003 1004
	list_add_tail(&lu->link, &tgt->lu_list);
	return 0;
}
1005

1006 1007 1008 1009
static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
{
	struct fw_csr_iterator ci;
	int key, value;
1010

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
	fw_csr_iterator_init(&ci, directory);
	while (fw_csr_iterator_next(&ci, &key, &value))
		if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
		    sbp2_add_logical_unit(tgt, value) < 0)
			return -ENOMEM;
	return 0;
}

static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
			      u32 *model, u32 *firmware_revision)
{
	struct fw_csr_iterator ci;
	int key, value;
1024
	unsigned int timeout;
1025 1026

	fw_csr_iterator_init(&ci, directory);
1027 1028
	while (fw_csr_iterator_next(&ci, &key, &value)) {
		switch (key) {
1029

1030
		case CSR_DEPENDENT_INFO | CSR_OFFSET:
1031 1032
			tgt->management_agent_address =
					CSR_REGISTER_BASE + 4 * value;
1033
			break;
1034 1035 1036

		case CSR_DIRECTORY_ID:
			tgt->directory_id = value;
1037
			break;
1038

1039
		case CSR_MODEL:
1040 1041 1042 1043 1044 1045 1046
			*model = value;
			break;

		case SBP2_CSR_FIRMWARE_REVISION:
			*firmware_revision = value;
			break;

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
		case SBP2_CSR_UNIT_CHARACTERISTICS:
			/* the timeout value is stored in 500ms units */
			timeout = ((unsigned int) value >> 8 & 0xff) * 500;
			timeout = max(timeout, SBP2_MIN_LOGIN_ORB_TIMEOUT);
			tgt->mgt_orb_timeout =
				  min(timeout, SBP2_MAX_LOGIN_ORB_TIMEOUT);

			if (timeout > tgt->mgt_orb_timeout)
				fw_notify("%s: config rom contains %ds "
					  "management ORB timeout, limiting "
1057
					  "to %ds\n", tgt->bus_id,
1058 1059 1060 1061
					  timeout / 1000,
					  tgt->mgt_orb_timeout / 1000);
			break;

1062 1063 1064 1065 1066 1067
		case SBP2_CSR_LOGICAL_UNIT_NUMBER:
			if (sbp2_add_logical_unit(tgt, value) < 0)
				return -ENOMEM;
			break;

		case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
1068 1069
			/* Adjust for the increment in the iterator */
			if (sbp2_scan_logical_unit_dir(tgt, ci.p - 1 + value) < 0)
1070
				return -ENOMEM;
1071 1072 1073
			break;
		}
	}
1074 1075 1076 1077 1078 1079 1080
	return 0;
}

static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
				  u32 firmware_revision)
{
	int i;
1081
	unsigned int w = sbp2_param_workarounds;
1082 1083 1084 1085

	if (w)
		fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
			  "if you need the workarounds parameter for %s\n",
1086
			  tgt->bus_id);
1087

1088 1089
	if (w & SBP2_WORKAROUND_OVERRIDE)
		goto out;
1090 1091

	for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1092

1093 1094 1095
		if (sbp2_workarounds_table[i].firmware_revision !=
		    (firmware_revision & 0xffffff00))
			continue;
1096

1097
		if (sbp2_workarounds_table[i].model != model &&
1098
		    sbp2_workarounds_table[i].model != SBP2_ROM_VALUE_WILDCARD)
1099
			continue;
1100

1101
		w |= sbp2_workarounds_table[i].workarounds;
1102 1103
		break;
	}
1104 1105
 out:
	if (w)
1106
		fw_notify("Workarounds for %s: 0x%x "
1107
			  "(firmware_revision 0x%06x, model_id 0x%06x)\n",
1108
			  tgt->bus_id, w, firmware_revision, model);
1109
	tgt->workarounds = w;
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
}

static struct scsi_host_template scsi_driver_template;

static int sbp2_probe(struct device *dev)
{
	struct fw_unit *unit = fw_unit(dev);
	struct fw_device *device = fw_device(unit->device.parent);
	struct sbp2_target *tgt;
	struct sbp2_logical_unit *lu;
	struct Scsi_Host *shost;
	u32 model, firmware_revision;

1123 1124 1125 1126
	if (dma_get_max_seg_size(device->card->device) > SBP2_MAX_SEG_SIZE)
		BUG_ON(dma_set_max_seg_size(device->card->device,
					    SBP2_MAX_SEG_SIZE));

1127 1128 1129 1130 1131 1132 1133 1134 1135
	shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
	if (shost == NULL)
		return -ENOMEM;

	tgt = (struct sbp2_target *)shost->hostdata;
	unit->device.driver_data = tgt;
	tgt->unit = unit;
	kref_init(&tgt->kref);
	INIT_LIST_HEAD(&tgt->lu_list);
1136
	tgt->bus_id = dev_name(&unit->device);
1137
	tgt->guid = (u64)device->config_rom[3] << 32 | device->config_rom[4];
1138 1139 1140 1141 1142 1143 1144

	if (fw_device_enable_phys_dma(device) < 0)
		goto fail_shost_put;

	if (scsi_add_host(shost, &unit->device) < 0)
		goto fail_shost_put;

1145
	fw_device_get(device);
1146
	fw_unit_get(unit);
1147

1148 1149 1150 1151
	/* implicit directory ID */
	tgt->directory_id = ((unit->directory - device->config_rom) * 4
			     + CSR_CONFIG_ROM) & 0xffffff;

1152 1153 1154
	firmware_revision = SBP2_ROM_VALUE_MISSING;
	model		  = SBP2_ROM_VALUE_MISSING;

1155 1156 1157 1158 1159
	if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
			       &firmware_revision) < 0)
		goto fail_tgt_put;

	sbp2_init_workarounds(tgt, model, firmware_revision);
1160

1161 1162 1163 1164 1165 1166 1167 1168 1169
	/*
	 * At S100 we can do 512 bytes per packet, at S200 1024 bytes,
	 * and so on up to 4096 bytes.  The SBP-2 max_payload field
	 * specifies the max payload size as 2 ^ (max_payload + 2), so
	 * if we set this to max_speed + 7, we get the right value.
	 */
	tgt->max_payload = min(device->max_speed + 7, 10U);
	tgt->max_payload = min(tgt->max_payload, device->card->max_receive - 1);

1170
	/* Do the login in a workqueue so we can easily reschedule retries. */
1171
	list_for_each_entry(lu, &tgt->lu_list, link)
1172
		sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
1173
	return 0;
1174

1175
 fail_tgt_put:
1176
	sbp2_target_put(tgt);
1177 1178 1179 1180 1181
	return -ENOMEM;

 fail_shost_put:
	scsi_host_put(shost);
	return -ENOMEM;
1182 1183 1184 1185 1186
}

static int sbp2_remove(struct device *dev)
{
	struct fw_unit *unit = fw_unit(dev);
1187
	struct sbp2_target *tgt = unit->device.driver_data;
1188

1189
	sbp2_target_put(tgt);
1190 1191 1192 1193 1194
	return 0;
}

static void sbp2_reconnect(struct work_struct *work)
{
1195 1196
	struct sbp2_logical_unit *lu =
		container_of(work, struct sbp2_logical_unit, work.work);
1197 1198
	struct sbp2_target *tgt = lu->tgt;
	struct fw_device *device = fw_device(tgt->unit->device.parent);
1199 1200
	int generation, node_id, local_node_id;

1201 1202 1203
	if (fw_device_is_shutdown(device))
		goto out;

1204
	generation    = device->generation;
1205
	smp_rmb();    /* node IDs must not be older than generation */
1206 1207
	node_id       = device->node_id;
	local_node_id = device->card->node_id;
1208

1209
	if (sbp2_send_management_orb(lu, node_id, generation,
1210
				     SBP2_RECONNECT_REQUEST,
1211
				     lu->login_id, NULL) < 0) {
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
		/*
		 * If reconnect was impossible even though we are in the
		 * current generation, fall back and try to log in again.
		 *
		 * We could check for "Function rejected" status, but
		 * looking at the bus generation as simpler and more general.
		 */
		smp_rmb(); /* get current card generation */
		if (generation == device->card->generation ||
		    lu->retries++ >= 5) {
1222
			fw_error("%s: failed to reconnect\n", tgt->bus_id);
1223 1224
			lu->retries = 0;
			PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
1225
		}
1226 1227
		sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
		goto out;
1228
	}
1229

1230 1231
	tgt->node_id      = node_id;
	tgt->address_high = local_node_id << 16;
1232 1233
	smp_wmb();	  /* node IDs must not be older than generation */
	lu->generation	  = generation;
1234

1235 1236
	fw_notify("%s: reconnected to LUN %04x (%d retries)\n",
		  tgt->bus_id, lu->lun, lu->retries);
1237 1238 1239

	sbp2_agent_reset(lu);
	sbp2_cancel_orbs(lu);
1240
	sbp2_conditionally_unblock(lu);
1241
 out:
1242
	sbp2_target_put(tgt);
1243 1244 1245 1246
}

static void sbp2_update(struct fw_unit *unit)
{
1247 1248
	struct sbp2_target *tgt = unit->device.driver_data;
	struct sbp2_logical_unit *lu;
1249

1250 1251 1252 1253 1254 1255 1256
	fw_device_enable_phys_dma(fw_device(unit->device.parent));

	/*
	 * Fw-core serializes sbp2_update() against sbp2_remove().
	 * Iteration over tgt->lu_list is therefore safe here.
	 */
	list_for_each_entry(lu, &tgt->lu_list, link) {
1257
		sbp2_conditionally_block(lu);
1258
		lu->retries = 0;
1259
		sbp2_queue_work(lu, 0);
1260
	}
1261 1262 1263 1264 1265
}

#define SBP2_UNIT_SPEC_ID_ENTRY	0x0000609e
#define SBP2_SW_VERSION_ENTRY	0x00010483

1266
static const struct fw_device_id sbp2_id_table[] = {
1267 1268 1269
	{
		.match_flags  = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
		.specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
1270
		.version      = SBP2_SW_VERSION_ENTRY,
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
	},
	{ }
};

static struct fw_driver sbp2_driver = {
	.driver   = {
		.owner  = THIS_MODULE,
		.name   = sbp2_driver_name,
		.bus    = &fw_bus_type,
		.probe  = sbp2_probe,
		.remove = sbp2_remove,
	},
	.update   = sbp2_update,
	.id_table = sbp2_id_table,
};

1287 1288
static unsigned int
sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
1289
{
1290 1291
	int sam_status;

1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
	sense_data[0] = 0x70;
	sense_data[1] = 0x0;
	sense_data[2] = sbp2_status[1];
	sense_data[3] = sbp2_status[4];
	sense_data[4] = sbp2_status[5];
	sense_data[5] = sbp2_status[6];
	sense_data[6] = sbp2_status[7];
	sense_data[7] = 10;
	sense_data[8] = sbp2_status[8];
	sense_data[9] = sbp2_status[9];
	sense_data[10] = sbp2_status[10];
	sense_data[11] = sbp2_status[11];
	sense_data[12] = sbp2_status[2];
	sense_data[13] = sbp2_status[3];
	sense_data[14] = sbp2_status[12];
	sense_data[15] = sbp2_status[13];

1309
	sam_status = sbp2_status[0] & 0x3f;
1310

1311 1312
	switch (sam_status) {
	case SAM_STAT_GOOD:
1313 1314
	case SAM_STAT_CHECK_CONDITION:
	case SAM_STAT_CONDITION_MET:
1315
	case SAM_STAT_BUSY:
1316 1317
	case SAM_STAT_RESERVATION_CONFLICT:
	case SAM_STAT_COMMAND_TERMINATED:
1318 1319
		return DID_OK << 16 | sam_status;

1320
	default:
1321
		return DID_ERROR << 16;
1322 1323 1324 1325 1326 1327
	}
}

static void
complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
{
1328 1329
	struct sbp2_command_orb *orb =
		container_of(base_orb, struct sbp2_command_orb, base);
1330
	struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
1331 1332 1333
	int result;

	if (status != NULL) {
1334
		if (STATUS_GET_DEAD(*status))
1335
			sbp2_agent_reset_no_wait(orb->lu);
1336

1337
		switch (STATUS_GET_RESPONSE(*status)) {
1338
		case SBP2_STATUS_REQUEST_COMPLETE:
1339
			result = DID_OK << 16;
1340 1341
			break;
		case SBP2_STATUS_TRANSPORT_FAILURE:
1342
			result = DID_BUS_BUSY << 16;
1343 1344 1345 1346
			break;
		case SBP2_STATUS_ILLEGAL_REQUEST:
		case SBP2_STATUS_VENDOR_DEPENDENT:
		default:
1347
			result = DID_ERROR << 16;
1348 1349 1350
			break;
		}

1351 1352
		if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
			result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
1353 1354
							   orb->cmd->sense_buffer);
	} else {
1355 1356
		/*
		 * If the orb completes with status == NULL, something
1357
		 * went wrong, typically a bus reset happened mid-orb
1358 1359
		 * or when sending the write (less likely).
		 */
1360
		result = DID_BUS_BUSY << 16;
1361
		sbp2_conditionally_block(orb->lu);
1362 1363 1364
	}

	dma_unmap_single(device->card->device, orb->base.request_bus,
1365
			 sizeof(orb->request), DMA_TO_DEVICE);
1366

1367 1368 1369
	if (scsi_sg_count(orb->cmd) > 0)
		dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
			     scsi_sg_count(orb->cmd),
1370 1371 1372 1373
			     orb->cmd->sc_data_direction);

	if (orb->page_table_bus != 0)
		dma_unmap_single(device->card->device, orb->page_table_bus,
1374
				 sizeof(orb->page_table), DMA_TO_DEVICE);
1375

1376
	orb->cmd->result = result;
1377 1378 1379
	orb->done(orb->cmd);
}

1380 1381 1382
static int
sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
		     struct sbp2_logical_unit *lu)
1383
{
1384 1385 1386 1387 1388 1389
	struct scatterlist *sg = scsi_sglist(orb->cmd);
	int i, n;

	n = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
		       orb->cmd->sc_data_direction);
	if (n == 0)
1390
		goto fail;
1391

1392 1393
	/*
	 * Handle the special case where there is only one element in
1394 1395 1396
	 * the scatter list by converting it to an immediate block
	 * request. This is also a workaround for broken devices such
	 * as the second generation iPod which doesn't support page
1397 1398
	 * tables.
	 */
1399
	if (n == 1) {
1400 1401 1402 1403 1404 1405
		orb->request.data_descriptor.high =
			cpu_to_be32(lu->tgt->address_high);
		orb->request.data_descriptor.low  =
			cpu_to_be32(sg_dma_address(sg));
		orb->request.misc |=
			cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg)));
1406
		return 0;
1407 1408
	}

1409 1410 1411
	for_each_sg(sg, sg, n, i) {
		orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
		orb->page_table[i].low = cpu_to_be32(sg_dma_address(sg));
1412 1413
	}

1414 1415 1416
	orb->page_table_bus =
		dma_map_single(device->card->device, orb->page_table,
			       sizeof(orb->page_table), DMA_TO_DEVICE);
1417
	if (dma_mapping_error(device->card->device, orb->page_table_bus))
1418
		goto fail_page_table;
1419

1420 1421
	/*
	 * The data_descriptor pointer is the one case where we need
1422 1423 1424
	 * to fill in the node ID part of the address.  All other
	 * pointers assume that the data referenced reside on the
	 * initiator (i.e. us), but data_descriptor can refer to data
1425 1426
	 * on other nodes so we need to put our ID in descriptor.high.
	 */
1427 1428 1429
	orb->request.data_descriptor.high = cpu_to_be32(lu->tgt->address_high);
	orb->request.data_descriptor.low  = cpu_to_be32(orb->page_table_bus);
	orb->request.misc |= cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT |
1430
					 COMMAND_ORB_DATA_SIZE(n));
1431

1432 1433 1434
	return 0;

 fail_page_table:
1435 1436
	dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
		     scsi_sg_count(orb->cmd), orb->cmd->sc_data_direction);
1437 1438
 fail:
	return -ENOMEM;
1439 1440 1441 1442 1443 1444
}

/* SCSI stack integration */

static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
{
1445 1446
	struct sbp2_logical_unit *lu = cmd->device->hostdata;
	struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
1447
	struct sbp2_command_orb *orb;
1448
	int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
1449

1450 1451 1452 1453
	/*
	 * Bidirectional commands are not yet implemented, and unknown
	 * transfer direction not handled.
	 */
1454
	if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
1455
		fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
1456 1457 1458
		cmd->result = DID_ERROR << 16;
		done(cmd);
		return 0;
1459 1460
	}

1461
	orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
1462 1463
	if (orb == NULL) {
		fw_notify("failed to alloc orb\n");
1464
		return SCSI_MLQUEUE_HOST_BUSY;
1465 1466
	}

1467 1468
	/* Initialize rcode to something not RCODE_COMPLETE. */
	orb->base.rcode = -1;
1469
	kref_init(&orb->base.kref);
1470

1471
	orb->lu   = lu;
1472 1473 1474
	orb->done = done;
	orb->cmd  = cmd;

1475
	orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL);
1476
	orb->request.misc = cpu_to_be32(
1477
		COMMAND_ORB_MAX_PAYLOAD(lu->tgt->max_payload) |
1478
		COMMAND_ORB_SPEED(device->max_speed) |
1479
		COMMAND_ORB_NOTIFY);
1480 1481

	if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1482
		orb->request.misc |= cpu_to_be32(COMMAND_ORB_DIRECTION);
1483

1484 1485 1486
	generation = device->generation;
	smp_rmb();    /* sbp2_map_scatterlist looks at tgt->address_high */

1487 1488
	if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
		goto out;
1489

1490
	memcpy(orb->request.command_block, cmd->cmnd, cmd->cmd_len);
1491 1492

	orb->base.callback = complete_command_orb;
1493 1494 1495
	orb->base.request_bus =
		dma_map_single(device->card->device, &orb->request,
			       sizeof(orb->request), DMA_TO_DEVICE);
1496
	if (dma_mapping_error(device->card->device, orb->base.request_bus))
1497
		goto out;
1498

1499
	sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, generation,
1500 1501 1502
		      lu->command_block_agent_address + SBP2_ORB_POINTER);
	retval = 0;
 out:
1503
	kref_put(&orb->base.kref, free_orb);
1504
	return retval;
1505 1506
}

1507 1508
static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
{
1509
	struct sbp2_logical_unit *lu = sdev->hostdata;
1510

1511 1512 1513 1514
	/* (Re-)Adding logical units via the SCSI stack is not supported. */
	if (!lu)
		return -ENOSYS;

1515 1516
	sdev->allow_restart = 1;

1517 1518
	/* SBP-2 requires quadlet alignment of the data buffers. */
	blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
1519

1520
	if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1521
		sdev->inquiry_len = 36;
1522

1523 1524 1525
	return 0;
}

1526 1527
static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
{
1528
	struct sbp2_logical_unit *lu = sdev->hostdata;
1529

1530 1531
	sdev->use_10_for_rw = 1;

1532 1533 1534
	if (sbp2_param_exclusive_login)
		sdev->manage_start_stop = 1;

1535 1536
	if (sdev->type == TYPE_ROM)
		sdev->use_10_for_ms = 1;
1537

1538
	if (sdev->type == TYPE_DISK &&
1539
	    lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
1540
		sdev->skip_ms_page_8 = 1;
1541 1542

	if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
1543
		sdev->fix_capacity = 1;
1544

1545 1546 1547
	if (lu->tgt->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
		sdev->start_stop_pwr_cond = 1;

1548
	if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
1549
		blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
1550

1551 1552
	blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);

1553 1554 1555 1556 1557 1558 1559 1560 1561
	return 0;
}

/*
 * Called by scsi stack when something has really gone wrong.  Usually
 * called when a command has timed-out for some reason.
 */
static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
{
1562
	struct sbp2_logical_unit *lu = cmd->device->hostdata;
1563

1564
	fw_notify("%s: sbp2_scsi_abort\n", lu->tgt->bus_id);
1565 1566
	sbp2_agent_reset(lu);
	sbp2_cancel_orbs(lu);
1567 1568 1569 1570

	return SUCCESS;
}

1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
/*
 * Format of /sys/bus/scsi/devices/.../ieee1394_id:
 * u64 EUI-64 : u24 directory_ID : u16 LUN  (all printed in hexadecimal)
 *
 * This is the concatenation of target port identifier and logical unit
 * identifier as per SAM-2...SAM-4 annex A.
 */
static ssize_t
sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct scsi_device *sdev = to_scsi_device(dev);
1583
	struct sbp2_logical_unit *lu;
1584 1585 1586 1587

	if (!sdev)
		return 0;

1588
	lu = sdev->hostdata;
1589

1590 1591
	return sprintf(buf, "%016llx:%06x:%04x\n",
			(unsigned long long)lu->tgt->guid,
1592
			lu->tgt->directory_id, lu->lun);
1593 1594 1595 1596 1597 1598 1599 1600 1601
}

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

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

1602 1603 1604
static struct scsi_host_template scsi_driver_template = {
	.module			= THIS_MODULE,
	.name			= "SBP-2 IEEE-1394",
1605
	.proc_name		= sbp2_driver_name,
1606
	.queuecommand		= sbp2_scsi_queuecommand,
1607
	.slave_alloc		= sbp2_scsi_slave_alloc,
1608 1609 1610 1611 1612
	.slave_configure	= sbp2_scsi_slave_configure,
	.eh_abort_handler	= sbp2_scsi_abort,
	.this_id		= -1,
	.sg_tablesize		= SG_ALL,
	.use_clustering		= ENABLE_CLUSTERING,
1613 1614
	.cmd_per_lun		= 1,
	.can_queue		= 1,
1615
	.sdev_attrs		= sbp2_scsi_sysfs_attrs,
1616 1617 1618 1619 1620 1621 1622
};

MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
MODULE_DESCRIPTION("SCSI over IEEE1394");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);

1623 1624 1625 1626 1627
/* Provide a module alias so root-on-sbp2 initrds don't break. */
#ifndef CONFIG_IEEE1394_SBP2_MODULE
MODULE_ALIAS("sbp2");
#endif

1628 1629
static int __init sbp2_init(void)
{
1630 1631 1632 1633
	sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
	if (!sbp2_wq)
		return -ENOMEM;

1634 1635 1636 1637 1638 1639
	return driver_register(&sbp2_driver.driver);
}

static void __exit sbp2_cleanup(void)
{
	driver_unregister(&sbp2_driver.driver);
1640
	destroy_workqueue(sbp2_wq);
1641 1642 1643 1644
}

module_init(sbp2_init);
module_exit(sbp2_cleanup);