redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

ieee1394: whitespace cleanup in hosts.[ch], ieee1394_core.[ch] 

Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
wifi-calibration
Stefan Richter 2005-12-01 18:52:03 -05:00 committed by Jody McIntyre
parent 546513f9fd
commit 741854e4f9
4 changed files with 489 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
drivers/ieee1394/hosts.c
View File

@ -61,12 +61,12 @@ static void delayed_reset_bus(void * __reset_info)
static int dummy_transmit_packet(struct hpsb_host *h, struct hpsb_packet *p) static int dummy_transmit_packet(struct hpsb_host *h, struct hpsb_packet *p)
{ {
return 0; return 0;
} }
static int dummy_devctl(struct hpsb_host *h, enum devctl_cmd c, int arg) static int dummy_devctl(struct hpsb_host *h, enum devctl_cmd c, int arg)
{ {
return -1; return -1;
} }
static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg) static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg)
@ -75,9 +75,9 @@ static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned
} }
static struct hpsb_host_driver dummy_driver = { static struct hpsb_host_driver dummy_driver = {
.transmit_packet = dummy_transmit_packet, .transmit_packet = dummy_transmit_packet,
.devctl = dummy_devctl, .devctl = dummy_devctl,
.isoctl = dummy_isoctl .isoctl = dummy_isoctl
}; };
static int alloc_hostnum_cb(struct hpsb_host *host, void *__data) static int alloc_hostnum_cb(struct hpsb_host *host, void *__data)
@ -110,12 +110,12 @@ static DECLARE_MUTEX(host_num_alloc);
struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra, struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
struct device *dev) struct device *dev)
{ {
struct hpsb_host *h; struct hpsb_host *h;
int i; int i;
int hostnum = 0; int hostnum = 0;
h = kzalloc(sizeof(*h) + extra, SLAB_KERNEL); h = kzalloc(sizeof(*h) + extra, SLAB_KERNEL);
if (!h) if (!h)
return NULL; return NULL;
h->csr.rom = csr1212_create_csr(&csr_bus_ops, CSR_BUS_INFO_SIZE, h); h->csr.rom = csr1212_create_csr(&csr_bus_ops, CSR_BUS_INFO_SIZE, h);
@ -125,7 +125,7 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
} }
h->hostdata = h + 1; h->hostdata = h + 1;
h->driver = drv; h->driver = drv;
skb_queue_head_init(&h->pending_packet_queue); skb_queue_head_init(&h->pending_packet_queue);
INIT_LIST_HEAD(&h->addr_space); INIT_LIST_HEAD(&h->addr_space);
@ -145,8 +145,8 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra,
h->timeout.function = abort_timedouts; h->timeout.function = abort_timedouts;
h->timeout_interval = HZ / 20; // 50ms by default h->timeout_interval = HZ / 20; // 50ms by default
h->topology_map = h->csr.topology_map + 3; h->topology_map = h->csr.topology_map + 3;
h->speed_map = (u8 *)(h->csr.speed_map + 2); h->speed_map = (u8 *)(h->csr.speed_map + 2);
down(&host_num_alloc); down(&host_num_alloc);
@ -186,14 +186,14 @@ int hpsb_add_host(struct hpsb_host *host)
void hpsb_remove_host(struct hpsb_host *host) void hpsb_remove_host(struct hpsb_host *host)
{ {
host->is_shutdown = 1; host->is_shutdown = 1;
cancel_delayed_work(&host->delayed_reset); cancel_delayed_work(&host->delayed_reset);
flush_scheduled_work(); flush_scheduled_work();
host->driver = &dummy_driver; host->driver = &dummy_driver;
highlevel_remove_host(host); highlevel_remove_host(host);
hpsb_remove_extra_config_roms(host); hpsb_remove_extra_config_roms(host);

148
drivers/ieee1394/hosts.h
View File

@ -17,47 +17,47 @@ struct hpsb_packet;
struct hpsb_iso; struct hpsb_iso;
struct hpsb_host { struct hpsb_host {
struct list_head host_list; struct list_head host_list;
void *hostdata; void *hostdata;
atomic_t generation; atomic_t generation;
struct sk_buff_head pending_packet_queue; struct sk_buff_head pending_packet_queue;
struct timer_list timeout; struct timer_list timeout;
unsigned long timeout_interval; unsigned long timeout_interval;
unsigned char iso_listen_count[64]; unsigned char iso_listen_count[64];
int node_count; /* number of identified nodes on this bus */ int node_count; /* number of identified nodes on this bus */
int selfid_count; /* total number of SelfIDs received */ int selfid_count; /* total number of SelfIDs received */
int nodes_active; /* number of nodes that are actually active */ int nodes_active; /* number of nodes that are actually active */
nodeid_t node_id; /* node ID of this host */ nodeid_t node_id; /* node ID of this host */
nodeid_t irm_id; /* ID of this bus' isochronous resource manager */ nodeid_t irm_id; /* ID of this bus' isochronous resource manager */
nodeid_t busmgr_id; /* ID of this bus' bus manager */ nodeid_t busmgr_id; /* ID of this bus' bus manager */
/* this nodes state */ /* this nodes state */
unsigned in_bus_reset:1; unsigned in_bus_reset:1;
unsigned is_shutdown:1; unsigned is_shutdown:1;
unsigned resume_packet_sent:1; unsigned resume_packet_sent:1;
/* this nodes' duties on the bus */ /* this nodes' duties on the bus */
unsigned is_root:1; unsigned is_root:1;
unsigned is_cycmst:1; unsigned is_cycmst:1;
unsigned is_irm:1; unsigned is_irm:1;
unsigned is_busmgr:1; unsigned is_busmgr:1;
int reset_retries; int reset_retries;
quadlet_t *topology_map; quadlet_t *topology_map;
u8 *speed_map; u8 *speed_map;
struct csr_control csr; struct csr_control csr;
/* Per node tlabel pool allocation */ /* Per node tlabel pool allocation */
struct hpsb_tlabel_pool tpool[64]; struct hpsb_tlabel_pool tpool[64];
struct hpsb_host_driver *driver; struct hpsb_host_driver *driver;
struct pci_dev *pdev; struct pci_dev *pdev;
@ -77,34 +77,34 @@ struct hpsb_host {
enum devctl_cmd { enum devctl_cmd {
/* Host is requested to reset its bus and cancel all outstanding async /* Host is requested to reset its bus and cancel all outstanding async
* requests. If arg == 1, it shall also attempt to become root on the * requests. If arg == 1, it shall also attempt to become root on the
* bus. Return void. */ * bus. Return void. */
RESET_BUS, RESET_BUS,
/* Arg is void, return value is the hardware cycle counter value. */ /* Arg is void, return value is the hardware cycle counter value. */
GET_CYCLE_COUNTER, GET_CYCLE_COUNTER,
/* Set the hardware cycle counter to the value in arg, return void. /* Set the hardware cycle counter to the value in arg, return void.
* FIXME - setting is probably not required. */ * FIXME - setting is probably not required. */
SET_CYCLE_COUNTER, SET_CYCLE_COUNTER,
/* Configure hardware for new bus ID in arg, return void. */ /* Configure hardware for new bus ID in arg, return void. */
SET_BUS_ID, SET_BUS_ID,
/* If arg true, start sending cycle start packets, stop if arg == 0. /* If arg true, start sending cycle start packets, stop if arg == 0.
* Return void. */ * Return void. */
ACT_CYCLE_MASTER, ACT_CYCLE_MASTER,
/* Cancel all outstanding async requests without resetting the bus. /* Cancel all outstanding async requests without resetting the bus.
* Return void. */ * Return void. */
CANCEL_REQUESTS, CANCEL_REQUESTS,
/* Start or stop receiving isochronous channel in arg. Return void. /* Start or stop receiving isochronous channel in arg. Return void.
* This acts as an optimization hint, hosts are not required not to * This acts as an optimization hint, hosts are not required not to
* listen on unrequested channels. */ * listen on unrequested channels. */
ISO_LISTEN_CHANNEL, ISO_LISTEN_CHANNEL,
ISO_UNLISTEN_CHANNEL ISO_UNLISTEN_CHANNEL
}; };
enum isoctl_cmd { enum isoctl_cmd {
@ -135,13 +135,13 @@ enum isoctl_cmd {
}; };
enum reset_types { enum reset_types {
/* 166 microsecond reset -- only type of reset available on /* 166 microsecond reset -- only type of reset available on
non-1394a capable controllers */ non-1394a capable controllers */
LONG_RESET, LONG_RESET,
/* Short (arbitrated) reset -- only available on 1394a capable /* Short (arbitrated) reset -- only available on 1394a capable
controllers */ controllers */
SHORT_RESET, SHORT_RESET,
/* Variants that set force_root before issueing the bus reset */ /* Variants that set force_root before issueing the bus reset */
LONG_RESET_FORCE_ROOT, SHORT_RESET_FORCE_ROOT, LONG_RESET_FORCE_ROOT, SHORT_RESET_FORCE_ROOT,
@ -159,22 +159,22 @@ struct hpsb_host_driver {
* reads to the ConfigROM on its own. */ * reads to the ConfigROM on its own. */
void (*set_hw_config_rom) (struct hpsb_host *host, quadlet_t *config_rom); void (*set_hw_config_rom) (struct hpsb_host *host, quadlet_t *config_rom);
/* This function shall implement packet transmission based on /* This function shall implement packet transmission based on
* packet->type. It shall CRC both parts of the packet (unless * packet->type. It shall CRC both parts of the packet (unless
* packet->type == raw) and do byte-swapping as necessary or instruct * packet->type == raw) and do byte-swapping as necessary or instruct
* the hardware to do so. It can return immediately after the packet * the hardware to do so. It can return immediately after the packet
* was queued for sending. After sending, hpsb_sent_packet() has to be * was queued for sending. After sending, hpsb_sent_packet() has to be
* called. Return 0 on success, negative errno on failure. * called. Return 0 on success, negative errno on failure.
* NOTE: The function must be callable in interrupt context. * NOTE: The function must be callable in interrupt context.
*/ */
int (*transmit_packet) (struct hpsb_host *host, int (*transmit_packet) (struct hpsb_host *host,
struct hpsb_packet *packet); struct hpsb_packet *packet);
/* This function requests miscellanous services from the driver, see /* This function requests miscellanous services from the driver, see
* above for command codes and expected actions. Return -1 for unknown * above for command codes and expected actions. Return -1 for unknown
* command, though that should never happen. * command, though that should never happen.
*/ */
int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg); int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg);
/* ISO transmission/reception functions. Return 0 on success, -1 /* ISO transmission/reception functions. Return 0 on success, -1
* (or -EXXX errno code) on failure. If the low-level driver does not * (or -EXXX errno code) on failure. If the low-level driver does not
@ -182,15 +182,15 @@ struct hpsb_host_driver {
*/ */
int (*isoctl) (struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg); int (*isoctl) (struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg);
/* This function is mainly to redirect local CSR reads/locks to the iso /* This function is mainly to redirect local CSR reads/locks to the iso
* management registers (bus manager id, bandwidth available, channels * management registers (bus manager id, bandwidth available, channels
* available) to the hardware registers in OHCI. reg is 0,1,2,3 for bus * available) to the hardware registers in OHCI. reg is 0,1,2,3 for bus
* mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids * mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids
* as OHCI uses). data and compare are the new data and expected data * as OHCI uses). data and compare are the new data and expected data
* respectively, return value is the old value. * respectively, return value is the old value.
*/ */
quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg, quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg,
quadlet_t data, quadlet_t compare); quadlet_t data, quadlet_t compare);
}; };

702
drivers/ieee1394/ieee1394_core.c
View File

@ -179,34 +179,34 @@ void hpsb_free_packet(struct hpsb_packet *packet)
int hpsb_reset_bus(struct hpsb_host *host, int type) int hpsb_reset_bus(struct hpsb_host *host, int type)
{ {
if (!host->in_bus_reset) { if (!host->in_bus_reset) {
host->driver->devctl(host, RESET_BUS, type); host->driver->devctl(host, RESET_BUS, type);
return 0; return 0;
} else { } else {
return 1; return 1;
} }
} }
int hpsb_bus_reset(struct hpsb_host *host) int hpsb_bus_reset(struct hpsb_host *host)
{ {
if (host->in_bus_reset) { if (host->in_bus_reset) {
HPSB_NOTICE("%s called while bus reset already in progress", HPSB_NOTICE("%s called while bus reset already in progress",
__FUNCTION__); __FUNCTION__);
return 1; return 1;
} }
abort_requests(host); abort_requests(host);
host->in_bus_reset = 1; host->in_bus_reset = 1;
host->irm_id = -1; host->irm_id = -1;
host->is_irm = 0; host->is_irm = 0;
host->busmgr_id = -1; host->busmgr_id = -1;
host->is_busmgr = 0; host->is_busmgr = 0;
host->is_cycmst = 0; host->is_cycmst = 0;
host->node_count = 0; host->node_count = 0;
host->selfid_count = 0; host->selfid_count = 0;
return 0; return 0;
} }
@ -216,47 +216,47 @@ int hpsb_bus_reset(struct hpsb_host *host)
*/ */
static int check_selfids(struct hpsb_host *host) static int check_selfids(struct hpsb_host *host)
{ {
int nodeid = -1; int nodeid = -1;
int rest_of_selfids = host->selfid_count; int rest_of_selfids = host->selfid_count;
struct selfid *sid = (struct selfid *)host->topology_map; struct selfid *sid = (struct selfid *)host->topology_map;
struct ext_selfid *esid; struct ext_selfid *esid;
int esid_seq = 23; int esid_seq = 23;
host->nodes_active = 0; host->nodes_active = 0;
while (rest_of_selfids--) { while (rest_of_selfids--) {
if (!sid->extended) { if (!sid->extended) {
nodeid++; nodeid++;
esid_seq = 0; esid_seq = 0;
if (sid->phy_id != nodeid) { if (sid->phy_id != nodeid) {
HPSB_INFO("SelfIDs failed monotony check with " HPSB_INFO("SelfIDs failed monotony check with "
"%d", sid->phy_id); "%d", sid->phy_id);
return 0; return 0;
} }
if (sid->link_active) { if (sid->link_active) {
host->nodes_active++; host->nodes_active++;
if (sid->contender) if (sid->contender)
host->irm_id = LOCAL_BUS | sid->phy_id; host->irm_id = LOCAL_BUS | sid->phy_id;
} }
} else { } else {
esid = (struct ext_selfid *)sid; esid = (struct ext_selfid *)sid;
if ((esid->phy_id != nodeid) if ((esid->phy_id != nodeid)
|| (esid->seq_nr != esid_seq)) { || (esid->seq_nr != esid_seq)) {
HPSB_INFO("SelfIDs failed monotony check with " HPSB_INFO("SelfIDs failed monotony check with "
"%d/%d", esid->phy_id, esid->seq_nr); "%d/%d", esid->phy_id, esid->seq_nr);
return 0; return 0;
} }
esid_seq++; esid_seq++;
} }
sid++; sid++;
} }
esid = (struct ext_selfid *)(sid - 1); esid = (struct ext_selfid *)(sid - 1);
while (esid->extended) { while (esid->extended) {
if ((esid->porta == SELFID_PORT_PARENT) || if ((esid->porta == SELFID_PORT_PARENT) ||
(esid->portb == SELFID_PORT_PARENT) || (esid->portb == SELFID_PORT_PARENT) ||
(esid->portc == SELFID_PORT_PARENT) || (esid->portc == SELFID_PORT_PARENT) ||
(esid->portd == SELFID_PORT_PARENT) || (esid->portd == SELFID_PORT_PARENT) ||
@ -267,47 +267,47 @@ static int check_selfids(struct hpsb_host *host)
HPSB_INFO("SelfIDs failed root check on " HPSB_INFO("SelfIDs failed root check on "
"extended SelfID"); "extended SelfID");
return 0; return 0;
} }
esid--; esid--;
} }
sid = (struct selfid *)esid; sid = (struct selfid *)esid;
if ((sid->port0 == SELFID_PORT_PARENT) || if ((sid->port0 == SELFID_PORT_PARENT) ||
(sid->port1 == SELFID_PORT_PARENT) || (sid->port1 == SELFID_PORT_PARENT) ||
(sid->port2 == SELFID_PORT_PARENT)) { (sid->port2 == SELFID_PORT_PARENT)) {
HPSB_INFO("SelfIDs failed root check"); HPSB_INFO("SelfIDs failed root check");
return 0; return 0;
} }
host->node_count = nodeid + 1; host->node_count = nodeid + 1;
return 1; return 1;
} }
static void build_speed_map(struct hpsb_host *host, int nodecount) static void build_speed_map(struct hpsb_host *host, int nodecount)
{ {
u8 speedcap[nodecount]; u8 speedcap[nodecount];
u8 cldcnt[nodecount]; u8 cldcnt[nodecount];
u8 *map = host->speed_map; u8 *map = host->speed_map;
struct selfid *sid; struct selfid *sid;
struct ext_selfid *esid; struct ext_selfid *esid;
int i, j, n; int i, j, n;
for (i = 0; i < (nodecount * 64); i += 64) { for (i = 0; i < (nodecount * 64); i += 64) {
for (j = 0; j < nodecount; j++) { for (j = 0; j < nodecount; j++) {
map[i+j] = IEEE1394_SPEED_MAX; map[i+j] = IEEE1394_SPEED_MAX;
} }
} }
for (i = 0; i < nodecount; i++) { for (i = 0; i < nodecount; i++) {
cldcnt[i] = 0; cldcnt[i] = 0;
} }
/* find direct children count and speed */ /* find direct children count and speed */
for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1], for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1],
n = nodecount - 1; n = nodecount - 1;
(void *)sid >= (void *)host->topology_map; sid--) { (void *)sid >= (void *)host->topology_map; sid--) {
if (sid->extended) { if (sid->extended) {
esid = (struct ext_selfid *)sid; esid = (struct ext_selfid *)sid;
if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++; if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++;
if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++; if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++;
@ -322,50 +322,50 @@ static void build_speed_map(struct hpsb_host *host, int nodecount)
if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++; if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++;
if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++; if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++;
speedcap[n] = sid->speed; speedcap[n] = sid->speed;
n--; n--;
} }
} }
/* set self mapping */ /* set self mapping */
for (i = 0; i < nodecount; i++) { for (i = 0; i < nodecount; i++) {
map[64*i + i] = speedcap[i]; map[64*i + i] = speedcap[i];
} }
/* fix up direct children count to total children count; /* fix up direct children count to total children count;
* also fix up speedcaps for sibling and parent communication */ * also fix up speedcaps for sibling and parent communication */
for (i = 1; i < nodecount; i++) { for (i = 1; i < nodecount; i++) {
for (j = cldcnt[i], n = i - 1; j > 0; j--) { for (j = cldcnt[i], n = i - 1; j > 0; j--) {
cldcnt[i] += cldcnt[n]; cldcnt[i] += cldcnt[n];
speedcap[n] = min(speedcap[n], speedcap[i]); speedcap[n] = min(speedcap[n], speedcap[i]);
n -= cldcnt[n] + 1; n -= cldcnt[n] + 1;
} }
} }
for (n = 0; n < nodecount; n++) { for (n = 0; n < nodecount; n++) {
for (i = n - cldcnt[n]; i <= n; i++) { for (i = n - cldcnt[n]; i <= n; i++) {
for (j = 0; j < (n - cldcnt[n]); j++) { for (j = 0; j < (n - cldcnt[n]); j++) {
map[j*64 + i] = map[i*64 + j] = map[j*64 + i] = map[i*64 + j] =
min(map[i*64 + j], speedcap[n]); min(map[i*64 + j], speedcap[n]);
} }
for (j = n + 1; j < nodecount; j++) { for (j = n + 1; j < nodecount; j++) {
map[j*64 + i] = map[i*64 + j] = map[j*64 + i] = map[i*64 + j] =
min(map[i*64 + j], speedcap[n]); min(map[i*64 + j], speedcap[n]);
} }
} }
} }
} }
void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid) void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid)
{ {
if (host->in_bus_reset) { if (host->in_bus_reset) {
HPSB_VERBOSE("Including SelfID 0x%x", sid); HPSB_VERBOSE("Including SelfID 0x%x", sid);
host->topology_map[host->selfid_count++] = sid; host->topology_map[host->selfid_count++] = sid;
} else { } else {
HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
sid, NODEID_TO_BUS(host->node_id)); sid, NODEID_TO_BUS(host->node_id));
} }
} }
void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
@ -373,50 +373,50 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
if (!host->in_bus_reset) if (!host->in_bus_reset)
HPSB_NOTICE("SelfID completion called outside of bus reset!"); HPSB_NOTICE("SelfID completion called outside of bus reset!");
host->node_id = LOCAL_BUS | phyid; host->node_id = LOCAL_BUS | phyid;
host->is_root = isroot; host->is_root = isroot;
if (!check_selfids(host)) { if (!check_selfids(host)) {
if (host->reset_retries++ < 20) { if (host->reset_retries++ < 20) {
/* selfid stage did not complete without error */ /* selfid stage did not complete without error */
HPSB_NOTICE("Error in SelfID stage, resetting"); HPSB_NOTICE("Error in SelfID stage, resetting");
host->in_bus_reset = 0; host->in_bus_reset = 0;
/* this should work from ohci1394 now... */ /* this should work from ohci1394 now... */
hpsb_reset_bus(host, LONG_RESET); hpsb_reset_bus(host, LONG_RESET);
return; return;
} else { } else {
HPSB_NOTICE("Stopping out-of-control reset loop"); HPSB_NOTICE("Stopping out-of-control reset loop");
HPSB_NOTICE("Warning - topology map and speed map will not be valid"); HPSB_NOTICE("Warning - topology map and speed map will not be valid");
host->reset_retries = 0; host->reset_retries = 0;
} }
} else { } else {
host->reset_retries = 0; host->reset_retries = 0;
build_speed_map(host, host->node_count); build_speed_map(host, host->node_count);
} }
HPSB_VERBOSE("selfid_complete called with successful SelfID stage " HPSB_VERBOSE("selfid_complete called with successful SelfID stage "
"... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id); "... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id);
/* irm_id is kept up to date by check_selfids() */ /* irm_id is kept up to date by check_selfids() */
if (host->irm_id == host->node_id) { if (host->irm_id == host->node_id) {
host->is_irm = 1; host->is_irm = 1;
} else { } else {
host->is_busmgr = 0; host->is_busmgr = 0;
host->is_irm = 0; host->is_irm = 0;
} }
if (isroot) { if (isroot) {
host->driver->devctl(host, ACT_CYCLE_MASTER, 1); host->driver->devctl(host, ACT_CYCLE_MASTER, 1);
host->is_cycmst = 1; host->is_cycmst = 1;
} }
atomic_inc(&host->generation); atomic_inc(&host->generation);
host->in_bus_reset = 0; host->in_bus_reset = 0;
highlevel_host_reset(host); highlevel_host_reset(host);
} }
void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
int ackcode) int ackcode)
{ {
unsigned long flags; unsigned long flags;
@ -507,13 +507,13 @@ int hpsb_send_packet(struct hpsb_packet *packet)
{ {
struct hpsb_host *host = packet->host; struct hpsb_host *host = packet->host;
if (host->is_shutdown) if (host->is_shutdown)
return -EINVAL; return -EINVAL;
if (host->in_bus_reset || if (host->in_bus_reset ||
(packet->generation != get_hpsb_generation(host))) (packet->generation != get_hpsb_generation(host)))
return -EAGAIN; return -EAGAIN;
packet->state = hpsb_queued; packet->state = hpsb_queued;
/* This just seems silly to me */ /* This just seems silly to me */
WARN_ON(packet->no_waiter && packet->expect_response); WARN_ON(packet->no_waiter && packet->expect_response);
@ -527,42 +527,42 @@ int hpsb_send_packet(struct hpsb_packet *packet)
skb_queue_tail(&host->pending_packet_queue, packet->skb); skb_queue_tail(&host->pending_packet_queue, packet->skb);
} }
if (packet->node_id == host->node_id) { if (packet->node_id == host->node_id) {
/* it is a local request, so handle it locally */ /* it is a local request, so handle it locally */
quadlet_t *data; quadlet_t *data;
size_t size = packet->data_size + packet->header_size; size_t size = packet->data_size + packet->header_size;
data = kmalloc(size, GFP_ATOMIC); data = kmalloc(size, GFP_ATOMIC);
if (!data) { if (!data) {
HPSB_ERR("unable to allocate memory for concatenating header and data"); HPSB_ERR("unable to allocate memory for concatenating header and data");
return -ENOMEM; return -ENOMEM;
} }
memcpy(data, packet->header, packet->header_size); memcpy(data, packet->header, packet->header_size);
if (packet->data_size) if (packet->data_size)
memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size); memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size);
dump_packet("send packet local", packet->header, packet->header_size, -1); dump_packet("send packet local", packet->header, packet->header_size, -1);
hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE); hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE);
hpsb_packet_received(host, data, size, 0); hpsb_packet_received(host, data, size, 0);
kfree(data); kfree(data);
return 0; return 0;
} }
if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { if (packet->type == hpsb_async && packet->node_id != ALL_NODES) {
packet->speed_code = packet->speed_code =
host->speed_map[NODEID_TO_NODE(host->node_id) * 64 host->speed_map[NODEID_TO_NODE(host->node_id) * 64
+ NODEID_TO_NODE(packet->node_id)]; + NODEID_TO_NODE(packet->node_id)];
} }
dump_packet("send packet", packet->header, packet->header_size, packet->speed_code); dump_packet("send packet", packet->header, packet->header_size, packet->speed_code);
return host->driver->transmit_packet(host, packet); return host->driver->transmit_packet(host, packet);
} }
/* We could just use complete() directly as the packet complete /* We could just use complete() directly as the packet complete
@ -590,81 +590,81 @@ int hpsb_send_packet_and_wait(struct hpsb_packet *packet)
static void send_packet_nocare(struct hpsb_packet *packet) static void send_packet_nocare(struct hpsb_packet *packet)
{ {
if (hpsb_send_packet(packet) < 0) { if (hpsb_send_packet(packet) < 0) {
hpsb_free_packet(packet); hpsb_free_packet(packet);
} }
} }
static void handle_packet_response(struct hpsb_host *host, int tcode, static void handle_packet_response(struct hpsb_host *host, int tcode,
quadlet_t *data, size_t size) quadlet_t *data, size_t size)
{ {
struct hpsb_packet *packet = NULL; struct hpsb_packet *packet = NULL;
struct sk_buff *skb; struct sk_buff *skb;
int tcode_match = 0; int tcode_match = 0;
int tlabel; int tlabel;
unsigned long flags; unsigned long flags;
tlabel = (data[0] >> 10) & 0x3f; tlabel = (data[0] >> 10) & 0x3f;
spin_lock_irqsave(&host->pending_packet_queue.lock, flags); spin_lock_irqsave(&host->pending_packet_queue.lock, flags);
skb_queue_walk(&host->pending_packet_queue, skb) { skb_queue_walk(&host->pending_packet_queue, skb) {
packet = (struct hpsb_packet *)skb->data; packet = (struct hpsb_packet *)skb->data;
if ((packet->tlabel == tlabel) if ((packet->tlabel == tlabel)
&& (packet->node_id == (data[1] >> 16))){ && (packet->node_id == (data[1] >> 16))){
break; break;
} }
packet = NULL; packet = NULL;
} }
if (packet == NULL) { if (packet == NULL) {
HPSB_DEBUG("unsolicited response packet received - no tlabel match"); HPSB_DEBUG("unsolicited response packet received - no tlabel match");
dump_packet("contents", data, 16, -1); dump_packet("contents", data, 16, -1);
spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags);
return; return;
} }
switch (packet->tcode) { switch (packet->tcode) {
case TCODE_WRITEQ: case TCODE_WRITEQ:
case TCODE_WRITEB: case TCODE_WRITEB:
if (tcode != TCODE_WRITE_RESPONSE) if (tcode != TCODE_WRITE_RESPONSE)
break; break;
tcode_match = 1; tcode_match = 1;
memcpy(packet->header, data, 12); memcpy(packet->header, data, 12);
break; break;
case TCODE_READQ: case TCODE_READQ:
if (tcode != TCODE_READQ_RESPONSE) if (tcode != TCODE_READQ_RESPONSE)
break; break;
tcode_match = 1; tcode_match = 1;
memcpy(packet->header, data, 16); memcpy(packet->header, data, 16);
break; break;
case TCODE_READB: case TCODE_READB:
if (tcode != TCODE_READB_RESPONSE) if (tcode != TCODE_READB_RESPONSE)
break; break;
tcode_match = 1; tcode_match = 1;
BUG_ON(packet->skb->len - sizeof(*packet) < size - 16); BUG_ON(packet->skb->len - sizeof(*packet) < size - 16);
memcpy(packet->header, data, 16); memcpy(packet->header, data, 16);
memcpy(packet->data, data + 4, size - 16); memcpy(packet->data, data + 4, size - 16);
break; break;
case TCODE_LOCK_REQUEST: case TCODE_LOCK_REQUEST:
if (tcode != TCODE_LOCK_RESPONSE) if (tcode != TCODE_LOCK_RESPONSE)
break; break;
tcode_match = 1; tcode_match = 1;
size = min((size - 16), (size_t)8); size = min((size - 16), (size_t)8);
BUG_ON(packet->skb->len - sizeof(*packet) < size); BUG_ON(packet->skb->len - sizeof(*packet) < size);
memcpy(packet->header, data, 16); memcpy(packet->header, data, 16);
memcpy(packet->data, data + 4, size); memcpy(packet->data, data + 4, size);
break; break;
} }
if (!tcode_match) { if (!tcode_match) {
spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags);
HPSB_INFO("unsolicited response packet received - tcode mismatch"); HPSB_INFO("unsolicited response packet received - tcode mismatch");
dump_packet("contents", data, 16, -1); dump_packet("contents", data, 16, -1);
return; return;
} }
__skb_unlink(skb, &host->pending_packet_queue); __skb_unlink(skb, &host->pending_packet_queue);
@ -683,27 +683,27 @@ static void handle_packet_response(struct hpsb_host *host, int tcode,
static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
quadlet_t *data, size_t dsize) quadlet_t *data, size_t dsize)
{ {
struct hpsb_packet *p; struct hpsb_packet *p;
p = hpsb_alloc_packet(dsize); p = hpsb_alloc_packet(dsize);
if (unlikely(p == NULL)) { if (unlikely(p == NULL)) {
/* FIXME - send data_error response */ /* FIXME - send data_error response */
return NULL; return NULL;
} }
p->type = hpsb_async; p->type = hpsb_async;
p->state = hpsb_unused; p->state = hpsb_unused;
p->host = host; p->host = host;
p->node_id = data[1] >> 16; p->node_id = data[1] >> 16;
p->tlabel = (data[0] >> 10) & 0x3f; p->tlabel = (data[0] >> 10) & 0x3f;
p->no_waiter = 1; p->no_waiter = 1;
p->generation = get_hpsb_generation(host); p->generation = get_hpsb_generation(host);
if (dsize % 4) if (dsize % 4)
p->data[dsize / 4] = 0; p->data[dsize / 4] = 0;
return p; return p;
} }
#define PREP_ASYNC_HEAD_RCODE(tc) \ #define PREP_ASYNC_HEAD_RCODE(tc) \
@ -714,7 +714,7 @@ static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
packet->header[2] = 0 packet->header[2] = 0
static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
quadlet_t data) quadlet_t data)
{ {
PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE); PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE);
packet->header[3] = data; packet->header[3] = data;
@ -723,7 +723,7 @@ static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
} }
static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode, static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
int length) int length)
{ {
if (rcode != RCODE_COMPLETE) if (rcode != RCODE_COMPLETE)
length = 0; length = 0;
@ -743,7 +743,7 @@ static void fill_async_write_resp(struct hpsb_packet *packet, int rcode)
} }
static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode, static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
int length) int length)
{ {
if (rcode != RCODE_COMPLETE) if (rcode != RCODE_COMPLETE)
length = 0; length = 0;
@ -755,184 +755,184 @@ static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extc
} }
#define PREP_REPLY_PACKET(length) \ #define PREP_REPLY_PACKET(length) \
packet = create_reply_packet(host, data, length); \ packet = create_reply_packet(host, data, length); \
if (packet == NULL) break if (packet == NULL) break
static void handle_incoming_packet(struct hpsb_host *host, int tcode, static void handle_incoming_packet(struct hpsb_host *host, int tcode,
quadlet_t *data, size_t size, int write_acked) quadlet_t *data, size_t size, int write_acked)
{ {
struct hpsb_packet *packet; struct hpsb_packet *packet;
int length, rcode, extcode; int length, rcode, extcode;
quadlet_t buffer; quadlet_t buffer;
nodeid_t source = data[1] >> 16; nodeid_t source = data[1] >> 16;
nodeid_t dest = data[0] >> 16; nodeid_t dest = data[0] >> 16;
u16 flags = (u16) data[0]; u16 flags = (u16) data[0];
u64 addr; u64 addr;
/* big FIXME - no error checking is done for an out of bounds length */ /* big FIXME - no error checking is done for an out of bounds length */
switch (tcode) { switch (tcode) {
case TCODE_WRITEQ: case TCODE_WRITEQ:
addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
rcode = highlevel_write(host, source, dest, data+3, rcode = highlevel_write(host, source, dest, data+3,
addr, 4, flags); addr, 4, flags);
if (!write_acked if (!write_acked
&& (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
&& (rcode >= 0)) { && (rcode >= 0)) {
/* not a broadcast write, reply */ /* not a broadcast write, reply */
PREP_REPLY_PACKET(0); PREP_REPLY_PACKET(0);
fill_async_write_resp(packet, rcode); fill_async_write_resp(packet, rcode);
send_packet_nocare(packet); send_packet_nocare(packet);
} }
break; break;
case TCODE_WRITEB: case TCODE_WRITEB:
addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
rcode = highlevel_write(host, source, dest, data+4, rcode = highlevel_write(host, source, dest, data+4,
addr, data[3]>>16, flags); addr, data[3]>>16, flags);
if (!write_acked if (!write_acked
&& (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK)
&& (rcode >= 0)) { && (rcode >= 0)) {
/* not a broadcast write, reply */ /* not a broadcast write, reply */
PREP_REPLY_PACKET(0); PREP_REPLY_PACKET(0);
fill_async_write_resp(packet, rcode); fill_async_write_resp(packet, rcode);
send_packet_nocare(packet); send_packet_nocare(packet);
} }
break; break;
case TCODE_READQ: case TCODE_READQ:
addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
rcode = highlevel_read(host, source, &buffer, addr, 4, flags); rcode = highlevel_read(host, source, &buffer, addr, 4, flags);
if (rcode >= 0) { if (rcode >= 0) {
PREP_REPLY_PACKET(0); PREP_REPLY_PACKET(0);
fill_async_readquad_resp(packet, rcode, buffer); fill_async_readquad_resp(packet, rcode, buffer);
send_packet_nocare(packet); send_packet_nocare(packet);
} }
break; break;
case TCODE_READB: case TCODE_READB:
length = data[3] >> 16; length = data[3] >> 16;
PREP_REPLY_PACKET(length); PREP_REPLY_PACKET(length);
addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
rcode = highlevel_read(host, source, packet->data, addr, rcode = highlevel_read(host, source, packet->data, addr,
length, flags); length, flags);
if (rcode >= 0) { if (rcode >= 0) {
fill_async_readblock_resp(packet, rcode, length); fill_async_readblock_resp(packet, rcode, length);
send_packet_nocare(packet); send_packet_nocare(packet);
} else { } else {
hpsb_free_packet(packet); hpsb_free_packet(packet);
} }
break; break;
case TCODE_LOCK_REQUEST: case TCODE_LOCK_REQUEST:
length = data[3] >> 16; length = data[3] >> 16;
extcode = data[3] & 0xffff; extcode = data[3] & 0xffff;
addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
PREP_REPLY_PACKET(8); PREP_REPLY_PACKET(8);
if ((extcode == 0) || (extcode >= 7)) { if ((extcode == 0) || (extcode >= 7)) {
/* let switch default handle error */ /* let switch default handle error */
length = 0; length = 0;
} }
switch (length) { switch (length) {
case 4: case 4:
rcode = highlevel_lock(host, source, packet->data, addr, rcode = highlevel_lock(host, source, packet->data, addr,
data[4], 0, extcode,flags); data[4], 0, extcode,flags);
fill_async_lock_resp(packet, rcode, extcode, 4); fill_async_lock_resp(packet, rcode, extcode, 4);
break; break;
case 8: case 8:
if ((extcode != EXTCODE_FETCH_ADD) if ((extcode != EXTCODE_FETCH_ADD)
&& (extcode != EXTCODE_LITTLE_ADD)) { && (extcode != EXTCODE_LITTLE_ADD)) {
rcode = highlevel_lock(host, source, rcode = highlevel_lock(host, source,
packet->data, addr, packet->data, addr,
data[5], data[4], data[5], data[4],
extcode, flags); extcode, flags);
fill_async_lock_resp(packet, rcode, extcode, 4); fill_async_lock_resp(packet, rcode, extcode, 4);
} else { } else {
rcode = highlevel_lock64(host, source, rcode = highlevel_lock64(host, source,
(octlet_t *)packet->data, addr, (octlet_t *)packet->data, addr,
*(octlet_t *)(data + 4), 0ULL, *(octlet_t *)(data + 4), 0ULL,
extcode, flags); extcode, flags);
fill_async_lock_resp(packet, rcode, extcode, 8); fill_async_lock_resp(packet, rcode, extcode, 8);
} }
break; break;
case 16: case 16:
rcode = highlevel_lock64(host, source, rcode = highlevel_lock64(host, source,
(octlet_t *)packet->data, addr, (octlet_t *)packet->data, addr,
*(octlet_t *)(data + 6), *(octlet_t *)(data + 6),
*(octlet_t *)(data + 4), *(octlet_t *)(data + 4),
extcode, flags); extcode, flags);
fill_async_lock_resp(packet, rcode, extcode, 8); fill_async_lock_resp(packet, rcode, extcode, 8);
break; break;
default: default:
rcode = RCODE_TYPE_ERROR; rcode = RCODE_TYPE_ERROR;
fill_async_lock_resp(packet, rcode, fill_async_lock_resp(packet, rcode,
extcode, 0); extcode, 0);
} }
if (rcode >= 0) { if (rcode >= 0) {
send_packet_nocare(packet); send_packet_nocare(packet);
} else { } else {
hpsb_free_packet(packet); hpsb_free_packet(packet);
} }
break; break;
} }
} }
#undef PREP_REPLY_PACKET #undef PREP_REPLY_PACKET
void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
int write_acked) int write_acked)
{ {
int tcode; int tcode;
if (host->in_bus_reset) { if (host->in_bus_reset) {
HPSB_INFO("received packet during reset; ignoring"); HPSB_INFO("received packet during reset; ignoring");
return; return;
} }
dump_packet("received packet", data, size, -1); dump_packet("received packet", data, size, -1);
tcode = (data[0] >> 4) & 0xf; tcode = (data[0] >> 4) & 0xf;
switch (tcode) { switch (tcode) {
case TCODE_WRITE_RESPONSE: case TCODE_WRITE_RESPONSE:
case TCODE_READQ_RESPONSE: case TCODE_READQ_RESPONSE:
case TCODE_READB_RESPONSE: case TCODE_READB_RESPONSE:
case TCODE_LOCK_RESPONSE: case TCODE_LOCK_RESPONSE:
handle_packet_response(host, tcode, data, size); handle_packet_response(host, tcode, data, size);
break; break;
case TCODE_WRITEQ: case TCODE_WRITEQ:
case TCODE_WRITEB: case TCODE_WRITEB:
case TCODE_READQ: case TCODE_READQ:
case TCODE_READB: case TCODE_READB:
case TCODE_LOCK_REQUEST: case TCODE_LOCK_REQUEST:
handle_incoming_packet(host, tcode, data, size, write_acked); handle_incoming_packet(host, tcode, data, size, write_acked);
break; break;
case TCODE_ISO_DATA: case TCODE_ISO_DATA:
highlevel_iso_receive(host, data, size); highlevel_iso_receive(host, data, size);
break; break;
case TCODE_CYCLE_START: case TCODE_CYCLE_START:
/* simply ignore this packet if it is passed on */ /* simply ignore this packet if it is passed on */
break; break;
default: default:
HPSB_NOTICE("received packet with bogus transaction code %d", HPSB_NOTICE("received packet with bogus transaction code %d",
tcode); tcode);
break; break;
} }
} }
@ -1126,7 +1126,7 @@ static int __init ieee1394_init(void)
nodemgr implements functionality required of ieee1394a-2000 nodemgr implements functionality required of ieee1394a-2000
IRMs */ IRMs */
hpsb_disable_irm = 1; hpsb_disable_irm = 1;
return 0; return 0;
} }

