X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=drivers%2Ffirewire%2Ffw-device.c;h=de9066e69adfbeea440d31cec1c0945f337db728;hb=f8303dd3db57bd7ab2062985ad7a9e898a8ac423;hp=7503b8d9abe5ccc06e936932250e67ed47a8049a;hpb=dde2b954302d143deee6dbd931ba2aa21413bb0a;p=linux-2.6 diff --git a/drivers/firewire/fw-device.c b/drivers/firewire/fw-device.c index 7503b8d9ab..de9066e69a 100644 --- a/drivers/firewire/fw-device.c +++ b/drivers/firewire/fw-device.c @@ -1,6 +1,5 @@ -/* -*- c-basic-offset: 8 -*- - * - * fw-device.c - Device probing and sysfs code. +/* + * Device probing and sysfs code. * * Copyright (C) 2005-2006 Kristian Hoegsberg * @@ -28,6 +27,7 @@ #include #include #include +#include #include #include "fw-transaction.h" #include "fw-topology.h" @@ -131,23 +131,16 @@ static int get_modalias(struct fw_unit *unit, char *buffer, size_t buffer_size) } static int -fw_unit_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) +fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env) { struct fw_unit *unit = fw_unit(dev); char modalias[64]; - int length = 0; - int i = 0; - get_modalias(unit, modalias, sizeof modalias); + get_modalias(unit, modalias, sizeof(modalias)); - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MODALIAS=%s", modalias)) + if (add_uevent_var(env, "MODALIAS=%s", modalias)) return -ENOMEM; - envp[i] = NULL; - return 0; } @@ -157,14 +150,14 @@ struct bus_type fw_bus_type = { }; EXPORT_SYMBOL(fw_bus_type); -extern struct fw_device *fw_device_get(struct fw_device *device) +struct fw_device *fw_device_get(struct fw_device *device) { get_device(&device->device); return device; } -extern void fw_device_put(struct fw_device *device) +void fw_device_put(struct fw_device *device) { put_device(&device->device); } @@ -174,8 +167,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); @@ -188,9 +183,14 @@ static void fw_device_release(struct device *dev) int fw_device_enable_phys_dma(struct fw_device *device) { + int generation = device->generation; + + /* device->node_id, accessed below, must not be older than generation */ + smp_rmb(); + return device->card->driver->enable_phys_dma(device->card, device->node_id, - device->generation); + generation); } EXPORT_SYMBOL(fw_device_enable_phys_dma); @@ -362,7 +362,8 @@ guid_show(struct device *dev, struct device_attribute *attr, char *buf) guid = ((u64)device->config_rom[3] << 32) | device->config_rom[4]; - return snprintf(buf, PAGE_SIZE, "0x%016llx\n", guid); + return snprintf(buf, PAGE_SIZE, "0x%016llx\n", + (unsigned long long)guid); } static struct device_attribute fw_device_attributes[] = { @@ -389,18 +390,21 @@ complete_transaction(struct fw_card *card, int rcode, complete(&callback_data->done); } -static int read_rom(struct fw_device *device, int index, u32 * data) +static int +read_rom(struct fw_device *device, int generation, int index, u32 *data) { struct read_quadlet_callback_data callback_data; struct fw_transaction t; u64 offset; + /* device->node_id, accessed below, must not be older than generation */ + smp_rmb(); + init_completion(&callback_data.done); offset = 0xfffff0000400ULL + index * 4; fw_send_request(device->card, &t, TCODE_READ_QUADLET_REQUEST, - device->node_id, - device->generation, SCODE_100, + device->node_id, generation, device->max_speed, offset, NULL, 4, complete_transaction, &callback_data); wait_for_completion(&callback_data.done); @@ -410,63 +414,113 @@ static int read_rom(struct fw_device *device, int index, u32 * data) return callback_data.rcode; } -static int read_bus_info_block(struct fw_device *device) +/* + * Read the bus info block, perform a speed probe, and read all of the rest of + * the config ROM. We do all this with a cached bus generation. If the bus + * generation changes under us, read_bus_info_block will fail and get retried. + * It's better to start all over in this case because the node from which we + * are reading the ROM may have changed the ROM during the reset. + */ +static int read_bus_info_block(struct fw_device *device, int generation) { static u32 rom[256]; u32 stack[16], sp, key; int i, end, length; + device->max_speed = SCODE_100; + /* First read the bus info block. */ for (i = 0; i < 5; i++) { - if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE) + if (read_rom(device, generation, 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 + device->max_speed = device->node->max_speed; + + /* + * Determine the speed of + * - devices with link speed less than PHY speed, + * - devices with 1394b PHY (unless only connected to 1394a PHYs), + * - all devices if there are 1394b repeaters. + * Note, we cannot use the bus info block's link_spd as starting point + * because some buggy firmwares set it lower than necessary and because + * 1394-1995 nodes do not have the field. + */ + if ((rom[2] & 0x7) < device->max_speed || + device->max_speed == SCODE_BETA || + device->card->beta_repeaters_present) { + u32 dummy; + + /* for S1600 and S3200 */ + if (device->max_speed == SCODE_BETA) + device->max_speed = device->card->link_speed; + + while (device->max_speed > SCODE_100) { + if (read_rom(device, generation, 0, &dummy) == + RCODE_COMPLETE) + break; + device->max_speed--; + } + } + + /* + * 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. */ - if (read_rom(device, i, &rom[i]) != RCODE_COMPLETE) + if (read_rom(device, generation, i, &rom[i]) != RCODE_COMPLETE) return -1; 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) + if (read_rom(device, generation, i, &rom[i]) != + RCODE_COMPLETE) return -1; if ((key >> 30) == 3 && (rom[i] >> 30) > 1 && sp < ARRAY_SIZE(stack)) @@ -515,9 +569,11 @@ 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. */ - unit = kzalloc(sizeof *unit, GFP_KERNEL); + /* + * 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"); continue; @@ -527,7 +583,7 @@ static void create_units(struct fw_device *device) unit->device.bus = &fw_bus_type; unit->device.type = &fw_unit_type; unit->device.parent = &device->device; - snprintf(unit->device.bus_id, sizeof unit->device.bus_id, + snprintf(unit->device.bus_id, sizeof(unit->device.bus_id), "%s.%d", device->device.bus_id, i++); init_fw_attribute_group(&unit->device, @@ -584,14 +640,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) @@ -603,11 +661,13 @@ 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 (read_bus_info_block(device, device->generation) < 0) { if (device->config_rom_retries < MAX_RETRIES) { device->config_rom_retries++; schedule_delayed_work(&device->work, RETRY_DELAY); @@ -633,7 +693,7 @@ static void fw_device_init(struct work_struct *work) device->device.type = &fw_device_type; device->device.parent = device->card->device; device->device.devt = MKDEV(fw_cdev_major, minor); - snprintf(device->device.bus_id, sizeof device->device.bus_id, + snprintf(device->device.bus_id, sizeof(device->device.bus_id), "fw%d", minor); init_fw_attribute_group(&device->device, @@ -646,25 +706,31 @@ 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) fw_device_shutdown(&device->work.work); else - fw_notify("created new fw device %s (%d config rom retries)\n", - device->device.bus_id, device->config_rom_retries); + fw_notify("created new fw device %s " + "(%d config rom retries, S%d00)\n", + device->device.bus_id, device->config_rom_retries, + 1 << device->max_speed); - /* 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); @@ -715,12 +781,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); @@ -729,15 +797,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; @@ -748,6 +820,7 @@ void fw_node_event(struct fw_card *card, struct fw_node *node, int event) device = node->data; device->node_id = node->node_id; + smp_wmb(); /* update node_id before generation */ device->generation = card->generation; if (atomic_read(&device->state) == FW_DEVICE_RUNNING) { PREPARE_DELAYED_WORK(&device->work, fw_device_update); @@ -760,7 +833,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 @@ -769,7 +843,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) {