-/* -*- 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
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);
{
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;
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
* 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) {
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;
}
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;
}
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))
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);
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)
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;
}
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)
{
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);
-/* -*- 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
#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;
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;
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;
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;
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);
-/* -*- 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) {
-/* -*- 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
-/* -*- 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
-/* -*- c-basic-offset: 8 -*-
+/*
+ * Driver for OHCI 1394 controllers
*
- * fw-ohci.c - Driver for OHCI 1394 boards
* Copyright (C) 2003-2006 Kristian Hoegsberg <krh@bitplanet.net>
*
* This program is free software; you can redistribute it and/or modify
int request_generation;
u32 bus_seconds;
- /* Spinlock for accessing fw_ohci data. Never call out of
- * this driver with this lock held. */
+ /*
+ * Spinlock for accessing fw_ohci data. Never call out of
+ * this driver with this lock held.
+ */
spinlock_t lock;
u32 self_id_buffer[512];
p.timestamp = status & 0xffff;
p.generation = ohci->request_generation;
- /* The OHCI bus reset handler synthesizes a phy packet with
+ /*
+ * The OHCI bus reset handler synthesizes a phy packet with
* the new generation number when a bus reset happens (see
* section 8.4.2.3). This helps us determine when a request
* was received and make sure we send the response in the same
* generation. We only need this for requests; for responses
* we use the unique tlabel for finding the matching
- * request. */
+ * request.
+ */
if (p.ack + 16 == 0x09)
ohci->request_generation = (buffer[2] >> 16) & 0xff;
if (d->res_count == 0) {
size_t size, rest, offset;
- /* This descriptor is finished and we may have a
+ /*
+ * This descriptor is finished and we may have a
* packet split across this and the next buffer. We
- * reuse the page for reassembling the split packet. */
+ * reuse the page for reassembling the split packet.
+ */
offset = offsetof(struct ar_buffer, data);
dma_unmap_single(ohci->card.device,
ctx->tail_descriptor = ctx->buffer;
ctx->tail_descriptor_last = ctx->buffer;
- /* We put a dummy descriptor in the buffer that has a NULL
+ /*
+ * We put a dummy descriptor in the buffer that has a NULL
* branch address and looks like it's been sent. That way we
* have a descriptor to append DMA programs to. Also, the
* ring buffer invariant is that it always has at least one
- * element so that head == tail means buffer full. */
+ * element so that head == tail means buffer full.
+ */
memset(ctx->head_descriptor, 0, sizeof *ctx->head_descriptor);
ctx->head_descriptor->control = cpu_to_le16(descriptor_output_last);
struct fw_packet *packet;
};
-/* This function apppends a packet to the DMA queue for transmission.
+/*
+ * This function apppends a packet to the DMA queue for transmission.
* Must always be called with the ochi->lock held to ensure proper
- * generation handling and locking around packet queue manipulation. */
+ * generation handling and locking around packet queue manipulation.
+ */
static int
at_context_queue_packet(struct context *ctx, struct fw_packet *packet)
{
d[0].control = cpu_to_le16(descriptor_key_immediate);
d[0].res_count = cpu_to_le16(packet->timestamp);
- /* The DMA format for asyncronous link packets is different
+ /*
+ * The DMA format for asyncronous link packets is different
* from the IEEE1394 layout, so shift the fields around
* accordingly. If header_length is 8, it's a PHY packet, to
- * which we need to prepend an extra quadlet. */
+ * which we need to prepend an extra quadlet.
+ */
header = (__le32 *) &d[1];
if (packet->header_length > 8) {
break;
case OHCI1394_evt_flushed:
- /* The packet was flushed should give same error as
- * when we try to use a stale generation count. */
+ /*
+ * The packet was flushed should give same error as
+ * when we try to use a stale generation count.
+ */
packet->ack = RCODE_GENERATION;
break;
case OHCI1394_evt_missing_ack:
- /* Using a valid (current) generation count, but the
- * node is not on the bus or not sending acks. */
+ /*
+ * Using a valid (current) generation count, but the
+ * node is not on the bus or not sending acks.
+ */
packet->ack = RCODE_NO_ACK;
break;
}
ohci->node_id = reg & 0xffff;
- /* The count in the SelfIDCount register is the number of
+ /*
+ * The count in the SelfIDCount register is the number of
* bytes in the self ID receive buffer. Since we also receive
* the inverted quadlets and a header quadlet, we shift one
- * bit extra to get the actual number of self IDs. */
+ * bit extra to get the actual number of self IDs.
+ */
self_id_count = (reg_read(ohci, OHCI1394_SelfIDCount) >> 3) & 0x3ff;
generation = (le32_to_cpu(ohci->self_id_cpu[0]) >> 16) & 0xff;
ohci->self_id_buffer[j] = le32_to_cpu(ohci->self_id_cpu[i]);
}
- /* Check the consistency of the self IDs we just read. The
+ /*
+ * Check the consistency of the self IDs we just read. The
* problem we face is that a new bus reset can start while we
* read out the self IDs from the DMA buffer. If this happens,
* the DMA buffer will be overwritten with new self IDs and we
* self IDs in the buffer before reading them out and compare
* it to the current generation after reading them out. If
* the two generations match we know we have a consistent set
- * of self IDs. */
+ * of self IDs.
+ */
new_generation = (reg_read(ohci, OHCI1394_SelfIDCount) >> 16) & 0xff;
if (new_generation != generation) {
context_stop(&ohci->at_response_ctx);
reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
- /* This next bit is unrelated to the AT context stuff but we
+ /*
+ * This next bit is unrelated to the AT context stuff but we
* have to do it under the spinlock also. If a new config rom
* was set up before this reset, the old one is now no longer
* in use and we can free it. Update the config rom pointers
* to point to the current config rom and clear the
- * next_config_rom pointer so a new udpate can take place. */
+ * next_config_rom pointer so a new udpate can take place.
+ */
if (ohci->next_config_rom != NULL) {
dma_free_coherent(ohci->card.device, CONFIG_ROM_SIZE,
ohci->config_rom_bus = ohci->next_config_rom_bus;
ohci->next_config_rom = NULL;
- /* Restore config_rom image and manually update
+ /*
+ * Restore config_rom image and manually update
* config_rom registers. Writing the header quadlet
* will indicate that the config rom is ready, so we
- * do that last. */
+ * do that last.
+ */
reg_write(ohci, OHCI1394_BusOptions,
be32_to_cpu(ohci->config_rom[2]));
ohci->config_rom[0] = cpu_to_be32(ohci->next_header);
struct fw_ohci *ohci = fw_ohci(card);
struct pci_dev *dev = to_pci_dev(card->device);
- /* When the link is not yet enabled, the atomic config rom
+ /*
+ * When the link is not yet enabled, the atomic config rom
* update mechanism described below in ohci_set_config_rom()
* is not active. We have to update ConfigRomHeader and
* BusOptions manually, and the write to ConfigROMmap takes
OHCI1394_HCControl_BIBimageValid);
flush_writes(ohci);
- /* We are ready to go, initiate bus reset to finish the
- * initialization. */
+ /*
+ * We are ready to go, initiate bus reset to finish the
+ * initialization.
+ */
fw_core_initiate_bus_reset(&ohci->card, 1);
ohci = fw_ohci(card);
- /* When the OHCI controller is enabled, the config rom update
+ /*
+ * When the OHCI controller is enabled, the config rom update
* mechanism is a bit tricky, but easy enough to use. See
* section 5.5.6 in the OHCI specification.
*
spin_unlock_irqrestore(&ohci->lock, flags);
- /* Now initiate a bus reset to have the changes take
+ /*
+ * Now initiate a bus reset to have the changes take
* effect. We clean up the old config rom memory and DMA
* mappings in the bus reset tasklet, since the OHCI
* controller could need to access it before the bus reset
- * takes effect. */
+ * takes effect.
+ */
if (retval == 0)
fw_core_initiate_bus_reset(&ohci->card, 1);
unsigned long flags;
int n, retval = 0;
- /* FIXME: Make sure this bitmask is cleared when we clear the busReset
- * interrupt bit. Clear physReqResourceAllBuses on bus reset. */
+ /*
+ * FIXME: Make sure this bitmask is cleared when we clear the busReset
+ * interrupt bit. Clear physReqResourceAllBuses on bus reset.
+ */
spin_lock_irqsave(&ohci->lock, flags);
goto out;
}
- /* NOTE, if the node ID contains a non-local bus ID, physical DMA is
- * enabled for _all_ nodes on remote buses. */
+ /*
+ * Note, if the node ID contains a non-local bus ID, physical DMA is
+ * enabled for _all_ nodes on remote buses.
+ */
n = (node_id & 0xffc0) == LOCAL_BUS ? node_id & 0x3f : 63;
if (n < 32)
p = db + 1;
end = p + header_length;
while (p < end && i + ctx->base.header_size <= PAGE_SIZE) {
- /* The iso header is byteswapped to little endian by
+ /*
+ * The iso header is byteswapped to little endian by
* the controller, but the remaining header quadlets
* are big endian. We want to present all the headers
* as big endian, so we have to swap the first
- * quadlet. */
+ * quadlet.
+ */
*(u32 *) (ctx->header + i) = __swab32(*(u32 *) (p + 4));
memcpy(ctx->header + i + 4, p + 8, ctx->base.header_size - 4);
i += ctx->base.header_size;
u32 payload_index, payload_end_index, next_page_index;
int page, end_page, i, length, offset;
- /* FIXME: Cycle lost behavior should be configurable: lose
- * packet, retransmit or terminate.. */
+ /*
+ * FIXME: Cycle lost behavior should be configurable: lose
+ * packet, retransmit or terminate..
+ */
p = packet;
payload_index = payload;
u32 z, header_z, length, rest;
int page, offset, packet_count, header_size;
- /* FIXME: Cycle lost behavior should be configurable: lose
- * packet, retransmit or terminate.. */
+ /*
+ * FIXME: Cycle lost behavior should be configurable: lose
+ * packet, retransmit or terminate..
+ */
if (packet->skip) {
d = context_get_descriptors(&ctx->context, 2, &d_bus);
p = packet;
z = 2;
- /* The OHCI controller puts the status word in the header
- * buffer too, so we need 4 extra bytes per packet. */
+ /*
+ * The OHCI controller puts the status word in the header
+ * buffer too, so we need 4 extra bytes per packet.
+ */
packet_count = p->header_length / ctx->base.header_size;
header_size = packet_count * (ctx->base.header_size + 4);
return -EBUSY;
}
-/* ---------- pci subsystem interface ---------- */
-
enum {
CLEANUP_SELF_ID,
CLEANUP_REGISTERS,
return cleanup(ohci, CLEANUP_REGISTERS, -EBUSY);
}
- /* Now enable LPS, which we need in order to start accessing
+ /*
+ * Now enable LPS, which we need in order to start accessing
* most of the registers. In fact, on some cards (ALI M5251),
* accessing registers in the SClk domain without LPS enabled
* will lock up the machine. Wait 50msec to make sure we have
- * full link enabled. */
+ * full link enabled.
+ */
reg_write(ohci, OHCI1394_HCControlSet,
OHCI1394_HCControl_LPS |
OHCI1394_HCControl_postedWriteEnable);
flush_writes(ohci);
fw_core_remove_card(&ohci->card);
- /* FIXME: Fail all pending packets here, now that the upper
- * layers can't queue any more. */
+ /*
+ * FIXME: Fail all pending packets here, now that the upper
+ * layers can't queue any more.
+ */
software_reset(ohci);
free_irq(dev->irq, ohci);
-/* -*- c-basic-offset: 8 -*-
- * fw-spb2.c -- SBP2 driver (SCSI over IEEE1394)
+/*
+ * SBP2 driver (SCSI over IEEE1394)
*
* Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
*
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* The basic structure of this driver is based the old storage driver,
+/*
+ * The basic structure of this driver is based on the old storage driver,
* drivers/ieee1394/sbp2.c, originally written by
* James Goodwin <jamesg@filanet.com>
* with later contributions and ongoing maintenance from
u32 workarounds;
int login_id;
- /* We cache these addresses and only update them once we've
+ /*
+ * We cache these addresses and only update them once we've
* logged in or reconnected to the sbp2 device. That way, any
* IO to the device will automatically fail and get retried if
* it happens in a window where the device is not ready to
- * handle it (e.g. after a bus reset but before we reconnect). */
+ * handle it (e.g. after a bus reset but before we reconnect).
+ */
int node_id;
int address_high;
int generation;
.model = ~0,
.workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
},
- /* There are iPods (2nd gen, 3rd gen) with model_id == 0, but
+
+ /*
+ * 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. */
+ * could change due to Apple-supplied firmware updates though.
+ */
+
/* iPod 4th generation. */ {
.firmware_revision = 0x0a2700,
.model = 0x000021,
if (orb == NULL)
return -ENOMEM;
- /* The sbp2 device is going to send a block read request to
- * read out the request from host memory, so map it for
- * dma. */
+ /*
+ * The sbp2 device is going to send a block read request to
+ * read out the request from host memory, so map it for dma.
+ */
orb->base.request_bus =
dma_map_single(device->card->device, &orb->request,
sizeof orb->request, DMA_TO_DEVICE);
orb->request.status_fifo.high = sd->address_handler.offset >> 32;
orb->request.status_fifo.low = sd->address_handler.offset;
- /* FIXME: Yeah, ok this isn't elegant, we hardwire exclusive
+ /*
+ * FIXME: Yeah, ok this isn't elegant, we hardwire exclusive
* login and 1 second reconnect time. The reconnect setting
- * is probably fine, but the exclusive login should be an
- * option. */
+ * is probably fine, but the exclusive login should be an option.
+ */
if (function == SBP2_LOGIN_REQUEST) {
orb->request.misc |=
management_orb_exclusive |
sbp2_send_management_orb(unit, sd->node_id, sd->generation,
SBP2_LOGOUT_REQUEST, sd->login_id,
NULL);
- /* Set this back to sbp2_login so we fall back and
- * retry login on bus reset. */
+ /*
+ * Set this back to sbp2_login so we fall back and
+ * retry login on bus reset.
+ */
PREPARE_DELAYED_WORK(&sd->work, sbp2_login);
}
kref_put(&sd->kref, release_sbp2_device);
return -EBUSY;
}
- /* Scan unit directory to get management agent address,
+ /*
+ * Scan unit directory to get management agent address,
* firmware revison and model. Initialize firmware_revision
- * and model to values that wont match anything in our table. */
+ * and model to values that wont match anything in our table.
+ */
firmware_revision = 0xff000000;
model = 0xff000000;
fw_csr_iterator_init(&ci, unit->directory);
get_device(&unit->device);
- /* We schedule work to do the login so we can easily
+ /*
+ * We schedule work to do the login so we can easily
* reschedule retries. Always get the ref before scheduling
- * work.*/
+ * work.
+ */
INIT_DELAYED_WORK(&sd->work, sbp2_login);
if (schedule_delayed_work(&sd->work, 0))
kref_get(&sd->kref);
result = sbp2_status_to_sense_data(status_get_data(*status),
orb->cmd->sense_buffer);
} else {
- /* If the orb completes with status == NULL, something
+ /*
+ * If the orb completes with status == NULL, something
* went wrong, typically a bus reset happened mid-orb
- * or when sending the write (less likely). */
+ * or when sending the write (less likely).
+ */
result = DID_BUS_BUSY << 16;
}
count = dma_map_sg(device->card->device, sg, orb->cmd->use_sg,
orb->cmd->sc_data_direction);
- /* Handle the special case where there is only one element in
+ /*
+ * Handle the special case where there is only one element in
* the scatter list by converting it to an immediate block
* request. This is also a workaround for broken devices such
* as the second generation iPod which doesn't support page
- * tables. */
+ * tables.
+ */
if (count == 1 && sg_dma_len(sg) < SBP2_MAX_SG_ELEMENT_LENGTH) {
orb->request.data_descriptor.high = sd->address_high;
orb->request.data_descriptor.low = sg_dma_address(sg);
return;
}
- /* Convert the scatterlist to an sbp2 page table. If any
- * scatterlist entries are too big for sbp2 we split the as we go. */
+ /*
+ * Convert the scatterlist to an sbp2 page table. If any
+ * scatterlist entries are too big for sbp2 we split the as we go.
+ */
for (i = 0, j = 0; i < count; i++) {
sg_len = sg_dma_len(sg + i);
sg_addr = sg_dma_address(sg + i);
size = sizeof orb->page_table[0] * j;
- /* The data_descriptor pointer is the one case where we need
+ /*
+ * The data_descriptor pointer is the one case where we need
* to fill in the node ID part of the address. All other
* pointers assume that the data referenced reside on the
* initiator (i.e. us), but data_descriptor can refer to data
- * on other nodes so we need to put our ID in descriptor.high. */
+ * on other nodes so we need to put our ID in descriptor.high.
+ */
orb->page_table_bus =
dma_map_single(device->card->device, orb->page_table,
struct fw_device *device = fw_device(unit->device.parent);
struct sbp2_device *sd = unit->device.driver_data;
- /* As for map_scatterlist, we need to fill in the high bits of
- * the data_descriptor pointer. */
+ /*
+ * As for map_scatterlist, we need to fill in the high bits of
+ * the data_descriptor pointer.
+ */
orb->request_buffer_bus =
dma_map_single(device->card->device,
struct sbp2_device *sd = unit->device.driver_data;
struct sbp2_command_orb *orb;
- /* Bidirectional commands are not yet implemented, and unknown
- * transfer direction not handled. */
+ /*
+ * Bidirectional commands are not yet implemented, and unknown
+ * transfer direction not handled.
+ */
if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
fw_error("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
goto fail_alloc;
orb->request.next.high = SBP2_ORB_NULL;
orb->request.next.low = 0x0;
- /* At speed 100 we can do 512 bytes per packet, at speed 200,
+ /*
+ * 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. */
+ * if we set this to max_speed + 7, we get the right value.
+ */
orb->request.misc =
command_orb_max_payload(device->node->max_speed + 7) |
command_orb_speed(device->node->max_speed) |
if (cmd->use_sg) {
sbp2_command_orb_map_scatterlist(orb);
} else if (cmd->request_bufflen > SBP2_MAX_SG_ELEMENT_LENGTH) {
- /* FIXME: Need to split this into a sg list... but
+ /*
+ * FIXME: Need to split this into a sg list... but
* could we get the scsi or blk layer to do that by
- * reporting our max supported block size? */
+ * reporting our max supported block size?
+ */
fw_error("command > 64k\n");
goto fail_bufflen;
} else if (cmd->request_bufflen > 0) {
-/* -*- c-basic-offset: 8 -*-
- *
- * fw-topology.c - Incremental bus scan, based on bus topology
+/*
+ * Incremental bus scan, based on bus topology
*
* Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net>
*
sid++;
q = *sid;
- /* Check that the extra packets actually are
+ /*
+ * Check that the extra packets actually are
* extended self ID packets and that the
* sequence numbers in the extended self ID
- * packets increase as expected. */
+ * packets increase as expected.
+ */
if (!self_id_extended(q) ||
seq != self_id_ext_sequence(q))
return node;
}
-/* Compute the maximum hop count for this node and it's children. The
+/*
+ * Compute the maximum hop count for this node and it's children. The
* maximum hop count is the maximum number of connections between any
* two nodes in the subtree rooted at this node. We need this for
* setting the gap count. As we build the tree bottom up in
return NULL;
}
- /* Seek back from the top of our stack to find the
- * start of the child nodes for this node. */
+ /*
+ * Seek back from the top of our stack to find the
+ * start of the child nodes for this node.
+ */
for (i = 0, h = &stack; i < child_port_count; i++)
h = h->prev;
child = fw_node(h);
for (i = 0; i < port_count; i++) {
switch (get_port_type(sid, i)) {
case SELFID_PORT_PARENT:
- /* Who's your daddy? We dont know the
+ /*
+ * Who's your daddy? We dont know the
* parent node at this time, so we
* temporarily abuse node->color for
* remembering the entry in the
case SELFID_PORT_CHILD:
node->ports[i].node = child;
- /* Fix up parent reference for this
- * child node. */
+ /*
+ * Fix up parent reference for this
+ * child node.
+ */
child->ports[child->color].node = node;
child->color = card->color;
child = fw_node(child->link.next);
}
}
- /* Check that the node reports exactly one parent
+ /*
+ * Check that the node reports exactly one parent
* port, except for the root, which of course should
- * have no parents. */
+ * have no parents.
+ */
if ((next_sid == end && parent_count != 0) ||
(next_sid < end && parent_count != 1)) {
fw_error("Parent port inconsistency for node %d: "
list_add_tail(&node->link, &stack);
stack_depth += 1 - child_port_count;
- /* If all PHYs does not report the same gap count
+ /*
+ * If all PHYs does not report the same gap count
* setting, we fall back to 63 which will force a gap
- * count reconfiguration and a reset. */
+ * count reconfiguration and a reset.
+ */
if (self_id_gap_count(q) != gap_count)
gap_count = 63;
for (i = 0; i < node0->port_count; i++) {
if (node0->ports[i].node && node1->ports[i].node) {
- /* This port didn't change, queue the
+ /*
+ * This port didn't change, queue the
* connected node for further
- * investigation. */
+ * investigation.
+ */
if (node0->ports[i].node->color == card->color)
continue;
list_add_tail(&node0->ports[i].node->link,
list_add_tail(&node1->ports[i].node->link,
&list1);
} else if (node0->ports[i].node) {
- /* The nodes connected here were
+ /*
+ * The nodes connected here were
* unplugged; unref the lost nodes and
* queue FW_NODE_LOST callbacks for
- * them. */
+ * them.
+ */
for_each_fw_node(card, node0->ports[i].node,
report_lost_node);
node0->ports[i].node = NULL;
} else if (node1->ports[i].node) {
- /* One or more node were connected to
+ /*
+ * One or more node were connected to
* this port. Move the new nodes into
* the tree and queue FW_NODE_CREATED
- * callbacks for them. */
+ * callbacks for them.
+ */
move_tree(node0, node1, i);
for_each_fw_node(card, node0->ports[i].node,
report_found_node);
spin_lock_irqsave(&card->lock, flags);
- /* If the new topology has a different self_id_count the topology
+ /*
+ * If the new topology has a different self_id_count the topology
* changed, either nodes were added or removed. In that case we
- * reset the IRM reset counter. */
+ * reset the IRM reset counter.
+ */
if (card->self_id_count != self_id_count)
card->bm_retries = 0;
-/* -*- c-basic-offset: 8 -*-
- *
- * fw-topology.h -- Incremental bus scan, based on bus topology
- *
+/*
* Copyright (C) 2003-2006 Kristian Hoegsberg <krh@bitplanet.net>
*
* This program is free software; you can redistribute it and/or modify
-/* -*- c-basic-offset: 8 -*-
- *
- * fw-transaction.c - core IEEE1394 transaction logic
+/*
+ * Core IEEE1394 transaction logic
*
* Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net>
*
return -ENOENT;
}
-/* Only valid for transactions that are potentially pending (ie have
- * been sent). */
+/*
+ * Only valid for transactions that are potentially pending (ie have
+ * been sent).
+ */
int
fw_cancel_transaction(struct fw_card *card,
struct fw_transaction *transaction)
{
- /* Cancel the packet transmission if it's still queued. That
+ /*
+ * Cancel the packet transmission if it's still queued. That
* will call the packet transmission callback which cancels
- * the transaction. */
+ * the transaction.
+ */
if (card->driver->cancel_packet(card, &transaction->packet) == 0)
return 0;
- /* If the request packet has already been sent, we need to see
- * if the transaction is still pending and remove it in that case. */
+ /*
+ * If the request packet has already been sent, we need to see
+ * if the transaction is still pending and remove it in that case.
+ */
return close_transaction(transaction, card, RCODE_CANCELLED, NULL, 0);
}
close_transaction(t, card, RCODE_TYPE_ERROR, NULL, 0);
break;
default:
- /* In this case the ack is really a juju specific
- * rcode, so just forward that to the callback. */
+ /*
+ * In this case the ack is really a juju specific
+ * rcode, so just forward that to the callback.
+ */
close_transaction(t, card, status, NULL, 0);
break;
}
unsigned long flags;
int tlabel, source;
- /* Bump the flush timer up 100ms first of all so we
- * don't race with a flush timer callback. */
+ /*
+ * Bump the flush timer up 100ms first of all so we
+ * don't race with a flush timer callback.
+ */
mod_timer(&card->flush_timer, jiffies + DIV_ROUND_UP(HZ, 10));
- /* Allocate tlabel from the bitmap and put the transaction on
- * the list while holding the card spinlock. */
+ /*
+ * Allocate tlabel from the bitmap and put the transaction on
+ * the list while holding the card spinlock.
+ */
spin_lock_irqsave(&card->lock, flags);
list_for_each_entry_safe(t, next, &list, link) {
card->driver->cancel_packet(card, &t->packet);
- /* At this point cancel_packet will never call the
+ /*
+ * At this point cancel_packet will never call the
* transaction callback, since we just took all the
- * transactions out of the list. So do it here.*/
+ * transactions out of the list. So do it here.
+ */
t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
}
}
void
fw_send_response(struct fw_card *card, struct fw_request *request, int rcode)
{
- /* Broadcast packets are reported as ACK_COMPLETE, so this
+ /*
+ * Broadcast packets are reported as ACK_COMPLETE, so this
* check is sufficient to ensure we don't send response to
- * broadcast packets or posted writes. */
+ * broadcast packets or posted writes.
+ */
if (request->ack != ACK_PENDING)
return;
offset, request->length);
spin_unlock_irqrestore(&address_handler_lock, flags);
- /* FIXME: lookup the fw_node corresponding to the sender of
+ /*
+ * FIXME: lookup the fw_node corresponding to the sender of
* this request and pass that to the address handler instead
* of the node ID. We may also want to move the address
* allocations to fw_node so we only do this callback if the
- * upper layers registered it for this node. */
+ * upper layers registered it for this node.
+ */
if (handler == NULL)
fw_send_response(card, request, RCODE_ADDRESS_ERROR);
return;
}
- /* FIXME: sanity check packet, is length correct, does tcodes
- * and addresses match. */
+ /*
+ * FIXME: sanity check packet, is length correct, does tcodes
+ * and addresses match.
+ */
switch (tcode) {
case TCODE_READ_QUADLET_RESPONSE:
case CSR_BANDWIDTH_AVAILABLE:
case CSR_CHANNELS_AVAILABLE_HI:
case CSR_CHANNELS_AVAILABLE_LO:
- /* FIXME: these are handled by the OHCI hardware and
+ /*
+ * FIXME: these are handled by the OHCI hardware and
* the stack never sees these request. If we add
* support for a new type of controller that doesn't
* handle this in hardware we need to deal with these
- * transactions. */
+ * transactions.
+ */
BUG();
break;
-/* -*- c-basic-offset: 8 -*-
- *
- * fw-transaction.h - Header for IEEE1394 transaction logic
- *
+/*
* Copyright (C) 2003-2006 Kristian Hoegsberg <krh@bitplanet.net>
*
* This program is free software; you can redistribute it and/or modify
size_t payload_length;
u32 timestamp;
- /* This callback is called when the packet transmission has
+ /*
+ * This callback is called when the packet transmission has
* completed; for successful transmission, the status code is
* the ack received from the destination, otherwise it's a
* negative errno: ENOMEM, ESTALE, ETIMEDOUT, ENODEV, EIO.
struct fw_packet packet;
- /* The data passed to the callback is valid only during the
- * callback. */
+ /*
+ * The data passed to the callback is valid only during the
+ * callback.
+ */
fw_transaction_callback_t callback;
void *callback_data;
};
int link_speed;
int config_rom_generation;
- /* We need to store up to 4 self ID for a maximum of 63
- * devices plus 3 words for the topology map header. */
+ /*
+ * We need to store up to 4 self ID for a maximum of 63
+ * devices plus 3 words for the topology map header.
+ */
int self_id_count;
u32 topology_map[252 + 3];
struct fw_card *fw_card_get(struct fw_card *card);
void fw_card_put(struct fw_card *card);
-/* The iso packet format allows for an immediate header/payload part
+/*
+ * The iso packet format allows for an immediate header/payload part
* stored in 'header' immediately after the packet info plus an
* indirect payload part that is pointer to by the 'payload' field.
* Applications can use one or the other or both to implement simple
* low-bandwidth streaming (e.g. audio) or more advanced
- * scatter-gather streaming (e.g. assembling video frame automatically). */
+ * scatter-gather streaming (e.g. assembling video frame automatically).
+ */
struct fw_iso_packet {
u16 payload_length; /* Length of indirect payload. */
void *header,
void *data);
-/* An iso buffer is just a set of pages mapped for DMA in the
+/*
+ * An iso buffer is just a set of pages mapped for DMA in the
* specified direction. Since the pages are to be used for DMA, they
* are not mapped into the kernel virtual address space. We store the
* DMA address in the page private. The helper function
- * fw_iso_buffer_map() will map the pages into a given vma. */
+ * fw_iso_buffer_map() will map the pages into a given vma.
+ */
struct fw_iso_buffer {
enum dma_data_direction direction;
struct fw_card_driver {
const char *name;
- /* Enable the given card with the given initial config rom.
+ /*
+ * Enable the given card with the given initial config rom.
* This function is expected to activate the card, and either
* enable the PHY or set the link_on bit and initiate a bus
- * reset. */
+ * reset.
+ */
int (*enable) (struct fw_card *card, u32 *config_rom, size_t length);
int (*update_phy_reg) (struct fw_card *card, int address,
int clear_bits, int set_bits);
- /* Update the config rom for an enabled card. This function
+ /*
+ * Update the config rom for an enabled card. This function
* should change the config rom that is presented on the bus
- * an initiate a bus reset. */
+ * an initiate a bus reset.
+ */
int (*set_config_rom) (struct fw_card *card,
u32 *config_rom, size_t length);
/* Calling cancel is valid once a packet has been submitted. */
int (*cancel_packet) (struct fw_card *card, struct fw_packet *packet);
- /* Allow the specified node ID to do direct DMA out and in of
+ /*
+ * Allow the specified node ID to do direct DMA out and in of
* host memory. The card will disable this for all node when
* a bus reset happens, so driver need to reenable this after
* bus reset. Returns 0 on success, -ENODEV if the card
* doesn't support this, -ESTALE if the generation doesn't
- * match. */
+ * match.
+ */
int (*enable_phys_dma) (struct fw_card *card,
int node_id, int generation);
void fw_send_phy_config(struct fw_card *card,
int node_id, int generation, int gap_count);
-/* Called by the topology code to inform the device code of node
- * activity; found, lost, or updated nodes */
+/*
+ * Called by the topology code to inform the device code of node
+ * activity; found, lost, or updated nodes.
+ */
void
fw_node_event(struct fw_card *card, struct fw_node *node, int event);
/* API used by card level drivers */
-/* Do we need phy speed here also? If we add more args, maybe we
- should go back to struct fw_card_info. */
void
fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
struct device *device);
projects / linux-2.6 / commitdiff