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>
40 #include <asm/byteorder.h>
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)
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)
64 #define HEADER_DESTINATION_IS_BROADCAST(q) \
65 (((q) & HEADER_DESTINATION(0x3f)) == HEADER_DESTINATION(0x3f))
67 #define PHY_PACKET_CONFIG 0x0
68 #define PHY_PACKET_LINK_ON 0x1
69 #define PHY_PACKET_SELF_ID 0x2
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)
75 static int close_transaction(struct fw_transaction *transaction,
76 struct fw_card *card, int rcode)
78 struct fw_transaction *t;
81 spin_lock_irqsave(&card->lock, flags);
82 list_for_each_entry(t, &card->transaction_list, link) {
83 if (t == transaction) {
84 list_del_init(&t->link);
85 card->tlabel_mask &= ~(1ULL << t->tlabel);
89 spin_unlock_irqrestore(&card->lock, flags);
91 if (&t->link != &card->transaction_list) {
92 del_timer_sync(&t->split_timeout_timer);
93 t->callback(card, rcode, NULL, 0, t->callback_data);
101 * Only valid for transactions that are potentially pending (ie have
104 int fw_cancel_transaction(struct fw_card *card,
105 struct fw_transaction *transaction)
108 * Cancel the packet transmission if it's still queued. That
109 * will call the packet transmission callback which cancels
113 if (card->driver->cancel_packet(card, &transaction->packet) == 0)
117 * If the request packet has already been sent, we need to see
118 * if the transaction is still pending and remove it in that case.
121 return close_transaction(transaction, card, RCODE_CANCELLED);
123 EXPORT_SYMBOL(fw_cancel_transaction);
125 static void split_transaction_timeout_callback(unsigned long data)
127 struct fw_transaction *t = (struct fw_transaction *)data;
128 struct fw_card *card = t->card;
131 spin_lock_irqsave(&card->lock, flags);
132 if (list_empty(&t->link)) {
133 spin_unlock_irqrestore(&card->lock, flags);
137 card->tlabel_mask &= ~(1ULL << t->tlabel);
138 spin_unlock_irqrestore(&card->lock, flags);
140 card->driver->cancel_packet(card, &t->packet);
143 * At this point cancel_packet will never call the transaction
144 * callback, since we just took the transaction out of the list.
147 t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
150 static void transmit_complete_callback(struct fw_packet *packet,
151 struct fw_card *card, int status)
153 struct fw_transaction *t =
154 container_of(packet, struct fw_transaction, packet);
158 close_transaction(t, card, RCODE_COMPLETE);
161 t->timestamp = packet->timestamp;
166 close_transaction(t, card, RCODE_BUSY);
169 close_transaction(t, card, RCODE_DATA_ERROR);
172 close_transaction(t, card, RCODE_TYPE_ERROR);
176 * In this case the ack is really a juju specific
177 * rcode, so just forward that to the callback.
179 close_transaction(t, card, status);
184 static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
185 int destination_id, int source_id, int generation, int speed,
186 unsigned long long offset, void *payload, size_t length)
190 if (tcode == TCODE_STREAM_DATA) {
192 HEADER_DATA_LENGTH(length) |
194 HEADER_TCODE(TCODE_STREAM_DATA);
195 packet->header_length = 4;
196 packet->payload = payload;
197 packet->payload_length = length;
203 ext_tcode = tcode & ~0x10;
204 tcode = TCODE_LOCK_REQUEST;
209 HEADER_RETRY(RETRY_X) |
210 HEADER_TLABEL(tlabel) |
211 HEADER_TCODE(tcode) |
212 HEADER_DESTINATION(destination_id);
214 HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id);
219 case TCODE_WRITE_QUADLET_REQUEST:
220 packet->header[3] = *(u32 *)payload;
221 packet->header_length = 16;
222 packet->payload_length = 0;
225 case TCODE_LOCK_REQUEST:
226 case TCODE_WRITE_BLOCK_REQUEST:
228 HEADER_DATA_LENGTH(length) |
229 HEADER_EXTENDED_TCODE(ext_tcode);
230 packet->header_length = 16;
231 packet->payload = payload;
232 packet->payload_length = length;
235 case TCODE_READ_QUADLET_REQUEST:
236 packet->header_length = 12;
237 packet->payload_length = 0;
240 case TCODE_READ_BLOCK_REQUEST:
242 HEADER_DATA_LENGTH(length) |
243 HEADER_EXTENDED_TCODE(ext_tcode);
244 packet->header_length = 16;
245 packet->payload_length = 0;
249 WARN(1, "wrong tcode %d", tcode);
252 packet->speed = speed;
253 packet->generation = generation;
255 packet->payload_mapped = false;
258 static int allocate_tlabel(struct fw_card *card)
262 tlabel = card->current_tlabel;
263 while (card->tlabel_mask & (1ULL << tlabel)) {
264 tlabel = (tlabel + 1) & 0x3f;
265 if (tlabel == card->current_tlabel)
269 card->current_tlabel = (tlabel + 1) & 0x3f;
270 card->tlabel_mask |= 1ULL << tlabel;
276 * This function provides low-level access to the IEEE1394 transaction
277 * logic. Most C programs would use either fw_read(), fw_write() or
278 * fw_lock() instead - those function are convenience wrappers for
279 * this function. The fw_send_request() function is primarily
280 * provided as a flexible, one-stop entry point for languages bindings
281 * and protocol bindings.
283 * FIXME: Document this function further, in particular the possible
284 * values for rcode in the callback. In short, we map ACK_COMPLETE to
285 * RCODE_COMPLETE, internal errors set errno and set rcode to
286 * RCODE_SEND_ERROR (which is out of range for standard ieee1394
287 * rcodes). All other rcodes are forwarded unchanged. For all
288 * errors, payload is NULL, length is 0.
290 * Can not expect the callback to be called before the function
291 * returns, though this does happen in some cases (ACK_COMPLETE and
294 * The payload is only used for write requests and must not be freed
295 * until the callback has been called.
297 * @param card the card from which to send the request
298 * @param tcode the tcode for this transaction. Do not use
299 * TCODE_LOCK_REQUEST directly, instead use TCODE_LOCK_MASK_SWAP
300 * etc. to specify tcode and ext_tcode.
301 * @param node_id the destination node ID (bus ID and PHY ID concatenated)
302 * @param generation the generation for which node_id is valid
303 * @param speed the speed to use for sending the request
304 * @param offset the 48 bit offset on the destination node
305 * @param payload the data payload for the request subaction
306 * @param length the length in bytes of the data to read
307 * @param callback function to be called when the transaction is completed
308 * @param callback_data pointer to arbitrary data, which will be
309 * passed to the callback
311 * In case of asynchronous stream packets i.e. TCODE_STREAM_DATA, the caller
312 * needs to synthesize @destination_id with fw_stream_packet_destination_id().
314 void fw_send_request(struct fw_card *card, struct fw_transaction *t, int tcode,
315 int destination_id, int generation, int speed,
316 unsigned long long offset, void *payload, size_t length,
317 fw_transaction_callback_t callback, void *callback_data)
323 * Allocate tlabel from the bitmap and put the transaction on
324 * the list while holding the card spinlock.
327 spin_lock_irqsave(&card->lock, flags);
329 tlabel = allocate_tlabel(card);
331 spin_unlock_irqrestore(&card->lock, flags);
332 callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data);
336 t->node_id = destination_id;
339 setup_timer(&t->split_timeout_timer,
340 split_transaction_timeout_callback, (unsigned long)t);
341 /* FIXME: start this timer later, relative to t->timestamp */
342 mod_timer(&t->split_timeout_timer, jiffies + DIV_ROUND_UP(HZ, 10));
343 t->callback = callback;
344 t->callback_data = callback_data;
346 fw_fill_request(&t->packet, tcode, t->tlabel,
347 destination_id, card->node_id, generation,
348 speed, offset, payload, length);
349 t->packet.callback = transmit_complete_callback;
351 list_add_tail(&t->link, &card->transaction_list);
353 spin_unlock_irqrestore(&card->lock, flags);
355 card->driver->send_request(card, &t->packet);
357 EXPORT_SYMBOL(fw_send_request);
359 struct transaction_callback_data {
360 struct completion done;
365 static void transaction_callback(struct fw_card *card, int rcode,
366 void *payload, size_t length, void *data)
368 struct transaction_callback_data *d = data;
370 if (rcode == RCODE_COMPLETE)
371 memcpy(d->payload, payload, length);
377 * fw_run_transaction - send request and sleep until transaction is completed
381 int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
382 int generation, int speed, unsigned long long offset,
383 void *payload, size_t length)
385 struct transaction_callback_data d;
386 struct fw_transaction t;
388 init_timer_on_stack(&t.split_timeout_timer);
389 init_completion(&d.done);
391 fw_send_request(card, &t, tcode, destination_id, generation, speed,
392 offset, payload, length, transaction_callback, &d);
393 wait_for_completion(&d.done);
394 destroy_timer_on_stack(&t.split_timeout_timer);
398 EXPORT_SYMBOL(fw_run_transaction);
400 static DEFINE_MUTEX(phy_config_mutex);
401 static DECLARE_COMPLETION(phy_config_done);
403 static void transmit_phy_packet_callback(struct fw_packet *packet,
404 struct fw_card *card, int status)
406 complete(&phy_config_done);
409 static struct fw_packet phy_config_packet = {
413 .callback = transmit_phy_packet_callback,
416 void fw_send_phy_config(struct fw_card *card,
417 int node_id, int generation, int gap_count)
419 long timeout = DIV_ROUND_UP(HZ, 10);
420 u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG) |
421 PHY_CONFIG_ROOT_ID(node_id) |
422 PHY_CONFIG_GAP_COUNT(gap_count);
424 mutex_lock(&phy_config_mutex);
426 phy_config_packet.header[0] = data;
427 phy_config_packet.header[1] = ~data;
428 phy_config_packet.generation = generation;
429 INIT_COMPLETION(phy_config_done);
431 card->driver->send_request(card, &phy_config_packet);
432 wait_for_completion_timeout(&phy_config_done, timeout);
434 mutex_unlock(&phy_config_mutex);
437 static struct fw_address_handler *lookup_overlapping_address_handler(
438 struct list_head *list, unsigned long long offset, size_t length)
440 struct fw_address_handler *handler;
442 list_for_each_entry(handler, list, link) {
443 if (handler->offset < offset + length &&
444 offset < handler->offset + handler->length)
451 static bool is_enclosing_handler(struct fw_address_handler *handler,
452 unsigned long long offset, size_t length)
454 return handler->offset <= offset &&
455 offset + length <= handler->offset + handler->length;
458 static struct fw_address_handler *lookup_enclosing_address_handler(
459 struct list_head *list, unsigned long long offset, size_t length)
461 struct fw_address_handler *handler;
463 list_for_each_entry(handler, list, link) {
464 if (is_enclosing_handler(handler, offset, length))
471 static DEFINE_SPINLOCK(address_handler_lock);
472 static LIST_HEAD(address_handler_list);
474 const struct fw_address_region fw_high_memory_region =
475 { .start = 0x000100000000ULL, .end = 0xffffe0000000ULL, };
476 EXPORT_SYMBOL(fw_high_memory_region);
479 const struct fw_address_region fw_low_memory_region =
480 { .start = 0x000000000000ULL, .end = 0x000100000000ULL, };
481 const struct fw_address_region fw_private_region =
482 { .start = 0xffffe0000000ULL, .end = 0xfffff0000000ULL, };
483 const struct fw_address_region fw_csr_region =
484 { .start = CSR_REGISTER_BASE,
485 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM_END, };
486 const struct fw_address_region fw_unit_space_region =
487 { .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
490 static bool is_in_fcp_region(u64 offset, size_t length)
492 return offset >= (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
493 offset + length <= (CSR_REGISTER_BASE | CSR_FCP_END);
497 * fw_core_add_address_handler - register for incoming requests
499 * @region: region in the IEEE 1212 node space address range
501 * region->start, ->end, and handler->length have to be quadlet-aligned.
503 * When a request is received that falls within the specified address range,
504 * the specified callback is invoked. The parameters passed to the callback
505 * give the details of the particular request.
507 * Return value: 0 on success, non-zero otherwise.
509 * The start offset of the handler's address region is determined by
510 * fw_core_add_address_handler() and is returned in handler->offset.
512 * Address allocations are exclusive, except for the FCP registers.
514 int fw_core_add_address_handler(struct fw_address_handler *handler,
515 const struct fw_address_region *region)
517 struct fw_address_handler *other;
521 if (region->start & 0xffff000000000003ULL ||
522 region->end & 0xffff000000000003ULL ||
523 region->start >= region->end ||
524 handler->length & 3 ||
525 handler->length == 0)
528 spin_lock_irqsave(&address_handler_lock, flags);
530 handler->offset = region->start;
531 while (handler->offset + handler->length <= region->end) {
532 if (is_in_fcp_region(handler->offset, handler->length))
535 other = lookup_overlapping_address_handler
536 (&address_handler_list,
537 handler->offset, handler->length);
539 handler->offset += other->length;
541 list_add_tail(&handler->link, &address_handler_list);
547 spin_unlock_irqrestore(&address_handler_lock, flags);
551 EXPORT_SYMBOL(fw_core_add_address_handler);
554 * fw_core_remove_address_handler - unregister an address handler
556 void fw_core_remove_address_handler(struct fw_address_handler *handler)
560 spin_lock_irqsave(&address_handler_lock, flags);
561 list_del(&handler->link);
562 spin_unlock_irqrestore(&address_handler_lock, flags);
564 EXPORT_SYMBOL(fw_core_remove_address_handler);
567 struct fw_packet response;
568 u32 request_header[4];
574 static void free_response_callback(struct fw_packet *packet,
575 struct fw_card *card, int status)
577 struct fw_request *request;
579 request = container_of(packet, struct fw_request, response);
583 int fw_get_response_length(struct fw_request *r)
585 int tcode, ext_tcode, data_length;
587 tcode = HEADER_GET_TCODE(r->request_header[0]);
590 case TCODE_WRITE_QUADLET_REQUEST:
591 case TCODE_WRITE_BLOCK_REQUEST:
594 case TCODE_READ_QUADLET_REQUEST:
597 case TCODE_READ_BLOCK_REQUEST:
598 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
601 case TCODE_LOCK_REQUEST:
602 ext_tcode = HEADER_GET_EXTENDED_TCODE(r->request_header[3]);
603 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]);
605 case EXTCODE_FETCH_ADD:
606 case EXTCODE_LITTLE_ADD:
609 return data_length / 2;
613 WARN(1, "wrong tcode %d", tcode);
618 void fw_fill_response(struct fw_packet *response, u32 *request_header,
619 int rcode, void *payload, size_t length)
621 int tcode, tlabel, extended_tcode, source, destination;
623 tcode = HEADER_GET_TCODE(request_header[0]);
624 tlabel = HEADER_GET_TLABEL(request_header[0]);
625 source = HEADER_GET_DESTINATION(request_header[0]);
626 destination = HEADER_GET_SOURCE(request_header[1]);
627 extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]);
629 response->header[0] =
630 HEADER_RETRY(RETRY_1) |
631 HEADER_TLABEL(tlabel) |
632 HEADER_DESTINATION(destination);
633 response->header[1] =
634 HEADER_SOURCE(source) |
636 response->header[2] = 0;
639 case TCODE_WRITE_QUADLET_REQUEST:
640 case TCODE_WRITE_BLOCK_REQUEST:
641 response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE);
642 response->header_length = 12;
643 response->payload_length = 0;
646 case TCODE_READ_QUADLET_REQUEST:
647 response->header[0] |=
648 HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE);
650 response->header[3] = *(u32 *)payload;
652 response->header[3] = 0;
653 response->header_length = 16;
654 response->payload_length = 0;
657 case TCODE_READ_BLOCK_REQUEST:
658 case TCODE_LOCK_REQUEST:
659 response->header[0] |= HEADER_TCODE(tcode + 2);
660 response->header[3] =
661 HEADER_DATA_LENGTH(length) |
662 HEADER_EXTENDED_TCODE(extended_tcode);
663 response->header_length = 16;
664 response->payload = payload;
665 response->payload_length = length;
669 WARN(1, "wrong tcode %d", tcode);
672 response->payload_mapped = false;
674 EXPORT_SYMBOL(fw_fill_response);
676 static struct fw_request *allocate_request(struct fw_packet *p)
678 struct fw_request *request;
680 int request_tcode, t;
682 request_tcode = HEADER_GET_TCODE(p->header[0]);
683 switch (request_tcode) {
684 case TCODE_WRITE_QUADLET_REQUEST:
685 data = &p->header[3];
689 case TCODE_WRITE_BLOCK_REQUEST:
690 case TCODE_LOCK_REQUEST:
692 length = HEADER_GET_DATA_LENGTH(p->header[3]);
695 case TCODE_READ_QUADLET_REQUEST:
700 case TCODE_READ_BLOCK_REQUEST:
702 length = HEADER_GET_DATA_LENGTH(p->header[3]);
706 fw_error("ERROR - corrupt request received - %08x %08x %08x\n",
707 p->header[0], p->header[1], p->header[2]);
711 request = kmalloc(sizeof(*request) + length, GFP_ATOMIC);
715 t = (p->timestamp & 0x1fff) + 4000;
717 t = (p->timestamp & ~0x1fff) + 0x2000 + t - 8000;
719 t = (p->timestamp & ~0x1fff) + t;
721 request->response.speed = p->speed;
722 request->response.timestamp = t;
723 request->response.generation = p->generation;
724 request->response.ack = 0;
725 request->response.callback = free_response_callback;
726 request->ack = p->ack;
727 request->length = length;
729 memcpy(request->data, data, length);
731 memcpy(request->request_header, p->header, sizeof(p->header));
736 void fw_send_response(struct fw_card *card,
737 struct fw_request *request, int rcode)
739 if (WARN_ONCE(!request, "invalid for FCP address handlers"))
742 /* unified transaction or broadcast transaction: don't respond */
743 if (request->ack != ACK_PENDING ||
744 HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) {
749 if (rcode == RCODE_COMPLETE)
750 fw_fill_response(&request->response, request->request_header,
751 rcode, request->data,
752 fw_get_response_length(request));
754 fw_fill_response(&request->response, request->request_header,
757 card->driver->send_response(card, &request->response);
759 EXPORT_SYMBOL(fw_send_response);
761 static void handle_exclusive_region_request(struct fw_card *card,
763 struct fw_request *request,
764 unsigned long long offset)
766 struct fw_address_handler *handler;
768 int tcode, destination, source;
770 tcode = HEADER_GET_TCODE(p->header[0]);
771 destination = HEADER_GET_DESTINATION(p->header[0]);
772 source = HEADER_GET_SOURCE(p->header[1]);
774 spin_lock_irqsave(&address_handler_lock, flags);
775 handler = lookup_enclosing_address_handler(&address_handler_list,
776 offset, request->length);
777 spin_unlock_irqrestore(&address_handler_lock, flags);
780 * FIXME: lookup the fw_node corresponding to the sender of
781 * this request and pass that to the address handler instead
782 * of the node ID. We may also want to move the address
783 * allocations to fw_node so we only do this callback if the
784 * upper layers registered it for this node.
788 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
790 handler->address_callback(card, request,
791 tcode, destination, source,
792 p->generation, p->speed, offset,
793 request->data, request->length,
794 handler->callback_data);
797 static void handle_fcp_region_request(struct fw_card *card,
799 struct fw_request *request,
800 unsigned long long offset)
802 struct fw_address_handler *handler;
804 int tcode, destination, source;
806 if ((offset != (CSR_REGISTER_BASE | CSR_FCP_COMMAND) &&
807 offset != (CSR_REGISTER_BASE | CSR_FCP_RESPONSE)) ||
808 request->length > 0x200) {
809 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
814 tcode = HEADER_GET_TCODE(p->header[0]);
815 destination = HEADER_GET_DESTINATION(p->header[0]);
816 source = HEADER_GET_SOURCE(p->header[1]);
818 if (tcode != TCODE_WRITE_QUADLET_REQUEST &&
819 tcode != TCODE_WRITE_BLOCK_REQUEST) {
820 fw_send_response(card, request, RCODE_TYPE_ERROR);
825 spin_lock_irqsave(&address_handler_lock, flags);
826 list_for_each_entry(handler, &address_handler_list, link) {
827 if (is_enclosing_handler(handler, offset, request->length))
828 handler->address_callback(card, NULL, tcode,
830 p->generation, p->speed,
831 offset, request->data,
833 handler->callback_data);
835 spin_unlock_irqrestore(&address_handler_lock, flags);
837 fw_send_response(card, request, RCODE_COMPLETE);
840 void fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
842 struct fw_request *request;
843 unsigned long long offset;
845 if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
848 request = allocate_request(p);
849 if (request == NULL) {
850 /* FIXME: send statically allocated busy packet. */
854 offset = ((u64)HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) |
857 if (!is_in_fcp_region(offset, request->length))
858 handle_exclusive_region_request(card, p, request, offset);
860 handle_fcp_region_request(card, p, request, offset);
863 EXPORT_SYMBOL(fw_core_handle_request);
865 void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
867 struct fw_transaction *t;
871 int tcode, tlabel, destination, source, rcode;
873 tcode = HEADER_GET_TCODE(p->header[0]);
874 tlabel = HEADER_GET_TLABEL(p->header[0]);
875 destination = HEADER_GET_DESTINATION(p->header[0]);
876 source = HEADER_GET_SOURCE(p->header[1]);
877 rcode = HEADER_GET_RCODE(p->header[1]);
879 spin_lock_irqsave(&card->lock, flags);
880 list_for_each_entry(t, &card->transaction_list, link) {
881 if (t->node_id == source && t->tlabel == tlabel) {
882 list_del_init(&t->link);
883 card->tlabel_mask &= ~(1ULL << t->tlabel);
887 spin_unlock_irqrestore(&card->lock, flags);
889 if (&t->link == &card->transaction_list) {
890 fw_notify("Unsolicited response (source %x, tlabel %x)\n",
896 * FIXME: sanity check packet, is length correct, does tcodes
897 * and addresses match.
901 case TCODE_READ_QUADLET_RESPONSE:
902 data = (u32 *) &p->header[3];
906 case TCODE_WRITE_RESPONSE:
911 case TCODE_READ_BLOCK_RESPONSE:
912 case TCODE_LOCK_RESPONSE:
914 data_length = HEADER_GET_DATA_LENGTH(p->header[3]);
918 /* Should never happen, this is just to shut up gcc. */
924 del_timer_sync(&t->split_timeout_timer);
927 * The response handler may be executed while the request handler
928 * is still pending. Cancel the request handler.
930 card->driver->cancel_packet(card, &t->packet);
932 t->callback(card, rcode, data, data_length, t->callback_data);
934 EXPORT_SYMBOL(fw_core_handle_response);
936 static const struct fw_address_region topology_map_region =
937 { .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP,
938 .end = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, };
940 static void handle_topology_map(struct fw_card *card, struct fw_request *request,
941 int tcode, int destination, int source, int generation,
942 int speed, unsigned long long offset,
943 void *payload, size_t length, void *callback_data)
947 if (!TCODE_IS_READ_REQUEST(tcode)) {
948 fw_send_response(card, request, RCODE_TYPE_ERROR);
952 if ((offset & 3) > 0 || (length & 3) > 0) {
953 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
957 start = (offset - topology_map_region.start) / 4;
958 memcpy(payload, &card->topology_map[start], length);
960 fw_send_response(card, request, RCODE_COMPLETE);
963 static struct fw_address_handler topology_map = {
965 .address_callback = handle_topology_map,
968 static const struct fw_address_region registers_region =
969 { .start = CSR_REGISTER_BASE,
970 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM, };
972 static u32 read_state_register(struct fw_card *card)
975 * Fixed bits (IEEE 1394-2008 8.3.2.2.1):
976 * Bits 0-1 (state) always read 00=running.
977 * Bits 2,3 (off, atn) are not implemented as per the spec.
978 * Bit 4 (elog) is not implemented because there is no error log.
979 * Bit 6 (dreq) cannot be set. It is intended to "disable requests
980 * from unreliable nodes"; however, IEEE 1212 states that devices
981 * may "clear their own dreq bit when it has been improperly set".
982 * Our implementation might be seen as an improperly extensive
983 * interpretation of "improperly", but the 1212-2001 revision
984 * dropped this bit altogether, so we're in the clear. :o)
985 * Bit 7 (lost) always reads 0 because a power reset has never occurred
986 * during normal operation.
987 * Bit 9 (linkoff) is not implemented because the PC is not powered
988 * from the FireWire cable.
989 * Bit 15 (gone) always reads 0. It must be set at a power/command/bus
990 * reset, but then cleared when the units are ready again, which
991 * happens immediately for us.
996 static void handle_registers(struct fw_card *card, struct fw_request *request,
997 int tcode, int destination, int source, int generation,
998 int speed, unsigned long long offset,
999 void *payload, size_t length, void *callback_data)
1001 int reg = offset & ~CSR_REGISTER_BASE;
1002 __be32 *data = payload;
1003 int rcode = RCODE_COMPLETE;
1006 case CSR_STATE_CLEAR:
1007 if (tcode == TCODE_READ_QUADLET_REQUEST) {
1008 *data = cpu_to_be32(read_state_register(card));
1009 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1011 rcode = RCODE_TYPE_ERROR;
1016 if (tcode == TCODE_READ_QUADLET_REQUEST) {
1017 *data = cpu_to_be32(read_state_register(card));
1018 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) {
1019 /* FIXME: implement cmstr */
1020 /* FIXME: implement abdicate */
1022 rcode = RCODE_TYPE_ERROR;
1027 if (tcode == TCODE_READ_QUADLET_REQUEST)
1028 *data = cpu_to_be32(card->driver->
1029 read_csr_reg(card, CSR_NODE_IDS));
1030 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1031 card->driver->write_csr_reg(card, CSR_NODE_IDS,
1032 be32_to_cpu(*data));
1034 rcode = RCODE_TYPE_ERROR;
1037 case CSR_CYCLE_TIME:
1038 if (TCODE_IS_READ_REQUEST(tcode) && length == 4)
1039 *data = cpu_to_be32(card->driver->
1040 read_csr_reg(card, CSR_CYCLE_TIME));
1042 rcode = RCODE_TYPE_ERROR;
1045 case CSR_BROADCAST_CHANNEL:
1046 if (tcode == TCODE_READ_QUADLET_REQUEST)
1047 *data = cpu_to_be32(card->broadcast_channel);
1048 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
1049 card->broadcast_channel =
1050 (be32_to_cpu(*data) & BROADCAST_CHANNEL_VALID) |
1051 BROADCAST_CHANNEL_INITIAL;
1053 rcode = RCODE_TYPE_ERROR;
1056 case CSR_BUS_MANAGER_ID:
1057 case CSR_BANDWIDTH_AVAILABLE:
1058 case CSR_CHANNELS_AVAILABLE_HI:
1059 case CSR_CHANNELS_AVAILABLE_LO:
1061 * FIXME: these are handled by the OHCI hardware and
1062 * the stack never sees these request. If we add
1063 * support for a new type of controller that doesn't
1064 * handle this in hardware we need to deal with these
1070 case CSR_BUSY_TIMEOUT:
1071 /* FIXME: Implement this. */
1074 /* Useless without initialization by the bus manager. */
1077 rcode = RCODE_ADDRESS_ERROR;
1081 fw_send_response(card, request, rcode);
1084 static struct fw_address_handler registers = {
1086 .address_callback = handle_registers,
1089 MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1090 MODULE_DESCRIPTION("Core IEEE1394 transaction logic");
1091 MODULE_LICENSE("GPL");
1093 static const u32 vendor_textual_descriptor[] = {
1094 /* textual descriptor leaf () */
1098 0x4c696e75, /* L i n u */
1099 0x78204669, /* x F i */
1100 0x72657769, /* r e w i */
1101 0x72650000, /* r e */
1104 static const u32 model_textual_descriptor[] = {
1105 /* model descriptor leaf () */
1109 0x4a756a75, /* J u j u */
1112 static struct fw_descriptor vendor_id_descriptor = {
1113 .length = ARRAY_SIZE(vendor_textual_descriptor),
1114 .immediate = 0x03d00d1e,
1116 .data = vendor_textual_descriptor,
1119 static struct fw_descriptor model_id_descriptor = {
1120 .length = ARRAY_SIZE(model_textual_descriptor),
1121 .immediate = 0x17000001,
1123 .data = model_textual_descriptor,
1126 static int __init fw_core_init(void)
1130 ret = bus_register(&fw_bus_type);
1134 fw_cdev_major = register_chrdev(0, "firewire", &fw_device_ops);
1135 if (fw_cdev_major < 0) {
1136 bus_unregister(&fw_bus_type);
1137 return fw_cdev_major;
1140 fw_core_add_address_handler(&topology_map, &topology_map_region);
1141 fw_core_add_address_handler(®isters, ®isters_region);
1142 fw_core_add_descriptor(&vendor_id_descriptor);
1143 fw_core_add_descriptor(&model_id_descriptor);
1148 static void __exit fw_core_cleanup(void)
1150 unregister_chrdev(fw_cdev_major, "firewire");
1151 bus_unregister(&fw_bus_type);
1152 idr_destroy(&fw_device_idr);
1155 module_init(fw_core_init);
1156 module_exit(fw_core_cleanup);