firewire: Clean up comment style. (c781c06d) · Commits · e / devices / android_kernel_sony_msm8998

drivers/firewire/fw-card.c

+66 −39

Original line number	Diff line number	Diff line
		/* -- c-basic-offset: 8 --
		*
		* fw-card.c - card level functions
		*
		* Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
		/*
		* Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
		*
		* 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
		@@ -69,12 +66,14 @@ generate_config_rom (struct fw_card card, size_t config_rom_length)
		static u32 config_rom[256];
		int i, j, length;

		/* Initialize contents of config rom buffer. On the OHCI
		/*
		* Initialize contents of config rom buffer. On the OHCI
		* controller, block reads to the config rom accesses the host
		* memory, but quadlet read access the hardware bus info block
		* registers. That's just crack, but it means we should make
		* sure the contents of bus info block in host memory mathces
		* the version stored in the OHCI registers. */
		* the version stored in the OHCI registers.
		*/

		memset(config_rom, 0, sizeof config_rom);
		config_rom[0] = bib_crc_length(4) \| bib_info_length(4) \| bib_crc(0);
		@@ -143,9 +142,11 @@ fw_core_add_descriptor (struct fw_descriptor *desc)
		{
		size_t i;

		/* Check descriptor is valid; the length of all blocks in the
		/*
		* Check descriptor is valid; the length of all blocks in the
		* descriptor has to add up to exactly the length of the
		* block. */
		* block.
		*/
		i = 0;
		while (i < desc->length)
		i += (desc->data[i] >> 16) + 1;
		@@ -228,7 +229,8 @@ fw_card_bm_work(struct work_struct *work)

		if (card->bm_generation + 1 == generation \|\|
		(card->bm_generation != generation && grace)) {
		/* This first step is to figure out who is IRM and
		/*
		* This first step is to figure out who is IRM and
		* then try to become bus manager. If the IRM is not
		* well defined (e.g. does not have an active link
		* layer or does not responds to our lock request, we
		@@ -236,7 +238,8 @@ fw_card_bm_work(struct work_struct *work)
		* In that case, we do a goto into the gap count logic
		* so that when we do the reset, we still optimize the
		* gap count. That could well save a reset in the
		* next generation. */
		* next generation.
		*/

		irm_id = card->irm_node->node_id;
		if (!card->irm_node->link_on) {
		@@ -260,8 +263,10 @@ fw_card_bm_work(struct work_struct *work)
		wait_for_completion(&bmd.done);

		if (bmd.rcode == RCODE_GENERATION) {
		/* Another bus reset happened. Just return,
		* the BM work has been rescheduled. */
		/*
		* Another bus reset happened. Just return,
		* the BM work has been rescheduled.
		*/
		return;
		}

		@@ -271,48 +276,62 @@ fw_card_bm_work(struct work_struct *work)

		spin_lock_irqsave(&card->lock, flags);
		if (bmd.rcode != RCODE_COMPLETE) {
		/* The lock request failed, maybe the IRM
		/*
		* The lock request failed, maybe the IRM
		* isn't really IRM capable after all. Let's
		* do a bus reset and pick the local node as
		* root, and thus, IRM. */
		* root, and thus, IRM.
		*/
		new_root_id = card->local_node->node_id;
		fw_notify("BM lock failed, making local node (%02x) root.\n",
		new_root_id);
		goto pick_me;
		}
		} else if (card->bm_generation != generation) {
		/* OK, we weren't BM in the last generation, and it's
		/*
		* OK, we weren't BM in the last generation, and it's
		* less than 100ms since last bus reset. Reschedule
		* this task 100ms from now. */
		* this task 100ms from now.
		*/
		spin_unlock_irqrestore(&card->lock, flags);
		schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10));
		return;
		}

		/* We're bus manager for this generation, so next step is to
		/*
		* We're bus manager for this generation, so next step is to
		* make sure we have an active cycle master and do gap count
		* optimization. */
		* optimization.
		*/
		card->bm_generation = generation;

		if (root == NULL) {
		/* Either link_on is false, or we failed to read the
		* config rom. In either case, pick another root. */
		/*
		* Either link_on is false, or we failed to read the
		* config rom. In either case, pick another root.
		*/
		new_root_id = card->local_node->node_id;
		} else if (atomic_read(&root->state) != FW_DEVICE_RUNNING) {
		/* If we haven't probed this device yet, bail out now
		* and let's try again once that's done. */
		/*
		* If we haven't probed this device yet, bail out now
		* and let's try again once that's done.
		*/
		spin_unlock_irqrestore(&card->lock, flags);
		return;
		} else if (root->config_rom[2] & bib_cmc) {
		/* FIXME: I suppose we should set the cmstr bit in the
		/*
		* FIXME: I suppose we should set the cmstr bit in the
		* STATE_CLEAR register of this node, as described in
		* 1394-1995, 8.4.2.6. Also, send out a force root
		* packet for this node. */
		* packet for this node.
		*/
		new_root_id = root_id;
		} else {
		/* Current root has an active link layer and we
		/*
		* Current root has an active link layer and we
		* successfully read the config rom, but it's not
		* cycle master capable. */
		* cycle master capable.
		*/
		new_root_id = card->local_node->node_id;
		}

		@@ -324,9 +343,11 @@ fw_card_bm_work(struct work_struct *work)
		else
		gap_count = 63;

		/* Finally, figure out if we should do a reset or not. If we've
		/*
		* Finally, figure out if we should do a reset or not. If we've
		* done less that 5 resets with the same physical topology and we
		* have either a new root or a new gap count setting, let's do it. */
		* have either a new root or a new gap count setting, let's do it.
		*/

		if (card->bm_retries++ < 5 &&
		(card->gap_count != gap_count \|\| new_root_id != root_id))
		@@ -391,8 +412,10 @@ fw_card_add(struct fw_card *card,
		PHY_LINK_ACTIVE \| PHY_CONTENDER) < 0)
		return -EIO;

		/* The subsystem grabs a reference when the card is added and
		* drops it when the driver calls fw_core_remove_card. */
		/*
		* The subsystem grabs a reference when the card is added and
		* drops it when the driver calls fw_core_remove_card.
		*/
		fw_card_get(card);

		down_write(&card_rwsem);
		@@ -405,11 +428,13 @@ fw_card_add(struct fw_card *card,
		EXPORT_SYMBOL(fw_card_add);


		/* The next few functions implements a dummy driver that use once a
		/*
		* The next few functions implements a dummy driver that use once a
		* card driver shuts down an fw_card. This allows the driver to
		* cleanly unload, as all IO to the card will be handled by the dummy
		* driver instead of calling into the (possibly) unloaded module. The
		* dummy driver just fails all IO. */
		* dummy driver just fails all IO.
		*/

		static int
		dummy_enable(struct fw_card card, u32 config_rom, size_t length)
		@@ -429,8 +454,10 @@ static int
		dummy_set_config_rom(struct fw_card *card,
		u32 *config_rom, size_t length)
		{
		/* We take the card out of card_list before setting the dummy
		* driver, so this should never get called. */
		/*
		* We take the card out of card_list before setting the dummy
		* driver, so this should never get called.
		*/
		BUG();
		return -1;
		}
		@@ -510,9 +537,11 @@ release_card(struct kref *kref)
		kfree(card);
		}

		/* An assumption for fw_card_put() is that the card driver allocates
		/*
		* An assumption for fw_card_put() is that the card driver allocates
		* the fw_card struct with kalloc and that it has been shut down
		* before the last ref is dropped. */
		* before the last ref is dropped.
		*/
		void
		fw_card_put(struct fw_card *card)
		{
		@@ -524,8 +553,6 @@ int
		fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
		{
		int reg = short_reset ? 5 : 1;
		/* The following values happen to be the same bit. However be
		* explicit for clarity. */
		int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;

		return card->driver->update_phy_reg(card, reg, 0, bit);

drivers/firewire/fw-cdev.c

+20 −13

Original line number	Diff line number	Diff line
		/* -- c-basic-offset: 8 --
		/*
		* Char device for device raw access
		*
		* fw-device-cdev.c - Char device for device raw access
		*
		* Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
		* Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
		*
		* 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
		@@ -36,9 +35,6 @@
		#include "fw-topology.h"
		#include "fw-device.h"

		/* dequeue_event() just kfree()'s the event, so the event has to be
		* the first field in the struct. */

		struct client;
		struct client_resource {
		struct list_head link;
		@@ -46,6 +42,11 @@ struct client_resource {
		u32 handle;
		};

		/*
		* dequeue_event() just kfree()'s the event, so the event has to be
		* the first field in the struct.
		*/

		struct event {
		struct { void *data; size_t size; } v[2];
		struct list_head link;
		@@ -691,13 +692,15 @@ static int ioctl_queue_iso(struct client client, void buffer)
		if (ctx == NULL \|\| request->handle != 0)
		return -EINVAL;

		/* If the user passes a non-NULL data pointer, has mmap()'ed
		/*
		* If the user passes a non-NULL data pointer, has mmap()'ed
		* the iso buffer, and the pointer points inside the buffer,
		* we setup the payload pointers accordingly. Otherwise we
		* set them both to 0, which will still let packets with
		* payload_length == 0 through. In other words, if no packets
		* use the indirect payload, the iso buffer need not be mapped
		* and the request->data pointer is ignored.*/
		* and the request->data pointer is ignored.
		*/

		payload = (unsigned long)request->data - client->vm_start;
		buffer_end = client->buffer.page_count << PAGE_SHIFT;
		@@ -720,8 +723,10 @@ static int ioctl_queue_iso(struct client client, void buffer)
		if (ctx->type == FW_ISO_CONTEXT_TRANSMIT) {
		header_length = u.packet.header_length;
		} else {
		/* We require that header_length is a multiple of
		* the fixed header size, ctx->header_size */
		/*
		* We require that header_length is a multiple of
		* the fixed header size, ctx->header_size.
		*/
		if (ctx->header_size == 0) {
		if (u.packet.header_length > 0)
		return -EINVAL;
		@@ -908,8 +913,10 @@ static int fw_device_op_release(struct inode inode, struct file file)
		list_for_each_entry_safe(r, next_r, &client->resource_list, link)
		r->release(client, r);

		/* FIXME: We should wait for the async tasklets to stop
		* running before freeing the memory. */
		/*
		* FIXME: We should wait for the async tasklets to stop
		* running before freeing the memory.
		*/

		list_for_each_entry_safe(e, next_e, &client->event_list, link)
		kfree(e);

drivers/firewire/fw-device.c

+66 −35

Original line number	Diff line number	Diff line
		/* -- c-basic-offset: 8 --
		*
		* fw-device.c - Device probing and sysfs code.
		/*
		* Device probing and sysfs code.
		*
		* Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
		*
		@@ -174,8 +173,10 @@ static void fw_device_release(struct device *dev)
		struct fw_device *device = fw_device(dev);
		unsigned long flags;

		/* Take the card lock so we don't set this to NULL while a
		* FW_NODE_UPDATED callback is being handled. */
		/*
		* Take the card lock so we don't set this to NULL while a
		* FW_NODE_UPDATED callback is being handled.
		*/
		spin_lock_irqsave(&device->card->lock, flags);
		device->node->data = NULL;
		spin_unlock_irqrestore(&device->card->lock, flags);
		@@ -421,34 +422,42 @@ static int read_bus_info_block(struct fw_device *device)
		for (i = 0; i < 5; i++) {
		if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE)
		return -1;
		/* As per IEEE1212 7.2, during power-up, devices can
		/*
		* As per IEEE1212 7.2, during power-up, devices can
		* reply with a 0 for the first quadlet of the config
		* rom to indicate that they are booting (for example,
		* if the firmware is on the disk of a external
		* harddisk). In that case we just fail, and the
		* retry mechanism will try again later. */
		* retry mechanism will try again later.
		*/
		if (i == 0 && rom[i] == 0)
		return -1;
		}

		/* Now parse the config rom. The config rom is a recursive
		/*
		* Now parse the config rom. The config rom is a recursive
		* directory structure so we parse it using a stack of
		* references to the blocks that make up the structure. We
		* push a reference to the root directory on the stack to
		* start things off. */
		* start things off.
		*/
		length = i;
		sp = 0;
		stack[sp++] = 0xc0000005;
		while (sp > 0) {
		/* Pop the next block reference of the stack. The
		/*
		* Pop the next block reference of the stack. The
		* lower 24 bits is the offset into the config rom,
		* the upper 8 bits are the type of the reference the
		* block. */
		* block.
		*/
		key = stack[--sp];
		i = key & 0xffffff;
		if (i >= ARRAY_SIZE(rom))
		/* The reference points outside the standard
		* config rom area, something's fishy. */
		/*
		* The reference points outside the standard
		* config rom area, something's fishy.
		*/
		return -1;

		/* Read header quadlet for the block to get the length. */
		@@ -457,15 +466,19 @@ static int read_bus_info_block(struct fw_device *device)
		end = i + (rom[i] >> 16) + 1;
		i++;
		if (end > ARRAY_SIZE(rom))
		/* This block extends outside standard config
		/*
		* This block extends outside standard config
		* area (and the array we're reading it
		* into). That's broken, so ignore this
		* device. */
		* device.
		*/
		return -1;

		/* Now read in the block. If this is a directory
		/*
		* Now read in the block. If this is a directory
		* block, check the entries as we read them to see if
		* it references another block, and push it in that case. */
		* it references another block, and push it in that case.
		*/
		while (i < end) {
		if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE)
		return -1;
		@@ -516,8 +529,10 @@ static void create_units(struct fw_device *device)
		if (key != (CSR_UNIT \| CSR_DIRECTORY))
		continue;

		/* Get the address of the unit directory and try to
		* match the drivers id_tables against it. */
		/*
		* Get the address of the unit directory and try to
		* match the drivers id_tables against it.
		*/
		unit = kzalloc(sizeof *unit, GFP_KERNEL);
		if (unit == NULL) {
		fw_error("failed to allocate memory for unit\n");
		@@ -585,14 +600,16 @@ static struct device_type fw_device_type = {
		.release = fw_device_release,
		};

		/* These defines control the retry behavior for reading the config
		/*
		* 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. */
		* are plugged in, they're all getting read within one second.
		*/

		#define MAX_RETRIES 10
		#define RETRY_DELAY (3 * HZ)
		@@ -604,9 +621,11 @@ static void fw_device_init(struct work_struct *work)
		container_of(work, struct fw_device, work.work);
		int minor, err;

		/* All failure paths here set node->data to NULL, so that we
		/*
		* All failure paths here set node->data to NULL, so that we
		* don't try to do device_for_each_child() on a kfree()'d
		* device. */
		* device.
		*/

		if (read_bus_info_block(device) < 0) {
		if (device->config_rom_retries < MAX_RETRIES) {
		@@ -647,13 +666,15 @@ static void fw_device_init(struct work_struct *work)

		create_units(device);

		/* Transition the device to running state. If it got pulled
		/*
		* Transition the device to running state. If it got pulled
		* out from under us while we did the intialization work, we
		* have to shut down the device again here. Normally, though,
		* fw_node_event will be responsible for shutting it down when
		* necessary. We have to use the atomic cmpxchg here to avoid
		* racing with the FW_NODE_DESTROYED case in
		* fw_node_event(). */
		* fw_node_event().
		*/
		if (atomic_cmpxchg(&device->state,
		FW_DEVICE_INITIALIZING,
		FW_DEVICE_RUNNING) == FW_DEVICE_SHUTDOWN)
		@@ -662,10 +683,12 @@ static void fw_device_init(struct work_struct *work)
		fw_notify("created new fw device %s (%d config rom retries)\n",
		device->device.bus_id, device->config_rom_retries);

		/* Reschedule the IRM work if we just finished reading the
		/*
		* Reschedule the IRM work if we just finished reading the
		* root node config rom. If this races with a bus reset we
		* just end up running the IRM work a couple of extra times -
		* pretty harmless. */
		* pretty harmless.
		*/
		if (device->node == device->card->root_node)
		schedule_delayed_work(&device->card->work, 0);

		@@ -716,12 +739,14 @@ void fw_node_event(struct fw_card card, struct fw_node node, int event)
		if (device == NULL)
		break;

		/* Do minimal intialization of the device here, the
		/*
		* Do minimal intialization of the device here, the
		* rest will happen in fw_device_init(). We need the
		* card and node so we can read the config rom and we
		* need to do device_initialize() now so
		* device_for_each_child() in FW_NODE_UPDATED is
		* doesn't freak out. */
		* doesn't freak out.
		*/
		device_initialize(&device->device);
		atomic_set(&device->state, FW_DEVICE_INITIALIZING);
		device->card = fw_card_get(card);
		@@ -730,15 +755,19 @@ void fw_node_event(struct fw_card card, struct fw_node node, int event)
		device->generation = card->generation;
		INIT_LIST_HEAD(&device->client_list);

		/* Set the node data to point back to this device so
		/*
		* Set the node data to point back to this device so
		* FW_NODE_UPDATED callbacks can update the node_id
		* and generation for the device. */
		* and generation for the device.
		*/
		node->data = device;

		/* Many devices are slow to respond after bus resets,
		/*
		* Many devices are slow to respond after bus resets,
		* especially if they are bus powered and go through
		* power-up after getting plugged in. We schedule the
		* first config rom scan half a second after bus reset. */
		* first config rom scan half a second after bus reset.
		*/
		INIT_DELAYED_WORK(&device->work, fw_device_init);
		schedule_delayed_work(&device->work, INITIAL_DELAY);
		break;
		@@ -761,7 +790,8 @@ void fw_node_event(struct fw_card card, struct fw_node node, int event)
		if (!node->data)
		break;

		/* Destroy the device associated with the node. There
		/*
		* Destroy the device associated with the node. There
		* are two cases here: either the device is fully
		* initialized (FW_DEVICE_RUNNING) or we're in the
		* process of reading its config rom
		@@ -770,7 +800,8 @@ void fw_node_event(struct fw_card card, struct fw_node node, int event)
		* full fw_device_shutdown(). If not, there's work
		* scheduled to read it's config rom, and we just put
		* the device in shutdown state to have that code fail
		* to create the device. */
		* to create the device.
		*/
		device = node->data;
		if (atomic_xchg(&device->state,
		FW_DEVICE_SHUTDOWN) == FW_DEVICE_RUNNING) {

drivers/firewire/fw-device.h

+1 −4

Original line number	Diff line number	Diff line
		/* -- c-basic-offset: 8 --
		*
		* fw-device.h - Device probing and sysfs code.
		*
		/*
		* Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
		*
		* This program is free software; you can redistribute it and/or modify

drivers/firewire/fw-iso.c

+2 −2

Original line number	Diff line number	Diff line
		/* -- c-basic-offset: 8 --
		/*
		* Isochronous IO functionality
		*
		* fw-iso.c - Isochronous IO
		* Copyright (C) 2006 Kristian Hoegsberg <krh@bitplanet.net>
		*
		* This program is free software; you can redistribute it and/or modify