linuxmsm/laptops-kernel
0
0
Fork 0
mirror of https://github.com/linux-msm/laptops-kernel.git synced 2026-08-13 14:19:53 -07:00
Code Issues Packages Projects Releases Wiki Activity

firewire: Add core firewire stack.

Browse Source 
Signed-off-by: Kristian Høgsberg <krh@redhat.com>
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
This commit is contained in:
Kristian Høgsberg
2007-03-09 22:02:33 +01:00
committed by Stefan Richter
parent 08e15e81a4
commit 3038e353cf
10 changed files with 2235 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/Kconfig
+2
View File
@@ -30,6 +30,8 @@ source "drivers/md/Kconfig"
source "drivers/message/fusion/Kconfig"
source "drivers/firewire/Kconfig"
source "drivers/ieee1394/Kconfig"
source "drivers/message/i2o/Kconfig"
drivers/Makefile
+1
View File
@@ -36,6 +36,7 @@ obj-$(CONFIG_FC4) += fc4/
obj-$(CONFIG_SCSI) += scsi/
obj-$(CONFIG_ATA) += ata/
obj-$(CONFIG_FUSION) += message/
obj-$(CONFIG_FW) += firewire/
obj-$(CONFIG_IEEE1394) += ieee1394/
obj-y += cdrom/
obj-y += auxdisplay/
drivers/firewire/Kconfig
+23
View File
@@ -0,0 +1,23 @@
# -*- shell-script -*-
menu "IEEE 1394 (FireWire) support (JUJU alternative stack)"
config FW
tristate "IEEE 1394 (FireWire) support (JUJU alternative stack)"
help
IEEE 1394 describes a high performance serial bus, which is also
known as FireWire(tm) or i.Link(tm) and is used for connecting all
sorts of devices (most notably digital video cameras) to your
computer.
If you have FireWire hardware and want to use it, say Y here. This
is the core support only, you will also need to select a driver for
your IEEE 1394 adapter.
This is the "JUJU" firewire stack, an alternative
implementation designed for roboustness and simplicity.
To compile this driver as a module, say M here: the
module will be called fw-core.
endmenu
drivers/firewire/Makefile
+7
View File
@@ -0,0 +1,7 @@
#
# Makefile for the Linux IEEE 1394 implementation
#
fw-core-objs := fw-card.o fw-topology.o fw-transaction.o fw-iso.o
obj-$(CONFIG_FW) += fw-core.o
drivers/firewire/fw-card.c
+384
View File
@@ -0,0 +1,384 @@
/* -*- c-basic-offset: 8 -*-
*
* fw-card.c - card level functions
*
* Copyright (C) 2005-2006 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/device.h>
#include "fw-transaction.h"
#include "fw-topology.h"
/* The lib/crc16.c implementation uses the standard (0x8005)
* polynomial, but we need the ITU-T (or CCITT) polynomial (0x1021).
* The implementation below works on an array of host-endian u32
* words, assuming they'll be transmited msb first. */
static u16
crc16_itu_t(const u32 *buffer, size_t length)
{
int shift, i;
u32 data;
u16 sum, crc = 0;
for (i = 0; i < length; i++) {
data = *buffer++;
for (shift = 28; shift >= 0; shift -= 4 ) {
sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
}
crc &= 0xffff;
}
return crc;
}
static LIST_HEAD(card_list);
static LIST_HEAD(descriptor_list);
static int descriptor_count;
#define bib_crc(v) ((v) << 0)
#define bib_crc_length(v) ((v) << 16)
#define bib_info_length(v) ((v) << 24)
#define bib_link_speed(v) ((v) << 0)
#define bib_generation(v) ((v) << 4)
#define bib_max_rom(v) ((v) << 8)
#define bib_max_receive(v) ((v) << 12)
#define bib_cyc_clk_acc(v) ((v) << 16)
#define bib_pmc ((1) << 27)
#define bib_bmc ((1) << 28)
#define bib_isc ((1) << 29)
#define bib_cmc ((1) << 30)
#define bib_imc ((1) << 31)
static u32 *
generate_config_rom (struct fw_card *card, size_t *config_rom_length)
{
struct fw_descriptor *desc;
static u32 config_rom[256];
int i, j, length;
/* 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. */
memset(config_rom, 0, sizeof config_rom);
config_rom[0] = bib_crc_length(4) | bib_info_length(4) | bib_crc(0);
config_rom[1] = 0x31333934;
config_rom[2] =
bib_link_speed(card->link_speed) |
bib_generation(card->config_rom_generation++ % 14 + 2) |
bib_max_rom(2) |
bib_max_receive(card->max_receive) |
bib_isc | bib_cmc | bib_imc;
config_rom[3] = card->guid >> 32;
config_rom[4] = card->guid;
/* Generate root directory. */
i = 5;
config_rom[i++] = 0;
config_rom[i++] = 0x0c0083c0; /* node capabilities */
config_rom[i++] = 0x03d00d1e; /* vendor id */
j = i + descriptor_count;
/* Generate root directory entries for descriptors. */
list_for_each_entry (desc, &descriptor_list, link) {
config_rom[i] = desc->key | (j - i);
i++;
j += desc->length;
}
/* Update root directory length. */
config_rom[5] = (i - 5 - 1) << 16;
/* End of root directory, now copy in descriptors. */
list_for_each_entry (desc, &descriptor_list, link) {
memcpy(&config_rom[i], desc->data, desc->length * 4);
i += desc->length;
}
/* Calculate CRCs for all blocks in the config rom. This
* assumes that CRC length and info length are identical for
* the bus info block, which is always the case for this
* implementation. */
for (i = 0; i < j; i += length + 1) {
length = (config_rom[i] >> 16) & 0xff;
config_rom[i] |= crc16_itu_t(&config_rom[i + 1], length);
}
*config_rom_length = j;
return config_rom;
}
static void
update_config_roms (void)
{
struct fw_card *card;
u32 *config_rom;
size_t length;
list_for_each_entry (card, &card_list, link) {
config_rom = generate_config_rom(card, &length);
card->driver->set_config_rom(card, config_rom, length);
}
}
int
fw_core_add_descriptor (struct fw_descriptor *desc)
{
size_t i;
/* Check descriptor is valid; the length of all blocks in the
* descriptor has to add up to exactly the length of the
* block. */
i = 0;
while (i < desc->length)
i += (desc->data[i] >> 16) + 1;
if (i != desc->length)
return -1;
down_write(&fw_bus_type.subsys.rwsem);
list_add_tail (&desc->link, &descriptor_list);
descriptor_count++;
update_config_roms();
up_write(&fw_bus_type.subsys.rwsem);
return 0;
}
EXPORT_SYMBOL(fw_core_add_descriptor);
void
fw_core_remove_descriptor (struct fw_descriptor *desc)
{
down_write(&fw_bus_type.subsys.rwsem);
list_del(&desc->link);
descriptor_count--;
update_config_roms();
up_write(&fw_bus_type.subsys.rwsem);
}
EXPORT_SYMBOL(fw_core_remove_descriptor);
static void
release_card(struct device *device)
{
struct fw_card *card =
container_of(device, struct fw_card, card_device);
kfree(card);
}
static void
flush_timer_callback(unsigned long data)
{
struct fw_card *card = (struct fw_card *)data;
fw_flush_transactions(card);
}
void
fw_card_initialize(struct fw_card *card, struct fw_card_driver *driver,
struct device *device)
{
static int index;
card->index = index++;
card->driver = driver;
card->device = device;
card->current_tlabel = 0;
card->tlabel_mask = 0;
card->color = 0;
INIT_LIST_HEAD(&card->transaction_list);
spin_lock_init(&card->lock);
setup_timer(&card->flush_timer,
flush_timer_callback, (unsigned long)card);
card->local_node = NULL;
card->card_device.bus = &fw_bus_type;
card->card_device.release = release_card;
card->card_device.parent = card->device;
snprintf(card->card_device.bus_id, sizeof card->card_device.bus_id,
"fwcard%d", card->index);
device_initialize(&card->card_device);
}
EXPORT_SYMBOL(fw_card_initialize);
int
fw_card_add(struct fw_card *card,
u32 max_receive, u32 link_speed, u64 guid)
{
int retval;
u32 *config_rom;
size_t length;
card->max_receive = max_receive;
card->link_speed = link_speed;
card->guid = guid;
/* FIXME: add #define's for phy registers. */
/* Activate link_on bit and contender bit in our self ID packets.*/
if (card->driver->update_phy_reg(card, 4, 0, 0x80 | 0x40) < 0)
return -EIO;
retval = device_add(&card->card_device);
if (retval < 0) {
fw_error("Failed to register card device.");
return retval;
}
/* 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(&fw_bus_type.subsys.rwsem);
config_rom = generate_config_rom (card, &length);
list_add_tail(&card->link, &card_list);
up_write(&fw_bus_type.subsys.rwsem);
return card->driver->enable(card, config_rom, length);
}
EXPORT_SYMBOL(fw_card_add);
/* 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. */
static int
dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
{
BUG();
return -1;
}
static int
dummy_update_phy_reg(struct fw_card *card, int address,
int clear_bits, int set_bits)
{
return -ENODEV;
}
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. */
BUG();
return -1;
}
static void
dummy_send_request(struct fw_card *card, struct fw_packet *packet)
{
packet->callback(packet, card, -ENODEV);
}
static void
dummy_send_response(struct fw_card *card, struct fw_packet *packet)
{
packet->callback(packet, card, -ENODEV);
}
static int
dummy_enable_phys_dma(struct fw_card *card,
int node_id, int generation)
{
return -ENODEV;
}
static struct fw_card_driver dummy_driver = {
.name = "dummy",
.enable = dummy_enable,
.update_phy_reg = dummy_update_phy_reg,
.set_config_rom = dummy_set_config_rom,
.send_request = dummy_send_request,
.send_response = dummy_send_response,
.enable_phys_dma = dummy_enable_phys_dma
};
void
fw_core_remove_card(struct fw_card *card)
{
card->driver->update_phy_reg(card, 4, 0x80 | 0x40, 0);
fw_core_initiate_bus_reset(card, 1);
down_write(&fw_bus_type.subsys.rwsem);
list_del(&card->link);
up_write(&fw_bus_type.subsys.rwsem);
/* Set up the dummy driver. */
card->driver = &dummy_driver;
fw_flush_transactions(card);
fw_destroy_nodes(card);
/* This also drops the subsystem reference. */
device_unregister(&card->card_device);
}
EXPORT_SYMBOL(fw_core_remove_card);
struct fw_card *
fw_card_get(struct fw_card *card)
{
get_device(&card->card_device);
return card;
}
EXPORT_SYMBOL(fw_card_get);
/* 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. */
void
fw_card_put(struct fw_card *card)
{
put_device(&card->card_device);
}
EXPORT_SYMBOL(fw_card_put);
int
fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
{
u32 address;
if (short_reset)
address = 5;
else
address = 1;
return card->driver->update_phy_reg(card, address, 0, 0x40);
}
EXPORT_SYMBOL(fw_core_initiate_bus_reset);
drivers/firewire/fw-iso.c
+136
View File
@@ -0,0 +1,136 @@
/* -*- c-basic-offset: 8 -*-
*
* 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
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include "fw-transaction.h"
#include "fw-topology.h"
static int
setup_iso_buffer(struct fw_iso_context *ctx, size_t size,
enum dma_data_direction direction)
{
struct page *page;
int i;
void *p;
ctx->buffer_size = PAGE_ALIGN(size);
if (size == 0)
return 0;
ctx->buffer = vmalloc_32_user(ctx->buffer_size);
if (ctx->buffer == NULL)
return -ENOMEM;
ctx->page_count = ctx->buffer_size >> PAGE_SHIFT;
ctx->pages =
kzalloc(ctx->page_count * sizeof(ctx->pages[0]), GFP_KERNEL);
if (ctx->pages == NULL) {
vfree(ctx->buffer);
return -ENOMEM;
}
p = ctx->buffer;
for (i = 0; i < ctx->page_count; i++, p += PAGE_SIZE) {
page = vmalloc_to_page(p);
ctx->pages[i] = dma_map_page(ctx->card->device,
page, 0, PAGE_SIZE, direction);
}
return 0;
}
static void destroy_iso_buffer(struct fw_iso_context *ctx)
{
int i;
for (i = 0; i < ctx->page_count; i++)
dma_unmap_page(ctx->card->device, ctx->pages[i],
PAGE_SIZE, DMA_TO_DEVICE);
kfree(ctx->pages);
vfree(ctx->buffer);
}
struct fw_iso_context *fw_iso_context_create(struct fw_card *card, int type,
size_t buffer_size,
fw_iso_callback_t callback,
void *callback_data)
{
struct fw_iso_context *ctx;
int retval;
ctx = card->driver->allocate_iso_context(card, type);
if (IS_ERR(ctx))
return ctx;
ctx->card = card;
ctx->type = type;
ctx->callback = callback;
ctx->callback_data = callback_data;
retval = setup_iso_buffer(ctx, buffer_size, DMA_TO_DEVICE);
if (retval < 0) {
card->driver->free_iso_context(ctx);
return ERR_PTR(retval);
}
return ctx;
}
EXPORT_SYMBOL(fw_iso_context_create);
void fw_iso_context_destroy(struct fw_iso_context *ctx)
{
struct fw_card *card = ctx->card;
destroy_iso_buffer(ctx);
card->driver->free_iso_context(ctx);
}
EXPORT_SYMBOL(fw_iso_context_destroy);
int
fw_iso_context_send(struct fw_iso_context *ctx,
int channel, int speed, int cycle)
{
ctx->channel = channel;
ctx->speed = speed;
return ctx->card->driver->send_iso(ctx, cycle);
}
EXPORT_SYMBOL(fw_iso_context_send);
int
fw_iso_context_queue(struct fw_iso_context *ctx,
struct fw_iso_packet *packet, void *payload)
{
struct fw_card *card = ctx->card;
return card->driver->queue_iso(ctx, packet, payload);
}
EXPORT_SYMBOL(fw_iso_context_queue);
drivers/firewire/fw-topology.c
+446
View File
@@ -0,0 +1,446 @@
/* -*- c-basic-offset: 8 -*-
*
* fw-topology.c - Incremental bus scan, based on bus topology
*
* Copyright (C) 2004-2006 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <linux/module.h>
#include <linux/wait.h>
#include <linux/errno.h>
#include "fw-transaction.h"
#include "fw-topology.h"
#define self_id_phy_id(q) (((q) >> 24) & 0x3f)
#define self_id_extended(q) (((q) >> 23) & 0x01)
#define self_id_link_on(q) (((q) >> 22) & 0x01)
#define self_id_gap_count(q) (((q) >> 16) & 0x3f)
#define self_id_phy_speed(q) (((q) >> 14) & 0x03)
#define self_id_contender(q) (((q) >> 11) & 0x01)
#define self_id_phy_initiator(q) (((q) >> 1) & 0x01)
#define self_id_more_packets(q) (((q) >> 0) & 0x01)
#define self_id_ext_sequence(q) (((q) >> 20) & 0x07)
static u32 *count_ports(u32 *sid, int *total_port_count, int *child_port_count)
{
u32 q;
int port_type, shift, seq;
*total_port_count = 0;
*child_port_count = 0;
shift = 6;
q = *sid;
seq = 0;
while (1) {
port_type = (q >> shift) & 0x03;
switch (port_type) {
case SELFID_PORT_CHILD:
(*child_port_count)++;
case SELFID_PORT_PARENT:
case SELFID_PORT_NCONN:
(*total_port_count)++;
case SELFID_PORT_NONE:
break;
}
shift -= 2;
if (shift == 0) {
if (!self_id_more_packets(q))
return sid + 1;
shift = 16;
sid++;
q = *sid;
/* 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. */
if (!self_id_extended(q) ||
seq != self_id_ext_sequence(q))
return NULL;
seq++;
}
}
}
static int get_port_type(u32 *sid, int port_index)
{
int index, shift;
index = (port_index + 5) / 8;
shift = 16 - ((port_index + 5) & 7) * 2;
return (sid[index] >> shift) & 0x03;
}
struct fw_node *fw_node_create(u32 sid, int port_count, int color)
{
struct fw_node *node;
node = kzalloc(sizeof *node + port_count * sizeof node->ports[0],
GFP_ATOMIC);
if (node == NULL)
return NULL;
node->color = color;
node->node_id = self_id_phy_id(sid);
node->link_on = self_id_link_on(sid);
node->phy_speed = self_id_phy_speed(sid);
node->port_count = port_count;
atomic_set(&node->ref_count, 1);
INIT_LIST_HEAD(&node->link);
return node;
}
/**
* build_tree - Build the tree representation of the topology
* @self_ids: array of self IDs to create the tree from
* @self_id_count: the length of the self_ids array
* @local_id: the node ID of the local node
*
* This function builds the tree representation of the topology given
* by the self IDs from the latest bus reset. During the construction
* of the tree, the function checks that the self IDs are valid and
* internally consistent. On succcess this funtions returns the
* fw_node corresponding to the local card otherwise NULL.
*/
static struct fw_node *build_tree(struct fw_card *card)
{
struct fw_node *node, *child, *local_node;
struct list_head stack, *h;
u32 *sid, *next_sid, *end, q;
int i, port_count, child_port_count, phy_id, parent_count, stack_depth;
local_node = NULL;
node = NULL;
INIT_LIST_HEAD(&stack);
stack_depth = 0;
sid = card->self_ids;
end = sid + card->self_id_count;
phy_id = 0;
card->irm_node = NULL;
while (sid < end) {
next_sid = count_ports(sid, &port_count, &child_port_count);
if (next_sid == NULL) {
fw_error("Inconsistent extended self IDs.\n");
return NULL;
}
q = *sid;
if (phy_id != self_id_phy_id(q)) {
fw_error("PHY ID mismatch in self ID: %d != %d.\n",
phy_id, self_id_phy_id(q));
return NULL;
}
if (child_port_count > stack_depth) {
fw_error("Topology stack underflow\n");
return NULL;
}
/* 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);
node = fw_node_create(q, port_count, card->color);
if (node == NULL) {
fw_error("Out of memory while building topology.");
return NULL;
}
if (phy_id == (card->node_id & 0x3f))
local_node = node;
if (self_id_contender(q))
card->irm_node = node;
parent_count = 0;
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
* parent node at this time, so we
* temporarily abuse node->color for
* remembering the entry in the
* node->ports array where the parent
* node should be. Later, when we
* handle the parent node, we fix up
* the reference.
*/
parent_count++;
node->color = i;
break;
case SELFID_PORT_CHILD:
node->ports[i].node = child;
/* Fix up parent reference for this
* child node. */
child->ports[child->color].node = node;
child->color = card->color;
child = fw_node(child->link.next);
break;
}
}
/* Check that the node reports exactly one parent
* port, except for the root, which of course should
* have no parents. */
if ((next_sid == end && parent_count != 0) ||
(next_sid < end && parent_count != 1)) {
fw_error("Parent port inconsistency for node %d: "
"parent_count=%d\n", phy_id, parent_count);
return NULL;
}
/* Pop the child nodes off the stack and push the new node. */
__list_del(h->prev, &stack);
list_add_tail(&node->link, &stack);
stack_depth += 1 - child_port_count;
sid = next_sid;
phy_id++;
}
card->root_node = node;
return local_node;
}
typedef void (*fw_node_callback_t) (struct fw_card * card,
struct fw_node * node,
struct fw_node * parent);
static void
for_each_fw_node(struct fw_card *card, struct fw_node *root,
fw_node_callback_t callback)
{
struct list_head list;
struct fw_node *node, *next, *child, *parent;
int i;
INIT_LIST_HEAD(&list);
fw_node_get(root);
list_add_tail(&root->link, &list);
parent = NULL;
list_for_each_entry(node, &list, link) {
node->color = card->color;
for (i = 0; i < node->port_count; i++) {
child = node->ports[i].node;
if (!child)
continue;
if (child->color == card->color)
parent = child;
else {
fw_node_get(child);
list_add_tail(&child->link, &list);
}
}
callback(card, node, parent);
}
list_for_each_entry_safe(node, next, &list, link)
fw_node_put(node);
}
static void
report_lost_node(struct fw_card *card,
struct fw_node *node, struct fw_node *parent)
{
fw_node_event(card, node, FW_NODE_DESTROYED);
fw_node_put(node);
}
static void
report_found_node(struct fw_card *card,
struct fw_node *node, struct fw_node *parent)
{
int b_path = (node->phy_speed == SCODE_BETA);
if (parent != NULL) {
node->max_speed = min(parent->max_speed, node->phy_speed);
node->b_path = parent->b_path && b_path;
} else {
node->max_speed = node->phy_speed;
node->b_path = b_path;
}
fw_node_event(card, node, FW_NODE_CREATED);
}
void fw_destroy_nodes(struct fw_card *card)
{
unsigned long flags;
spin_lock_irqsave(&card->lock, flags);
card->color++;
if (card->local_node != NULL)
for_each_fw_node(card, card->local_node, report_lost_node);
spin_unlock_irqrestore(&card->lock, flags);
}
static void move_tree(struct fw_node *node0, struct fw_node *node1, int port)
{
struct fw_node *tree;
int i;
tree = node1->ports[port].node;
node0->ports[port].node = tree;
for (i = 0; i < tree->port_count; i++) {
if (tree->ports[i].node == node1) {
tree->ports[i].node = node0;
break;
}
}
}
/**
* update_tree - compare the old topology tree for card with the new
* one specified by root. Queue the nodes and mark them as either
* found, lost or updated. Update the nodes in the card topology tree
* as we go.
*/
static void
update_tree(struct fw_card *card, struct fw_node *root, int *changed)
{
struct list_head list0, list1;
struct fw_node *node0, *node1;
int i, event;
INIT_LIST_HEAD(&list0);
list_add_tail(&card->local_node->link, &list0);
INIT_LIST_HEAD(&list1);
list_add_tail(&root->link, &list1);
node0 = fw_node(list0.next);
node1 = fw_node(list1.next);
*changed = 0;
while (&node0->link != &list0) {
/* assert(node0->port_count == node1->port_count); */
if (node0->link_on && !node1->link_on)
event = FW_NODE_LINK_OFF;
else if (!node0->link_on && node1->link_on)
event = FW_NODE_LINK_ON;
else
event = FW_NODE_UPDATED;
node0->node_id = node1->node_id;
node0->color = card->color;
node0->link_on = node1->link_on;
node0->initiated_reset = node1->initiated_reset;
node1->color = card->color;
fw_node_event(card, node0, event);
if (card->root_node == node1)
card->root_node = node0;
if (card->irm_node == node1)
card->irm_node = node0;
for (i = 0; i < node0->port_count; i++) {
if (node0->ports[i].node && node1->ports[i].node) {
/* This port didn't change, queue the
* connected node for further
* investigation. */
if (node0->ports[i].node->color == card->color)
continue;
list_add_tail(&node0->ports[i].node->link,
&list0);
list_add_tail(&node1->ports[i].node->link,
&list1);
} else if (node0->ports[i].node) {
/* The nodes connected here were
* unplugged; unref the lost nodes and
* queue FW_NODE_LOST callbacks for
* them. */
for_each_fw_node(card, node0->ports[i].node,
report_lost_node);
node0->ports[i].node = NULL;
*changed = 1;
} else if (node1->ports[i].node) {
/* One or more node were connected to
* this port. Move the new nodes into
* the tree and queue FW_NODE_CREATED
* callbacks for them. */
move_tree(node0, node1, i);
for_each_fw_node(card, node0->ports[i].node,
report_found_node);
*changed = 1;
}
}
node0 = fw_node(node0->link.next);
node1 = fw_node(node1->link.next);
}
}
void
fw_core_handle_bus_reset(struct fw_card *card,
int node_id, int generation,
int self_id_count, u32 * self_ids)
{
struct fw_node *local_node;
unsigned long flags;
int changed;
fw_flush_transactions(card);
spin_lock_irqsave(&card->lock, flags);
card->node_id = node_id;
card->self_id_count = self_id_count;
card->generation = generation;
memcpy(card->self_ids, self_ids, self_id_count * 4);
local_node = build_tree(card);
card->color++;
if (local_node == NULL) {
fw_error("topology build failed\n");
/* FIXME: We need to issue a bus reset in this case. */
} else if (card->local_node == NULL) {
card->local_node = local_node;
for_each_fw_node(card, local_node, report_found_node);
} else {
update_tree(card, local_node, &changed);
}
spin_unlock_irqrestore(&card->lock, flags);
}
EXPORT_SYMBOL(fw_core_handle_bus_reset);
void fw_node_event(struct fw_card *card, struct fw_node *node, int event)
{
}
drivers/firewire/fw-topology.h
+84
View File
@@ -0,0 +1,84 @@
/* -*- 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
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __fw_topology_h
#define __fw_topology_h
enum {
FW_NODE_CREATED = 0x00,
FW_NODE_UPDATED = 0x01,
FW_NODE_DESTROYED = 0x02,
FW_NODE_LINK_ON = 0x03,
FW_NODE_LINK_OFF = 0x04
};
struct fw_port {
struct fw_node *node;
unsigned speed : 3; /* S100, S200, ... S3200 */
};
struct fw_node {
u16 node_id;
u8 color;
u8 port_count;
unsigned link_on : 1;
unsigned initiated_reset : 1;
unsigned b_path : 1;
u8 phy_speed; /* As in the self ID packet. */
u8 max_speed; /* Minimum of all phy-speeds and port speeds on
* the path from the local node to this node. */
atomic_t ref_count;
/* For serializing node topology into a list. */
struct list_head link;
/* Upper layer specific data. */
void *data;
struct fw_port ports[0];
};
extern inline struct fw_node *
fw_node(struct list_head *l)
{
return list_entry (l, struct fw_node, link);
}
extern inline struct fw_node *
fw_node_get(struct fw_node *node)
{
atomic_inc(&node->ref_count);
return node;
}
extern inline void
fw_node_put(struct fw_node *node)
{
if (atomic_dec_and_test(&node->ref_count))
kfree(node);
}
void
fw_destroy_nodes(struct fw_card *card);
#endif
drivers/firewire/fw-transaction.c
+730
View File
File diff suppressed because it is too large Load Diff
drivers/firewire/fw-transaction.h
+422
View File
@@ -0,0 +1,422 @@
/* -*- 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
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __fw_core_h
#define __fw_core_h
#include <linux/device.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/fs.h>
#define TCODE_WRITE_QUADLET_REQUEST 0
#define TCODE_WRITE_BLOCK_REQUEST 1
#define TCODE_WRITE_RESPONSE 2
#define TCODE_READ_QUADLET_REQUEST 4
#define TCODE_READ_BLOCK_REQUEST 5
#define TCODE_READ_QUADLET_RESPONSE 6
#define TCODE_READ_BLOCK_RESPONSE 7
#define TCODE_CYCLE_START 8
#define TCODE_LOCK_REQUEST 9
#define TCODE_STREAM_DATA 10
#define TCODE_LOCK_RESPONSE 11
#define TCODE_IS_BLOCK_PACKET(tcode) (((tcode) & 1) != 0)
#define TCODE_IS_REQUEST(tcode) (((tcode) & 2) == 0)
#define TCODE_IS_RESPONSE(tcode) (((tcode) & 2) != 0)
#define TCODE_HAS_REQUEST_DATA(tcode) (((tcode) & 12) != 4)
#define TCODE_HAS_RESPONSE_DATA(tcode) (((tcode) & 12) != 0)
/* Juju specific tcodes */
#define TCODE_DEALLOCATE 0x10
#define TCODE_LOCK_MASK_SWAP 0x11
#define TCODE_LOCK_COMPARE_SWAP 0x12
#define TCODE_LOCK_FETCH_ADD 0x13
#define TCODE_LOCK_LITTLE_ADD 0x14
#define TCODE_LOCK_BOUNDED_ADD 0x15
#define TCODE_LOCK_WRAP_ADD 0x16
#define TCODE_LOCK_VENDOR_SPECIFIC 0x17
#define SCODE_100 0x0
#define SCODE_200 0x1
#define SCODE_400 0x2
#define SCODE_BETA 0x3
#define EXTCODE_MASK_SWAP 0x1
#define EXTCODE_COMPARE_SWAP 0x2
#define EXTCODE_FETCH_ADD 0x3
#define EXTCODE_LITTLE_ADD 0x4
#define EXTCODE_BOUNDED_ADD 0x5
#define EXTCODE_WRAP_ADD 0x6
#define ACK_COMPLETE 0x1
#define ACK_PENDING 0x2
#define ACK_BUSY_X 0x4
#define ACK_BUSY_A 0x5
#define ACK_BUSY_B 0x6
#define ACK_DATA_ERROR 0xd
#define ACK_TYPE_ERROR 0xe
#define RCODE_COMPLETE 0x0
#define RCODE_CONFLICT_ERROR 0x4
#define RCODE_DATA_ERROR 0x5
#define RCODE_TYPE_ERROR 0x6
#define RCODE_ADDRESS_ERROR 0x7
/* Juju specific rcodes */
#define RCODE_SEND_ERROR 0x10
#define RCODE_CANCELLED 0x11
#define RCODE_BUSY 0x12
#define RETRY_1 0x00
#define RETRY_X 0x01
#define RETRY_A 0x02
#define RETRY_B 0x03
#define LOCAL_BUS 0xffc0
#define SELFID_PORT_CHILD 0x3
#define SELFID_PORT_PARENT 0x2
#define SELFID_PORT_NCONN 0x1
#define SELFID_PORT_NONE 0x0
#define PHY_PACKET_CONFIG 0x0
#define PHY_PACKET_LINK_ON 0x1
#define PHY_PACKET_SELF_ID 0x2
#define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
#define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
#define fw_debug(s, args...) printk(KERN_DEBUG KBUILD_MODNAME ": " s, ## args)
static inline void
fw_memcpy_from_be32(void *_dst, void *_src, size_t size)
{
u32 *dst = _dst;
u32 *src = _src;
int i;
for (i = 0; i < size / 4; i++)
dst[i] = cpu_to_be32(src[i]);
}
static inline void
fw_memcpy_to_be32(void *_dst, void *_src, size_t size)
{
fw_memcpy_from_be32(_dst, _src, size);
}
struct fw_card;
struct fw_packet;
struct fw_node;
struct fw_request;
struct fw_descriptor {
struct list_head link;
size_t length;
u32 key;
u32 *data;
};
int fw_core_add_descriptor (struct fw_descriptor *desc);
void fw_core_remove_descriptor (struct fw_descriptor *desc);
typedef void (*fw_packet_callback_t) (struct fw_packet *packet,
struct fw_card *card, int status);
typedef void (*fw_transaction_callback_t)(struct fw_card *card, int rcode,
void *data,
size_t length,
void *callback_data);
typedef void (*fw_address_callback_t)(struct fw_card *card,
struct fw_request *request,
int tcode, int destination, int source,
int generation, int speed,
unsigned long long offset,
void *data, size_t length,
void *callback_data);
typedef void (*fw_bus_reset_callback_t)(struct fw_card *handle,
int node_id, int generation,
u32 *self_ids,
int self_id_count,
void *callback_data);
struct fw_packet {
int speed;
int generation;
u32 header[4];
size_t header_length;
void *payload;
size_t payload_length;
u32 timestamp;
dma_addr_t payload_bus;
/* 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.
* The callback can be called from tasklet context and thus
* must never block.
*/
fw_packet_callback_t callback;
int status;
struct list_head link;
};
struct fw_transaction {
int node_id; /* The generation is implied; it is always the current. */
int tlabel;
int timestamp;
struct list_head link;
struct fw_packet packet;
/* The data passed to the callback is valid only during the
* callback. */
fw_transaction_callback_t callback;
void *callback_data;
};
extern inline struct fw_packet *
fw_packet(struct list_head *l)
{
return list_entry (l, struct fw_packet, link);
}
struct fw_address_handler {
u64 offset;
size_t length;
fw_address_callback_t address_callback;
void *callback_data;
struct list_head link;
};
struct fw_address_region {
u64 start;
u64 end;
};
extern struct fw_address_region fw_low_memory_region;
extern struct fw_address_region fw_high_memory_region;
extern struct fw_address_region fw_private_region;
extern struct fw_address_region fw_csr_region;
extern struct fw_address_region fw_unit_space_region;
int fw_core_add_address_handler(struct fw_address_handler *handler,
struct fw_address_region *region);
void fw_core_remove_address_handler(struct fw_address_handler *handler);
void fw_send_response(struct fw_card *card,
struct fw_request *request, int rcode);
extern struct bus_type fw_bus_type;
struct fw_card {
struct fw_card_driver *driver;
struct device *device;
int node_id;
int generation;
/* This is the generation used for timestamping incoming requests. */
int request_generation;
int current_tlabel, tlabel_mask;
struct list_head transaction_list;
struct timer_list flush_timer;
unsigned long long guid;
int max_receive;
int link_speed;
int config_rom_generation;
/* We need to store up to 4 self ID for a maximum of 63 devices. */
int self_id_count;
u32 self_ids[252];
spinlock_t lock; /* Take this lock when handling the lists in
* this struct. */
struct fw_node *local_node;
struct fw_node *root_node;
struct fw_node *irm_node;
int color;
int index;
struct device card_device;
struct list_head link;
};
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
* 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). */
struct fw_iso_packet {
u16 payload_length; /* Length of indirect payload. */
u32 interrupt : 1; /* Generate interrupt on this packet */
u32 skip : 1; /* Set to not send packet at all. */
u32 tag : 2;
u32 sy : 4;
u32 header_length : 8; /* Length of immediate header. */
u32 header[0];
};
#define FW_ISO_CONTEXT_TRANSMIT 0
#define FW_ISO_CONTEXT_RECEIVE 1
struct fw_iso_context;
typedef void (*fw_iso_callback_t) (struct fw_iso_context *context,
int status, u32 cycle, void *data);
struct fw_iso_context {
struct fw_card *card;
int type;
int channel;
int speed;
fw_iso_callback_t callback;
void *callback_data;
void *buffer;
size_t buffer_size;
dma_addr_t *pages;
int page_count;
};
struct fw_iso_context *
fw_iso_context_create(struct fw_card *card, int type,
size_t buffer_size,
fw_iso_callback_t callback,
void *callback_data);
void
fw_iso_context_destroy(struct fw_iso_context *ctx);
void
fw_iso_context_start(struct fw_iso_context *ctx,
int channel, int speed, int cycle);
int
fw_iso_context_queue(struct fw_iso_context *ctx,
struct fw_iso_packet *packet, void *payload);
int
fw_iso_context_send(struct fw_iso_context *ctx,
int channel, int speed, int cycle);
struct fw_card_driver {
const char *name;
/* 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. */
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
* should change the config rom that is presented on the bus
* an initiate a bus reset. */
int (*set_config_rom) (struct fw_card *card,
u32 *config_rom, size_t length);
void (*send_request) (struct fw_card *card, struct fw_packet *packet);
void (*send_response) (struct fw_card *card, struct fw_packet *packet);
/* 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. */
int (*enable_phys_dma) (struct fw_card *card,
int node_id, int generation);
struct fw_iso_context *
(*allocate_iso_context)(struct fw_card *card, int type);
void (*free_iso_context)(struct fw_iso_context *ctx);
int (*send_iso)(struct fw_iso_context *ctx, s32 cycle);
int (*queue_iso)(struct fw_iso_context *ctx,
struct fw_iso_packet *packet, void *payload);
};
int
fw_core_initiate_bus_reset(struct fw_card *card, int short_reset);
void
fw_send_request(struct fw_card *card, struct fw_transaction *t,
int tcode, int node_id, int generation, int speed,
unsigned long long offset,
void *data, size_t length,
fw_transaction_callback_t callback, void *callback_data);
void fw_flush_transactions(struct fw_card *card);
void
fw_send_force_root(struct fw_card *card, int node_id, int generation);
/* 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, struct fw_card_driver *driver,
struct device *device);
int
fw_card_add(struct fw_card *card,
u32 max_receive, u32 link_speed, u64 guid);
void
fw_core_remove_card(struct fw_card *card);
void
fw_core_handle_bus_reset(struct fw_card *card,
int node_id, int generation,
int self_id_count, u32 *self_ids);
void
fw_core_handle_request(struct fw_card *card,
int speed, int ack, int timestamp,
int generation,
u32 length, u32 *payload);
void
fw_core_handle_response(struct fw_card *card,
int speed, int ack, int timestamp,
u32 length, u32 *payload);
#endif /* __fw_core_h */