-/* -*- 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>
*
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);
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. */
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;
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");
.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)
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) {
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)
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);
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);
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;
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
* 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) {
projects / deliverable / linux.git / blobdiff