1 /*
2 * Core IEEE1394 transaction logic
3 *
4 * Copyright (C) 2004-2006 Kristian Hoegsberg <krh@bitplanet.net>
5 *
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.
10 *
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.
15 *
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.
19 */
20
21 #include <linux/completion.h>
22 #include <linux/idr.h>
23 #include <linux/kernel.h>
24 #include <linux/kref.h>
25 #include <linux/module.h>
26 #include <linux/mutex.h>
27 #include <linux/init.h>
28 #include <linux/interrupt.h>
29 #include <linux/pci.h>
30 #include <linux/delay.h>
31 #include <linux/poll.h>
32 #include <linux/list.h>
33 #include <linux/kthread.h>
34 #include <asm/uaccess.h>
35
36 #include "fw-transaction.h"
37 #include "fw-topology.h"
38 #include "fw-device.h"
39
40 #define HEADER_PRI(pri) ((pri) << 0)
41 #define HEADER_TCODE(tcode) ((tcode) << 4)
42 #define HEADER_RETRY(retry) ((retry) << 8)
43 #define HEADER_TLABEL(tlabel) ((tlabel) << 10)
44 #define HEADER_DESTINATION(destination) ((destination) << 16)
45 #define HEADER_SOURCE(source) ((source) << 16)
46 #define HEADER_RCODE(rcode) ((rcode) << 12)
47 #define HEADER_OFFSET_HIGH(offset_high) ((offset_high) << 0)
48 #define HEADER_DATA_LENGTH(length) ((length) << 16)
49 #define HEADER_EXTENDED_TCODE(tcode) ((tcode) << 0)
50
51 #define HEADER_GET_TCODE(q) (((q) >> 4) & 0x0f)
52 #define HEADER_GET_TLABEL(q) (((q) >> 10) & 0x3f)
53 #define HEADER_GET_RCODE(q) (((q) >> 12) & 0x0f)
54 #define HEADER_GET_DESTINATION(q) (((q) >> 16) & 0xffff)
55 #define HEADER_GET_SOURCE(q) (((q) >> 16) & 0xffff)
56 #define HEADER_GET_OFFSET_HIGH(q) (((q) >> 0) & 0xffff)
57 #define HEADER_GET_DATA_LENGTH(q) (((q) >> 16) & 0xffff)
58 #define HEADER_GET_EXTENDED_TCODE(q) (((q) >> 0) & 0xffff)
59
60 #define HEADER_DESTINATION_IS_BROADCAST(q) \
61 (((q) & HEADER_DESTINATION(0x3f)) == HEADER_DESTINATION(0x3f))
62
63 #define PHY_CONFIG_GAP_COUNT(gap_count) (((gap_count) << 16) | (1 << 22))
64 #define PHY_CONFIG_ROOT_ID(node_id) ((((node_id) & 0x3f) << 24) | (1 << 23))
65 #define PHY_IDENTIFIER(id) ((id) << 30)
66
67 static int
close_transaction(struct fw_transaction * transaction,struct fw_card * card,int rcode,u32 * payload,size_t length)68 close_transaction(struct fw_transaction *transaction,
69 struct fw_card *card, int rcode,
70 u32 *payload, size_t length)
71 {
72 struct fw_transaction *t;
73 unsigned long flags;
74
75 spin_lock_irqsave(&card->lock, flags);
76 list_for_each_entry(t, &card->transaction_list, link) {
77 if (t == transaction) {
78 list_del(&t->link);
79 card->tlabel_mask &= ~(1 << t->tlabel);
80 break;
81 }
82 }
83 spin_unlock_irqrestore(&card->lock, flags);
84
85 if (&t->link != &card->transaction_list) {
86 t->callback(card, rcode, payload, length, t->callback_data);
87 return 0;
88 }
89
90 return -ENOENT;
91 }
92
93 /*
94 * Only valid for transactions that are potentially pending (ie have
95 * been sent).
96 */
97 int
fw_cancel_transaction(struct fw_card * card,struct fw_transaction * transaction)98 fw_cancel_transaction(struct fw_card *card,
99 struct fw_transaction *transaction)
100 {
101 /*
102 * Cancel the packet transmission if it's still queued. That
103 * will call the packet transmission callback which cancels
104 * the transaction.
105 */
106
107 if (card->driver->cancel_packet(card, &transaction->packet) == 0)
108 return 0;
109
110 /*
111 * If the request packet has already been sent, we need to see
112 * if the transaction is still pending and remove it in that case.
113 */
114
115 return close_transaction(transaction, card, RCODE_CANCELLED, NULL, 0);
116 }
117 EXPORT_SYMBOL(fw_cancel_transaction);
118
119 static void
transmit_complete_callback(struct fw_packet * packet,struct fw_card * card,int status)120 transmit_complete_callback(struct fw_packet *packet,
121 struct fw_card *card, int status)
122 {
123 struct fw_transaction *t =
124 container_of(packet, struct fw_transaction, packet);
125
126 switch (status) {
127 case ACK_COMPLETE:
128 close_transaction(t, card, RCODE_COMPLETE, NULL, 0);
129 break;
130 case ACK_PENDING:
131 t->timestamp = packet->timestamp;
132 break;
133 case ACK_BUSY_X:
134 case ACK_BUSY_A:
135 case ACK_BUSY_B:
136 close_transaction(t, card, RCODE_BUSY, NULL, 0);
137 break;
138 case ACK_DATA_ERROR:
139 close_transaction(t, card, RCODE_DATA_ERROR, NULL, 0);
140 break;
141 case ACK_TYPE_ERROR:
142 close_transaction(t, card, RCODE_TYPE_ERROR, NULL, 0);
143 break;
144 default:
145 /*
146 * In this case the ack is really a juju specific
147 * rcode, so just forward that to the callback.
148 */
149 close_transaction(t, card, status, NULL, 0);
150 break;
151 }
152 }
153
154 static void
fw_fill_request(struct fw_packet * packet,int tcode,int tlabel,int destination_id,int source_id,int generation,int speed,unsigned long long offset,void * payload,size_t length)155 fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
156 int destination_id, int source_id, int generation, int speed,
157 unsigned long long offset, void *payload, size_t length)
158 {
159 int ext_tcode;
160
161 if (tcode > 0x10) {
162 ext_tcode = tcode & ~0x10;
163 tcode = TCODE_LOCK_REQUEST;
164 } else
165 ext_tcode = 0;
166
167 packet->header[0] =
168 HEADER_RETRY(RETRY_X) |
169 HEADER_TLABEL(tlabel) |
170 HEADER_TCODE(tcode) |
171 HEADER_DESTINATION(destination_id);
172 packet->header[1] =
173 HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id);
174 packet->header[2] =
175 offset;
176
177 switch (tcode) {
178 case TCODE_WRITE_QUADLET_REQUEST:
179 packet->header[3] = *(u32 *)payload;
180 packet->header_length = 16;
181 packet->payload_length = 0;
182 break;
183
184 case TCODE_LOCK_REQUEST:
185 case TCODE_WRITE_BLOCK_REQUEST:
186 packet->header[3] =
187 HEADER_DATA_LENGTH(length) |
188 HEADER_EXTENDED_TCODE(ext_tcode);
189 packet->header_length = 16;
190 packet->payload = payload;
191 packet->payload_length = length;
192 break;
193
194 case TCODE_READ_QUADLET_REQUEST:
195 packet->header_length = 12;
196 packet->payload_length = 0;
197 break;
198
199 case TCODE_READ_BLOCK_REQUEST:
200 packet->header[3] =
201 HEADER_DATA_LENGTH(length) |
202 HEADER_EXTENDED_TCODE(ext_tcode);
203 packet->header_length = 16;
204 packet->payload_length = 0;
205 break;
206 }
207
208 packet->speed = speed;
209 packet->generation = generation;
210 packet->ack = 0;
211 packet->payload_bus = 0;
212 }
213
214 /**
215 * This function provides low-level access to the IEEE1394 transaction
216 * logic. Most C programs would use either fw_read(), fw_write() or
217 * fw_lock() instead - those function are convenience wrappers for
218 * this function. The fw_send_request() function is primarily
219 * provided as a flexible, one-stop entry point for languages bindings
220 * and protocol bindings.
221 *
222 * FIXME: Document this function further, in particular the possible
223 * values for rcode in the callback. In short, we map ACK_COMPLETE to
224 * RCODE_COMPLETE, internal errors set errno and set rcode to
225 * RCODE_SEND_ERROR (which is out of range for standard ieee1394
226 * rcodes). All other rcodes are forwarded unchanged. For all
227 * errors, payload is NULL, length is 0.
228 *
229 * Can not expect the callback to be called before the function
230 * returns, though this does happen in some cases (ACK_COMPLETE and
231 * errors).
232 *
233 * The payload is only used for write requests and must not be freed
234 * until the callback has been called.
235 *
236 * @param card the card from which to send the request
237 * @param tcode the tcode for this transaction. Do not use
238 * TCODE_LOCK_REQUEST directly, instead use TCODE_LOCK_MASK_SWAP
239 * etc. to specify tcode and ext_tcode.
240 * @param node_id the destination node ID (bus ID and PHY ID concatenated)
241 * @param generation the generation for which node_id is valid
242 * @param speed the speed to use for sending the request
243 * @param offset the 48 bit offset on the destination node
244 * @param payload the data payload for the request subaction
245 * @param length the length in bytes of the data to read
246 * @param callback function to be called when the transaction is completed
247 * @param callback_data pointer to arbitrary data, which will be
248 * passed to the callback
249 */
250 void
fw_send_request(struct fw_card * card,struct fw_transaction * t,int tcode,int destination_id,int generation,int speed,unsigned long long offset,void * payload,size_t length,fw_transaction_callback_t callback,void * callback_data)251 fw_send_request(struct fw_card *card, struct fw_transaction *t,
252 int tcode, int destination_id, int generation, int speed,
253 unsigned long long offset,
254 void *payload, size_t length,
255 fw_transaction_callback_t callback, void *callback_data)
256 {
257 unsigned long flags;
258 int tlabel;
259
260 /*
261 * Bump the flush timer up 100ms first of all so we
262 * don't race with a flush timer callback.
263 */
264
265 mod_timer(&card->flush_timer, jiffies + DIV_ROUND_UP(HZ, 10));
266
267 /*
268 * Allocate tlabel from the bitmap and put the transaction on
269 * the list while holding the card spinlock.
270 */
271
272 spin_lock_irqsave(&card->lock, flags);
273
274 tlabel = card->current_tlabel;
275 if (card->tlabel_mask & (1 << tlabel)) {
276 spin_unlock_irqrestore(&card->lock, flags);
277 callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data);
278 return;
279 }
280
281 card->current_tlabel = (card->current_tlabel + 1) & 0x1f;
282 card->tlabel_mask |= (1 << tlabel);
283
284 t->node_id = destination_id;
285 t->tlabel = tlabel;
286 t->callback = callback;
287 t->callback_data = callback_data;
288
289 fw_fill_request(&t->packet, tcode, t->tlabel,
290 destination_id, card->node_id, generation,
291 speed, offset, payload, length);
292 t->packet.callback = transmit_complete_callback;
293
294 list_add_tail(&t->link, &card->transaction_list);
295
296 spin_unlock_irqrestore(&card->lock, flags);
297
298 card->driver->send_request(card, &t->packet);
299 }
300 EXPORT_SYMBOL(fw_send_request);
301
302 struct transaction_callback_data {
303 struct completion done;
304 void *payload;
305 int rcode;
306 };
307
transaction_callback(struct fw_card * card,int rcode,void * payload,size_t length,void * data)308 static void transaction_callback(struct fw_card *card, int rcode,
309 void *payload, size_t length, void *data)
310 {
311 struct transaction_callback_data *d = data;
312
313 if (rcode == RCODE_COMPLETE)
314 memcpy(d->payload, payload, length);
315 d->rcode = rcode;
316 complete(&d->done);
317 }
318
319 /**
320 * fw_run_transaction - send request and sleep until transaction is completed
321 *
322 * Returns the RCODE.
323 */
fw_run_transaction(struct fw_card * card,int tcode,int destination_id,int generation,int speed,unsigned long long offset,void * data,size_t length)324 int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
325 int generation, int speed, unsigned long long offset,
326 void *data, size_t length)
327 {
328 struct transaction_callback_data d;
329 struct fw_transaction t;
330
331 init_completion(&d.done);
332 d.payload = data;
333 fw_send_request(card, &t, tcode, destination_id, generation, speed,
334 offset, data, length, transaction_callback, &d);
335 wait_for_completion(&d.done);
336
337 return d.rcode;
338 }
339 EXPORT_SYMBOL(fw_run_transaction);
340
341 static DEFINE_MUTEX(phy_config_mutex);
342 static DECLARE_COMPLETION(phy_config_done);
343
transmit_phy_packet_callback(struct fw_packet * packet,struct fw_card * card,int status)344 static void transmit_phy_packet_callback(struct fw_packet *packet,
345 struct fw_card *card, int status)
346 {
347 complete(&phy_config_done);
348 }
349
350 static struct fw_packet phy_config_packet = {
351 .header_length = 8,
352 .payload_length = 0,
353 .speed = SCODE_100,
354 .callback = transmit_phy_packet_callback,
355 };
356
fw_send_phy_config(struct fw_card * card,int node_id,int generation,int gap_count)357 void fw_send_phy_config(struct fw_card *card,
358 int node_id, int generation, int gap_count)
359 {
360 long timeout = DIV_ROUND_UP(HZ, 10);
361 u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG) |
362 PHY_CONFIG_ROOT_ID(node_id) |
363 PHY_CONFIG_GAP_COUNT(gap_count);
364
365 mutex_lock(&phy_config_mutex);
366
367 phy_config_packet.header[0] = data;
368 phy_config_packet.header[1] = ~data;
369 phy_config_packet.generation = generation;
370 INIT_COMPLETION(phy_config_done);
371
372 card->driver->send_request(card, &phy_config_packet);
373 wait_for_completion_timeout(&phy_config_done, timeout);
374
375 mutex_unlock(&phy_config_mutex);
376 }
377
fw_flush_transactions(struct fw_card * card)378 void fw_flush_transactions(struct fw_card *card)
379 {
380 struct fw_transaction *t, *next;
381 struct list_head list;
382 unsigned long flags;
383
384 INIT_LIST_HEAD(&list);
385 spin_lock_irqsave(&card->lock, flags);
386 list_splice_init(&card->transaction_list, &list);
387 card->tlabel_mask = 0;
388 spin_unlock_irqrestore(&card->lock, flags);
389
390 list_for_each_entry_safe(t, next, &list, link) {
391 card->driver->cancel_packet(card, &t->packet);
392
393 /*
394 * At this point cancel_packet will never call the
395 * transaction callback, since we just took all the
396 * transactions out of the list. So do it here.
397 */
398 t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
399 }
400 }
401
402 static struct fw_address_handler *
lookup_overlapping_address_handler(struct list_head * list,unsigned long long offset,size_t length)403 lookup_overlapping_address_handler(struct list_head *list,
404 unsigned long long offset, size_t length)
405 {
406 struct fw_address_handler *handler;
407
408 list_for_each_entry(handler, list, link) {
409 if (handler->offset < offset + length &&
410 offset < handler->offset + handler->length)
411 return handler;
412 }
413
414 return NULL;
415 }
416
417 static struct fw_address_handler *
lookup_enclosing_address_handler(struct list_head * list,unsigned long long offset,size_t length)418 lookup_enclosing_address_handler(struct list_head *list,
419 unsigned long long offset, size_t length)
420 {
421 struct fw_address_handler *handler;
422
423 list_for_each_entry(handler, list, link) {
424 if (handler->offset <= offset &&
425 offset + length <= handler->offset + handler->length)
426 return handler;
427 }
428
429 return NULL;
430 }
431
432 static DEFINE_SPINLOCK(address_handler_lock);
433 static LIST_HEAD(address_handler_list);
434
435 const struct fw_address_region fw_high_memory_region =
436 { .start = 0x000100000000ULL, .end = 0xffffe0000000ULL, };
437 EXPORT_SYMBOL(fw_high_memory_region);
438
439 #if 0
440 const struct fw_address_region fw_low_memory_region =
441 { .start = 0x000000000000ULL, .end = 0x000100000000ULL, };
442 const struct fw_address_region fw_private_region =
443 { .start = 0xffffe0000000ULL, .end = 0xfffff0000000ULL, };
444 const struct fw_address_region fw_csr_region =
445 { .start = CSR_REGISTER_BASE,
446 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM_END, };
447 const struct fw_address_region fw_unit_space_region =
448 { .start = 0xfffff0000900ULL, .end = 0x1000000000000ULL, };
449 #endif /* 0 */
450
451 /**
452 * Allocate a range of addresses in the node space of the OHCI
453 * controller. When a request is received that falls within the
454 * specified address range, the specified callback is invoked. The
455 * parameters passed to the callback give the details of the
456 * particular request.
457 *
458 * Return value: 0 on success, non-zero otherwise.
459 * The start offset of the handler's address region is determined by
460 * fw_core_add_address_handler() and is returned in handler->offset.
461 * The offset is quadlet-aligned.
462 */
463 int
fw_core_add_address_handler(struct fw_address_handler * handler,const struct fw_address_region * region)464 fw_core_add_address_handler(struct fw_address_handler *handler,
465 const struct fw_address_region *region)
466 {
467 struct fw_address_handler *other;
468 unsigned long flags;
469 int ret = -EBUSY;
470
471 spin_lock_irqsave(&address_handler_lock, flags);
472
473 handler->offset = roundup(region->start, 4);
474 while (handler->offset + handler->length <= region->end) {
475 other =
476 lookup_overlapping_address_handler(&address_handler_list,
477 handler->offset,
478 handler->length);
479 if (other != NULL) {
480 handler->offset =
481 roundup(other->offset + other->length, 4);
482 } else {
483 list_add_tail(&handler->link, &address_handler_list);
484 ret = 0;
485 break;
486 }
487 }
488
489 spin_unlock_irqrestore(&address_handler_lock, flags);
490
491 return ret;
492 }
493 EXPORT_SYMBOL(fw_core_add_address_handler);
494
495 /**
496 * Deallocate a range of addresses allocated with fw_allocate. This
497 * will call the associated callback one last time with a the special
498 * tcode TCODE_DEALLOCATE, to let the client destroy the registered
499 * callback data. For convenience, the callback parameters offset and
500 * length are set to the start and the length respectively for the
501 * deallocated region, payload is set to NULL.
502 */
fw_core_remove_address_handler(struct fw_address_handler * handler)503 void fw_core_remove_address_handler(struct fw_address_handler *handler)
504 {
505 unsigned long flags;
506
507 spin_lock_irqsave(&address_handler_lock, flags);
508 list_del(&handler->link);
509 spin_unlock_irqrestore(&address_handler_lock, flags);
510 }
511 EXPORT_SYMBOL(fw_core_remove_address_handler);
512
513 struct fw_request {
514 struct fw_packet response;
515 u32 request_header[4];
516 int ack;
517 u32 length;
518 u32 data[0];
519 };
520
521 static void
free_response_callback(struct fw_packet * packet,struct fw_card * card,int status)522 free_response_callback(struct fw_packet *packet,
523 struct fw_card *card, int status)
524 {
525 struct fw_request *request;
526
527 request = container_of(packet, struct fw_request, response);
528 kfree(request);
529 }
530
531 void
fw_fill_response(struct fw_packet * response,u32 * request_header,int rcode,void * payload,size_t length)532 fw_fill_response(struct fw_packet *response, u32 *request_header,
533 int rcode, void *payload, size_t length)
534 {
535 int tcode, tlabel, extended_tcode, source, destination;
536
537 tcode = HEADER_GET_TCODE(request_header[0]);
538 tlabel = HEADER_GET_TLABEL(request_header[0]);
539 source = HEADER_GET_DESTINATION(request_header[0]);
540 destination = HEADER_GET_SOURCE(request_header[1]);
541 extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]);
542
543 response->header[0] =
544 HEADER_RETRY(RETRY_1) |
545 HEADER_TLABEL(tlabel) |
546 HEADER_DESTINATION(destination);
547 response->header[1] =
548 HEADER_SOURCE(source) |
549 HEADER_RCODE(rcode);
550 response->header[2] = 0;
551
552 switch (tcode) {
553 case TCODE_WRITE_QUADLET_REQUEST:
554 case TCODE_WRITE_BLOCK_REQUEST:
555 response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE);
556 response->header_length = 12;
557 response->payload_length = 0;
558 break;
559
560 case TCODE_READ_QUADLET_REQUEST:
561 response->header[0] |=
562 HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE);
563 if (payload != NULL)
564 response->header[3] = *(u32 *)payload;
565 else
566 response->header[3] = 0;
567 response->header_length = 16;
568 response->payload_length = 0;
569 break;
570
571 case TCODE_READ_BLOCK_REQUEST:
572 case TCODE_LOCK_REQUEST:
573 response->header[0] |= HEADER_TCODE(tcode + 2);
574 response->header[3] =
575 HEADER_DATA_LENGTH(length) |
576 HEADER_EXTENDED_TCODE(extended_tcode);
577 response->header_length = 16;
578 response->payload = payload;
579 response->payload_length = length;
580 break;
581
582 default:
583 BUG();
584 return;
585 }
586
587 response->payload_bus = 0;
588 }
589 EXPORT_SYMBOL(fw_fill_response);
590
591 static struct fw_request *
allocate_request(struct fw_packet * p)592 allocate_request(struct fw_packet *p)
593 {
594 struct fw_request *request;
595 u32 *data, length;
596 int request_tcode, t;
597
598 request_tcode = HEADER_GET_TCODE(p->header[0]);
599 switch (request_tcode) {
600 case TCODE_WRITE_QUADLET_REQUEST:
601 data = &p->header[3];
602 length = 4;
603 break;
604
605 case TCODE_WRITE_BLOCK_REQUEST:
606 case TCODE_LOCK_REQUEST:
607 data = p->payload;
608 length = HEADER_GET_DATA_LENGTH(p->header[3]);
609 break;
610
611 case TCODE_READ_QUADLET_REQUEST:
612 data = NULL;
613 length = 4;
614 break;
615
616 case TCODE_READ_BLOCK_REQUEST:
617 data = NULL;
618 length = HEADER_GET_DATA_LENGTH(p->header[3]);
619 break;
620
621 default:
622 fw_error("ERROR - corrupt request received - %08x %08x %08x\n",
623 p->header[0], p->header[1], p->header[2]);
624 return NULL;
625 }
626
627 request = kmalloc(sizeof(*request) + length, GFP_ATOMIC);
628 if (request == NULL)
629 return NULL;
630
631 t = (p->timestamp & 0x1fff) + 4000;
632 if (t >= 8000)
633 t = (p->timestamp & ~0x1fff) + 0x2000 + t - 8000;
634 else
635 t = (p->timestamp & ~0x1fff) + t;
636
637 request->response.speed = p->speed;
638 request->response.timestamp = t;
639 request->response.generation = p->generation;
640 request->response.ack = 0;
641 request->response.callback = free_response_callback;
642 request->ack = p->ack;
643 request->length = length;
644 if (data)
645 memcpy(request->data, data, length);
646
647 memcpy(request->request_header, p->header, sizeof(p->header));
648
649 return request;
650 }
651
652 void
fw_send_response(struct fw_card * card,struct fw_request * request,int rcode)653 fw_send_response(struct fw_card *card, struct fw_request *request, int rcode)
654 {
655 /* unified transaction or broadcast transaction: don't respond */
656 if (request->ack != ACK_PENDING ||
657 HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) {
658 kfree(request);
659 return;
660 }
661
662 if (rcode == RCODE_COMPLETE)
663 fw_fill_response(&request->response, request->request_header,
664 rcode, request->data, request->length);
665 else
666 fw_fill_response(&request->response, request->request_header,
667 rcode, NULL, 0);
668
669 card->driver->send_response(card, &request->response);
670 }
671 EXPORT_SYMBOL(fw_send_response);
672
673 void
fw_core_handle_request(struct fw_card * card,struct fw_packet * p)674 fw_core_handle_request(struct fw_card *card, struct fw_packet *p)
675 {
676 struct fw_address_handler *handler;
677 struct fw_request *request;
678 unsigned long long offset;
679 unsigned long flags;
680 int tcode, destination, source;
681
682 if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE)
683 return;
684
685 request = allocate_request(p);
686 if (request == NULL) {
687 /* FIXME: send statically allocated busy packet. */
688 return;
689 }
690
691 offset =
692 ((unsigned long long)
693 HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) | p->header[2];
694 tcode = HEADER_GET_TCODE(p->header[0]);
695 destination = HEADER_GET_DESTINATION(p->header[0]);
696 source = HEADER_GET_SOURCE(p->header[1]);
697
698 spin_lock_irqsave(&address_handler_lock, flags);
699 handler = lookup_enclosing_address_handler(&address_handler_list,
700 offset, request->length);
701 spin_unlock_irqrestore(&address_handler_lock, flags);
702
703 /*
704 * FIXME: lookup the fw_node corresponding to the sender of
705 * this request and pass that to the address handler instead
706 * of the node ID. We may also want to move the address
707 * allocations to fw_node so we only do this callback if the
708 * upper layers registered it for this node.
709 */
710
711 if (handler == NULL)
712 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
713 else
714 handler->address_callback(card, request,
715 tcode, destination, source,
716 p->generation, p->speed, offset,
717 request->data, request->length,
718 handler->callback_data);
719 }
720 EXPORT_SYMBOL(fw_core_handle_request);
721
722 void
fw_core_handle_response(struct fw_card * card,struct fw_packet * p)723 fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
724 {
725 struct fw_transaction *t;
726 unsigned long flags;
727 u32 *data;
728 size_t data_length;
729 int tcode, tlabel, destination, source, rcode;
730
731 tcode = HEADER_GET_TCODE(p->header[0]);
732 tlabel = HEADER_GET_TLABEL(p->header[0]);
733 destination = HEADER_GET_DESTINATION(p->header[0]);
734 source = HEADER_GET_SOURCE(p->header[1]);
735 rcode = HEADER_GET_RCODE(p->header[1]);
736
737 spin_lock_irqsave(&card->lock, flags);
738 list_for_each_entry(t, &card->transaction_list, link) {
739 if (t->node_id == source && t->tlabel == tlabel) {
740 list_del(&t->link);
741 card->tlabel_mask &= ~(1 << t->tlabel);
742 break;
743 }
744 }
745 spin_unlock_irqrestore(&card->lock, flags);
746
747 if (&t->link == &card->transaction_list) {
748 fw_notify("Unsolicited response (source %x, tlabel %x)\n",
749 source, tlabel);
750 return;
751 }
752
753 /*
754 * FIXME: sanity check packet, is length correct, does tcodes
755 * and addresses match.
756 */
757
758 switch (tcode) {
759 case TCODE_READ_QUADLET_RESPONSE:
760 data = (u32 *) &p->header[3];
761 data_length = 4;
762 break;
763
764 case TCODE_WRITE_RESPONSE:
765 data = NULL;
766 data_length = 0;
767 break;
768
769 case TCODE_READ_BLOCK_RESPONSE:
770 case TCODE_LOCK_RESPONSE:
771 data = p->payload;
772 data_length = HEADER_GET_DATA_LENGTH(p->header[3]);
773 break;
774
775 default:
776 /* Should never happen, this is just to shut up gcc. */
777 data = NULL;
778 data_length = 0;
779 break;
780 }
781
782 /*
783 * The response handler may be executed while the request handler
784 * is still pending. Cancel the request handler.
785 */
786 card->driver->cancel_packet(card, &t->packet);
787
788 t->callback(card, rcode, data, data_length, t->callback_data);
789 }
790 EXPORT_SYMBOL(fw_core_handle_response);
791
792 static const struct fw_address_region topology_map_region =
793 { .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP,
794 .end = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, };
795
796 static void
handle_topology_map(struct fw_card * card,struct fw_request * request,int tcode,int destination,int source,int generation,int speed,unsigned long long offset,void * payload,size_t length,void * callback_data)797 handle_topology_map(struct fw_card *card, struct fw_request *request,
798 int tcode, int destination, int source,
799 int generation, int speed,
800 unsigned long long offset,
801 void *payload, size_t length, void *callback_data)
802 {
803 int i, start, end;
804 __be32 *map;
805
806 if (!TCODE_IS_READ_REQUEST(tcode)) {
807 fw_send_response(card, request, RCODE_TYPE_ERROR);
808 return;
809 }
810
811 if ((offset & 3) > 0 || (length & 3) > 0) {
812 fw_send_response(card, request, RCODE_ADDRESS_ERROR);
813 return;
814 }
815
816 start = (offset - topology_map_region.start) / 4;
817 end = start + length / 4;
818 map = payload;
819
820 for (i = 0; i < length / 4; i++)
821 map[i] = cpu_to_be32(card->topology_map[start + i]);
822
823 fw_send_response(card, request, RCODE_COMPLETE);
824 }
825
826 static struct fw_address_handler topology_map = {
827 .length = 0x200,
828 .address_callback = handle_topology_map,
829 };
830
831 static const struct fw_address_region registers_region =
832 { .start = CSR_REGISTER_BASE,
833 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM, };
834
835 static void
handle_registers(struct fw_card * card,struct fw_request * request,int tcode,int destination,int source,int generation,int speed,unsigned long long offset,void * payload,size_t length,void * callback_data)836 handle_registers(struct fw_card *card, struct fw_request *request,
837 int tcode, int destination, int source,
838 int generation, int speed,
839 unsigned long long offset,
840 void *payload, size_t length, void *callback_data)
841 {
842 int reg = offset & ~CSR_REGISTER_BASE;
843 unsigned long long bus_time;
844 __be32 *data = payload;
845 int rcode = RCODE_COMPLETE;
846
847 switch (reg) {
848 case CSR_CYCLE_TIME:
849 case CSR_BUS_TIME:
850 if (!TCODE_IS_READ_REQUEST(tcode) || length != 4) {
851 rcode = RCODE_TYPE_ERROR;
852 break;
853 }
854
855 bus_time = card->driver->get_bus_time(card);
856 if (reg == CSR_CYCLE_TIME)
857 *data = cpu_to_be32(bus_time);
858 else
859 *data = cpu_to_be32(bus_time >> 25);
860 break;
861
862 case CSR_BROADCAST_CHANNEL:
863 if (tcode == TCODE_READ_QUADLET_REQUEST)
864 *data = cpu_to_be32(card->broadcast_channel);
865 else if (tcode == TCODE_WRITE_QUADLET_REQUEST)
866 card->broadcast_channel =
867 (be32_to_cpu(*data) & BROADCAST_CHANNEL_VALID) |
868 BROADCAST_CHANNEL_INITIAL;
869 else
870 rcode = RCODE_TYPE_ERROR;
871 break;
872
873 case CSR_BUS_MANAGER_ID:
874 case CSR_BANDWIDTH_AVAILABLE:
875 case CSR_CHANNELS_AVAILABLE_HI:
876 case CSR_CHANNELS_AVAILABLE_LO:
877 /*
878 * FIXME: these are handled by the OHCI hardware and
879 * the stack never sees these request. If we add
880 * support for a new type of controller that doesn't
881 * handle this in hardware we need to deal with these
882 * transactions.
883 */
884 BUG();
885 break;
886
887 case CSR_BUSY_TIMEOUT:
888 /* FIXME: Implement this. */
889
890 default:
891 rcode = RCODE_ADDRESS_ERROR;
892 break;
893 }
894
895 fw_send_response(card, request, rcode);
896 }
897
898 static struct fw_address_handler registers = {
899 .length = 0x400,
900 .address_callback = handle_registers,
901 };
902
903 MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
904 MODULE_DESCRIPTION("Core IEEE1394 transaction logic");
905 MODULE_LICENSE("GPL");
906
907 static const u32 vendor_textual_descriptor[] = {
908 /* textual descriptor leaf () */
909 0x00060000,
910 0x00000000,
911 0x00000000,
912 0x4c696e75, /* L i n u */
913 0x78204669, /* x F i */
914 0x72657769, /* r e w i */
915 0x72650000, /* r e */
916 };
917
918 static const u32 model_textual_descriptor[] = {
919 /* model descriptor leaf () */
920 0x00030000,
921 0x00000000,
922 0x00000000,
923 0x4a756a75, /* J u j u */
924 };
925
926 static struct fw_descriptor vendor_id_descriptor = {
927 .length = ARRAY_SIZE(vendor_textual_descriptor),
928 .immediate = 0x03d00d1e,
929 .key = 0x81000000,
930 .data = vendor_textual_descriptor,
931 };
932
933 static struct fw_descriptor model_id_descriptor = {
934 .length = ARRAY_SIZE(model_textual_descriptor),
935 .immediate = 0x17000001,
936 .key = 0x81000000,
937 .data = model_textual_descriptor,
938 };
939
fw_core_init(void)940 static int __init fw_core_init(void)
941 {
942 int retval;
943
944 retval = bus_register(&fw_bus_type);
945 if (retval < 0)
946 return retval;
947
948 fw_cdev_major = register_chrdev(0, "firewire", &fw_device_ops);
949 if (fw_cdev_major < 0) {
950 bus_unregister(&fw_bus_type);
951 return fw_cdev_major;
952 }
953
954 retval = fw_core_add_address_handler(&topology_map,
955 &topology_map_region);
956 BUG_ON(retval < 0);
957
958 retval = fw_core_add_address_handler(®isters,
959 ®isters_region);
960 BUG_ON(retval < 0);
961
962 /* Add the vendor textual descriptor. */
963 retval = fw_core_add_descriptor(&vendor_id_descriptor);
964 BUG_ON(retval < 0);
965 retval = fw_core_add_descriptor(&model_id_descriptor);
966 BUG_ON(retval < 0);
967
968 return 0;
969 }
970
fw_core_cleanup(void)971 static void __exit fw_core_cleanup(void)
972 {
973 unregister_chrdev(fw_cdev_major, "firewire");
974 bus_unregister(&fw_bus_type);
975 idr_destroy(&fw_device_idr);
976 }
977
978 module_init(fw_core_init);
979 module_exit(fw_core_cleanup);
980