1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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>
27#include <linux/fs.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
40#include <asm/byteorder.h>
41
42#include "core.h"
43
44#define HEADER_PRI(pri) ((pri) << 0)
45#define HEADER_TCODE(tcode) ((tcode) << 4)
46#define HEADER_RETRY(retry) ((retry) << 8)
47#define HEADER_TLABEL(tlabel) ((tlabel) << 10)
48#define HEADER_DESTINATION(destination) ((destination) << 16)
49#define HEADER_SOURCE(source) ((source) << 16)
50#define HEADER_RCODE(rcode) ((rcode) << 12)
51#define HEADER_OFFSET_HIGH(offset_high) ((offset_high) << 0)
52#define HEADER_DATA_LENGTH(length) ((length) << 16)
53#define HEADER_EXTENDED_TCODE(tcode) ((tcode) << 0)
54
55#define HEADER_GET_TCODE(q) (((q) >> 4) & 0x0f)
56#define HEADER_GET_TLABEL(q) (((q) >> 10) & 0x3f)
57#define HEADER_GET_RCODE(q) (((q) >> 12) & 0x0f)
58#define HEADER_GET_DESTINATION(q) (((q) >> 16) & 0xffff)
59#define HEADER_GET_SOURCE(q) (((q) >> 16) & 0xffff)
60#define HEADER_GET_OFFSET_HIGH(q) (((q) >> 0) & 0xffff)
61#define HEADER_GET_DATA_LENGTH(q) (((q) >> 16) & 0xffff)
62#define HEADER_GET_EXTENDED_TCODE(q) (((q) >> 0) & 0xffff)
63
64#define HEADER_DESTINATION_IS_BROADCAST(q) \
65 (((q) & HEADER_DESTINATION(0x3f)) == HEADER_DESTINATION(0x3f))
66
67#define PHY_PACKET_CONFIG 0x0
68#define PHY_PACKET_LINK_ON 0x1
69#define PHY_PACKET_SELF_ID 0x2
70
71#define PHY_CONFIG_GAP_COUNT(gap_count) (((gap_count) << 16) | (1 << 22))
72#define PHY_CONFIG_ROOT_ID(node_id) ((((node_id) & 0x3f) << 24) | (1 << 23))
73#define PHY_IDENTIFIER(id) ((id) << 30)
74
75
76static int try_cancel_split_timeout(struct fw_transaction *t)
77{
78 if (t->is_split_transaction)
79 return del_timer(&t->split_timeout_timer);
80 else
81 return 1;
82}
83
84static int close_transaction(struct fw_transaction *transaction,
85 struct fw_card *card, int rcode)
86{
87 struct fw_transaction *t;
88 unsigned long flags;
89
90 spin_lock_irqsave(&card->lock, flags);
91 list_for_each_entry(t, &card->transaction_list, link) {
92 if (t == transaction) {
93 if (!try_cancel_split_timeout(t)) {
94 spin_unlock_irqrestore(&card->lock, flags);
95 goto timed_out;
96 }
97 list_del_init(&t->link);
98 card->tlabel_mask &= ~(1ULL << t->tlabel);
99 break;
100 }
101 }
102 spin_unlock_irqrestore(&card->lock, flags);
103
104 if (&t->link != &card->transaction_list) {
105 t->callback(card, rcode, NULL, 0, t->callback_data);
106 return 0;
107 }
108
109 timed_out:
110 return -ENOENT;
111}
112
113
114
115
116
117int fw_cancel_transaction(struct fw_card *card,
118 struct fw_transaction *transaction)
119{
120
121
122
123
124
125
126 if (card->driver->cancel_packet(card, &transaction->packet) == 0)
127 return 0;
128
129
130
131
132
133
134 return close_transaction(transaction, card, RCODE_CANCELLED);
135}
136EXPORT_SYMBOL(fw_cancel_transaction);
137
138static void split_transaction_timeout_callback(unsigned long data)
139{
140 struct fw_transaction *t = (struct fw_transaction *)data;
141 struct fw_card *card = t->card;
142 unsigned long flags;
143
144 spin_lock_irqsave(&card->lock, flags);
145 if (list_empty(&t->link)) {
146 spin_unlock_irqrestore(&card->lock, flags);
147 return;
148 }
149 list_del(&t->link);
150 card->tlabel_mask &= ~(1ULL << t->tlabel);
151 spin_unlock_irqrestore(&card->lock, flags);
152
153 t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
154}
155
156static void start_split_transaction_timeout(struct fw_transaction *t,
157 struct fw_card *card)
158{
159 unsigned long flags;
160
161 spin_lock_irqsave(&card->lock, flags);
162
163 if (list_empty(&t->link) || WARN_ON(t->is_split_transaction)) {
164 spin_unlock_irqrestore(&card->lock, flags);
165 return;
166 }
167
168 t->is_split_transaction = true;
169 mod_timer(&t->split_timeout_timer,
170 jiffies + card->split_timeout_jiffies);
171
172 spin_unlock_irqrestore(&card->lock, flags);
173}
174
175static void transmit_complete_callback(struct fw_packet *packet,
176 struct fw_card *card, int status)
177{
178 struct fw_transaction *t =
179 container_of(packet, struct fw_transaction, packet);
180
181 switch (status) {
182 case ACK_COMPLETE:
183 close_transaction(t, card, RCODE_COMPLETE);
184 break;
185 case ACK_PENDING:
186 start_split_transaction_timeout(t, card);
187 break;
188 case ACK_BUSY_X:
189 case ACK_BUSY_A:
190 case ACK_BUSY_B:
191 close_transaction(t, card, RCODE_BUSY);
192 break;
193 case ACK_DATA_ERROR:
194 close_transaction(t, card, RCODE_DATA_ERROR);
195 break;
196 case ACK_TYPE_ERROR:
197 close_transaction(t, card, RCODE_TYPE_ERROR);
198 break;
199 default:
200
201
202
203
204 close_transaction(t, card, status);
205 break;
206 }
207}
208
209static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
210 int destination_id, int source_id, int generation, int speed,
211 unsigned long long offset, void *payload, size_t length)
212{
213 int ext_tcode;
214
215 if (tcode == TCODE_STREAM_DATA) {
216 packet->header[0] =
217 HEADER_DATA_LENGTH(length) |
218 destination_id |
219 HEADER_TCODE(TCODE_STREAM_DATA);
220 packet->header_length = 4;
221 packet->payload = payload;
222 packet->payload_length = length;
223
224 goto common;
225 }
226
227 if (tcode > 0x10) {
228 ext_tcode = tcode & ~0x10;
229 tcode = TCODE_LOCK_REQUEST;
230 } else
231 ext_tcode = 0;
232
233 packet->header[0] =
234 HEADER_RETRY(RETRY_X) |
235 HEADER_TLABEL(tlabel) |
236 HEADER_TCODE(tcode) |
237 HEADER_DESTINATION(destination_id);
238 packet->header[1] =
239 HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id);
240 packet->header[2] =
241 offset;
242
243 switch (tcode) {
244 case TCODE_WRITE_QUADLET_REQUEST:
245 packet->header[3] = *(u32 *)payload;
246 packet->header_length = 16;
247 packet->payload_length = 0;
248 break;
249
250 case TCODE_LOCK_REQUEST:
251 case TCODE_WRITE_BLOCK_REQUEST:
252 packet->header[3] =
253 HEADER_DATA_LENGTH(length) |
254 HEADER_EXTENDED_TCODE(ext_tcode);
255 packet->header_length = 16;
256 packet->payload = payload;
257 packet->payload_length = length;
258 break;
259
260 case TCODE_READ_QUADLET_REQUEST:
261 packet->header_length = 12;
262 packet->payload_length = 0;
263 break;
264
265 case TCODE_READ_BLOCK_REQUEST:
266 packet->header[3] =
267 HEADER_DATA_LENGTH(length) |
268 HEADER_EXTENDED_TCODE(ext_tcode);
269 packet->header_length = 16;
270 packet->payload_length = 0;
271 break;
272
273 default:
274 WARN(1, "wrong tcode %d\n", tcode);
275 }
276 common:
277 packet->speed = speed;
278 packet->generation = generation;
279 packet->ack = 0;
280 packet->payload_mapped = false;
281}
282
283static int allocate_tlabel(struct fw_card *card)
284{
285 int tlabel;
286
287 tlabel = card->current_tlabel;
288 while (card->tlabel_mask & (1ULL << tlabel)) {
289 tlabel = (tlabel + 1) & 0x3f;
290 if (tlabel == card->current_tlabel)
291 return -EBUSY;
292 }
293
294 card->current_tlabel = (tlabel + 1) & 0x3f;
295 card->tlabel_mask |= 1ULL << tlabel;
296
297 return tlabel;
298}
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348void fw_send_request(struct fw_card *card, struct fw_transaction *t, int tcode,
349 int destination_id, int generation, int speed,
350 unsigned long long offset, void *payload, size_t length,
351 fw_transaction_callback_t callback, void *callback_data)
352{
353 unsigned long flags;
354 int tlabel;
355
356
357
358
359
360
361 spin_lock_irqsave(&card->lock, flags);
362
363 tlabel = allocate_tlabel(card);
364 if (tlabel < 0) {
365 spin_unlock_irqrestore(&card->lock, flags);
366 callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data);
367 return;
368 }
369
370 t->node_id = destination_id;
371 t->tlabel = tlabel;
372 t->card = card;
373 t->is_split_transaction = false;
374 setup_timer(&t->split_timeout_timer,
375 split_transaction_timeout_callback, (unsigned long)t);
376 t->callback = callback;
377 t->callback_data = callback_data;
378
379 fw_fill_request(&t->packet, tcode, t->tlabel,
380 destination_id, card->node_id, generation,
381 speed, offset, payload, length);
382 t->packet.callback = transmit_complete_callback;
383
384 list_add_tail(&t->link, &card->transaction_list);
385
386 spin_unlock_irqrestore(&card->lock, flags);
387
388 card->driver->send_request(card, &t->packet);
389}
390EXPORT_SYMBOL(fw_send_request);
391
392struct transaction_callback_data {
393 struct completion done;
394 void *payload;
395 int rcode;
396};
397
398static void transaction_callback(struct fw_card *card, int rcode,
399 void *payload, size_t length, void *data)
400{
401 struct transaction_callback_data *d = data;
402
403 if (rcode == RCODE_COMPLETE)
404 memcpy(d->payload, payload, length);
405 d->rcode = rcode;
406 complete(&d->done);
407}
408
409
410
411
412
413
414
415
416int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
417 int generation, int speed, unsigned long long offset,
418 void *payload, size_t length)
419{
420 struct transaction_callback_data d;
421 struct fw_transaction t;
422
423 init_timer_on_stack(&t.split_timeout_timer);
424 init_completion(&d.done);
425 d.payload = payload;
426 fw_send_request(card, &t, tcode, destination_id, generation, speed,
427 offset, payload, length, transaction_callback, &d);
428 wait_for_completion(&d.done);
429 destroy_timer_on_stack(&t.split_timeout_timer);
430
431 return d.rcode;
432}
433EXPORT_SYMBOL(fw_run_transaction);
434
435static DEFINE_MUTEX(phy_config_mutex);
436static DECLARE_COMPLETION(phy_config_done);
437
438static void transmit_phy_packet_callback(struct fw_packet *packet,
439 struct fw_card *card, int status)
440{
441 complete(&phy_config_done);
442}
443
444static struct fw_packet phy_config_packet = {
445 .header_length = 12,
446 .header[0] = TCODE_LINK_INTERNAL << 4,
447 .payload_length = 0,
448 .speed = SCODE_100,
449 .callback = transmit_phy_packet_callback,
450};
451
452void fw_send_phy_config(struct fw_card *card,
453 int node_id, int generation, int gap_count)
454{
455 long timeout = DIV_ROUND_UP(HZ, 10);
456 u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG);
457
458 if (node_id != FW_PHY_CONFIG_NO_NODE_ID)
459 data |= PHY_CONFIG_ROOT_ID(node_id);
460
461 if (gap_count == FW_PHY_CONFIG_CURRENT_GAP_COUNT) {
462 gap_count = card->driver->read_phy_reg(card, 1);
463 if (gap_count < 0)
464 return;
465
466 gap_count &= 63;
467 if (gap_count == 63)
468 return;
469 }
470 data |= PHY_CONFIG_GAP_COUNT(gap_count);
471
472 mutex_lock(&phy_config_mutex);
473
474 phy_config_packet.header[1] = data;
475 phy_config_packet.header[2] = ~data;
476 phy_config_packet.generation = generation;
477 INIT_COMPLETION(phy_config_done);
478
479 card->driver->send_request(card, &phy_config_packet);
480 wait_for_completion_timeout(&phy_config_done, timeout);
481
482 mutex_unlock(&phy_config_mutex);
483}
484
485static struct fw_address_handler *lookup_overlapping_address_handler(
486 struct list_head *list, unsigned long long offset, size_t length)
487{
488 struct fw_address_handler *handler;
489
490 list_for_each_entry(handler, list, link) {
491 if (handler->offset < offset + length &&
492 offset < handler->offset + handler->length)
493 return handler;
494 }
495
496 return NULL;
497}
498
499static bool is_enclosing_handler(struct fw_address_handler *handler,
500 unsigned long long offset, size_t length)
501{
502 return handler->offset <= offset &&
503 offset + length <= handler->offset + handler->length;
504}
505
506static struct fw_address_handler *lookup_enclosing_address_handler(
507 struct list_head *list, unsigned long long offset, size_t length)
508{
509 struct fw_address_handler *handler;
510
511 list_for_each_entry(handler, list, link) {
512 if (is_enclosing_handler(handler, offset, length))
513 return handler;
514 }
515
516 return NULL;
517}
518
519static DEFINE_SPINLOCK(address_handler_lock);
520static LIST_HEAD(address_handler_list);
521
522const struct fw_address_region fw_high_memory_region =
523 { .start = 0x000100000000ULL, .end = 0xffffe0000000ULL, };
524EXPORT_SYMBOL(fw_high_memory_region);
525
526#if 0
527const struct fw_address_region fw_low_memory_region =
528 { .start = 0x000000000000ULL, .end = 0x000100000000ULL, };
529const struct fw_address_region fw_private_region =
530 { .start = 0xffffe0000000ULL, .end = 0xfffff0000000ULL, };
531const struct fw_address_region fw_csr_region =
532 { .start = CSR_REGISTER_BASE,
533 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM_END, };
534const struct fw_address_region fw_unit_space_region =
535 { .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
536#endif
537
538static bool is_in_fcp_region(u64 offset, size_t length)
539{
540 return offset >= (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
541 offset + length <= (CSR_REGISTER_BASE | CSR_FCP_END);
542}
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562int fw_core_add_address_handler(struct fw_address_handler *handler,
563 const struct fw_address_region *region)
564{
565 struct fw_address_handler *other;
566 unsigned long flags;
567 int ret = -EBUSY;
568
569 if (region->start & 0xffff000000000003ULL ||
570 region->start >= region->end ||
571 region->end > 0x0001000000000000ULL ||
572 handler->length & 3 ||
573 handler->length == 0)
574 return -EINVAL;
575
576 spin_lock_irqsave(&address_handler_lock, flags);
577
578 handler->offset = region->start;
579 while (handler->offset + handler->length <= region->end) {
580 if (is_in_fcp_region(handler->offset, handler->length))
581 other = NULL;
582 else
583 other = lookup_overlapping_address_handler
584 (&address_handler_list,
585 handler->offset, handler->length);
586 if (other != NULL) {
587 handler->offset += other->length;
588 } else {
589 list_add_tail(&handler->link, &address_handler_list);
590 ret = 0;
591 break;
592 }
593 }
594
595 spin_unlock_irqrestore(&address_handler_lock, flags);
596
597 return ret;
598}
599EXPORT_SYMBOL(fw_core_add_address_handler);
600
601
602
603
604void fw_core_remove_address_handler(struct fw_address_handler *handler)
605{
606 unsigned long flags;
607
608 spin_lock_irqsave(&address_handler_lock, flags);
609 list_del(&handler->link);
610 spin_unlock_irqrestore(&address_handler_lock, flags);
611}
612EXPORT_SYMBOL(fw_core_remove_address_handler);
613
614struct fw_request {
615 struct fw_packet response;
616 u32 request_header[4];
617 int ack;
618 u32 length;
619 u32 data[0];
620};
621
622static void free_response_callback(struct fw_packet *packet,
623 struct fw_card *card, int status)
624{
625 struct fw_request *request;
626
627 request = container_of(packet, struct fw_request, response);
628 kfree(request);
629}
630
631int fw_get_response_length(struct fw_request *r)
632{
633 int tcode, ext_tcode, data_length;
634
635 tcode = HEADER_GET_TCODE(r->request_header[0]);
636
637 switch (tcode) {
638 case TCODE_WRITE_QUADLET_REQUEST:
639 case TCODE_WRITE_BLOCK_REQUEST:
640 return 0;
641
642 case TCODE_READ_QUADLET_REQUEST:
643 return 4;
644
645 case TCODE_READ_BLOCK_REQUEST:
646 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
647 return data_length;
648
649 case TCODE_LOCK_REQUEST:
650 ext_tcode = HEADER_GET_EXTENDED_TCODE(r->request_header[3]);
651 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
652 switch (ext_tcode) {
653 case EXTCODE_FETCH_ADD:
654 case EXTCODE_LITTLE_ADD:
655 return data_length;
656 default:
657 return data_length / 2;
658 }
659
660 default:
661 WARN(1, "wrong tcode %d\n", tcode);
662 return 0;
663 }
664}
665
666void fw_fill_response(struct fw_packet *response, u32 *request_header,
667 int rcode, void *payload, size_t length)
668{
669 int tcode, tlabel, extended_tcode, source, destination;
670
671 tcode = HEADER_GET_TCODE(request_header[0]);
672 tlabel = HEADER_GET_TLABEL(request_header[0]);
673 source = HEADER_GET_DESTINATION(request_header[0]);
674 destination = HEADER_GET_SOURCE(request_header[1]);
675 extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]);
676
677 response->header[0] =
678 HEADER_RETRY(RETRY_1) |
679 HEADER_TLABEL(tlabel) |
680 HEADER_DESTINATION(destination);
681 response->header[1] =
682 HEADER_SOURCE(source) |
683 HEADER_RCODE(rcode);
684 response->header[2] = 0;
685
686 switch (tcode) {
687 case TCODE_WRITE_QUADLET_REQUEST:
688 case TCODE_WRITE_BLOCK_REQUEST:
689 response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE);
690 response->header_length = 12;
691 response->payload_length = 0;
692 break;
693
694 case TCODE_READ_QUADLET_REQUEST:
695 response->header[0] |=
696 HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE);
697 if (payload != NULL)
698 response->header[3] = *(u32 *)payload;
699 else
700 response->header[3] = 0;
701 response->header_length = 16;
702 response->payload_length = 0;
703 break;
704
705 case TCODE_READ_BLOCK_REQUEST:
706 case TCODE_LOCK_REQUEST:
707 response->header[0] |= HEADER_TCODE(tcode + 2);
708 response->header[3] =
709 HEADER_DATA_LENGTH(length) |
710 HEADER_EXTENDED_TCODE(extended_tcode);
711 response->header_length = 16;
712 response->payload = payload;
713 response->payload_length = length;
714 break;
715
716 default:
717 WARN(1, "wrong tcode %d\n", tcode);
718 }
719
720 response->payload_mapped = false;
721}
722EXPORT_SYMBOL(fw_fill_response);
723
724static u32 compute_split_timeout_timestamp(struct fw_card *card,
725 u32 request_timestamp)
726{
727 unsigned int cycles;
728 u32 timestamp;
729
730 cycles = card->split_timeout_cycles;
731 cycles += request_timestamp & 0x1fff;
732
733 timestamp = request_timestamp & ~0x1fff;
734 timestamp += (cycles / 8000) << 13;
735 timestamp |= cycles % 8000;
736
737 return timestamp;
738}
739
740static struct fw_request *allocate_request(struct fw_card *card,
741 struct fw_packet *p)
742{
743 struct fw_request *request;
744 u32 *data, length;
745 int request_tcode;
746
747 request_tcode = HEADER_GET_TCODE(p->header[0]);
748 switch (request_tcode) {
749 case TCODE_WRITE_QUADLET_REQUEST:
750 data = &p->header[3];
751 length = 4;
752 break;
753
754 case TCODE_WRITE_BLOCK_REQUEST:
755 case TCODE_LOCK_REQUEST:
756 data = p->payload;
757 length = HEADER_GET_DATA_LENGTH(p->header[3]);
758 break;
759
760 case TCODE_READ_QUADLET_REQUEST:
761 data = NULL;
762 length = 4;
763 break;
764
765 case TCODE_READ_BLOCK_REQUEST:
766 data = NULL;
767 length = HEADER_GET_DATA_LENGTH(p->header[3]);
768 break;
769
770 default:
771 fw_error("ERROR - corrupt request received - %08x %08x %08x\n",
772 p->header[0], p->header[1], p->header[2]);
773 return NULL;
774 }
775
776 request = kmalloc(sizeof(*request) + length, GFP_ATOMIC);
777 if (request == NULL)
778 return NULL;
779
780 request->response.speed = p->speed;
781 request->response.timestamp =
782 compute_split_timeout_timestamp(card, p->timestamp);
783 request->response.generation = p->generation;
784 request->response.ack = 0;
785 request->response.callback = free_response_callback;
786 request->ack = p->ack;
787 request->length = length;
788 if (data)
789 memcpy(request->data, data, length);
790
791 memcpy(request->request_header, p->header, sizeof(p->header));
792
793 return request;
794}
795
796void fw_send_response(struct fw_card *card,
797 struct fw_request *request, int rcode)
798{
799 if (WARN_ONCE(!request, "invalid for FCP address handlers"))
800 return;
801
802
803 if (request->ack != ACK_PENDING ||
804 HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) {
805 kfree(request);
806 return;
807 }
808
809 if (rcode == RCODE_COMPLETE)
810 fw_fill_response(&request->response, request->request_header,
811 rcode, request->data,
812 fw_get_response_length(request));
813 else
814 fw_fill_response(&request->response, request->request_header,
815 rcode, NULL, 0);
816
817 card->driver->send_response(card, &request->response);
818}
819EXPORT_SYMBOL(fw_send_response);
820
821static void handle_exclusive_region_request(struct fw_card *card,
822 struct fw_packet *p,
823 struct fw_request *request,
824 unsigned long long offset)
825{
826 struct fw_address_handler *handler;
827 unsigned long flags;
828 int tcode, destination, source;
829
830 destination = HEADER_GET_DESTINATION(p->header[0]);
831 source = HEADER_GET_SOURCE(p->header[1]);
832 tcode = HEADER_GET_TCODE(p->header[0]);
833 if (tcode == TCODE_LOCK_REQUEST)
834 tcode = 0x10 + HEADER_GET_EXTENDED_TCODE(p->header[3]);
835
836 spin_lock_irqsave(&address_handler_lock, flags);
837 handler = lookup_enclosing_address_handler(&address_handler_list,
838 offset, request->length);
839 spin_unlock_irqrestore(&address_handler_lock, flags);
840
841
842
843
844
845
846
847
848
849 if (handler == NULL)
850 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
851 else
852 handler->address_callback(card, request,
853 tcode, destination, source,
854 p->generation, offset,
855 request->data, request->length,
856 handler->callback_data);
857}
858
859static void handle_fcp_region_request(struct fw_card *card,
860 struct fw_packet *p,
861 struct fw_request *request,
862 unsigned long long offset)
863{
864 struct fw_address_handler *handler;
865 unsigned long flags;
866 int tcode, destination, source;
867
868 if ((offset != (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
869 offset != (CSR_REGISTER_BASE | CSR_FCP_RESPONSE)) ||
870 request->length > 0x200) {
871 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
872
873 return;
874 }
875
876 tcode = HEADER_GET_TCODE(p->header[0]);
877 destination = HEADER_GET_DESTINATION(p->header[0]);
878 source = HEADER_GET_SOURCE(p->header[1]);
879
880 if (tcode != TCODE_WRITE_QUADLET_REQUEST &&
881 tcode != TCODE_WRITE_BLOCK_REQUEST) {
882 fw_send_response(card, request, RCODE_TYPE_ERROR);
883
884 return;
885 }
886
887 spin_lock_irqsave(&address_handler_lock, flags);
888 list_for_each_entry(handler, &address_handler_list, link) {
889 if (is_enclosing_handler(handler, offset, request->length))
890 handler->address_callback(card, NULL, tcode,
891 destination, source,
892 p->generation, offset,
893 request->data,
894 request->length,
895 handler->callback_data);
896 }
897 spin_unlock_irqrestore(&address_handler_lock, flags);
898
899 fw_send_response(card, request, RCODE_COMPLETE);
900}
901
902void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
903{
904 struct fw_request *request;
905 unsigned long long offset;
906
907 if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
908 return;
909
910 if (TCODE_IS_LINK_INTERNAL(HEADER_GET_TCODE(p->header[0]))) {
911 fw_cdev_handle_phy_packet(card, p);
912 return;
913 }
914
915 request = allocate_request(card, p);
916 if (request == NULL) {
917
918 return;
919 }
920
921 offset = ((u64)HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) |
922 p->header[2];
923
924 if (!is_in_fcp_region(offset, request->length))
925 handle_exclusive_region_request(card, p, request, offset);
926 else
927 handle_fcp_region_request(card, p, request, offset);
928
929}
930EXPORT_SYMBOL(fw_core_handle_request);
931
932void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
933{
934 struct fw_transaction *t;
935 unsigned long flags;
936 u32 *data;
937 size_t data_length;
938 int tcode, tlabel, source, rcode;
939
940 tcode = HEADER_GET_TCODE(p->header[0]);
941 tlabel = HEADER_GET_TLABEL(p->header[0]);
942 source = HEADER_GET_SOURCE(p->header[1]);
943 rcode = HEADER_GET_RCODE(p->header[1]);
944
945 spin_lock_irqsave(&card->lock, flags);
946 list_for_each_entry(t, &card->transaction_list, link) {
947 if (t->node_id == source && t->tlabel == tlabel) {
948 if (!try_cancel_split_timeout(t)) {
949 spin_unlock_irqrestore(&card->lock, flags);
950 goto timed_out;
951 }
952 list_del_init(&t->link);
953 card->tlabel_mask &= ~(1ULL << t->tlabel);
954 break;
955 }
956 }
957 spin_unlock_irqrestore(&card->lock, flags);
958
959 if (&t->link == &card->transaction_list) {
960 timed_out:
961 fw_notify("Unsolicited response (source %x, tlabel %x)\n",
962 source, tlabel);
963 return;
964 }
965
966
967
968
969
970
971 switch (tcode) {
972 case TCODE_READ_QUADLET_RESPONSE:
973 data = (u32 *) &p->header[3];
974 data_length = 4;
975 break;
976
977 case TCODE_WRITE_RESPONSE:
978 data = NULL;
979 data_length = 0;
980 break;
981
982 case TCODE_READ_BLOCK_RESPONSE:
983 case TCODE_LOCK_RESPONSE:
984 data = p->payload;
985 data_length = HEADER_GET_DATA_LENGTH(p->header[3]);
986 break;
987
988 default:
989
990 data = NULL;
991 data_length = 0;
992 break;
993 }
994
995
996
997
998
999 card->driver->cancel_packet(card, &t->packet);
1000
1001 t->callback(card, rcode, data, data_length, t->callback_data);
1002}
1003EXPORT_SYMBOL(fw_core_handle_response);
1004
1005static const struct fw_address_region topology_map_region =
1006 { .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP,
1007 .end = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, };
1008
1009static void handle_topology_map(struct fw_card *card, struct fw_request *request,
1010 int tcode, int destination, int source, int generation,
1011 unsigned long long offset, void *payload, size_t length,
1012 void *callback_data)
1013{
1014 int start;
1015
1016 if (!TCODE_IS_READ_REQUEST(tcode)) {
1017 fw_send_response(card, request, RCODE_TYPE_ERROR);
1018 return;
1019 }
1020
1021 if ((offset & 3) > 0 || (length & 3) > 0) {
1022 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
1023 return;
1024 }
1025
1026 start = (offset - topology_map_region.start) / 4;
1027 memcpy(payload, &card->topology_map[start], length);
1028
1029 fw_send_response(card, request, RCODE_COMPLETE);
1030}
1031
1032static struct fw_address_handler topology_map = {
1033 .length = 0x400,
1034 .address_callback = handle_topology_map,
1035};
1036
1037static const struct fw_address_region registers_region =
1038 { .start = CSR_REGISTER_BASE,
1039 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM, };
1040
1041static void update_split_timeout(struct fw_card *card)
1042{
1043 unsigned int cycles;
1044
1045 cycles = card->split_timeout_hi * 8000 + (card->split_timeout_lo >> 19);
1046
1047 cycles = max(cycles, 800u);
1048 cycles = min(cycles, 3u * 8000u);
1049
1050 card->split_timeout_cycles = cycles;
1051 card->split_timeout_jiffies = DIV_ROUND_UP(cycles * HZ, 8000);
1052}
1053
1054static void handle_registers(struct fw_card *card, struct fw_request *request,
1055 int tcode, int destination, int source, int generation,
1056 unsigned long long offset, void *payload, size_t length,
1057 void *callback_data)
1058{
1059 int reg = offset & ~CSR_REGISTER_BASE;
1060 __be32 *data = payload;
1061 int rcode = RCODE_COMPLETE;
1062 unsigned long flags;
1063
1064 switch (reg) {
1065 case CSR_PRIORITY_BUDGET:
1066 if (!card->priority_budget_implemented) {
1067 rcode = RCODE_ADDRESS_ERROR;
1068 break;
1069 }
1070
1071
1072 case CSR_NODE_IDS:
1073
1074
1075
1076
1077
1078
1079 case CSR_STATE_CLEAR:
1080 case CSR_STATE_SET:
1081 case CSR_CYCLE_TIME:
1082 case CSR_BUS_TIME:
1083 case CSR_BUSY_TIMEOUT:
1084 if (tcode == TCODE_READ_QUADLET_REQUEST)
1085 *data = cpu_to_be32(card->driver->read_csr(card, reg));
1086 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1087 card->driver->write_csr(card, reg, be32_to_cpu(*data));
1088 else
1089 rcode = RCODE_TYPE_ERROR;
1090 break;
1091
1092 case CSR_RESET_START:
1093 if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1094 card->driver->write_csr(card, CSR_STATE_CLEAR,
1095 CSR_STATE_BIT_ABDICATE);
1096 else
1097 rcode = RCODE_TYPE_ERROR;
1098 break;
1099
1100 case CSR_SPLIT_TIMEOUT_HI:
1101 if (tcode == TCODE_READ_QUADLET_REQUEST) {
1102 *data = cpu_to_be32(card->split_timeout_hi);
1103 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1104 spin_lock_irqsave(&card->lock, flags);
1105 card->split_timeout_hi = be32_to_cpu(*data) & 7;
1106 update_split_timeout(card);
1107 spin_unlock_irqrestore(&card->lock, flags);
1108 } else {
1109 rcode = RCODE_TYPE_ERROR;
1110 }
1111 break;
1112
1113 case CSR_SPLIT_TIMEOUT_LO:
1114 if (tcode == TCODE_READ_QUADLET_REQUEST) {
1115 *data = cpu_to_be32(card->split_timeout_lo);
1116 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1117 spin_lock_irqsave(&card->lock, flags);
1118 card->split_timeout_lo =
1119 be32_to_cpu(*data) & 0xfff80000;
1120 update_split_timeout(card);
1121 spin_unlock_irqrestore(&card->lock, flags);
1122 } else {
1123 rcode = RCODE_TYPE_ERROR;
1124 }
1125 break;
1126
1127 case CSR_MAINT_UTILITY:
1128 if (tcode == TCODE_READ_QUADLET_REQUEST)
1129 *data = card->maint_utility_register;
1130 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1131 card->maint_utility_register = *data;
1132 else
1133 rcode = RCODE_TYPE_ERROR;
1134 break;
1135
1136 case CSR_BROADCAST_CHANNEL:
1137 if (tcode == TCODE_READ_QUADLET_REQUEST)
1138 *data = cpu_to_be32(card->broadcast_channel);
1139 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1140 card->broadcast_channel =
1141 (be32_to_cpu(*data) & BROADCAST_CHANNEL_VALID) |
1142 BROADCAST_CHANNEL_INITIAL;
1143 else
1144 rcode = RCODE_TYPE_ERROR;
1145 break;
1146
1147 case CSR_BUS_MANAGER_ID:
1148 case CSR_BANDWIDTH_AVAILABLE:
1149 case CSR_CHANNELS_AVAILABLE_HI:
1150 case CSR_CHANNELS_AVAILABLE_LO:
1151
1152
1153
1154
1155
1156
1157
1158 BUG();
1159 break;
1160
1161 default:
1162 rcode = RCODE_ADDRESS_ERROR;
1163 break;
1164 }
1165
1166 fw_send_response(card, request, rcode);
1167}
1168
1169static struct fw_address_handler registers = {
1170 .length = 0x400,
1171 .address_callback = handle_registers,
1172};
1173
1174MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1175MODULE_DESCRIPTION("Core IEEE1394 transaction logic");
1176MODULE_LICENSE("GPL");
1177
1178static const u32 vendor_textual_descriptor[] = {
1179
1180 0x00060000,
1181 0x00000000,
1182 0x00000000,
1183 0x4c696e75,
1184 0x78204669,
1185 0x72657769,
1186 0x72650000,
1187};
1188
1189static const u32 model_textual_descriptor[] = {
1190
1191 0x00030000,
1192 0x00000000,
1193 0x00000000,
1194 0x4a756a75,
1195};
1196
1197static struct fw_descriptor vendor_id_descriptor = {
1198 .length = ARRAY_SIZE(vendor_textual_descriptor),
1199 .immediate = 0x03d00d1e,
1200 .key = 0x81000000,
1201 .data = vendor_textual_descriptor,
1202};
1203
1204static struct fw_descriptor model_id_descriptor = {
1205 .length = ARRAY_SIZE(model_textual_descriptor),
1206 .immediate = 0x17000001,
1207 .key = 0x81000000,
1208 .data = model_textual_descriptor,
1209};
1210
1211static int __init fw_core_init(void)
1212{
1213 int ret;
1214
1215 ret = bus_register(&fw_bus_type);
1216 if (ret < 0)
1217 return ret;
1218
1219 fw_cdev_major = register_chrdev(0, "firewire", &fw_device_ops);
1220 if (fw_cdev_major < 0) {
1221 bus_unregister(&fw_bus_type);
1222 return fw_cdev_major;
1223 }
1224
1225 fw_core_add_address_handler(&topology_map, &topology_map_region);
1226 fw_core_add_address_handler(®isters, ®isters_region);
1227 fw_core_add_descriptor(&vendor_id_descriptor);
1228 fw_core_add_descriptor(&model_id_descriptor);
1229
1230 return 0;
1231}
1232
1233static void __exit fw_core_cleanup(void)
1234{
1235 unregister_chrdev(fw_cdev_major, "firewire");
1236 bus_unregister(&fw_bus_type);
1237 idr_destroy(&fw_device_idr);
1238}
1239
1240module_init(fw_core_init);
1241module_exit(fw_core_cleanup);
1242