haiku.git

/*
 * Copyright 2004-2007, Haiku, Inc. All RightsReserved.
 * Copyright 2002/03, Thomas Kurschel. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */

/*!
	Device scanner.

	Scans SCSI busses for devices. Scanning is initiated by
	a SCSI device node probe (see device_mgr.c)
*/


#include "scsi_internal.h"

#include <string.h>
#include <stdlib.h>

#include <algorithm>


/*! send TUR
	result: true, if device answered
		false, if there is no device
*/
static bool
scsi_scan_send_tur(scsi_ccb *worker_req)
{
	scsi_cmd_tur *cmd = (scsi_cmd_tur *)worker_req->cdb;

	SHOW_FLOW0( 3, "" );

	memset( cmd, 0, sizeof( *cmd ));
	cmd->opcode = SCSI_OP_TEST_UNIT_READY;

	worker_req->sg_list = NULL;
	worker_req->data = NULL;
	worker_req->data_length = 0;
	worker_req->cdb_length = sizeof(*cmd);
	worker_req->timeout = 0;
	worker_req->sort = -1;
	worker_req->flags = SCSI_DIR_NONE;

	scsi_sync_io( worker_req );

	SHOW_FLOW( 3, "status=%x", worker_req->subsys_status );

	// as this command was only for syncing, we ignore almost all errors
	switch (worker_req->subsys_status) {
		case SCSI_SEL_TIMEOUT:
			// there seems to be no device around
			return false;

		default:
			return true;
	}
}


/*!	get inquiry data
	returns true on success
*/
static bool
scsi_scan_get_inquiry(scsi_ccb *worker_req, scsi_res_inquiry *new_inquiry_data)
{
	scsi_cmd_inquiry *cmd = (scsi_cmd_inquiry *)worker_req->cdb;
	scsi_device_info *device = worker_req->device;

	SHOW_FLOW0(3, "");

	// in case not whole structure gets transferred, we set remaining data to zero
	memset(new_inquiry_data, 0, sizeof(*new_inquiry_data));

	cmd->opcode = SCSI_OP_INQUIRY;
	cmd->lun = device->target_lun;
	cmd->evpd = 0;
	cmd->page_code = 0;
	cmd->allocation_length = sizeof(*new_inquiry_data);

	worker_req->sg_list = NULL;
	worker_req->data = (uchar *)new_inquiry_data;
	worker_req->data_length = sizeof(*new_inquiry_data);
	worker_req->cdb_length = 6;
	worker_req->timeout = SCSI_STD_TIMEOUT;
	worker_req->sort = -1;
	worker_req->flags = SCSI_DIR_IN;

	scsi_sync_io(worker_req);

	switch (worker_req->subsys_status) {
		case SCSI_REQ_CMP: {
			char vendor[9], product[17], rev[5];

			SHOW_FLOW0(3, "send successfully");

			// we could check transmission length here, but as we reset
			// missing bytes before, we get kind of valid data anyway (hopefully)

			strlcpy(vendor, new_inquiry_data->vendor_ident, sizeof(vendor));
			strlcpy(product, new_inquiry_data->product_ident, sizeof(product));
			strlcpy(rev, new_inquiry_data->product_rev, sizeof(rev));

			SHOW_INFO(3, "device type: %d, qualifier: %d, removable: %d, ANSI version: %d, response data format: %d\n"
				"vendor: %s, product: %s, rev: %s",
				new_inquiry_data->device_type, new_inquiry_data->device_qualifier,
				new_inquiry_data->removable_medium, new_inquiry_data->ansi_version,
				new_inquiry_data->response_data_format,
				vendor, product, rev);

			SHOW_INFO(3, "additional_length: %d", new_inquiry_data->additional_length + 4);

			// time to show standards the device conforms to;
			// unfortunately, ATAPI CD-ROM drives tend to tell that they have
			// only minimal info (36 bytes), but still they return (valid!) 96 bytes -
			// bad luck
			if (std::min((int)cmd->allocation_length,
						new_inquiry_data->additional_length + 4)
					>= (int)offsetof(scsi_res_inquiry, _res74)) {
				int i, previousStandard = -1;

				for (i = 0; i < 8; ++i) {
					int standard = B_BENDIAN_TO_HOST_INT16(
						new_inquiry_data->version_descriptor[i]);

					// omit standards reported twice
					if (standard != previousStandard && standard != 0)
						SHOW_INFO(3, "standard: %04x", standard);

					previousStandard = standard;
				}
			}

			//snooze( 1000000 );

	/*		{
				unsigned int i;

				for( i = 0; i < worker_req->data_length - worker_req->data_resid; ++i ) {
					dprintf( "%2x ", *((char *)new_inquiry_data + i) );
				}

				dprintf( "\n" );
			}*/

			return true;
		}

		default:
			return false;
	}
}