100
drivers/ieee1394/ieee1394_core.h
View File

@ -10,8 +10,8 @@
struct hpsb_packet { struct hpsb_packet {
/* This struct is basically read-only for hosts with the exception of /* This struct is basically read-only for hosts with the exception of
* the data buffer contents and xnext - see below. */ * the data buffer contents and xnext - see below. */
/* This can be used for host driver internal linking. /* This can be used for host driver internal linking.
* *
@ -21,47 +21,47 @@ struct hpsb_packet {
* driver_list when free'ing it. */ * driver_list when free'ing it. */
struct list_head driver_list; struct list_head driver_list;
nodeid_t node_id; nodeid_t node_id;
/* Async and Iso types should be clear, raw means send-as-is, do not /* Async and Iso types should be clear, raw means send-as-is, do not
* CRC! Byte swapping shall still be done in this case. */ * CRC! Byte swapping shall still be done in this case. */
enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type; enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type;
/* Okay, this is core internal and a no care for hosts. /* Okay, this is core internal and a no care for hosts.
* queued = queued for sending * queued = queued for sending
* pending = sent, waiting for response * pending = sent, waiting for response
* complete = processing completed, successful or not * complete = processing completed, successful or not
*/ */
enum { enum {
hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete
} __attribute__((packed)) state; } __attribute__((packed)) state;
/* These are core internal. */ /* These are core internal. */
signed char tlabel; signed char tlabel;
signed char ack_code; signed char ack_code;
unsigned char tcode; unsigned char tcode;
unsigned expect_response:1; unsigned expect_response:1;
unsigned no_waiter:1; unsigned no_waiter:1;
/* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */ /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */
unsigned speed_code:2; unsigned speed_code:2;
/* /*
* *header and *data are guaranteed to be 32-bit DMAable and may be * *header and *data are guaranteed to be 32-bit DMAable and may be
* overwritten to allow in-place byte swapping. Neither of these is * overwritten to allow in-place byte swapping. Neither of these is
* CRCed (the sizes also don't include CRC), but contain space for at * CRCed (the sizes also don't include CRC), but contain space for at
* least one additional quadlet to allow in-place CRCing. The memory is * least one additional quadlet to allow in-place CRCing. The memory is
* also guaranteed to be DMA mappable. * also guaranteed to be DMA mappable.
*/ */
quadlet_t *header; quadlet_t *header;
quadlet_t *data; quadlet_t *data;
size_t header_size; size_t header_size;
size_t data_size; size_t data_size;
struct hpsb_host *host; struct hpsb_host *host;
unsigned int generation; unsigned int generation;
atomic_t refcnt; atomic_t refcnt;
@ -73,10 +73,10 @@ struct hpsb_packet {
/* XXX This is just a hack at the moment */ /* XXX This is just a hack at the moment */
struct sk_buff *skb; struct sk_buff *skb;
/* Store jiffies for implementing bus timeouts. */ /* Store jiffies for implementing bus timeouts. */
unsigned long sendtime; unsigned long sendtime;
quadlet_t embedded_header[5]; quadlet_t embedded_header[5];
}; };
/* Set a task for when a packet completes */ /* Set a task for when a packet completes */
@ -102,7 +102,7 @@ void hpsb_free_packet(struct hpsb_packet *packet);
*/ */
static inline unsigned int get_hpsb_generation(struct hpsb_host *host) static inline unsigned int get_hpsb_generation(struct hpsb_host *host)
{ {
return atomic_read(&host->generation); return atomic_read(&host->generation);
} }
/* /*
@ -157,7 +157,7 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot);
* from within a transmit packet routine. * from within a transmit packet routine.
*/ */
void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
int ackcode); int ackcode);
/* /*
* Hand over received packet to the core. The contents of data are expected to * Hand over received packet to the core. The contents of data are expected to
@ -171,7 +171,7 @@ void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
* packet type. * packet type.
*/ */
void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
int write_acked); int write_acked);
/* /*
@ -197,20 +197,20 @@ void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
* Block 15 (240-255) reserved for drivers under development, etc. * Block 15 (240-255) reserved for drivers under development, etc.
*/ */
#define IEEE1394_MAJOR 171 #define IEEE1394_MAJOR 171
#define IEEE1394_MINOR_BLOCK_RAW1394 0 #define IEEE1394_MINOR_BLOCK_RAW1394 0
#define IEEE1394_MINOR_BLOCK_VIDEO1394 1 #define IEEE1394_MINOR_BLOCK_VIDEO1394 1
#define IEEE1394_MINOR_BLOCK_DV1394 2 #define IEEE1394_MINOR_BLOCK_DV1394 2
#define IEEE1394_MINOR_BLOCK_AMDTP 3 #define IEEE1394_MINOR_BLOCK_AMDTP 3
#define IEEE1394_MINOR_BLOCK_EXPERIMENTAL 15 #define IEEE1394_MINOR_BLOCK_EXPERIMENTAL 15
#define IEEE1394_CORE_DEV MKDEV(IEEE1394_MAJOR, 0) #define IEEE1394_CORE_DEV MKDEV(IEEE1394_MAJOR, 0)
#define IEEE1394_RAW1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16) #define IEEE1394_RAW1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)
#define IEEE1394_VIDEO1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16) #define IEEE1394_VIDEO1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16)
#define IEEE1394_DV1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16) #define IEEE1394_DV1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16)
#define IEEE1394_AMDTP_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16) #define IEEE1394_AMDTP_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16)
#define IEEE1394_EXPERIMENTAL_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16) #define IEEE1394_EXPERIMENTAL_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16)
/* return the index (within a minor number block) of a file */ /* return the index (within a minor number block) of a file */
static inline unsigned char ieee1394_file_to_instance(struct file *file) static inline unsigned char ieee1394_file_to_instance(struct file *file)