2
* Core IEEE1394 transaction logic
4
* Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net>
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software Foundation,
18
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21
#include <linux/bug.h>
22
#include <linux/completion.h>
23
#include <linux/device.h>
24
#include <linux/errno.h>
25
#include <linux/firewire.h>
26
#include <linux/firewire-constants.h>
28
#include <linux/init.h>
29
#include <linux/idr.h>
30
#include <linux/jiffies.h>
31
#include <linux/kernel.h>
32
#include <linux/list.h>
33
#include <linux/module.h>
34
#include <linux/slab.h>
35
#include <linux/spinlock.h>
36
#include <linux/string.h>
37
#include <linux/timer.h>
38
#include <linux/types.h>
39
#include <linux/workqueue.h>
41
#include <asm/byteorder.h>
45
#define HEADER_PRI(pri) ((pri) << 0)
46
#define HEADER_TCODE(tcode) ((tcode) << 4)
47
#define HEADER_RETRY(retry) ((retry) << 8)
48
#define HEADER_TLABEL(tlabel) ((tlabel) << 10)
49
#define HEADER_DESTINATION(destination) ((destination) << 16)
50
#define HEADER_SOURCE(source) ((source) << 16)
51
#define HEADER_RCODE(rcode) ((rcode) << 12)
52
#define HEADER_OFFSET_HIGH(offset_high) ((offset_high) << 0)
53
#define HEADER_DATA_LENGTH(length) ((length) << 16)
54
#define HEADER_EXTENDED_TCODE(tcode) ((tcode) << 0)
56
#define HEADER_GET_TCODE(q) (((q) >> 4) & 0x0f)
57
#define HEADER_GET_TLABEL(q) (((q) >> 10) & 0x3f)
58
#define HEADER_GET_RCODE(q) (((q) >> 12) & 0x0f)
59
#define HEADER_GET_DESTINATION(q) (((q) >> 16) & 0xffff)
60
#define HEADER_GET_SOURCE(q) (((q) >> 16) & 0xffff)
61
#define HEADER_GET_OFFSET_HIGH(q) (((q) >> 0) & 0xffff)
62
#define HEADER_GET_DATA_LENGTH(q) (((q) >> 16) & 0xffff)
63
#define HEADER_GET_EXTENDED_TCODE(q) (((q) >> 0) & 0xffff)
65
#define HEADER_DESTINATION_IS_BROADCAST(q) \
66
(((q) & HEADER_DESTINATION(0x3f)) == HEADER_DESTINATION(0x3f))
68
#define PHY_PACKET_CONFIG 0x0
69
#define PHY_PACKET_LINK_ON 0x1
70
#define PHY_PACKET_SELF_ID 0x2
72
#define PHY_CONFIG_GAP_COUNT(gap_count) (((gap_count) << 16) | (1 << 22))
73
#define PHY_CONFIG_ROOT_ID(node_id) ((((node_id) & 0x3f) << 24) | (1 << 23))
74
#define PHY_IDENTIFIER(id) ((id) << 30)
76
/* returns 0 if the split timeout handler is already running */
77
static int try_cancel_split_timeout(struct fw_transaction *t)
79
if (t->is_split_transaction)
80
return del_timer(&t->split_timeout_timer);
85
static int close_transaction(struct fw_transaction *transaction,
86
struct fw_card *card, int rcode)
88
struct fw_transaction *t;
91
spin_lock_irqsave(&card->lock, flags);
92
list_for_each_entry(t, &card->transaction_list, link) {
93
if (t == transaction) {
94
if (!try_cancel_split_timeout(t)) {
95
spin_unlock_irqrestore(&card->lock, flags);
98
list_del_init(&t->link);
99
card->tlabel_mask &= ~(1ULL << t->tlabel);
103
spin_unlock_irqrestore(&card->lock, flags);
105
if (&t->link != &card->transaction_list) {
106
t->callback(card, rcode, NULL, 0, t->callback_data);
115
* Only valid for transactions that are potentially pending (ie have
118
int fw_cancel_transaction(struct fw_card *card,
119
struct fw_transaction *transaction)
122
* Cancel the packet transmission if it's still queued. That
123
* will call the packet transmission callback which cancels
127
if (card->driver->cancel_packet(card, &transaction->packet) == 0)
131
* If the request packet has already been sent, we need to see
132
* if the transaction is still pending and remove it in that case.
135
return close_transaction(transaction, card, RCODE_CANCELLED);
137
EXPORT_SYMBOL(fw_cancel_transaction);
139
static void split_transaction_timeout_callback(unsigned long data)
141
struct fw_transaction *t = (struct fw_transaction *)data;
142
struct fw_card *card = t->card;
145
spin_lock_irqsave(&card->lock, flags);
146
if (list_empty(&t->link)) {
147
spin_unlock_irqrestore(&card->lock, flags);
151
card->tlabel_mask &= ~(1ULL << t->tlabel);
152
spin_unlock_irqrestore(&card->lock, flags);
154
t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
157
static void start_split_transaction_timeout(struct fw_transaction *t,
158
struct fw_card *card)
162
spin_lock_irqsave(&card->lock, flags);
164
if (list_empty(&t->link) || WARN_ON(t->is_split_transaction)) {
165
spin_unlock_irqrestore(&card->lock, flags);
169
t->is_split_transaction = true;
170
mod_timer(&t->split_timeout_timer,
171
jiffies + card->split_timeout_jiffies);
173
spin_unlock_irqrestore(&card->lock, flags);
176
static void transmit_complete_callback(struct fw_packet *packet,
177
struct fw_card *card, int status)
179
struct fw_transaction *t =
180
container_of(packet, struct fw_transaction, packet);
184
close_transaction(t, card, RCODE_COMPLETE);
187
start_split_transaction_timeout(t, card);
192
close_transaction(t, card, RCODE_BUSY);
195
close_transaction(t, card, RCODE_DATA_ERROR);
198
close_transaction(t, card, RCODE_TYPE_ERROR);
202
* In this case the ack is really a juju specific
203
* rcode, so just forward that to the callback.
205
close_transaction(t, card, status);
210
static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
211
int destination_id, int source_id, int generation, int speed,
212
unsigned long long offset, void *payload, size_t length)
216
if (tcode == TCODE_STREAM_DATA) {
218
HEADER_DATA_LENGTH(length) |
220
HEADER_TCODE(TCODE_STREAM_DATA);
221
packet->header_length = 4;
222
packet->payload = payload;
223
packet->payload_length = length;
229
ext_tcode = tcode & ~0x10;
230
tcode = TCODE_LOCK_REQUEST;
235
HEADER_RETRY(RETRY_X) |
236
HEADER_TLABEL(tlabel) |
237
HEADER_TCODE(tcode) |
238
HEADER_DESTINATION(destination_id);
240
HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id);
245
case TCODE_WRITE_QUADLET_REQUEST:
246
packet->header[3] = *(u32 *)payload;
247
packet->header_length = 16;
248
packet->payload_length = 0;
251
case TCODE_LOCK_REQUEST:
252
case TCODE_WRITE_BLOCK_REQUEST:
254
HEADER_DATA_LENGTH(length) |
255
HEADER_EXTENDED_TCODE(ext_tcode);
256
packet->header_length = 16;
257
packet->payload = payload;
258
packet->payload_length = length;
261
case TCODE_READ_QUADLET_REQUEST:
262
packet->header_length = 12;
263
packet->payload_length = 0;
266
case TCODE_READ_BLOCK_REQUEST:
268
HEADER_DATA_LENGTH(length) |
269
HEADER_EXTENDED_TCODE(ext_tcode);
270
packet->header_length = 16;
271
packet->payload_length = 0;
275
WARN(1, "wrong tcode %d\n", tcode);
278
packet->speed = speed;
279
packet->generation = generation;
281
packet->payload_mapped = false;
284
static int allocate_tlabel(struct fw_card *card)
288
tlabel = card->current_tlabel;
289
while (card->tlabel_mask & (1ULL << tlabel)) {
290
tlabel = (tlabel + 1) & 0x3f;
291
if (tlabel == card->current_tlabel)
295
card->current_tlabel = (tlabel + 1) & 0x3f;
296
card->tlabel_mask |= 1ULL << tlabel;
302
* fw_send_request() - submit a request packet for transmission
303
* @card: interface to send the request at
304
* @t: transaction instance to which the request belongs
305
* @tcode: transaction code
306
* @destination_id: destination node ID, consisting of bus_ID and phy_ID
307
* @generation: bus generation in which request and response are valid
308
* @speed: transmission speed
309
* @offset: 48bit wide offset into destination's address space
310
* @payload: data payload for the request subaction
311
* @length: length of the payload, in bytes
312
* @callback: function to be called when the transaction is completed
313
* @callback_data: data to be passed to the transaction completion callback
315
* Submit a request packet into the asynchronous request transmission queue.
316
* Can be called from atomic context. If you prefer a blocking API, use
317
* fw_run_transaction() in a context that can sleep.
319
* In case of lock requests, specify one of the firewire-core specific %TCODE_
320
* constants instead of %TCODE_LOCK_REQUEST in @tcode.
322
* Make sure that the value in @destination_id is not older than the one in
323
* @generation. Otherwise the request is in danger to be sent to a wrong node.
325
* In case of asynchronous stream packets i.e. %TCODE_STREAM_DATA, the caller
326
* needs to synthesize @destination_id with fw_stream_packet_destination_id().
327
* It will contain tag, channel, and sy data instead of a node ID then.
329
* The payload buffer at @data is going to be DMA-mapped except in case of
330
* @length <= 8 or of local (loopback) requests. Hence make sure that the
331
* buffer complies with the restrictions of the streaming DMA mapping API.
332
* @payload must not be freed before the @callback is called.
334
* In case of request types without payload, @data is NULL and @length is 0.
336
* After the transaction is completed successfully or unsuccessfully, the
337
* @callback will be called. Among its parameters is the response code which
338
* is either one of the rcodes per IEEE 1394 or, in case of internal errors,
339
* the firewire-core specific %RCODE_SEND_ERROR. The other firewire-core
340
* specific rcodes (%RCODE_CANCELLED, %RCODE_BUSY, %RCODE_GENERATION,
341
* %RCODE_NO_ACK) denote transaction timeout, busy responder, stale request
342
* generation, or missing ACK respectively.
344
* Note some timing corner cases: fw_send_request() may complete much earlier
345
* than when the request packet actually hits the wire. On the other hand,
346
* transaction completion and hence execution of @callback may happen even
347
* before fw_send_request() returns.
349
void fw_send_request(struct fw_card *card, struct fw_transaction *t, int tcode,
350
int destination_id, int generation, int speed,
351
unsigned long long offset, void *payload, size_t length,
352
fw_transaction_callback_t callback, void *callback_data)
358
* Allocate tlabel from the bitmap and put the transaction on
359
* the list while holding the card spinlock.
362
spin_lock_irqsave(&card->lock, flags);
364
tlabel = allocate_tlabel(card);
366
spin_unlock_irqrestore(&card->lock, flags);
367
callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data);
371
t->node_id = destination_id;
374
t->is_split_transaction = false;
375
setup_timer(&t->split_timeout_timer,
376
split_transaction_timeout_callback, (unsigned long)t);
377
t->callback = callback;
378
t->callback_data = callback_data;
380
fw_fill_request(&t->packet, tcode, t->tlabel,
381
destination_id, card->node_id, generation,
382
speed, offset, payload, length);
383
t->packet.callback = transmit_complete_callback;
385
list_add_tail(&t->link, &card->transaction_list);
387
spin_unlock_irqrestore(&card->lock, flags);
389
card->driver->send_request(card, &t->packet);
391
EXPORT_SYMBOL(fw_send_request);
393
struct transaction_callback_data {
394
struct completion done;
399
static void transaction_callback(struct fw_card *card, int rcode,
400
void *payload, size_t length, void *data)
402
struct transaction_callback_data *d = data;
404
if (rcode == RCODE_COMPLETE)
405
memcpy(d->payload, payload, length);
411
* fw_run_transaction() - send request and sleep until transaction is completed
413
* Returns the RCODE. See fw_send_request() for parameter documentation.
414
* Unlike fw_send_request(), @data points to the payload of the request or/and
415
* to the payload of the response. DMA mapping restrictions apply to outbound
416
* request payloads of >= 8 bytes but not to inbound response payloads.
418
int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
419
int generation, int speed, unsigned long long offset,
420
void *payload, size_t length)
422
struct transaction_callback_data d;
423
struct fw_transaction t;
425
init_timer_on_stack(&t.split_timeout_timer);
426
init_completion(&d.done);
428
fw_send_request(card, &t, tcode, destination_id, generation, speed,
429
offset, payload, length, transaction_callback, &d);
430
wait_for_completion(&d.done);
431
destroy_timer_on_stack(&t.split_timeout_timer);
435
EXPORT_SYMBOL(fw_run_transaction);
437
static DEFINE_MUTEX(phy_config_mutex);
438
static DECLARE_COMPLETION(phy_config_done);
440
static void transmit_phy_packet_callback(struct fw_packet *packet,
441
struct fw_card *card, int status)
443
complete(&phy_config_done);
446
static struct fw_packet phy_config_packet = {
448
.header[0] = TCODE_LINK_INTERNAL << 4,
451
.callback = transmit_phy_packet_callback,
454
void fw_send_phy_config(struct fw_card *card,
455
int node_id, int generation, int gap_count)
457
long timeout = DIV_ROUND_UP(HZ, 10);
458
u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG);
460
if (node_id != FW_PHY_CONFIG_NO_NODE_ID)
461
data |= PHY_CONFIG_ROOT_ID(node_id);
463
if (gap_count == FW_PHY_CONFIG_CURRENT_GAP_COUNT) {
464
gap_count = card->driver->read_phy_reg(card, 1);
472
data |= PHY_CONFIG_GAP_COUNT(gap_count);
474
mutex_lock(&phy_config_mutex);
476
phy_config_packet.header[1] = data;
477
phy_config_packet.header[2] = ~data;
478
phy_config_packet.generation = generation;
479
INIT_COMPLETION(phy_config_done);
481
card->driver->send_request(card, &phy_config_packet);
482
wait_for_completion_timeout(&phy_config_done, timeout);
484
mutex_unlock(&phy_config_mutex);
487
static struct fw_address_handler *lookup_overlapping_address_handler(
488
struct list_head *list, unsigned long long offset, size_t length)
490
struct fw_address_handler *handler;
492
list_for_each_entry(handler, list, link) {
493
if (handler->offset < offset + length &&
494
offset < handler->offset + handler->length)
501
static bool is_enclosing_handler(struct fw_address_handler *handler,
502
unsigned long long offset, size_t length)
504
return handler->offset <= offset &&
505
offset + length <= handler->offset + handler->length;
508
static struct fw_address_handler *lookup_enclosing_address_handler(
509
struct list_head *list, unsigned long long offset, size_t length)
511
struct fw_address_handler *handler;
513
list_for_each_entry(handler, list, link) {
514
if (is_enclosing_handler(handler, offset, length))
521
static DEFINE_SPINLOCK(address_handler_lock);
522
static LIST_HEAD(address_handler_list);
524
const struct fw_address_region fw_high_memory_region =
525
{ .start = 0x000100000000ULL, .end = 0xffffe0000000ULL, };
526
EXPORT_SYMBOL(fw_high_memory_region);
529
const struct fw_address_region fw_low_memory_region =
530
{ .start = 0x000000000000ULL, .end = 0x000100000000ULL, };
531
const struct fw_address_region fw_private_region =
532
{ .start = 0xffffe0000000ULL, .end = 0xfffff0000000ULL, };
533
const struct fw_address_region fw_csr_region =
534
{ .start = CSR_REGISTER_BASE,
535
.end = CSR_REGISTER_BASE | CSR_CONFIG_ROM_END, };
536
const struct fw_address_region fw_unit_space_region =
537
{ .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
540
static bool is_in_fcp_region(u64 offset, size_t length)
542
return offset >= (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
543
offset + length <= (CSR_REGISTER_BASE | CSR_FCP_END);
547
* fw_core_add_address_handler() - register for incoming requests
549
* @region: region in the IEEE 1212 node space address range
551
* region->start, ->end, and handler->length have to be quadlet-aligned.
553
* When a request is received that falls within the specified address range,
554
* the specified callback is invoked. The parameters passed to the callback
555
* give the details of the particular request.
557
* Return value: 0 on success, non-zero otherwise.
559
* The start offset of the handler's address region is determined by
560
* fw_core_add_address_handler() and is returned in handler->offset.
562
* Address allocations are exclusive, except for the FCP registers.
564
int fw_core_add_address_handler(struct fw_address_handler *handler,
565
const struct fw_address_region *region)
567
struct fw_address_handler *other;
571
if (region->start & 0xffff000000000003ULL ||
572
region->start >= region->end ||
573
region->end > 0x0001000000000000ULL ||
574
handler->length & 3 ||
575
handler->length == 0)
578
spin_lock_irqsave(&address_handler_lock, flags);
580
handler->offset = region->start;
581
while (handler->offset + handler->length <= region->end) {
582
if (is_in_fcp_region(handler->offset, handler->length))
585
other = lookup_overlapping_address_handler
586
(&address_handler_list,
587
handler->offset, handler->length);
589
handler->offset += other->length;
591
list_add_tail(&handler->link, &address_handler_list);
597
spin_unlock_irqrestore(&address_handler_lock, flags);
601
EXPORT_SYMBOL(fw_core_add_address_handler);
604
* fw_core_remove_address_handler() - unregister an address handler
606
void fw_core_remove_address_handler(struct fw_address_handler *handler)
610
spin_lock_irqsave(&address_handler_lock, flags);
611
list_del(&handler->link);
612
spin_unlock_irqrestore(&address_handler_lock, flags);
614
EXPORT_SYMBOL(fw_core_remove_address_handler);
617
struct fw_packet response;
618
u32 request_header[4];
624
static void free_response_callback(struct fw_packet *packet,
625
struct fw_card *card, int status)
627
struct fw_request *request;
629
request = container_of(packet, struct fw_request, response);
633
int fw_get_response_length(struct fw_request *r)
635
int tcode, ext_tcode, data_length;
637
tcode = HEADER_GET_TCODE(r->request_header[0]);
640
case TCODE_WRITE_QUADLET_REQUEST:
641
case TCODE_WRITE_BLOCK_REQUEST:
644
case TCODE_READ_QUADLET_REQUEST:
647
case TCODE_READ_BLOCK_REQUEST:
648
data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
651
case TCODE_LOCK_REQUEST:
652
ext_tcode = HEADER_GET_EXTENDED_TCODE(r->request_header[3]);
653
data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
655
case EXTCODE_FETCH_ADD:
656
case EXTCODE_LITTLE_ADD:
659
return data_length / 2;
663
WARN(1, "wrong tcode %d\n", tcode);
668
void fw_fill_response(struct fw_packet *response, u32 *request_header,
669
int rcode, void *payload, size_t length)
671
int tcode, tlabel, extended_tcode, source, destination;
673
tcode = HEADER_GET_TCODE(request_header[0]);
674
tlabel = HEADER_GET_TLABEL(request_header[0]);
675
source = HEADER_GET_DESTINATION(request_header[0]);
676
destination = HEADER_GET_SOURCE(request_header[1]);
677
extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]);
679
response->header[0] =
680
HEADER_RETRY(RETRY_1) |
681
HEADER_TLABEL(tlabel) |
682
HEADER_DESTINATION(destination);
683
response->header[1] =
684
HEADER_SOURCE(source) |
686
response->header[2] = 0;
689
case TCODE_WRITE_QUADLET_REQUEST:
690
case TCODE_WRITE_BLOCK_REQUEST:
691
response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE);
692
response->header_length = 12;
693
response->payload_length = 0;
696
case TCODE_READ_QUADLET_REQUEST:
697
response->header[0] |=
698
HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE);
700
response->header[3] = *(u32 *)payload;
702
response->header[3] = 0;
703
response->header_length = 16;
704
response->payload_length = 0;
707
case TCODE_READ_BLOCK_REQUEST:
708
case TCODE_LOCK_REQUEST:
709
response->header[0] |= HEADER_TCODE(tcode + 2);
710
response->header[3] =
711
HEADER_DATA_LENGTH(length) |
712
HEADER_EXTENDED_TCODE(extended_tcode);
713
response->header_length = 16;
714
response->payload = payload;
715
response->payload_length = length;
719
WARN(1, "wrong tcode %d\n", tcode);
722
response->payload_mapped = false;
724
EXPORT_SYMBOL(fw_fill_response);
726
static u32 compute_split_timeout_timestamp(struct fw_card *card,
727
u32 request_timestamp)
732
cycles = card->split_timeout_cycles;
733
cycles += request_timestamp & 0x1fff;
735
timestamp = request_timestamp & ~0x1fff;
736
timestamp += (cycles / 8000) << 13;
737
timestamp |= cycles % 8000;
742
static struct fw_request *allocate_request(struct fw_card *card,
745
struct fw_request *request;
749
request_tcode = HEADER_GET_TCODE(p->header[0]);
750
switch (request_tcode) {
751
case TCODE_WRITE_QUADLET_REQUEST:
752
data = &p->header[3];
756
case TCODE_WRITE_BLOCK_REQUEST:
757
case TCODE_LOCK_REQUEST:
759
length = HEADER_GET_DATA_LENGTH(p->header[3]);
762
case TCODE_READ_QUADLET_REQUEST:
767
case TCODE_READ_BLOCK_REQUEST:
769
length = HEADER_GET_DATA_LENGTH(p->header[3]);
773
fw_error("ERROR - corrupt request received - %08x %08x %08x\n",
774
p->header[0], p->header[1], p->header[2]);
778
request = kmalloc(sizeof(*request) + length, GFP_ATOMIC);
782
request->response.speed = p->speed;
783
request->response.timestamp =
784
compute_split_timeout_timestamp(card, p->timestamp);
785
request->response.generation = p->generation;
786
request->response.ack = 0;
787
request->response.callback = free_response_callback;
788
request->ack = p->ack;
789
request->length = length;
791
memcpy(request->data, data, length);
793
memcpy(request->request_header, p->header, sizeof(p->header));
798
void fw_send_response(struct fw_card *card,
799
struct fw_request *request, int rcode)
801
if (WARN_ONCE(!request, "invalid for FCP address handlers"))
804
/* unified transaction or broadcast transaction: don't respond */
805
if (request->ack != ACK_PENDING ||
806
HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) {
811
if (rcode == RCODE_COMPLETE)
812
fw_fill_response(&request->response, request->request_header,
813
rcode, request->data,
814
fw_get_response_length(request));
816
fw_fill_response(&request->response, request->request_header,
819
card->driver->send_response(card, &request->response);
821
EXPORT_SYMBOL(fw_send_response);
823
static void handle_exclusive_region_request(struct fw_card *card,
825
struct fw_request *request,
826
unsigned long long offset)
828
struct fw_address_handler *handler;
830
int tcode, destination, source;
832
destination = HEADER_GET_DESTINATION(p->header[0]);
833
source = HEADER_GET_SOURCE(p->header[1]);
834
tcode = HEADER_GET_TCODE(p->header[0]);
835
if (tcode == TCODE_LOCK_REQUEST)
836
tcode = 0x10 + HEADER_GET_EXTENDED_TCODE(p->header[3]);
838
spin_lock_irqsave(&address_handler_lock, flags);
839
handler = lookup_enclosing_address_handler(&address_handler_list,
840
offset, request->length);
841
spin_unlock_irqrestore(&address_handler_lock, flags);
844
* FIXME: lookup the fw_node corresponding to the sender of
845
* this request and pass that to the address handler instead
846
* of the node ID. We may also want to move the address
847
* allocations to fw_node so we only do this callback if the
848
* upper layers registered it for this node.
852
fw_send_response(card, request, RCODE_ADDRESS_ERROR);
854
handler->address_callback(card, request,
855
tcode, destination, source,
856
p->generation, offset,
857
request->data, request->length,
858
handler->callback_data);
861
static void handle_fcp_region_request(struct fw_card *card,
863
struct fw_request *request,
864
unsigned long long offset)
866
struct fw_address_handler *handler;
868
int tcode, destination, source;
870
if ((offset != (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
871
offset != (CSR_REGISTER_BASE | CSR_FCP_RESPONSE)) ||
872
request->length > 0x200) {
873
fw_send_response(card, request, RCODE_ADDRESS_ERROR);
878
tcode = HEADER_GET_TCODE(p->header[0]);
879
destination = HEADER_GET_DESTINATION(p->header[0]);
880
source = HEADER_GET_SOURCE(p->header[1]);
882
if (tcode != TCODE_WRITE_QUADLET_REQUEST &&
883
tcode != TCODE_WRITE_BLOCK_REQUEST) {
884
fw_send_response(card, request, RCODE_TYPE_ERROR);
889
spin_lock_irqsave(&address_handler_lock, flags);
890
list_for_each_entry(handler, &address_handler_list, link) {
891
if (is_enclosing_handler(handler, offset, request->length))
892
handler->address_callback(card, NULL, tcode,
894
p->generation, offset,
897
handler->callback_data);
899
spin_unlock_irqrestore(&address_handler_lock, flags);
901
fw_send_response(card, request, RCODE_COMPLETE);
904
void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
906
struct fw_request *request;
907
unsigned long long offset;
909
if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
912
if (TCODE_IS_LINK_INTERNAL(HEADER_GET_TCODE(p->header[0]))) {
913
fw_cdev_handle_phy_packet(card, p);
917
request = allocate_request(card, p);
918
if (request == NULL) {
919
/* FIXME: send statically allocated busy packet. */
923
offset = ((u64)HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) |
926
if (!is_in_fcp_region(offset, request->length))
927
handle_exclusive_region_request(card, p, request, offset);
929
handle_fcp_region_request(card, p, request, offset);
932
EXPORT_SYMBOL(fw_core_handle_request);
934
void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
936
struct fw_transaction *t;
940
int tcode, tlabel, source, rcode;
942
tcode = HEADER_GET_TCODE(p->header[0]);
943
tlabel = HEADER_GET_TLABEL(p->header[0]);
944
source = HEADER_GET_SOURCE(p->header[1]);
945
rcode = HEADER_GET_RCODE(p->header[1]);
947
spin_lock_irqsave(&card->lock, flags);
948
list_for_each_entry(t, &card->transaction_list, link) {
949
if (t->node_id == source && t->tlabel == tlabel) {
950
if (!try_cancel_split_timeout(t)) {
951
spin_unlock_irqrestore(&card->lock, flags);
954
list_del_init(&t->link);
955
card->tlabel_mask &= ~(1ULL << t->tlabel);
959
spin_unlock_irqrestore(&card->lock, flags);
961
if (&t->link == &card->transaction_list) {
963
fw_notify("Unsolicited response (source %x, tlabel %x)\n",
969
* FIXME: sanity check packet, is length correct, does tcodes
970
* and addresses match.
974
case TCODE_READ_QUADLET_RESPONSE:
975
data = (u32 *) &p->header[3];
979
case TCODE_WRITE_RESPONSE:
984
case TCODE_READ_BLOCK_RESPONSE:
985
case TCODE_LOCK_RESPONSE:
987
data_length = HEADER_GET_DATA_LENGTH(p->header[3]);
991
/* Should never happen, this is just to shut up gcc. */
998
* The response handler may be executed while the request handler
999
* is still pending. Cancel the request handler.
1001
card->driver->cancel_packet(card, &t->packet);
1003
t->callback(card, rcode, data, data_length, t->callback_data);
1005
EXPORT_SYMBOL(fw_core_handle_response);
1007
static const struct fw_address_region topology_map_region =
1008
{ .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP,
1009
.end = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, };
1011
static void handle_topology_map(struct fw_card *card, struct fw_request *request,
1012
int tcode, int destination, int source, int generation,
1013
unsigned long long offset, void *payload, size_t length,
1014
void *callback_data)
1018
if (!TCODE_IS_READ_REQUEST(tcode)) {
1019
fw_send_response(card, request, RCODE_TYPE_ERROR);
1023
if ((offset & 3) > 0 || (length & 3) > 0) {
1024
fw_send_response(card, request, RCODE_ADDRESS_ERROR);
1028
start = (offset - topology_map_region.start) / 4;
1029
memcpy(payload, &card->topology_map[start], length);
1031
fw_send_response(card, request, RCODE_COMPLETE);
1034
static struct fw_address_handler topology_map = {
1036
.address_callback = handle_topology_map,
1039
static const struct fw_address_region registers_region =
1040
{ .start = CSR_REGISTER_BASE,
1041
.end = CSR_REGISTER_BASE | CSR_CONFIG_ROM, };
1043
static void update_split_timeout(struct fw_card *card)
1045
unsigned int cycles;
1047
cycles = card->split_timeout_hi * 8000 + (card->split_timeout_lo >> 19);
1049
/* minimum per IEEE 1394, maximum which doesn't overflow OHCI */
1050
cycles = clamp(cycles, 800u, 3u * 8000u);
1052
card->split_timeout_cycles = cycles;
1053
card->split_timeout_jiffies = DIV_ROUND_UP(cycles * HZ, 8000);
1056
static void handle_registers(struct fw_card *card, struct fw_request *request,
1057
int tcode, int destination, int source, int generation,
1058
unsigned long long offset, void *payload, size_t length,
1059
void *callback_data)
1061
int reg = offset & ~CSR_REGISTER_BASE;
1062
__be32 *data = payload;
1063
int rcode = RCODE_COMPLETE;
1064
unsigned long flags;
1067
case CSR_PRIORITY_BUDGET:
1068
if (!card->priority_budget_implemented) {
1069
rcode = RCODE_ADDRESS_ERROR;
1072
/* else fall through */
1076
* per IEEE 1394-2008 8.3.22.3, not IEEE 1394.1-2004 3.2.8
1077
* and 9.6, but interoperable with IEEE 1394.1-2004 bridges
1081
case CSR_STATE_CLEAR:
1083
case CSR_CYCLE_TIME:
1085
case CSR_BUSY_TIMEOUT:
1086
if (tcode == TCODE_READ_QUADLET_REQUEST)
1087
*data = cpu_to_be32(card->driver->read_csr(card, reg));
1088
else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1089
card->driver->write_csr(card, reg, be32_to_cpu(*data));
1091
rcode = RCODE_TYPE_ERROR;
1094
case CSR_RESET_START:
1095
if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1096
card->driver->write_csr(card, CSR_STATE_CLEAR,
1097
CSR_STATE_BIT_ABDICATE);
1099
rcode = RCODE_TYPE_ERROR;
1102
case CSR_SPLIT_TIMEOUT_HI:
1103
if (tcode == TCODE_READ_QUADLET_REQUEST) {
1104
*data = cpu_to_be32(card->split_timeout_hi);
1105
} else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1106
spin_lock_irqsave(&card->lock, flags);
1107
card->split_timeout_hi = be32_to_cpu(*data) & 7;
1108
update_split_timeout(card);
1109
spin_unlock_irqrestore(&card->lock, flags);
1111
rcode = RCODE_TYPE_ERROR;
1115
case CSR_SPLIT_TIMEOUT_LO:
1116
if (tcode == TCODE_READ_QUADLET_REQUEST) {
1117
*data = cpu_to_be32(card->split_timeout_lo);
1118
} else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1119
spin_lock_irqsave(&card->lock, flags);
1120
card->split_timeout_lo =
1121
be32_to_cpu(*data) & 0xfff80000;
1122
update_split_timeout(card);
1123
spin_unlock_irqrestore(&card->lock, flags);
1125
rcode = RCODE_TYPE_ERROR;
1129
case CSR_MAINT_UTILITY:
1130
if (tcode == TCODE_READ_QUADLET_REQUEST)
1131
*data = card->maint_utility_register;
1132
else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1133
card->maint_utility_register = *data;
1135
rcode = RCODE_TYPE_ERROR;
1138
case CSR_BROADCAST_CHANNEL:
1139
if (tcode == TCODE_READ_QUADLET_REQUEST)
1140
*data = cpu_to_be32(card->broadcast_channel);
1141
else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1142
card->broadcast_channel =
1143
(be32_to_cpu(*data) & BROADCAST_CHANNEL_VALID) |
1144
BROADCAST_CHANNEL_INITIAL;
1146
rcode = RCODE_TYPE_ERROR;
1149
case CSR_BUS_MANAGER_ID:
1150
case CSR_BANDWIDTH_AVAILABLE:
1151
case CSR_CHANNELS_AVAILABLE_HI:
1152
case CSR_CHANNELS_AVAILABLE_LO:
1154
* FIXME: these are handled by the OHCI hardware and
1155
* the stack never sees these request. If we add
1156
* support for a new type of controller that doesn't
1157
* handle this in hardware we need to deal with these
1164
rcode = RCODE_ADDRESS_ERROR;
1168
fw_send_response(card, request, rcode);
1171
static struct fw_address_handler registers = {
1173
.address_callback = handle_registers,
1176
MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1177
MODULE_DESCRIPTION("Core IEEE1394 transaction logic");
1178
MODULE_LICENSE("GPL");
1180
static const u32 vendor_textual_descriptor[] = {
1181
/* textual descriptor leaf () */
1185
0x4c696e75, /* L i n u */
1186
0x78204669, /* x F i */
1187
0x72657769, /* r e w i */
1188
0x72650000, /* r e */
1191
static const u32 model_textual_descriptor[] = {
1192
/* model descriptor leaf () */
1196
0x4a756a75, /* J u j u */
1199
static struct fw_descriptor vendor_id_descriptor = {
1200
.length = ARRAY_SIZE(vendor_textual_descriptor),
1201
.immediate = 0x03d00d1e,
1203
.data = vendor_textual_descriptor,
1206
static struct fw_descriptor model_id_descriptor = {
1207
.length = ARRAY_SIZE(model_textual_descriptor),
1208
.immediate = 0x17000001,
1210
.data = model_textual_descriptor,
1213
static int __init fw_core_init(void)
1217
fw_workqueue = alloc_workqueue("firewire",
1218
WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);
1222
ret = bus_register(&fw_bus_type);
1224
destroy_workqueue(fw_workqueue);
1228
fw_cdev_major = register_chrdev(0, "firewire", &fw_device_ops);
1229
if (fw_cdev_major < 0) {
1230
bus_unregister(&fw_bus_type);
1231
destroy_workqueue(fw_workqueue);
1232
return fw_cdev_major;
1235
fw_core_add_address_handler(&topology_map, &topology_map_region);
1236
fw_core_add_address_handler(®isters, ®isters_region);
1237
fw_core_add_descriptor(&vendor_id_descriptor);
1238
fw_core_add_descriptor(&model_id_descriptor);
1243
static void __exit fw_core_cleanup(void)
1245
unregister_chrdev(fw_cdev_major, "firewire");
1246
bus_unregister(&fw_bus_type);
1247
destroy_workqueue(fw_workqueue);
1248
idr_destroy(&fw_device_idr);
1251
module_init(fw_core_init);
1252
module_exit(fw_core_cleanup);