Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394-2.6 (ceb5eb0c) · Commits · github.com / kvm-riscv / linux

drivers/firewire/fw-card.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -232,7 +232,7 @@ fw_card_bm_work(struct work_struct *work)
		root_id = root_node->node_id;
		grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 10));

		if (card->bm_generation + 1 == generation \|\|
		if (is_next_generation(generation, card->bm_generation) \|\|
		(card->bm_generation != generation && grace)) {
		/*
		* This first step is to figure out who is IRM and
		@@ -512,7 +512,7 @@ fw_core_remove_card(struct fw_card *card)
		fw_core_initiate_bus_reset(card, 1);

		mutex_lock(&card_mutex);
		list_del(&card->link);
		list_del_init(&card->link);
		mutex_unlock(&card_mutex);

		/* Set up the dummy driver. */

drivers/firewire/fw-device.c

+101 −22

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@
		#include <linux/device.h>
		#include <linux/delay.h>
		#include <linux/idr.h>
		#include <linux/jiffies.h>
		#include <linux/string.h>
		#include <linux/rwsem.h>
		#include <linux/semaphore.h>
		@@ -634,12 +635,39 @@ struct fw_device *fw_device_get_by_devt(dev_t devt)
		return device;
		}

		/*
		* These defines control the retry behavior for reading the config
		* rom. It shouldn't be necessary to tweak these; if the device
		* doesn't respond to a config rom read within 10 seconds, it's not
		* going to respond at all. As for the initial delay, a lot of
		* devices will be able to respond within half a second after bus
		* reset. On the other hand, it's not really worth being more
		* aggressive than that, since it scales pretty well; if 10 devices
		* are plugged in, they're all getting read within one second.
		*/

		#define MAX_RETRIES 10
		#define RETRY_DELAY (3 * HZ)
		#define INITIAL_DELAY (HZ / 2)
		#define SHUTDOWN_DELAY (2 * HZ)

		static void fw_device_shutdown(struct work_struct *work)
		{
		struct fw_device *device =
		container_of(work, struct fw_device, work.work);
		int minor = MINOR(device->device.devt);

		if (time_is_after_jiffies(device->card->reset_jiffies + SHUTDOWN_DELAY)
		&& !list_empty(&device->card->link)) {
		schedule_delayed_work(&device->work, SHUTDOWN_DELAY);
		return;
		}

		if (atomic_cmpxchg(&device->state,
		FW_DEVICE_GONE,
		FW_DEVICE_SHUTDOWN) != FW_DEVICE_GONE)
		return;

		fw_device_cdev_remove(device);
		device_for_each_child(&device->device, NULL, shutdown_unit);
		device_unregister(&device->device);
		@@ -647,6 +675,7 @@ static void fw_device_shutdown(struct work_struct *work)
		down_write(&fw_device_rwsem);
		idr_remove(&fw_device_idr, minor);
		up_write(&fw_device_rwsem);

		fw_device_put(device);
		}

		@@ -654,25 +683,63 @@ static struct device_type fw_device_type = {
		.release = fw_device_release,
		};

		static void fw_device_update(struct work_struct *work);

		/*
		* These defines control the retry behavior for reading the config
		* rom. It shouldn't be necessary to tweak these; if the device
		* doesn't respond to a config rom read within 10 seconds, it's not
		* going to respond at all. As for the initial delay, a lot of
		* devices will be able to respond within half a second after bus
		* reset. On the other hand, it's not really worth being more
		* aggressive than that, since it scales pretty well; if 10 devices
		* are plugged in, they're all getting read within one second.
		* If a device was pending for deletion because its node went away but its
		* bus info block and root directory header matches that of a newly discovered
		* device, revive the existing fw_device.
		* The newly allocated fw_device becomes obsolete instead.
		*/
		static int lookup_existing_device(struct device dev, void data)
		{
		struct fw_device *old = fw_device(dev);
		struct fw_device *new = data;
		struct fw_card *card = new->card;
		int match = 0;

		down_read(&fw_device_rwsem); /* serialize config_rom access */
		spin_lock_irq(&card->lock); /* serialize node access */

		if (memcmp(old->config_rom, new->config_rom, 6 * 4) == 0 &&
		atomic_cmpxchg(&old->state,
		FW_DEVICE_GONE,
		FW_DEVICE_RUNNING) == FW_DEVICE_GONE) {
		struct fw_node *current_node = new->node;
		struct fw_node *obsolete_node = old->node;

		new->node = obsolete_node;
		new->node->data = new;
		old->node = current_node;
		old->node->data = old;

		old->max_speed = new->max_speed;
		old->node_id = current_node->node_id;
		smp_wmb(); /* update node_id before generation */
		old->generation = card->generation;
		old->config_rom_retries = 0;
		fw_notify("rediscovered device %s\n", dev_name(dev));

		#define MAX_RETRIES 10
		#define RETRY_DELAY (3 * HZ)
		#define INITIAL_DELAY (HZ / 2)
		PREPARE_DELAYED_WORK(&old->work, fw_device_update);
		schedule_delayed_work(&old->work, 0);

		if (current_node == card->root_node)
		fw_schedule_bm_work(card, 0);

		match = 1;
		}

		spin_unlock_irq(&card->lock);
		up_read(&fw_device_rwsem);

		return match;
		}

		static void fw_device_init(struct work_struct *work)
		{
		struct fw_device *device =
		container_of(work, struct fw_device, work.work);
		struct device *revived_dev;
		int minor, err;

		/*
		@@ -696,6 +763,15 @@ static void fw_device_init(struct work_struct *work)
		return;
		}

		revived_dev = device_find_child(device->card->device,
		device, lookup_existing_device);
		if (revived_dev) {
		put_device(revived_dev);
		fw_device_release(&device->device);

		return;
		}

		device_initialize(&device->device);

		fw_device_get(device);
		@@ -735,8 +811,9 @@ static void fw_device_init(struct work_struct *work)
		*/
		if (atomic_cmpxchg(&device->state,
		FW_DEVICE_INITIALIZING,
		FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN) {
		fw_device_shutdown(work);
		FW_DEVICE_RUNNING) == FW_DEVICE_GONE) {
		PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
		schedule_delayed_work(&device->work, SHUTDOWN_DELAY);
		} else {
		if (device->config_rom_retries)
		fw_notify("created device %s: GUID %08x%08x, S%d00, "
		@@ -848,7 +925,7 @@ static void fw_device_refresh(struct work_struct *work)
		case REREAD_BIB_UNCHANGED:
		if (atomic_cmpxchg(&device->state,
		FW_DEVICE_INITIALIZING,
		FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
		FW_DEVICE_RUNNING) == FW_DEVICE_GONE)
		goto gone;

		fw_device_update(work);
		@@ -880,7 +957,7 @@ static void fw_device_refresh(struct work_struct *work)

		if (atomic_cmpxchg(&device->state,
		FW_DEVICE_INITIALIZING,
		FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
		FW_DEVICE_RUNNING) == FW_DEVICE_GONE)
		goto gone;

		fw_notify("refreshed device %s\n", dev_name(&device->device));
		@@ -890,8 +967,9 @@ static void fw_device_refresh(struct work_struct *work)
		give_up:
		fw_notify("giving up on refresh of device %s\n", dev_name(&device->device));
		gone:
		atomic_set(&device->state, FW_DEVICE_SHUTDOWN);
		fw_device_shutdown(work);
		atomic_set(&device->state, FW_DEVICE_GONE);
		PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
		schedule_delayed_work(&device->work, SHUTDOWN_DELAY);
		out:
		if (node_id == card->root_node->node_id)
		fw_schedule_bm_work(card, 0);
		@@ -995,9 +1073,10 @@ void fw_node_event(struct fw_card card, struct fw_node node, int event)
		*/
		device = node->data;
		if (atomic_xchg(&device->state,
		FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {
		FW_DEVICE_GONE) == FW_DEVICE_RUNNING) {
		PREPARE_DELAYED_WORK(&device->work, fw_device_shutdown);
		schedule_delayed_work(&device->work, 0);
		schedule_delayed_work(&device->work,
		list_empty(&card->link) ? 0 : SHUTDOWN_DELAY);
		}
		break;
		}

drivers/firewire/fw-device.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@
		enum fw_device_state {
		FW_DEVICE_INITIALIZING,
		FW_DEVICE_RUNNING,
		FW_DEVICE_GONE,
		FW_DEVICE_SHUTDOWN,
		};

drivers/firewire/fw-ohci.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -226,7 +226,7 @@ static inline struct fw_ohci fw_ohci(struct fw_card card)
		#define CONTEXT_DEAD 0x0800
		#define CONTEXT_ACTIVE 0x0400

		#define OHCI1394_MAX_AT_REQ_RETRIES 0x2
		#define OHCI1394_MAX_AT_REQ_RETRIES 0xf
		#define OHCI1394_MAX_AT_RESP_RETRIES 0x2
		#define OHCI1394_MAX_PHYS_RESP_RETRIES 0x8

		@@ -896,11 +896,11 @@ static void context_stop(struct context *ctx)
		for (i = 0; i < 10; i++) {
		reg = reg_read(ctx->ohci, CONTROL_SET(ctx->regs));
		if ((reg & CONTEXT_ACTIVE) == 0)
		break;
		return;

		fw_notify("context_stop: still active (0x%08x)\n", reg);
		mdelay(1);
		}
		fw_error("Error: DMA context still active (0x%08x)\n", reg);
		}

		struct driver_data {

drivers/firewire/fw-sbp2.c

+50 −39

Original line number	Diff line number	Diff line
		@@ -168,6 +168,7 @@ struct sbp2_target {
		int address_high;
		unsigned int workarounds;
		unsigned int mgt_orb_timeout;
		unsigned int max_payload;

		int dont_block; /* counter for each logical unit */
		int blocked; /* ditto */
		@@ -310,14 +311,16 @@ struct sbp2_command_orb {
		dma_addr_t page_table_bus;
		};

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

		/*
		* List of devices with known bugs.
		*
		* The firmware_revision field, masked with 0xffff00, is the best
		* indicator for the type of bridge chip of a device. It yields a few
		* false positives but this did not break correctly behaving devices
		* so far. We use ~0 as a wildcard, since the 24 bit values we get
		* from the config rom can never match that.
		* so far.
		*/
		static const struct {
		u32 firmware_revision;
		@@ -339,33 +342,35 @@ static const struct {
		},
		/* Initio bridges, actually only needed for some older ones */ {
		.firmware_revision = 0x000200,
		.model = ~0,
		.model = SBP2_ROM_VALUE_WILDCARD,
		.workarounds = SBP2_WORKAROUND_INQUIRY_36,
		},
		/* PL-3507 bridge with Prolific firmware */ {
		.firmware_revision = 0x012800,
		.model = ~0,
		.model = SBP2_ROM_VALUE_WILDCARD,
		.workarounds = SBP2_WORKAROUND_POWER_CONDITION,
		},
		/* Symbios bridge */ {
		.firmware_revision = 0xa0b800,
		.model = ~0,
		.model = SBP2_ROM_VALUE_WILDCARD,
		.workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
		},
		/* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
		.firmware_revision = 0x002600,
		.model = ~0,
		.model = SBP2_ROM_VALUE_WILDCARD,
		.workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
		},

		/*
		* There are iPods (2nd gen, 3rd gen) with model_id == 0, but
		* these iPods do not feature the read_capacity bug according
		* to one report. Read_capacity behaviour as well as model_id
		* could change due to Apple-supplied firmware updates though.
		* iPod 2nd generation: needs 128k max transfer size workaround
		* iPod 3rd generation: needs fix capacity workaround
		*/

		/* iPod 4th generation. */ {
		{
		.firmware_revision = 0x0a2700,
		.model = 0x000000,
		.workarounds = SBP2_WORKAROUND_128K_MAX_TRANS \|
		SBP2_WORKAROUND_FIX_CAPACITY,
		},
		/* iPod 4th generation */ {
		.firmware_revision = 0x0a2700,
		.model = 0x000021,
		.workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
		@@ -1092,7 +1097,7 @@ static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
		continue;

		if (sbp2_workarounds_table[i].model != model &&
		sbp2_workarounds_table[i].model != ~0)
		sbp2_workarounds_table[i].model != SBP2_ROM_VALUE_WILDCARD)
		continue;

		w \|= sbp2_workarounds_table[i].workarounds;
		@@ -1142,20 +1147,28 @@ static int sbp2_probe(struct device *dev)
		fw_device_get(device);
		fw_unit_get(unit);

		/* Initialize to values that won't match anything in our table. */
		firmware_revision = 0xff000000;
		model = 0xff000000;

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

		firmware_revision = SBP2_ROM_VALUE_MISSING;
		model = SBP2_ROM_VALUE_MISSING;

		if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
		&firmware_revision) < 0)
		goto fail_tgt_put;

		sbp2_init_workarounds(tgt, model, firmware_revision);

		/*
		* 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);

		/* Do the login in a workqueue so we can easily reschedule retries. */
		list_for_each_entry(lu, &tgt->lu_list, link)
		sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
		@@ -1273,6 +1286,19 @@ static struct fw_driver sbp2_driver = {
		.id_table = sbp2_id_table,
		};

		static void sbp2_unmap_scatterlist(struct device *card_device,
		struct sbp2_command_orb *orb)
		{
		if (scsi_sg_count(orb->cmd))
		dma_unmap_sg(card_device, scsi_sglist(orb->cmd),
		scsi_sg_count(orb->cmd),
		orb->cmd->sc_data_direction);

		if (orb->request.misc & cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT))
		dma_unmap_single(card_device, orb->page_table_bus,
		sizeof(orb->page_table), DMA_TO_DEVICE);
		}

		static unsigned int
		sbp2_status_to_sense_data(u8 sbp2_status, u8 sense_data)
		{
		@@ -1352,15 +1378,7 @@ complete_command_orb(struct sbp2_orb base_orb, struct sbp2_status status)

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

		if (scsi_sg_count(orb->cmd) > 0)
		dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
		scsi_sg_count(orb->cmd),
		orb->cmd->sc_data_direction);

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

		orb->cmd->result = result;
		orb->done(orb->cmd);
		@@ -1434,7 +1452,6 @@ static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
		struct sbp2_logical_unit *lu = cmd->device->hostdata;
		struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
		struct sbp2_command_orb *orb;
		unsigned int max_payload;
		int generation, retval = SCSI_MLQUEUE_HOST_BUSY;

		/*
		@@ -1463,16 +1480,8 @@ static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
		orb->cmd = cmd;

		orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL);
		/*
		* At speed 100 we can do 512 bytes per packet, at speed 200,
		* 1024 bytes per packet etc. 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.
		*/
		max_payload = min(device->max_speed + 7,
		device->card->max_receive - 1);
		orb->request.misc = cpu_to_be32(
		COMMAND_ORB_MAX_PAYLOAD(max_payload) \|
		COMMAND_ORB_MAX_PAYLOAD(lu->tgt->max_payload) \|
		COMMAND_ORB_SPEED(device->max_speed) \|
		COMMAND_ORB_NOTIFY);

		@@ -1491,8 +1500,10 @@ static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
		orb->base.request_bus =
		dma_map_single(device->card->device, &orb->request,
		sizeof(orb->request), DMA_TO_DEVICE);
		if (dma_mapping_error(device->card->device, orb->base.request_bus))
		if (dma_mapping_error(device->card->device, orb->base.request_bus)) {
		sbp2_unmap_scatterlist(device->card->device, orb);
		goto out;
		}

		sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, generation,
		lu->command_block_agent_address + SBP2_ORB_POINTER);