PageRenderTime 110ms CodeModel.GetById 38ms app.highlight 59ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/ieee1394/sbp2.c

https://bitbucket.org/evzijst/gittest
C | 2864 lines | 1736 code | 497 blank | 631 comment | 208 complexity | b41d19ec207fb703398f1a5252443a78 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * sbp2.c - SBP-2 protocol driver for IEEE-1394
   3 *
   4 * Copyright (C) 2000 James Goodwin, Filanet Corporation (www.filanet.com)
   5 * jamesg@filanet.com (JSG)
   6 *
   7 * Copyright (C) 2003 Ben Collins <bcollins@debian.org>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2 of the License, or
  12 * (at your option) any later version.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with this program; if not, write to the Free Software Foundation,
  21 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22 */
  23
  24/*
  25 * Brief Description:
  26 *
  27 * This driver implements the Serial Bus Protocol 2 (SBP-2) over IEEE-1394
  28 * under Linux. The SBP-2 driver is implemented as an IEEE-1394 high-level
  29 * driver. It also registers as a SCSI lower-level driver in order to accept
  30 * SCSI commands for transport using SBP-2.
  31 *
  32 * You may access any attached SBP-2 storage devices as if they were SCSI
  33 * devices (e.g. mount /dev/sda1,  fdisk, mkfs, etc.).
  34 *
  35 * Current Issues:
  36 *
  37 *	- Error Handling: SCSI aborts and bus reset requests are handled somewhat
  38 *	  but the code needs additional debugging.
  39 */
  40
  41#include <linux/config.h>
  42#include <linux/kernel.h>
  43#include <linux/list.h>
  44#include <linux/string.h>
  45#include <linux/slab.h>
  46#include <linux/interrupt.h>
  47#include <linux/fs.h>
  48#include <linux/poll.h>
  49#include <linux/module.h>
  50#include <linux/moduleparam.h>
  51#include <linux/types.h>
  52#include <linux/delay.h>
  53#include <linux/sched.h>
  54#include <linux/blkdev.h>
  55#include <linux/smp_lock.h>
  56#include <linux/init.h>
  57#include <linux/pci.h>
  58
  59#include <asm/current.h>
  60#include <asm/uaccess.h>
  61#include <asm/io.h>
  62#include <asm/byteorder.h>
  63#include <asm/atomic.h>
  64#include <asm/system.h>
  65#include <asm/scatterlist.h>
  66
  67#include <scsi/scsi.h>
  68#include <scsi/scsi_cmnd.h>
  69#include <scsi/scsi_dbg.h>
  70#include <scsi/scsi_device.h>
  71#include <scsi/scsi_host.h>
  72
  73#include "csr1212.h"
  74#include "ieee1394.h"
  75#include "ieee1394_types.h"
  76#include "ieee1394_core.h"
  77#include "nodemgr.h"
  78#include "hosts.h"
  79#include "highlevel.h"
  80#include "ieee1394_transactions.h"
  81#include "sbp2.h"
  82
  83static char version[] __devinitdata =
  84	"$Rev: 1219 $ Ben Collins <bcollins@debian.org>";
  85
  86/*
  87 * Module load parameter definitions
  88 */
  89
  90/*
  91 * Change max_speed on module load if you have a bad IEEE-1394
  92 * controller that has trouble running 2KB packets at 400mb.
  93 *
  94 * NOTE: On certain OHCI parts I have seen short packets on async transmit
  95 * (probably due to PCI latency/throughput issues with the part). You can
  96 * bump down the speed if you are running into problems.
  97 */
  98static int max_speed = IEEE1394_SPEED_MAX;
  99module_param(max_speed, int, 0644);
 100MODULE_PARM_DESC(max_speed, "Force max speed (3 = 800mb, 2 = 400mb default, 1 = 200mb, 0 = 100mb)");
 101
 102/*
 103 * Set serialize_io to 1 if you'd like only one scsi command sent
 104 * down to us at a time (debugging). This might be necessary for very
 105 * badly behaved sbp2 devices.
 106 */
 107static int serialize_io = 0;
 108module_param(serialize_io, int, 0444);
 109MODULE_PARM_DESC(serialize_io, "Serialize all I/O coming down from the scsi drivers (default = 0)");
 110
 111/*
 112 * Bump up max_sectors if you'd like to support very large sized
 113 * transfers. Please note that some older sbp2 bridge chips are broken for
 114 * transfers greater or equal to 128KB.  Default is a value of 255
 115 * sectors, or just under 128KB (at 512 byte sector size). I can note that
 116 * the Oxsemi sbp2 chipsets have no problems supporting very large
 117 * transfer sizes.
 118 */
 119static int max_sectors = SBP2_MAX_SECTORS;
 120module_param(max_sectors, int, 0444);
 121MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported (default = 255)");
 122
 123/*
 124 * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
 125 * do an exclusive login, as it's generally unsafe to have two hosts
 126 * talking to a single sbp2 device at the same time (filesystem coherency,
 127 * etc.). If you're running an sbp2 device that supports multiple logins,
 128 * and you're either running read-only filesystems or some sort of special
 129 * filesystem supporting multiple hosts (one such filesystem is OpenGFS,
 130 * see opengfs.sourceforge.net for more info), then set exclusive_login
 131 * to zero. Note: The Oxsemi OXFW911 sbp2 chipset supports up to four
 132 * concurrent logins.
 133 */
 134static int exclusive_login = 1;
 135module_param(exclusive_login, int, 0644);
 136MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device (default = 1)");
 137
 138/*
 139 * SCSI inquiry hack for really badly behaved sbp2 devices. Turn this on
 140 * if your sbp2 device is not properly handling the SCSI inquiry command.
 141 * This hack makes the inquiry look more like a typical MS Windows
 142 * inquiry.
 143 *
 144 * If force_inquiry_hack=1 is required for your device to work,
 145 * please submit the logged sbp2_firmware_revision value of this device to
 146 * the linux1394-devel mailing list.
 147 */
 148static int force_inquiry_hack = 0;
 149module_param(force_inquiry_hack, int, 0444);
 150MODULE_PARM_DESC(force_inquiry_hack, "Force SCSI inquiry hack (default = 0)");
 151
 152
 153/*
 154 * Export information about protocols/devices supported by this driver.
 155 */
 156static struct ieee1394_device_id sbp2_id_table[] = {
 157	{
 158		.match_flags =IEEE1394_MATCH_SPECIFIER_ID |
 159		              IEEE1394_MATCH_VERSION,
 160		.specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
 161		.version =    SBP2_SW_VERSION_ENTRY & 0xffffff
 162	},
 163	{ }
 164};
 165
 166MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
 167
 168/*
 169 * Debug levels, configured via kernel config, or enable here.
 170 */
 171
 172/* #define CONFIG_IEEE1394_SBP2_DEBUG_ORBS */
 173/* #define CONFIG_IEEE1394_SBP2_DEBUG_DMA */
 174/* #define CONFIG_IEEE1394_SBP2_DEBUG 1 */
 175/* #define CONFIG_IEEE1394_SBP2_DEBUG 2 */
 176/* #define CONFIG_IEEE1394_SBP2_PACKET_DUMP */
 177
 178#ifdef CONFIG_IEEE1394_SBP2_DEBUG_ORBS
 179#define SBP2_ORB_DEBUG(fmt, args...)	HPSB_ERR("sbp2(%s): "fmt, __FUNCTION__, ## args)
 180static u32 global_outstanding_command_orbs = 0;
 181#define outstanding_orb_incr global_outstanding_command_orbs++
 182#define outstanding_orb_decr global_outstanding_command_orbs--
 183#else
 184#define SBP2_ORB_DEBUG(fmt, args...)
 185#define outstanding_orb_incr
 186#define outstanding_orb_decr
 187#endif
 188
 189#ifdef CONFIG_IEEE1394_SBP2_DEBUG_DMA
 190#define SBP2_DMA_ALLOC(fmt, args...) \
 191	HPSB_ERR("sbp2(%s)alloc(%d): "fmt, __FUNCTION__, \
 192		 ++global_outstanding_dmas, ## args)
 193#define SBP2_DMA_FREE(fmt, args...) \
 194	HPSB_ERR("sbp2(%s)free(%d): "fmt, __FUNCTION__, \
 195		 --global_outstanding_dmas, ## args)
 196static u32 global_outstanding_dmas = 0;
 197#else
 198#define SBP2_DMA_ALLOC(fmt, args...)
 199#define SBP2_DMA_FREE(fmt, args...)
 200#endif
 201
 202#if CONFIG_IEEE1394_SBP2_DEBUG >= 2
 203#define SBP2_DEBUG(fmt, args...)	HPSB_ERR("sbp2: "fmt, ## args)
 204#define SBP2_INFO(fmt, args...)		HPSB_ERR("sbp2: "fmt, ## args)
 205#define SBP2_NOTICE(fmt, args...)	HPSB_ERR("sbp2: "fmt, ## args)
 206#define SBP2_WARN(fmt, args...)		HPSB_ERR("sbp2: "fmt, ## args)
 207#elif CONFIG_IEEE1394_SBP2_DEBUG == 1
 208#define SBP2_DEBUG(fmt, args...)	HPSB_DEBUG("sbp2: "fmt, ## args)
 209#define SBP2_INFO(fmt, args...)		HPSB_INFO("sbp2: "fmt, ## args)
 210#define SBP2_NOTICE(fmt, args...)	HPSB_NOTICE("sbp2: "fmt, ## args)
 211#define SBP2_WARN(fmt, args...)		HPSB_WARN("sbp2: "fmt, ## args)
 212#else
 213#define SBP2_DEBUG(fmt, args...)
 214#define SBP2_INFO(fmt, args...)		HPSB_INFO("sbp2: "fmt, ## args)
 215#define SBP2_NOTICE(fmt, args...)       HPSB_NOTICE("sbp2: "fmt, ## args)
 216#define SBP2_WARN(fmt, args...)         HPSB_WARN("sbp2: "fmt, ## args)
 217#endif
 218
 219#define SBP2_ERR(fmt, args...)		HPSB_ERR("sbp2: "fmt, ## args)
 220
 221
 222/*
 223 * Globals
 224 */
 225
 226static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id,
 227					   u32 status);
 228
 229static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
 230				      u32 scsi_status, struct scsi_cmnd *SCpnt,
 231				      void (*done)(struct scsi_cmnd *));
 232
 233static struct scsi_host_template scsi_driver_template;
 234
 235static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xA, 0xB, 0xC };
 236
 237static void sbp2_host_reset(struct hpsb_host *host);
 238
 239static int sbp2_probe(struct device *dev);
 240static int sbp2_remove(struct device *dev);
 241static int sbp2_update(struct unit_directory *ud);
 242
 243static struct hpsb_highlevel sbp2_highlevel = {
 244	.name =		SBP2_DEVICE_NAME,
 245	.host_reset =	sbp2_host_reset,
 246};
 247
 248static struct hpsb_address_ops sbp2_ops = {
 249	.write = sbp2_handle_status_write
 250};
 251
 252#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 253static struct hpsb_address_ops sbp2_physdma_ops = {
 254        .read = sbp2_handle_physdma_read,
 255        .write = sbp2_handle_physdma_write,
 256};
 257#endif
 258
 259static struct hpsb_protocol_driver sbp2_driver = {
 260	.name		= "SBP2 Driver",
 261	.id_table	= sbp2_id_table,
 262	.update		= sbp2_update,
 263	.driver		= {
 264		.name		= SBP2_DEVICE_NAME,
 265		.bus		= &ieee1394_bus_type,
 266		.probe		= sbp2_probe,
 267		.remove		= sbp2_remove,
 268	},
 269};
 270
 271
 272/* List of device firmware's that require a forced 36 byte inquiry.  */
 273static u32 sbp2_broken_inquiry_list[] = {
 274	0x00002800,	/* Stefan Richter <richtest@bauwesen.tu-cottbus.de> */
 275			/* DViCO Momobay CX-1 */
 276	0x00000200	/* Andreas Plesch <plesch@fas.harvard.edu> */
 277			/* QPS Fire DVDBurner */
 278};
 279
 280#define NUM_BROKEN_INQUIRY_DEVS \
 281	(sizeof(sbp2_broken_inquiry_list)/sizeof(*sbp2_broken_inquiry_list))
 282
 283/**************************************
 284 * General utility functions
 285 **************************************/
 286
 287
 288#ifndef __BIG_ENDIAN
 289/*
 290 * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
 291 */
 292static __inline__ void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
 293{
 294	u32 *temp = buffer;
 295
 296	for (length = (length >> 2); length--; )
 297		temp[length] = be32_to_cpu(temp[length]);
 298
 299	return;
 300}
 301
 302/*
 303 * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
 304 */
 305static __inline__ void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
 306{
 307	u32 *temp = buffer;
 308
 309	for (length = (length >> 2); length--; )
 310		temp[length] = cpu_to_be32(temp[length]);
 311
 312	return;
 313}
 314#else /* BIG_ENDIAN */
 315/* Why waste the cpu cycles? */
 316#define sbp2util_be32_to_cpu_buffer(x,y)
 317#define sbp2util_cpu_to_be32_buffer(x,y)
 318#endif
 319
 320#ifdef CONFIG_IEEE1394_SBP2_PACKET_DUMP
 321/*
 322 * Debug packet dump routine. Length is in bytes.
 323 */
 324static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, u32 dump_phys_addr)
 325{
 326	int i;
 327	unsigned char *dump = buffer;
 328
 329	if (!dump || !length || !dump_name)
 330		return;
 331
 332	if (dump_phys_addr)
 333		printk("[%s, 0x%x]", dump_name, dump_phys_addr);
 334	else
 335		printk("[%s]", dump_name);
 336	for (i = 0; i < length; i++) {
 337		if (i > 0x3f) {
 338			printk("\n   ...");
 339			break;
 340		}
 341		if ((i & 0x3) == 0)
 342			printk("  ");
 343		if ((i & 0xf) == 0)
 344			printk("\n   ");
 345		printk("%02x ", (int) dump[i]);
 346	}
 347	printk("\n");
 348
 349	return;
 350}
 351#else
 352#define sbp2util_packet_dump(w,x,y,z)
 353#endif
 354
 355/*
 356 * Goofy routine that basically does a down_timeout function.
 357 */
 358static int sbp2util_down_timeout(atomic_t *done, int timeout)
 359{
 360	int i;
 361
 362	for (i = timeout; (i > 0 && atomic_read(done) == 0); i-= HZ/10) {
 363		if (msleep_interruptible(100))	/* 100ms */
 364			return(1);
 365	}
 366	return ((i > 0) ? 0:1);
 367}
 368
 369/* Free's an allocated packet */
 370static void sbp2_free_packet(struct hpsb_packet *packet)
 371{
 372	hpsb_free_tlabel(packet);
 373	hpsb_free_packet(packet);
 374}
 375
 376/* This is much like hpsb_node_write(), except it ignores the response
 377 * subaction and returns immediately. Can be used from interrupts.
 378 */
 379static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
 380				quadlet_t *buffer, size_t length)
 381{
 382	struct hpsb_packet *packet;
 383
 384	packet = hpsb_make_writepacket(ne->host, ne->nodeid,
 385				       addr, buffer, length);
 386        if (!packet)
 387                return -ENOMEM;
 388
 389	hpsb_set_packet_complete_task(packet, (void (*)(void*))sbp2_free_packet,
 390				      packet);
 391
 392	hpsb_node_fill_packet(ne, packet);
 393
 394        if (hpsb_send_packet(packet) < 0) {
 395		sbp2_free_packet(packet);
 396		return -EIO;
 397	}
 398
 399	return 0;
 400}
 401
 402/*
 403 * This function is called to create a pool of command orbs used for
 404 * command processing. It is called when a new sbp2 device is detected.
 405 */
 406static int sbp2util_create_command_orb_pool(struct scsi_id_instance_data *scsi_id)
 407{
 408	struct sbp2scsi_host_info *hi = scsi_id->hi;
 409	int i;
 410	unsigned long flags, orbs;
 411	struct sbp2_command_info *command;
 412
 413	orbs = serialize_io ? 2 : SBP2_MAX_CMDS;
 414
 415	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 416	for (i = 0; i < orbs; i++) {
 417		command = (struct sbp2_command_info *)
 418		    kmalloc(sizeof(struct sbp2_command_info), GFP_ATOMIC);
 419		if (!command) {
 420			spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 421			return(-ENOMEM);
 422		}
 423		memset(command, '\0', sizeof(struct sbp2_command_info));
 424		command->command_orb_dma =
 425			pci_map_single (hi->host->pdev, &command->command_orb,
 426					sizeof(struct sbp2_command_orb),
 427					PCI_DMA_BIDIRECTIONAL);
 428		SBP2_DMA_ALLOC("single command orb DMA");
 429		command->sge_dma =
 430			pci_map_single (hi->host->pdev, &command->scatter_gather_element,
 431					sizeof(command->scatter_gather_element),
 432					PCI_DMA_BIDIRECTIONAL);
 433		SBP2_DMA_ALLOC("scatter_gather_element");
 434		INIT_LIST_HEAD(&command->list);
 435		list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed);
 436	}
 437	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 438	return 0;
 439}
 440
 441/*
 442 * This function is called to delete a pool of command orbs.
 443 */
 444static void sbp2util_remove_command_orb_pool(struct scsi_id_instance_data *scsi_id)
 445{
 446	struct hpsb_host *host = scsi_id->hi->host;
 447	struct list_head *lh, *next;
 448	struct sbp2_command_info *command;
 449	unsigned long flags;
 450
 451	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 452	if (!list_empty(&scsi_id->sbp2_command_orb_completed)) {
 453		list_for_each_safe(lh, next, &scsi_id->sbp2_command_orb_completed) {
 454			command = list_entry(lh, struct sbp2_command_info, list);
 455
 456			/* Release our generic DMA's */
 457			pci_unmap_single(host->pdev, command->command_orb_dma,
 458					 sizeof(struct sbp2_command_orb),
 459					 PCI_DMA_BIDIRECTIONAL);
 460			SBP2_DMA_FREE("single command orb DMA");
 461			pci_unmap_single(host->pdev, command->sge_dma,
 462					 sizeof(command->scatter_gather_element),
 463					 PCI_DMA_BIDIRECTIONAL);
 464			SBP2_DMA_FREE("scatter_gather_element");
 465
 466			kfree(command);
 467		}
 468	}
 469	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 470	return;
 471}
 472
 473/*
 474 * This function finds the sbp2_command for a given outstanding command
 475 * orb.Only looks at the inuse list.
 476 */
 477static struct sbp2_command_info *sbp2util_find_command_for_orb(
 478		struct scsi_id_instance_data *scsi_id, dma_addr_t orb)
 479{
 480	struct sbp2_command_info *command;
 481	unsigned long flags;
 482
 483	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 484	if (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
 485		list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
 486			if (command->command_orb_dma == orb) {
 487				spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 488				return (command);
 489			}
 490		}
 491	}
 492	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 493
 494	SBP2_ORB_DEBUG("could not match command orb %x", (unsigned int)orb);
 495
 496	return(NULL);
 497}
 498
 499/*
 500 * This function finds the sbp2_command for a given outstanding SCpnt.
 501 * Only looks at the inuse list.
 502 */
 503static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(struct scsi_id_instance_data *scsi_id, void *SCpnt)
 504{
 505	struct sbp2_command_info *command;
 506	unsigned long flags;
 507
 508	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 509	if (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
 510		list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
 511			if (command->Current_SCpnt == SCpnt) {
 512				spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 513				return (command);
 514			}
 515		}
 516	}
 517	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 518	return(NULL);
 519}
 520
 521/*
 522 * This function allocates a command orb used to send a scsi command.
 523 */
 524static struct sbp2_command_info *sbp2util_allocate_command_orb(
 525		struct scsi_id_instance_data *scsi_id,
 526		struct scsi_cmnd *Current_SCpnt,
 527		void (*Current_done)(struct scsi_cmnd *))
 528{
 529	struct list_head *lh;
 530	struct sbp2_command_info *command = NULL;
 531	unsigned long flags;
 532
 533	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 534	if (!list_empty(&scsi_id->sbp2_command_orb_completed)) {
 535		lh = scsi_id->sbp2_command_orb_completed.next;
 536		list_del(lh);
 537		command = list_entry(lh, struct sbp2_command_info, list);
 538		command->Current_done = Current_done;
 539		command->Current_SCpnt = Current_SCpnt;
 540		list_add_tail(&command->list, &scsi_id->sbp2_command_orb_inuse);
 541	} else {
 542		SBP2_ERR("sbp2util_allocate_command_orb - No orbs available!");
 543	}
 544	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 545	return (command);
 546}
 547
 548/* Free our DMA's */
 549static void sbp2util_free_command_dma(struct sbp2_command_info *command)
 550{
 551	struct scsi_id_instance_data *scsi_id =
 552		(struct scsi_id_instance_data *)command->Current_SCpnt->device->host->hostdata[0];
 553	struct hpsb_host *host;
 554
 555	if (!scsi_id) {
 556		printk(KERN_ERR "%s: scsi_id == NULL\n", __FUNCTION__);
 557		return;
 558	}
 559
 560	host = scsi_id->ud->ne->host;
 561
 562	if (command->cmd_dma) {
 563		if (command->dma_type == CMD_DMA_SINGLE) {
 564			pci_unmap_single(host->pdev, command->cmd_dma,
 565					 command->dma_size, command->dma_dir);
 566			SBP2_DMA_FREE("single bulk");
 567		} else if (command->dma_type == CMD_DMA_PAGE) {
 568			pci_unmap_page(host->pdev, command->cmd_dma,
 569				       command->dma_size, command->dma_dir);
 570			SBP2_DMA_FREE("single page");
 571		} /* XXX: Check for CMD_DMA_NONE bug */
 572		command->dma_type = CMD_DMA_NONE;
 573		command->cmd_dma = 0;
 574	}
 575
 576	if (command->sge_buffer) {
 577		pci_unmap_sg(host->pdev, command->sge_buffer,
 578			     command->dma_size, command->dma_dir);
 579		SBP2_DMA_FREE("scatter list");
 580		command->sge_buffer = NULL;
 581	}
 582}
 583
 584/*
 585 * This function moves a command to the completed orb list.
 586 */
 587static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id, struct sbp2_command_info *command)
 588{
 589	unsigned long flags;
 590
 591	spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
 592	list_del(&command->list);
 593	sbp2util_free_command_dma(command);
 594	list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed);
 595	spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
 596}
 597
 598
 599
 600/*********************************************
 601 * IEEE-1394 core driver stack related section
 602 *********************************************/
 603static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud);
 604
 605static int sbp2_probe(struct device *dev)
 606{
 607	struct unit_directory *ud;
 608	struct scsi_id_instance_data *scsi_id;
 609
 610	SBP2_DEBUG("sbp2_probe");
 611
 612	ud = container_of(dev, struct unit_directory, device);
 613
 614	/* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
 615	 * instead. */
 616	if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
 617		return -ENODEV;
 618
 619        scsi_id = sbp2_alloc_device(ud);
 620
 621        if (!scsi_id)
 622                return -ENOMEM;
 623
 624        sbp2_parse_unit_directory(scsi_id, ud);
 625
 626        return sbp2_start_device(scsi_id);
 627}
 628
 629static int sbp2_remove(struct device *dev)
 630{
 631	struct unit_directory *ud;
 632	struct scsi_id_instance_data *scsi_id;
 633
 634	SBP2_DEBUG("sbp2_remove");
 635
 636	ud = container_of(dev, struct unit_directory, device);
 637	scsi_id = ud->device.driver_data;
 638
 639	sbp2_logout_device(scsi_id);
 640	sbp2_remove_device(scsi_id);
 641
 642	return 0;
 643}
 644
 645static int sbp2_update(struct unit_directory *ud)
 646{
 647	struct scsi_id_instance_data *scsi_id = ud->device.driver_data;
 648
 649	SBP2_DEBUG("sbp2_update");
 650
 651	if (sbp2_reconnect_device(scsi_id)) {
 652
 653		/*
 654		 * Ok, reconnect has failed. Perhaps we didn't
 655		 * reconnect fast enough. Try doing a regular login, but
 656		 * first do a logout just in case of any weirdness.
 657		 */
 658		sbp2_logout_device(scsi_id);
 659
 660		if (sbp2_login_device(scsi_id)) {
 661			/* Login failed too, just fail, and the backend
 662			 * will call our sbp2_remove for us */
 663			SBP2_ERR("Failed to reconnect to sbp2 device!");
 664			return -EBUSY;
 665		}
 666	}
 667
 668	/* Set max retries to something large on the device. */
 669	sbp2_set_busy_timeout(scsi_id);
 670
 671	/* Do a SBP-2 fetch agent reset. */
 672	sbp2_agent_reset(scsi_id, 1);
 673
 674	/* Get the max speed and packet size that we can use. */
 675	sbp2_max_speed_and_size(scsi_id);
 676
 677	/* Complete any pending commands with busy (so they get
 678	 * retried) and remove them from our queue
 679	 */
 680	sbp2scsi_complete_all_commands(scsi_id, DID_BUS_BUSY);
 681
 682	/* Make sure we unblock requests (since this is likely after a bus
 683	 * reset). */
 684	scsi_unblock_requests(scsi_id->scsi_host);
 685
 686	return 0;
 687}
 688
 689/* This functions is called by the sbp2_probe, for each new device. We now
 690 * allocate one scsi host for each scsi_id (unit directory). */
 691static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud)
 692{
 693	struct sbp2scsi_host_info *hi;
 694	struct Scsi_Host *scsi_host = NULL;
 695	struct scsi_id_instance_data *scsi_id = NULL;
 696
 697	SBP2_DEBUG("sbp2_alloc_device");
 698
 699	scsi_id = kmalloc(sizeof(*scsi_id), GFP_KERNEL);
 700	if (!scsi_id) {
 701		SBP2_ERR("failed to create scsi_id");
 702		goto failed_alloc;
 703	}
 704	memset(scsi_id, 0, sizeof(*scsi_id));
 705
 706	scsi_id->ne = ud->ne;
 707	scsi_id->ud = ud;
 708	scsi_id->speed_code = IEEE1394_SPEED_100;
 709	scsi_id->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
 710	atomic_set(&scsi_id->sbp2_login_complete, 0);
 711	INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_inuse);
 712	INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_completed);
 713	INIT_LIST_HEAD(&scsi_id->scsi_list);
 714	spin_lock_init(&scsi_id->sbp2_command_orb_lock);
 715	scsi_id->sbp2_device_type_and_lun = SBP2_DEVICE_TYPE_LUN_UNINITIALIZED;
 716
 717	ud->device.driver_data = scsi_id;
 718
 719	hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
 720	if (!hi) {
 721		hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host, sizeof(*hi));
 722		if (!hi) {
 723			SBP2_ERR("failed to allocate hostinfo");
 724			goto failed_alloc;
 725		}
 726		SBP2_DEBUG("sbp2_alloc_device: allocated hostinfo");
 727		hi->host = ud->ne->host;
 728		INIT_LIST_HEAD(&hi->scsi_ids);
 729
 730		/* Register our sbp2 status address space... */
 731		hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host, &sbp2_ops,
 732					SBP2_STATUS_FIFO_ADDRESS,
 733					SBP2_STATUS_FIFO_ADDRESS +
 734					SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(SBP2_MAX_UDS_PER_NODE+1));
 735#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
 736		/* Handle data movement if physical dma is not
 737		 * enabled/supportedon host controller */
 738		hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host, &sbp2_physdma_ops,
 739					0x0ULL, 0xfffffffcULL);
 740#endif
 741	}
 742
 743	scsi_id->hi = hi;
 744
 745	list_add_tail(&scsi_id->scsi_list, &hi->scsi_ids);
 746
 747	/* Register our host with the SCSI stack. */
 748	scsi_host = scsi_host_alloc(&scsi_driver_template, 0);
 749	if (!scsi_host) {
 750		SBP2_ERR("failed to register scsi host");
 751		goto failed_alloc;
 752	}
 753
 754	scsi_host->hostdata[0] = (unsigned long)scsi_id;
 755
 756	if (!scsi_add_host(scsi_host, &ud->device)) {
 757		scsi_id->scsi_host = scsi_host;
 758		return scsi_id;
 759	}
 760
 761	SBP2_ERR("failed to add scsi host");
 762	scsi_host_put(scsi_host);
 763
 764failed_alloc:
 765	sbp2_remove_device(scsi_id);
 766	return NULL;
 767}
 768
 769
 770static void sbp2_host_reset(struct hpsb_host *host)
 771{
 772	struct sbp2scsi_host_info *hi;
 773	struct scsi_id_instance_data *scsi_id;
 774
 775	hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
 776
 777	if (hi) {
 778		list_for_each_entry(scsi_id, &hi->scsi_ids, scsi_list)
 779			scsi_block_requests(scsi_id->scsi_host);
 780	}
 781}
 782
 783
 784/*
 785 * This function is where we first pull the node unique ids, and then
 786 * allocate memory and register a SBP-2 device.
 787 */
 788static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
 789{
 790	struct sbp2scsi_host_info *hi = scsi_id->hi;
 791	struct scsi_device *sdev;
 792
 793	SBP2_DEBUG("sbp2_start_device");
 794
 795	/* Login FIFO DMA */
 796	scsi_id->login_response =
 797		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_response),
 798				     &scsi_id->login_response_dma);
 799	if (!scsi_id->login_response)
 800		goto alloc_fail;
 801	SBP2_DMA_ALLOC("consistent DMA region for login FIFO");
 802
 803	/* Query logins ORB DMA */
 804	scsi_id->query_logins_orb =
 805		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_orb),
 806				     &scsi_id->query_logins_orb_dma);
 807	if (!scsi_id->query_logins_orb)
 808		goto alloc_fail;
 809	SBP2_DMA_ALLOC("consistent DMA region for query logins ORB");
 810
 811	/* Query logins response DMA */
 812	scsi_id->query_logins_response =
 813		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_response),
 814				     &scsi_id->query_logins_response_dma);
 815	if (!scsi_id->query_logins_response)
 816		goto alloc_fail;
 817	SBP2_DMA_ALLOC("consistent DMA region for query logins response");
 818
 819	/* Reconnect ORB DMA */
 820	scsi_id->reconnect_orb =
 821		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_reconnect_orb),
 822				     &scsi_id->reconnect_orb_dma);
 823	if (!scsi_id->reconnect_orb)
 824		goto alloc_fail;
 825	SBP2_DMA_ALLOC("consistent DMA region for reconnect ORB");
 826
 827	/* Logout ORB DMA */
 828	scsi_id->logout_orb =
 829		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_logout_orb),
 830				     &scsi_id->logout_orb_dma);
 831	if (!scsi_id->logout_orb)
 832		goto alloc_fail;
 833	SBP2_DMA_ALLOC("consistent DMA region for logout ORB");
 834
 835	/* Login ORB DMA */
 836	scsi_id->login_orb =
 837		pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_orb),
 838				     &scsi_id->login_orb_dma);
 839	if (!scsi_id->login_orb) {
 840alloc_fail:
 841		if (scsi_id->query_logins_response) {
 842			pci_free_consistent(hi->host->pdev,
 843					    sizeof(struct sbp2_query_logins_response),
 844					    scsi_id->query_logins_response,
 845					    scsi_id->query_logins_response_dma);
 846			SBP2_DMA_FREE("query logins response DMA");
 847		}
 848
 849		if (scsi_id->query_logins_orb) {
 850			pci_free_consistent(hi->host->pdev,
 851					    sizeof(struct sbp2_query_logins_orb),
 852					    scsi_id->query_logins_orb,
 853					    scsi_id->query_logins_orb_dma);
 854			SBP2_DMA_FREE("query logins ORB DMA");
 855		}
 856
 857		if (scsi_id->logout_orb) {
 858			pci_free_consistent(hi->host->pdev,
 859					sizeof(struct sbp2_logout_orb),
 860					scsi_id->logout_orb,
 861					scsi_id->logout_orb_dma);
 862			SBP2_DMA_FREE("logout ORB DMA");
 863		}
 864
 865		if (scsi_id->reconnect_orb) {
 866			pci_free_consistent(hi->host->pdev,
 867					sizeof(struct sbp2_reconnect_orb),
 868					scsi_id->reconnect_orb,
 869					scsi_id->reconnect_orb_dma);
 870			SBP2_DMA_FREE("reconnect ORB DMA");
 871		}
 872
 873		if (scsi_id->login_response) {
 874			pci_free_consistent(hi->host->pdev,
 875					sizeof(struct sbp2_login_response),
 876					scsi_id->login_response,
 877					scsi_id->login_response_dma);
 878			SBP2_DMA_FREE("login FIFO DMA");
 879		}
 880
 881		list_del(&scsi_id->scsi_list);
 882
 883		kfree(scsi_id);
 884
 885		SBP2_ERR ("Could not allocate memory for scsi_id");
 886
 887		return -ENOMEM;
 888	}
 889	SBP2_DMA_ALLOC("consistent DMA region for login ORB");
 890
 891	SBP2_DEBUG("New SBP-2 device inserted, SCSI ID = %x", scsi_id->ud->id);
 892
 893	/*
 894	 * Create our command orb pool
 895	 */
 896	if (sbp2util_create_command_orb_pool(scsi_id)) {
 897		SBP2_ERR("sbp2util_create_command_orb_pool failed!");
 898		sbp2_remove_device(scsi_id);
 899		return -ENOMEM;
 900	}
 901
 902	/* Schedule a timeout here. The reason is that we may be so close
 903	 * to a bus reset, that the device is not available for logins.
 904	 * This can happen when the bus reset is caused by the host
 905	 * connected to the sbp2 device being removed. That host would
 906	 * have a certain amount of time to relogin before the sbp2 device
 907	 * allows someone else to login instead. One second makes sense. */
 908	msleep_interruptible(1000);
 909	if (signal_pending(current)) {
 910		SBP2_WARN("aborting sbp2_start_device due to event");
 911		sbp2_remove_device(scsi_id);
 912		return -EINTR;
 913	}
 914	
 915	/*
 916	 * Login to the sbp-2 device
 917	 */
 918	if (sbp2_login_device(scsi_id)) {
 919		/* Login failed, just remove the device. */
 920		sbp2_remove_device(scsi_id);
 921		return -EBUSY;
 922	}
 923
 924	/*
 925	 * Set max retries to something large on the device
 926	 */
 927	sbp2_set_busy_timeout(scsi_id);
 928
 929	/*
 930	 * Do a SBP-2 fetch agent reset
 931	 */
 932	sbp2_agent_reset(scsi_id, 1);
 933
 934	/*
 935	 * Get the max speed and packet size that we can use
 936	 */
 937	sbp2_max_speed_and_size(scsi_id);
 938
 939	/* Add this device to the scsi layer now */
 940	sdev = scsi_add_device(scsi_id->scsi_host, 0, scsi_id->ud->id, 0);
 941	if (IS_ERR(sdev)) {
 942		SBP2_ERR("scsi_add_device failed");
 943		return PTR_ERR(sdev);
 944	}
 945
 946	return 0;
 947}
 948
 949/*
 950 * This function removes an sbp2 device from the sbp2scsi_host_info struct.
 951 */
 952static void sbp2_remove_device(struct scsi_id_instance_data *scsi_id)
 953{
 954	struct sbp2scsi_host_info *hi;
 955
 956	SBP2_DEBUG("sbp2_remove_device");
 957
 958	if (!scsi_id)
 959		return;
 960
 961	hi = scsi_id->hi;
 962
 963	/* This will remove our scsi device aswell */
 964	if (scsi_id->scsi_host) {
 965		scsi_remove_host(scsi_id->scsi_host);
 966		scsi_host_put(scsi_id->scsi_host);
 967	}
 968
 969	sbp2util_remove_command_orb_pool(scsi_id);
 970
 971	list_del(&scsi_id->scsi_list);
 972
 973	if (scsi_id->login_response) {
 974		pci_free_consistent(hi->host->pdev,
 975				    sizeof(struct sbp2_login_response),
 976				    scsi_id->login_response,
 977				    scsi_id->login_response_dma);
 978		SBP2_DMA_FREE("single login FIFO");
 979	}
 980
 981	if (scsi_id->login_orb) {
 982		pci_free_consistent(hi->host->pdev,
 983				    sizeof(struct sbp2_login_orb),
 984				    scsi_id->login_orb,
 985				    scsi_id->login_orb_dma);
 986		SBP2_DMA_FREE("single login ORB");
 987	}
 988
 989	if (scsi_id->reconnect_orb) {
 990		pci_free_consistent(hi->host->pdev,
 991				    sizeof(struct sbp2_reconnect_orb),
 992				    scsi_id->reconnect_orb,
 993				    scsi_id->reconnect_orb_dma);
 994		SBP2_DMA_FREE("single reconnect orb");
 995	}
 996
 997	if (scsi_id->logout_orb) {
 998		pci_free_consistent(hi->host->pdev,
 999				    sizeof(struct sbp2_logout_orb),
1000				    scsi_id->logout_orb,
1001				    scsi_id->logout_orb_dma);
1002		SBP2_DMA_FREE("single logout orb");
1003	}
1004
1005	if (scsi_id->query_logins_orb) {
1006		pci_free_consistent(hi->host->pdev,
1007				    sizeof(struct sbp2_query_logins_orb),
1008				    scsi_id->query_logins_orb,
1009				    scsi_id->query_logins_orb_dma);
1010		SBP2_DMA_FREE("single query logins orb");
1011	}
1012
1013	if (scsi_id->query_logins_response) {
1014		pci_free_consistent(hi->host->pdev,
1015				    sizeof(struct sbp2_query_logins_response),
1016				    scsi_id->query_logins_response,
1017				    scsi_id->query_logins_response_dma);
1018		SBP2_DMA_FREE("single query logins data");
1019	}
1020
1021	scsi_id->ud->device.driver_data = NULL;
1022
1023	SBP2_DEBUG("SBP-2 device removed, SCSI ID = %d", scsi_id->ud->id);
1024
1025	kfree(scsi_id);
1026}
1027
1028#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
1029/*
1030 * This function deals with physical dma write requests (for adapters that do not support
1031 * physical dma in hardware). Mostly just here for debugging...
1032 */
1033static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t *data,
1034                                     u64 addr, size_t length, u16 flags)
1035{
1036
1037        /*
1038         * Manually put the data in the right place.
1039         */
1040        memcpy(bus_to_virt((u32)addr), data, length);
1041	sbp2util_packet_dump(data, length, "sbp2 phys dma write by device", (u32)addr);
1042        return(RCODE_COMPLETE);
1043}
1044
1045/*
1046 * This function deals with physical dma read requests (for adapters that do not support
1047 * physical dma in hardware). Mostly just here for debugging...
1048 */
1049static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid, quadlet_t *data,
1050                                    u64 addr, size_t length, u16 flags)
1051{
1052
1053        /*
1054         * Grab data from memory and send a read response.
1055         */
1056        memcpy(data, bus_to_virt((u32)addr), length);
1057	sbp2util_packet_dump(data, length, "sbp2 phys dma read by device", (u32)addr);
1058        return(RCODE_COMPLETE);
1059}
1060#endif
1061
1062
1063/**************************************
1064 * SBP-2 protocol related section
1065 **************************************/
1066
1067/*
1068 * This function determines if we should convert scsi commands for a particular sbp2 device type
1069 */
1070static __inline__ int sbp2_command_conversion_device_type(u8 device_type)
1071{
1072	return (((device_type == TYPE_DISK) ||
1073		 (device_type == TYPE_SDAD) ||
1074		 (device_type == TYPE_ROM)) ? 1:0);
1075}
1076
1077/*
1078 * This function queries the device for the maximum concurrent logins it
1079 * supports.
1080 */
1081static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
1082{
1083	struct sbp2scsi_host_info *hi = scsi_id->hi;
1084	quadlet_t data[2];
1085	int max_logins;
1086	int active_logins;
1087
1088	SBP2_DEBUG("sbp2_query_logins");
1089
1090	scsi_id->query_logins_orb->reserved1 = 0x0;
1091	scsi_id->query_logins_orb->reserved2 = 0x0;
1092
1093	scsi_id->query_logins_orb->query_response_lo = scsi_id->query_logins_response_dma;
1094	scsi_id->query_logins_orb->query_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1095	SBP2_DEBUG("sbp2_query_logins: query_response_hi/lo initialized");
1096
1097	scsi_id->query_logins_orb->lun_misc = ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
1098	scsi_id->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
1099	if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) {
1100		scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun);
1101		SBP2_DEBUG("sbp2_query_logins: set lun to %d",
1102			   ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun));
1103	}
1104	SBP2_DEBUG("sbp2_query_logins: lun_misc initialized");
1105
1106	scsi_id->query_logins_orb->reserved_resp_length =
1107		ORB_SET_QUERY_LOGINS_RESP_LENGTH(sizeof(struct sbp2_query_logins_response));
1108	SBP2_DEBUG("sbp2_query_logins: reserved_resp_length initialized");
1109
1110	scsi_id->query_logins_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1111						    SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1112	scsi_id->query_logins_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1113						     SBP2_STATUS_FIFO_ADDRESS_HI);
1114	SBP2_DEBUG("sbp2_query_logins: status FIFO initialized");
1115
1116	sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_orb, sizeof(struct sbp2_query_logins_orb));
1117
1118	SBP2_DEBUG("sbp2_query_logins: orb byte-swapped");
1119
1120	sbp2util_packet_dump(scsi_id->query_logins_orb, sizeof(struct sbp2_query_logins_orb),
1121			     "sbp2 query logins orb", scsi_id->query_logins_orb_dma);
1122
1123	memset(scsi_id->query_logins_response, 0, sizeof(struct sbp2_query_logins_response));
1124	memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1125
1126	SBP2_DEBUG("sbp2_query_logins: query_logins_response/status FIFO memset");
1127
1128	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1129	data[1] = scsi_id->query_logins_orb_dma;
1130	sbp2util_cpu_to_be32_buffer(data, 8);
1131
1132	atomic_set(&scsi_id->sbp2_login_complete, 0);
1133
1134	SBP2_DEBUG("sbp2_query_logins: prepared to write");
1135	hpsb_node_write(scsi_id->ne, scsi_id->sbp2_management_agent_addr, data, 8);
1136	SBP2_DEBUG("sbp2_query_logins: written");
1137
1138	if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 2*HZ)) {
1139		SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1140		return(-EIO);
1141	}
1142
1143	if (scsi_id->status_block.ORB_offset_lo != scsi_id->query_logins_orb_dma) {
1144		SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1145		return(-EIO);
1146	}
1147
1148	if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1149	    STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1150	    STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1151
1152		SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1153		return(-EIO);
1154	}
1155
1156	sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_response, sizeof(struct sbp2_query_logins_response));
1157
1158	SBP2_DEBUG("length_max_logins = %x",
1159		   (unsigned int)scsi_id->query_logins_response->length_max_logins);
1160
1161	SBP2_DEBUG("Query logins to SBP-2 device successful");
1162
1163	max_logins = RESPONSE_GET_MAX_LOGINS(scsi_id->query_logins_response->length_max_logins);
1164	SBP2_DEBUG("Maximum concurrent logins supported: %d", max_logins);
1165
1166	active_logins = RESPONSE_GET_ACTIVE_LOGINS(scsi_id->query_logins_response->length_max_logins);
1167	SBP2_DEBUG("Number of active logins: %d", active_logins);
1168
1169	if (active_logins >= max_logins) {
1170		return(-EIO);
1171	}
1172
1173	return 0;
1174}
1175
1176/*
1177 * This function is called in order to login to a particular SBP-2 device,
1178 * after a bus reset.
1179 */
1180static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
1181{
1182	struct sbp2scsi_host_info *hi = scsi_id->hi;
1183	quadlet_t data[2];
1184
1185	SBP2_DEBUG("sbp2_login_device");
1186
1187	if (!scsi_id->login_orb) {
1188		SBP2_DEBUG("sbp2_login_device: login_orb not alloc'd!");
1189		return(-EIO);
1190	}
1191
1192	if (!exclusive_login) {
1193		if (sbp2_query_logins(scsi_id)) {
1194			SBP2_INFO("Device does not support any more concurrent logins");
1195			return(-EIO);
1196		}
1197	}
1198
1199	/* Set-up login ORB, assume no password */
1200	scsi_id->login_orb->password_hi = 0;
1201	scsi_id->login_orb->password_lo = 0;
1202	SBP2_DEBUG("sbp2_login_device: password_hi/lo initialized");
1203
1204	scsi_id->login_orb->login_response_lo = scsi_id->login_response_dma;
1205	scsi_id->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1206	SBP2_DEBUG("sbp2_login_device: login_response_hi/lo initialized");
1207
1208	scsi_id->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
1209	scsi_id->login_orb->lun_misc |= ORB_SET_RECONNECT(0);	/* One second reconnect time */
1210	scsi_id->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(exclusive_login);	/* Exclusive access to device */
1211	scsi_id->login_orb->lun_misc |= ORB_SET_NOTIFY(1);	/* Notify us of login complete */
1212	/* Set the lun if we were able to pull it from the device's unit directory */
1213	if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) {
1214		scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun);
1215		SBP2_DEBUG("sbp2_query_logins: set lun to %d",
1216			   ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun));
1217	}
1218	SBP2_DEBUG("sbp2_login_device: lun_misc initialized");
1219
1220	scsi_id->login_orb->passwd_resp_lengths =
1221		ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
1222	SBP2_DEBUG("sbp2_login_device: passwd_resp_lengths initialized");
1223
1224	scsi_id->login_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1225					     SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1226	scsi_id->login_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1227					      SBP2_STATUS_FIFO_ADDRESS_HI);
1228	SBP2_DEBUG("sbp2_login_device: status FIFO initialized");
1229
1230	/*
1231	 * Byte swap ORB if necessary
1232	 */
1233	sbp2util_cpu_to_be32_buffer(scsi_id->login_orb, sizeof(struct sbp2_login_orb));
1234
1235	SBP2_DEBUG("sbp2_login_device: orb byte-swapped");
1236
1237	sbp2util_packet_dump(scsi_id->login_orb, sizeof(struct sbp2_login_orb),
1238			     "sbp2 login orb", scsi_id->login_orb_dma);
1239
1240	/*
1241	 * Initialize login response and status fifo
1242	 */
1243	memset(scsi_id->login_response, 0, sizeof(struct sbp2_login_response));
1244	memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1245
1246	SBP2_DEBUG("sbp2_login_device: login_response/status FIFO memset");
1247
1248	/*
1249	 * Ok, let's write to the target's management agent register
1250	 */
1251	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1252	data[1] = scsi_id->login_orb_dma;
1253	sbp2util_cpu_to_be32_buffer(data, 8);
1254
1255	atomic_set(&scsi_id->sbp2_login_complete, 0);
1256
1257	SBP2_DEBUG("sbp2_login_device: prepared to write to %08x",
1258		   (unsigned int)scsi_id->sbp2_management_agent_addr);
1259	hpsb_node_write(scsi_id->ne, scsi_id->sbp2_management_agent_addr, data, 8);
1260	SBP2_DEBUG("sbp2_login_device: written");
1261
1262	/*
1263	 * Wait for login status (up to 20 seconds)...
1264	 */
1265	if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 20*HZ)) {
1266		SBP2_ERR("Error logging into SBP-2 device - login timed-out");
1267		return(-EIO);
1268	}
1269
1270	/*
1271	 * Sanity. Make sure status returned matches login orb.
1272	 */
1273	if (scsi_id->status_block.ORB_offset_lo != scsi_id->login_orb_dma) {
1274		SBP2_ERR("Error logging into SBP-2 device - login timed-out");
1275		return(-EIO);
1276	}
1277
1278	/*
1279	 * Check status
1280	 */
1281	if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1282	    STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1283	    STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1284
1285		SBP2_ERR("Error logging into SBP-2 device - login failed");
1286		return(-EIO);
1287	}
1288
1289	/*
1290	 * Byte swap the login response, for use when reconnecting or
1291	 * logging out.
1292	 */
1293	sbp2util_cpu_to_be32_buffer(scsi_id->login_response, sizeof(struct sbp2_login_response));
1294
1295	/*
1296	 * Grab our command block agent address from the login response.
1297	 */
1298	SBP2_DEBUG("command_block_agent_hi = %x",
1299		   (unsigned int)scsi_id->login_response->command_block_agent_hi);
1300	SBP2_DEBUG("command_block_agent_lo = %x",
1301		   (unsigned int)scsi_id->login_response->command_block_agent_lo);
1302
1303	scsi_id->sbp2_command_block_agent_addr =
1304		((u64)scsi_id->login_response->command_block_agent_hi) << 32;
1305	scsi_id->sbp2_command_block_agent_addr |= ((u64)scsi_id->login_response->command_block_agent_lo);
1306	scsi_id->sbp2_command_block_agent_addr &= 0x0000ffffffffffffULL;
1307
1308	SBP2_INFO("Logged into SBP-2 device");
1309
1310	return(0);
1311
1312}
1313
1314/*
1315 * This function is called in order to logout from a particular SBP-2
1316 * device, usually called during driver unload.
1317 */
1318static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id)
1319{
1320	struct sbp2scsi_host_info *hi = scsi_id->hi;
1321	quadlet_t data[2];
1322	int error;
1323
1324	SBP2_DEBUG("sbp2_logout_device");
1325
1326	/*
1327	 * Set-up logout ORB
1328	 */
1329	scsi_id->logout_orb->reserved1 = 0x0;
1330	scsi_id->logout_orb->reserved2 = 0x0;
1331	scsi_id->logout_orb->reserved3 = 0x0;
1332	scsi_id->logout_orb->reserved4 = 0x0;
1333
1334	scsi_id->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
1335	scsi_id->logout_orb->login_ID_misc |= ORB_SET_LOGIN_ID(scsi_id->login_response->length_login_ID);
1336
1337	/* Notify us when complete */
1338	scsi_id->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1339
1340	scsi_id->logout_orb->reserved5 = 0x0;
1341	scsi_id->logout_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1342					      SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1343	scsi_id->logout_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1344					       SBP2_STATUS_FIFO_ADDRESS_HI);
1345
1346	/*
1347	 * Byte swap ORB if necessary
1348	 */
1349	sbp2util_cpu_to_be32_buffer(scsi_id->logout_orb, sizeof(struct sbp2_logout_orb));
1350
1351	sbp2util_packet_dump(scsi_id->logout_orb, sizeof(struct sbp2_logout_orb),
1352			     "sbp2 logout orb", scsi_id->logout_orb_dma);
1353
1354	/*
1355	 * Ok, let's write to the target's management agent register
1356	 */
1357	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1358	data[1] = scsi_id->logout_orb_dma;
1359	sbp2util_cpu_to_be32_buffer(data, 8);
1360
1361	atomic_set(&scsi_id->sbp2_login_complete, 0);
1362
1363	error = hpsb_node_write(scsi_id->ne,
1364	                            scsi_id->sbp2_management_agent_addr,
1365	                            data, 8);
1366	if (error)
1367		return error;
1368
1369	/* Wait for device to logout...1 second. */
1370	if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ))
1371		return -EIO;
1372
1373	SBP2_INFO("Logged out of SBP-2 device");
1374
1375	return(0);
1376
1377}
1378
1379/*
1380 * This function is called in order to reconnect to a particular SBP-2
1381 * device, after a bus reset.
1382 */
1383static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
1384{
1385	struct sbp2scsi_host_info *hi = scsi_id->hi;
1386	quadlet_t data[2];
1387	int error;
1388
1389	SBP2_DEBUG("sbp2_reconnect_device");
1390
1391	/*
1392	 * Set-up reconnect ORB
1393	 */
1394	scsi_id->reconnect_orb->reserved1 = 0x0;
1395	scsi_id->reconnect_orb->reserved2 = 0x0;
1396	scsi_id->reconnect_orb->reserved3 = 0x0;
1397	scsi_id->reconnect_orb->reserved4 = 0x0;
1398
1399	scsi_id->reconnect_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST);
1400	scsi_id->reconnect_orb->login_ID_misc |=
1401		ORB_SET_LOGIN_ID(scsi_id->login_response->length_login_ID);
1402
1403	/* Notify us when complete */
1404	scsi_id->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1405
1406	scsi_id->reconnect_orb->reserved5 = 0x0;
1407	scsi_id->reconnect_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1408						 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1409	scsi_id->reconnect_orb->status_FIFO_hi =
1410		(ORB_SET_NODE_ID(hi->host->node_id) | SBP2_STATUS_FIFO_ADDRESS_HI);
1411
1412	/*
1413	 * Byte swap ORB if necessary
1414	 */
1415	sbp2util_cpu_to_be32_buffer(scsi_id->reconnect_orb, sizeof(struct sbp2_reconnect_orb));
1416
1417	sbp2util_packet_dump(scsi_id->reconnect_orb, sizeof(struct sbp2_reconnect_orb),
1418			     "sbp2 reconnect orb", scsi_id->reconnect_orb_dma);
1419
1420	/*
1421	 * Initialize status fifo
1422	 */
1423	memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1424
1425	/*
1426	 * Ok, let's write to the target's management agent register
1427	 */
1428	data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1429	data[1] = scsi_id->reconnect_orb_dma;
1430	sbp2util_cpu_to_be32_buffer(data, 8);
1431
1432	atomic_set(&scsi_id->sbp2_login_complete, 0);
1433
1434	error = hpsb_node_write(scsi_id->ne,
1435	                            scsi_id->sbp2_management_agent_addr,
1436	                            data, 8);
1437	if (error)
1438		return error;
1439
1440	/*
1441	 * Wait for reconnect status (up to 1 second)...
1442	 */
1443	if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ)) {
1444		SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
1445		return(-EIO);
1446	}
1447
1448	/*
1449	 * Sanity. Make sure status returned matches reconnect orb.
1450	 */
1451	if (scsi_id->status_block.ORB_offset_lo != scsi_id->reconnect_orb_dma) {
1452		SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
1453		return(-EIO);
1454	}
1455
1456	/*
1457	 * Check status
1458	 */
1459	if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1460	    STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1461	    STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1462
1463		SBP2_ERR("Error reconnecting to SBP-2 device - reconnect failed");
1464		return(-EIO);
1465	}
1466
1467	HPSB_DEBUG("Reconnected to SBP-2 device");
1468
1469	return(0);
1470
1471}
1472
1473/*
1474 * This function is called in order to set the busy timeout (number of
1475 * retries to attempt) on the sbp2 device.
1476 */
1477static int sbp2_set_busy_timeout(struct scsi_id_instance_data *scsi_id)
1478{
1479	quadlet_t data;
1480
1481	SBP2_DEBUG("sbp2_set_busy_timeout");
1482
1483	/*
1484	 * Ok, let's write to the target's busy timeout register
1485	 */
1486	data = cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE);
1487
1488	if (hpsb_node_write(scsi_id->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4)) {
1489		SBP2_ERR("sbp2_set_busy_timeout error");
1490	}
1491
1492	return(0);
1493}
1494
1495
1496/*
1497 * This function is called to parse sbp2 device's config rom unit
1498 * directory. Used to determine things like sbp2 management agent offset,
1499 * and command set used (SCSI or RBC).
1500 */
1501static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
1502				      struct unit_directory *ud)
1503{
1504	struct csr1212_keyval *kv;
1505	struct csr1212_dentry *dentry;
1506	u64 management_agent_addr;
1507	u32 command_set_spec_id, command_set, unit_characteristics,
1508		firmware_revision, workarounds;
1509	int i;
1510
1511	SBP2_DEBUG("sbp2_parse_unit_directory");
1512
1513	management_agent_addr = 0x0;
1514	command_set_spec_id = 0x0;
1515	command_set = 0x0;
1516	unit_characteristics = 0x0;
1517	firmware_revision = 0x0;
1518
1519	/* Handle different fields in the unit directory, based on keys */
1520	csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
1521		switch (kv->key.id) {
1522		case CSR1212_KV_ID_DEPENDENT_INFO:
1523			if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET) {
1524				/* Save off the management agent address */
1525				management_agent_addr =
1526					CSR1212_REGISTER_SPACE_BASE +
1527					(kv->value.csr_offset << 2);
1528
1529				SBP2_DEBUG("sbp2_management_agent_addr = %x",
1530					   (unsigned int) management_agent_addr);
1531			} else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
1532				scsi_id->sbp2_device_type_and_lun = kv->value.immediate;
1533			}
1534			break;
1535
1536		case SBP2_COMMAND_SET_SPEC_ID_KEY:
1537			/* Command spec organization */
1538			command_set_spec_id = kv->value.immediate;
1539			SBP2_DEBUG("sbp2_command_set_spec_id = %x",
1540				   (unsigned int) command_set_spec_id);
1541			break;
1542
1543		case SBP2_COMMAND_SET_KEY:
1544			/* Command set used by sbp2 device */
1545			command_set = kv->value.immediate;
1546			SBP2_DEBUG("sbp2_command_set = %x",
1547				   (unsigned int) command_set);
1548			break;
1549
1550		case SBP2_UNIT_CHARACTERISTICS_KEY:
1551			/*
1552			 * Unit characterisitcs (orb related stuff
1553			 * that I'm not yet paying attention to)
1554			 */
1555			unit_characteristics = kv->value.immediate;
1556			SBP2_DEBUG("sbp2_unit_characteristics = %x",
1557				   (unsigned int) unit_characteristics);
1558			break;
1559
1560		case SBP2_FIRMWARE_REVISION_KEY:
1561			/* Firmware revision */
1562			firmware_revision = kv->value.immediate;
1563			if (force_inquiry_hack)
1564				SBP2_INFO("sbp2_firmware_revision = %x",
1565				   (unsigned int) firmware_revision);
1566			else	SBP2_DEBUG("sbp2_firmware_revision = %x",
1567				   (unsigned int) firmware_revision);
1568			break;
1569
1570		default:
1571			break;
1572		}
1573	}
1574
1575	/* This is the start of our broken device checking. We try to hack
1576	 * around oddities and known defects.  */
1577	workarounds = 0x0;
1578
1579	/* If the vendor id is 0xa0b8 (Symbios vendor id), then we have a
1580	 * bridge with 128KB max transfer size limitation. For sanity, we
1581	 * only voice this when the current max_sectors setting
1582	 * exceeds the 128k limit. By default, that is not the case.
1583	 *
1584	 * It would be really nice if we could detect this before the scsi
1585	 * host gets initialized. That way we can down-force the
1586	 * max_sectors to account for it. That is not currently
1587	 * possible.  */
1588	if ((firmware_revision & 0xffff00) ==
1589			SBP2_128KB_BROKEN_FIRMWARE &&
1590			(max_sectors * 512) > (128*1024)) {
1591		SBP2_WARN("Node " NODE_BUS_FMT ": Bridge only supports 128KB max transfer size.",
1592				NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid));
1593		SBP2_WARN("WARNING: Current max_sectors setting is larger than 128KB (%d sectors)!",
1594				max_sectors);
1595		workarounds |= SBP2_BREAKAGE_128K_MAX_TRANSFER;
1596	}
1597
1598	/* Check for a blacklisted set of devices that require us to force
1599	 * a 36 byte host inquiry. This can be overriden as a module param
1600	 * (to force all hosts).  */
1601	for (i = 0; i < NUM_BROKEN_INQUIRY_DEVS; i++) {
1602		if ((firmware_revision & 0xffff00) ==
1603				sbp2_broken_inquiry_list[i]) {
1604			SBP2_WARN("Node " NODE_BUS_FMT ": Using 36byte inquiry workaround",
1605					NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid));
1606			workarounds |= SBP2_BREAKAGE_INQUIRY_HACK;
1607			break; /* No need to continue. */
1608		}
1609	}
1610
1611	/* If this is a logical unit directory entry, process the parent
1612	 * to get the values. */
1613	if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
1614		struct unit_directory *parent_ud =
1615			container_of(ud->device.parent, struct unit_directory, device);
1616		sbp2_parse_unit_directory(scsi_id, parent_ud);
1617	} else {
1618		scsi_id->sbp2_management_agent_addr = management_agent_addr;
1619		scsi_id->sbp2_command_set_spec_id = command_set_spec_id;
1620		scsi_id->sbp2_command_set = command_set;
1621		scsi_id->sbp2_unit_characteristics = unit_characteristics;
1622		scsi_id->sbp2_firmware_revision = firmware_revision;
1623		scsi_id->workarounds = workarounds;
1624		if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
1625			scsi_id->sbp2_device_type_and_lun = ud->lun;
1626	}
1627}
1628
1629/*
1630 * This function is called in order to determine th…

Large files files are truncated, but you can click here to view the full file