status_t
scsi_scan_lun(scsi_bus_info *bus, uchar target_id, uchar target_lun)
{
	scsi_ccb *worker_req;
	scsi_res_inquiry new_inquiry_data;
	status_t res;
	scsi_device_info *device;
	bool found;

	//snooze(1000000);

	SHOW_FLOW(3, "%d:%d:%d", bus->path_id, target_id, target_lun);

	res = scsi_force_get_device(bus, target_id, target_lun, &device);
	if (res != B_OK)
		goto err;

	//SHOW_FLOW(3, "temp_device: %d", (int)temp_device);

	worker_req = scsi_alloc_ccb(device);
	if (worker_req == NULL) {
		// there is no out-of-mem code
		res = B_NO_MEMORY;
		goto err2;
	}

	SHOW_FLOW0(3, "2");

	worker_req->flags = SCSI_DIR_IN;

	// to give controller a chance to transfer speed negotiation, we
	// send a TUR first; unfortunatily, some devices don't like TURing
	// invalid luns apart from lun 0...
	if (device->target_lun == 0) {
		if (!scsi_scan_send_tur(worker_req)) {
			// TBD: need better error code like "device not found"
			res = B_NAME_NOT_FOUND;
			goto err3;
		}
	}

	// get inquiry data to be used as identification
	// and to check whether there is a device at all
	found = scsi_scan_get_inquiry(worker_req, &new_inquiry_data)
		&& new_inquiry_data.device_qualifier == scsi_periph_qual_connected;

	// get rid of temporary device - as soon as the device is
	// registered, it can be loaded, and we don't want two data
	// structures for one device (the temporary and the official one)
	scsi_free_ccb(worker_req);
	scsi_put_forced_device(device);

	if (!found) {
		// TBD: better error code, s.a.
		return B_NAME_NOT_FOUND;
	}

	// !danger!
	// if a new device is detected on the same connection, all connections
	// to the old device are disabled;
	// scenario: you plug in a device, scan the bus, replace the device and then
	// open it; in this case, the connection seems to be to the old device, but really
	// is to the new one; if you scan the bus now, the opened connection is disabled
	// - bad luck -
	// solution 1: scan device during each scsi_init_device
	// disadvantage: it takes time and we had to submit commands during the load
	//   sequence, which could lead to deadlocks
	// solution 2: device drivers must scan devices before first use
	// disadvantage: it takes time and driver must perform a task that
	//   the bus_manager should really take care of
	res = scsi_register_device(bus, target_id, target_lun, &new_inquiry_data);
	if (res == B_NAME_IN_USE) {
		SHOW_FLOW0(3, "name in use");
		if (scsi_force_get_device(bus, target_id, target_lun, &device) != B_OK)
			return B_OK;
		// the device was already registered, let's tell our child to rescan it
		device_node *childNode = NULL;
		const device_attr attrs[] = { { NULL } };
		if (pnp->get_next_child_node(bus->node, attrs, &childNode) == B_OK) {
			pnp->rescan_node(childNode);
			pnp->put_node(childNode);
		}
		scsi_put_forced_device(device);
	}
	return B_OK;

err3:
	scsi_free_ccb(worker_req);
err2:
	scsi_put_forced_device(device);
err:
	return res;
}


status_t
scsi_scan_bus(scsi_bus_info *bus)
{
	scsi_path_inquiry inquiry;

	SHOW_FLOW0( 3, "" );

	// get ID of initiator (i.e. controller)
	uchar res = scsi_inquiry_path(bus, &inquiry);
	if (res != SCSI_REQ_CMP)
		return B_ERROR;

	uint initiator_id = inquiry.initiator_id;

	SHOW_FLOW(3, "initiator_id=%d", initiator_id);

	// tell SIM to rescan bus (needed at least by IDE translator)
	// as this function is optional for SIM, we ignore its result
	bus->interface->scan_bus(bus->sim_cookie);

	for (uint target_id = 0; target_id < bus->max_target_count; ++target_id) {
		SHOW_FLOW(3, "target: %d", target_id);

		if (target_id == initiator_id)
			continue;

		// TODO: there are a lot of devices out there that go mad if you probe
		// anything but LUN 0, so we should probably add a black-list
		// or something
		for (uint lun = 0; lun < bus->max_lun_count; ++lun) {
			SHOW_FLOW(3, "lun: %d", lun);

			status_t status = scsi_scan_lun(bus, target_id, lun);

			// if there is no device at lun 0, there's probably no device at all
			if (lun == 0 && status != B_OK)
				break;
		}
	}

	SHOW_FLOW0(3, "done");
	return B_OK;
}