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/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 75static int close_transaction(struct fw_transaction *transaction, 76 struct fw_card *card, int rcode) 77{ 78 struct fw_transaction *t; 79 unsigned long flags; 80 81 spin_lock_irqsave(&card->lock, flags); 82 list_for_each_entry(t, &card->transaction_list, link) { 83 if (t == transaction) { 84 if (!del_timer(&t->split_timeout_timer)) { 85 spin_unlock_irqrestore(&card->lock, flags); 86 goto timed_out; 87 } 88 list_del_init(&t->link); 89 card->tlabel_mask &= ~(1ULL << t->tlabel); 90 break; 91 } 92 } 93 spin_unlock_irqrestore(&card->lock, flags); 94 95 if (&t->link != &card->transaction_list) { 96 t->callback(card, rcode, NULL, 0, t->callback_data); 97 return 0; 98 } 99 100 timed_out: 101 return -ENOENT; 102} 103 104/* 105 * Only valid for transactions that are potentially pending (ie have 106 * been sent). 107 */ 108int fw_cancel_transaction(struct fw_card *card, 109 struct fw_transaction *transaction) 110{ 111 /* 112 * Cancel the packet transmission if it's still queued. That 113 * will call the packet transmission callback which cancels 114 * the transaction. 115 */ 116 117 if (card->driver->cancel_packet(card, &transaction->packet) == 0) 118 return 0; 119 120 /* 121 * If the request packet has already been sent, we need to see 122 * if the transaction is still pending and remove it in that case. 123 */ 124 125 return close_transaction(transaction, card, RCODE_CANCELLED); 126} 127EXPORT_SYMBOL(fw_cancel_transaction); 128 129static void split_transaction_timeout_callback(unsigned long data) 130{ 131 struct fw_transaction *t = (struct fw_transaction *)data; 132 struct fw_card *card = t->card; 133 unsigned long flags; 134 135 spin_lock_irqsave(&card->lock, flags); 136 if (list_empty(&t->link)) { 137 spin_unlock_irqrestore(&card->lock, flags); 138 return; 139 } 140 list_del(&t->link); 141 card->tlabel_mask &= ~(1ULL << t->tlabel); 142 spin_unlock_irqrestore(&card->lock, flags); 143 144 card->driver->cancel_packet(card, &t->packet); 145 146 /* 147 * At this point cancel_packet will never call the transaction 148 * callback, since we just took the transaction out of the list. 149 * So do it here. 150 */ 151 t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data); 152} 153 154static void transmit_complete_callback(struct fw_packet *packet, 155 struct fw_card *card, int status) 156{ 157 struct fw_transaction *t = 158 container_of(packet, struct fw_transaction, packet); 159 160 switch (status) { 161 case ACK_COMPLETE: 162 close_transaction(t, card, RCODE_COMPLETE); 163 break; 164 case ACK_PENDING: 165 t->timestamp = packet->timestamp; 166 break; 167 case ACK_BUSY_X: 168 case ACK_BUSY_A: 169 case ACK_BUSY_B: 170 close_transaction(t, card, RCODE_BUSY); 171 break; 172 case ACK_DATA_ERROR: 173 close_transaction(t, card, RCODE_DATA_ERROR); 174 break; 175 case ACK_TYPE_ERROR: 176 close_transaction(t, card, RCODE_TYPE_ERROR); 177 break; 178 default: 179 /* 180 * In this case the ack is really a juju specific 181 * rcode, so just forward that to the callback. 182 */ 183 close_transaction(t, card, status); 184 break; 185 } 186} 187 188static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel, 189 int destination_id, int source_id, int generation, int speed, 190 unsigned long long offset, void *payload, size_t length) 191{ 192 int ext_tcode; 193 194 if (tcode == TCODE_STREAM_DATA) { 195 packet->header[0] = 196 HEADER_DATA_LENGTH(length) | 197 destination_id | 198 HEADER_TCODE(TCODE_STREAM_DATA); 199 packet->header_length = 4; 200 packet->payload = payload; 201 packet->payload_length = length; 202 203 goto common; 204 } 205 206 if (tcode > 0x10) { 207 ext_tcode = tcode & ~0x10; 208 tcode = TCODE_LOCK_REQUEST; 209 } else 210 ext_tcode = 0; 211 212 packet->header[0] = 213 HEADER_RETRY(RETRY_X) | 214 HEADER_TLABEL(tlabel) | 215 HEADER_TCODE(tcode) | 216 HEADER_DESTINATION(destination_id); 217 packet->header[1] = 218 HEADER_OFFSET_HIGH(offset >> 32) | HEADER_SOURCE(source_id); 219 packet->header[2] = 220 offset; 221 222 switch (tcode) { 223 case TCODE_WRITE_QUADLET_REQUEST: 224 packet->header[3] = *(u32 *)payload; 225 packet->header_length = 16; 226 packet->payload_length = 0; 227 break; 228 229 case TCODE_LOCK_REQUEST: 230 case TCODE_WRITE_BLOCK_REQUEST: 231 packet->header[3] = 232 HEADER_DATA_LENGTH(length) | 233 HEADER_EXTENDED_TCODE(ext_tcode); 234 packet->header_length = 16; 235 packet->payload = payload; 236 packet->payload_length = length; 237 break; 238 239 case TCODE_READ_QUADLET_REQUEST: 240 packet->header_length = 12; 241 packet->payload_length = 0; 242 break; 243 244 case TCODE_READ_BLOCK_REQUEST: 245 packet->header[3] = 246 HEADER_DATA_LENGTH(length) | 247 HEADER_EXTENDED_TCODE(ext_tcode); 248 packet->header_length = 16; 249 packet->payload_length = 0; 250 break; 251 252 default: 253 WARN(1, "wrong tcode %d", tcode); 254 } 255 common: 256 packet->speed = speed; 257 packet->generation = generation; 258 packet->ack = 0; 259 packet->payload_mapped = false; 260} 261 262static int allocate_tlabel(struct fw_card *card) 263{ 264 int tlabel; 265 266 tlabel = card->current_tlabel; 267 while (card->tlabel_mask & (1ULL << tlabel)) { 268 tlabel = (tlabel + 1) & 0x3f; 269 if (tlabel == card->current_tlabel) 270 return -EBUSY; 271 } 272 273 card->current_tlabel = (tlabel + 1) & 0x3f; 274 card->tlabel_mask |= 1ULL << tlabel; 275 276 return tlabel; 277} 278 279/** 280 * fw_send_request() - submit a request packet for transmission 281 * @card: interface to send the request at 282 * @t: transaction instance to which the request belongs 283 * @tcode: transaction code 284 * @destination_id: destination node ID, consisting of bus_ID and phy_ID 285 * @generation: bus generation in which request and response are valid 286 * @speed: transmission speed 287 * @offset: 48bit wide offset into destination's address space 288 * @payload: data payload for the request subaction 289 * @length: length of the payload, in bytes 290 * @callback: function to be called when the transaction is completed 291 * @callback_data: data to be passed to the transaction completion callback 292 * 293 * Submit a request packet into the asynchronous request transmission queue. 294 * Can be called from atomic context. If you prefer a blocking API, use 295 * fw_run_transaction() in a context that can sleep. 296 * 297 * In case of lock requests, specify one of the firewire-core specific %TCODE_ 298 * constants instead of %TCODE_LOCK_REQUEST in @tcode. 299 * 300 * Make sure that the value in @destination_id is not older than the one in 301 * @generation. Otherwise the request is in danger to be sent to a wrong node. 302 * 303 * In case of asynchronous stream packets i.e. %TCODE_STREAM_DATA, the caller 304 * needs to synthesize @destination_id with fw_stream_packet_destination_id(). 305 * It will contain tag, channel, and sy data instead of a node ID then. 306 * 307 * The payload buffer at @data is going to be DMA-mapped except in case of 308 * quadlet-sized payload or of local (loopback) requests. Hence make sure that 309 * the buffer complies with the restrictions for DMA-mapped memory. The 310 * @payload must not be freed before the @callback is called. 311 * 312 * In case of request types without payload, @data is NULL and @length is 0. 313 * 314 * After the transaction is completed successfully or unsuccessfully, the 315 * @callback will be called. Among its parameters is the response code which 316 * is either one of the rcodes per IEEE 1394 or, in case of internal errors, 317 * the firewire-core specific %RCODE_SEND_ERROR. The other firewire-core 318 * specific rcodes (%RCODE_CANCELLED, %RCODE_BUSY, %RCODE_GENERATION, 319 * %RCODE_NO_ACK) denote transaction timeout, busy responder, stale request 320 * generation, or missing ACK respectively. 321 * 322 * Note some timing corner cases: fw_send_request() may complete much earlier 323 * than when the request packet actually hits the wire. On the other hand, 324 * transaction completion and hence execution of @callback may happen even 325 * before fw_send_request() returns. 326 */ 327void fw_send_request(struct fw_card *card, struct fw_transaction *t, int tcode, 328 int destination_id, int generation, int speed, 329 unsigned long long offset, void *payload, size_t length, 330 fw_transaction_callback_t callback, void *callback_data) 331{ 332 unsigned long flags; 333 int tlabel; 334 335 /* 336 * Allocate tlabel from the bitmap and put the transaction on 337 * the list while holding the card spinlock. 338 */ 339 340 spin_lock_irqsave(&card->lock, flags); 341 342 tlabel = allocate_tlabel(card); 343 if (tlabel < 0) { 344 spin_unlock_irqrestore(&card->lock, flags); 345 callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data); 346 return; 347 } 348 349 t->node_id = destination_id; 350 t->tlabel = tlabel; 351 t->card = card; 352 setup_timer(&t->split_timeout_timer, 353 split_transaction_timeout_callback, (unsigned long)t); 354 mod_timer(&t->split_timeout_timer, 355 jiffies + card->split_timeout_jiffies); 356 t->callback = callback; 357 t->callback_data = callback_data; 358 359 fw_fill_request(&t->packet, tcode, t->tlabel, 360 destination_id, card->node_id, generation, 361 speed, offset, payload, length); 362 t->packet.callback = transmit_complete_callback; 363 364 list_add_tail(&t->link, &card->transaction_list); 365 366 spin_unlock_irqrestore(&card->lock, flags); 367 368 card->driver->send_request(card, &t->packet); 369} 370EXPORT_SYMBOL(fw_send_request); 371 372struct transaction_callback_data { 373 struct completion done; 374 void *payload; 375 int rcode; 376}; 377 378static void transaction_callback(struct fw_card *card, int rcode, 379 void *payload, size_t length, void *data) 380{ 381 struct transaction_callback_data *d = data; 382 383 if (rcode == RCODE_COMPLETE) 384 memcpy(d->payload, payload, length); 385 d->rcode = rcode; 386 complete(&d->done); 387} 388 389/** 390 * fw_run_transaction() - send request and sleep until transaction is completed 391 * 392 * Returns the RCODE. See fw_send_request() for parameter documentation. 393 * Unlike fw_send_request(), @data points to the payload of the request or/and 394 * to the payload of the response. 395 */ 396int fw_run_transaction(struct fw_card *card, int tcode, int destination_id, 397 int generation, int speed, unsigned long long offset, 398 void *payload, size_t length) 399{ 400 struct transaction_callback_data d; 401 struct fw_transaction t; 402 403 init_timer_on_stack(&t.split_timeout_timer); 404 init_completion(&d.done); 405 d.payload = payload; 406 fw_send_request(card, &t, tcode, destination_id, generation, speed, 407 offset, payload, length, transaction_callback, &d); 408 wait_for_completion(&d.done); 409 destroy_timer_on_stack(&t.split_timeout_timer); 410 411 return d.rcode; 412} 413EXPORT_SYMBOL(fw_run_transaction); 414 415static DEFINE_MUTEX(phy_config_mutex); 416static DECLARE_COMPLETION(phy_config_done); 417 418static void transmit_phy_packet_callback(struct fw_packet *packet, 419 struct fw_card *card, int status) 420{ 421 complete(&phy_config_done); 422} 423 424static struct fw_packet phy_config_packet = { 425 .header_length = 8, 426 .payload_length = 0, 427 .speed = SCODE_100, 428 .callback = transmit_phy_packet_callback, 429}; 430 431void fw_send_phy_config(struct fw_card *card, 432 int node_id, int generation, int gap_count) 433{ 434 long timeout = DIV_ROUND_UP(HZ, 10); 435 u32 data = PHY_IDENTIFIER(PHY_PACKET_CONFIG); 436 437 if (node_id != FW_PHY_CONFIG_NO_NODE_ID) 438 data |= PHY_CONFIG_ROOT_ID(node_id); 439 440 if (gap_count == FW_PHY_CONFIG_CURRENT_GAP_COUNT) { 441 gap_count = card->driver->read_phy_reg(card, 1); 442 if (gap_count < 0) 443 return; 444 445 gap_count &= 63; 446 if (gap_count == 63) 447 return; 448 } 449 data |= PHY_CONFIG_GAP_COUNT(gap_count); 450 451 mutex_lock(&phy_config_mutex); 452 453 phy_config_packet.header[0] = data; 454 phy_config_packet.header[1] = ~data; 455 phy_config_packet.generation = generation; 456 INIT_COMPLETION(phy_config_done); 457 458 card->driver->send_request(card, &phy_config_packet); 459 wait_for_completion_timeout(&phy_config_done, timeout); 460 461 mutex_unlock(&phy_config_mutex); 462} 463 464static struct fw_address_handler *lookup_overlapping_address_handler( 465 struct list_head *list, unsigned long long offset, size_t length) 466{ 467 struct fw_address_handler *handler; 468 469 list_for_each_entry(handler, list, link) { 470 if (handler->offset < offset + length && 471 offset < handler->offset + handler->length) 472 return handler; 473 } 474 475 return NULL; 476} 477 478static bool is_enclosing_handler(struct fw_address_handler *handler, 479 unsigned long long offset, size_t length) 480{ 481 return handler->offset <= offset && 482 offset + length <= handler->offset + handler->length; 483} 484 485static struct fw_address_handler *lookup_enclosing_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 (is_enclosing_handler(handler, offset, length)) 492 return handler; 493 } 494 495 return NULL; 496} 497 498static DEFINE_SPINLOCK(address_handler_lock); 499static LIST_HEAD(address_handler_list); 500 501const struct fw_address_region fw_high_memory_region = 502 { .start = 0x000100000000ULL, .end = 0xffffe0000000ULL, }; 503EXPORT_SYMBOL(fw_high_memory_region); 504 505 506static bool is_in_fcp_region(u64 offset, size_t length) 507{ 508 return offset >= (CSR_REGISTER_BASE | CSR_FCP_COMMAND) && 509 offset + length <= (CSR_REGISTER_BASE | CSR_FCP_END); 510} 511 512/** 513 * fw_core_add_address_handler() - register for incoming requests 514 * @handler: callback 515 * @region: region in the IEEE 1212 node space address range 516 * 517 * region->start, ->end, and handler->length have to be quadlet-aligned. 518 * 519 * When a request is received that falls within the specified address range, 520 * the specified callback is invoked. The parameters passed to the callback 521 * give the details of the particular request. 522 * 523 * Return value: 0 on success, non-zero otherwise. 524 * 525 * The start offset of the handler's address region is determined by 526 * fw_core_add_address_handler() and is returned in handler->offset. 527 * 528 * Address allocations are exclusive, except for the FCP registers. 529 */ 530int fw_core_add_address_handler(struct fw_address_handler *handler, 531 const struct fw_address_region *region) 532{ 533 struct fw_address_handler *other; 534 unsigned long flags; 535 int ret = -EBUSY; 536 537 if (region->start & 0xffff000000000003ULL || 538 region->start >= region->end || 539 region->end > 0x0001000000000000ULL || 540 handler->length & 3 || 541 handler->length == 0) 542 return -EINVAL; 543 544 spin_lock_irqsave(&address_handler_lock, flags); 545 546 handler->offset = region->start; 547 while (handler->offset + handler->length <= region->end) { 548 if (is_in_fcp_region(handler->offset, handler->length)) 549 other = NULL; 550 else 551 other = lookup_overlapping_address_handler 552 (&address_handler_list, 553 handler->offset, handler->length); 554 if (other != NULL) { 555 handler->offset += other->length; 556 } else { 557 list_add_tail(&handler->link, &address_handler_list); 558 ret = 0; 559 break; 560 } 561 } 562 563 spin_unlock_irqrestore(&address_handler_lock, flags); 564 565 return ret; 566} 567EXPORT_SYMBOL(fw_core_add_address_handler); 568 569/** 570 * fw_core_remove_address_handler() - unregister an address handler 571 */ 572void fw_core_remove_address_handler(struct fw_address_handler *handler) 573{ 574 unsigned long flags; 575 576 spin_lock_irqsave(&address_handler_lock, flags); 577 list_del(&handler->link); 578 spin_unlock_irqrestore(&address_handler_lock, flags); 579} 580EXPORT_SYMBOL(fw_core_remove_address_handler); 581 582struct fw_request { 583 struct fw_packet response; 584 u32 request_header[4]; 585 int ack; 586 u32 length; 587 u32 data[0]; 588}; 589 590static void free_response_callback(struct fw_packet *packet, 591 struct fw_card *card, int status) 592{ 593 struct fw_request *request; 594 595 request = container_of(packet, struct fw_request, response); 596 kfree(request); 597} 598 599int fw_get_response_length(struct fw_request *r) 600{ 601 int tcode, ext_tcode, data_length; 602 603 tcode = HEADER_GET_TCODE(r->request_header[0]); 604 605 switch (tcode) { 606 case TCODE_WRITE_QUADLET_REQUEST: 607 case TCODE_WRITE_BLOCK_REQUEST: 608 return 0; 609 610 case TCODE_READ_QUADLET_REQUEST: 611 return 4; 612 613 case TCODE_READ_BLOCK_REQUEST: 614 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]); 615 return data_length; 616 617 case TCODE_LOCK_REQUEST: 618 ext_tcode = HEADER_GET_EXTENDED_TCODE(r->request_header[3]); 619 data_length = HEADER_GET_DATA_LENGTH(r->request_header[3]); 620 switch (ext_tcode) { 621 case EXTCODE_FETCH_ADD: 622 case EXTCODE_LITTLE_ADD: 623 return data_length; 624 default: 625 return data_length / 2; 626 } 627 628 default: 629 WARN(1, "wrong tcode %d", tcode); 630 return 0; 631 } 632} 633 634void fw_fill_response(struct fw_packet *response, u32 *request_header, 635 int rcode, void *payload, size_t length) 636{ 637 int tcode, tlabel, extended_tcode, source, destination; 638 639 tcode = HEADER_GET_TCODE(request_header[0]); 640 tlabel = HEADER_GET_TLABEL(request_header[0]); 641 source = HEADER_GET_DESTINATION(request_header[0]); 642 destination = HEADER_GET_SOURCE(request_header[1]); 643 extended_tcode = HEADER_GET_EXTENDED_TCODE(request_header[3]); 644 645 response->header[0] = 646 HEADER_RETRY(RETRY_1) | 647 HEADER_TLABEL(tlabel) | 648 HEADER_DESTINATION(destination); 649 response->header[1] = 650 HEADER_SOURCE(source) | 651 HEADER_RCODE(rcode); 652 response->header[2] = 0; 653 654 switch (tcode) { 655 case TCODE_WRITE_QUADLET_REQUEST: 656 case TCODE_WRITE_BLOCK_REQUEST: 657 response->header[0] |= HEADER_TCODE(TCODE_WRITE_RESPONSE); 658 response->header_length = 12; 659 response->payload_length = 0; 660 break; 661 662 case TCODE_READ_QUADLET_REQUEST: 663 response->header[0] |= 664 HEADER_TCODE(TCODE_READ_QUADLET_RESPONSE); 665 if (payload != NULL) 666 response->header[3] = *(u32 *)payload; 667 else 668 response->header[3] = 0; 669 response->header_length = 16; 670 response->payload_length = 0; 671 break; 672 673 case TCODE_READ_BLOCK_REQUEST: 674 case TCODE_LOCK_REQUEST: 675 response->header[0] |= HEADER_TCODE(tcode + 2); 676 response->header[3] = 677 HEADER_DATA_LENGTH(length) | 678 HEADER_EXTENDED_TCODE(extended_tcode); 679 response->header_length = 16; 680 response->payload = payload; 681 response->payload_length = length; 682 break; 683 684 default: 685 WARN(1, "wrong tcode %d", tcode); 686 } 687 688 response->payload_mapped = false; 689} 690EXPORT_SYMBOL(fw_fill_response); 691 692static u32 compute_split_timeout_timestamp(struct fw_card *card, 693 u32 request_timestamp) 694{ 695 unsigned int cycles; 696 u32 timestamp; 697 698 cycles = card->split_timeout_cycles; 699 cycles += request_timestamp & 0x1fff; 700 701 timestamp = request_timestamp & ~0x1fff; 702 timestamp += (cycles / 8000) << 13; 703 timestamp |= cycles % 8000; 704 705 return timestamp; 706} 707 708static struct fw_request *allocate_request(struct fw_card *card, 709 struct fw_packet *p) 710{ 711 struct fw_request *request; 712 u32 *data, length; 713 int request_tcode; 714 715 request_tcode = HEADER_GET_TCODE(p->header[0]); 716 switch (request_tcode) { 717 case TCODE_WRITE_QUADLET_REQUEST: 718 data = &p->header[3]; 719 length = 4; 720 break; 721 722 case TCODE_WRITE_BLOCK_REQUEST: 723 case TCODE_LOCK_REQUEST: 724 data = p->payload; 725 length = HEADER_GET_DATA_LENGTH(p->header[3]); 726 break; 727 728 case TCODE_READ_QUADLET_REQUEST: 729 data = NULL; 730 length = 4; 731 break; 732 733 case TCODE_READ_BLOCK_REQUEST: 734 data = NULL; 735 length = HEADER_GET_DATA_LENGTH(p->header[3]); 736 break; 737 738 default: 739 fw_error("ERROR - corrupt request received - %08x %08x %08x\n", 740 p->header[0], p->header[1], p->header[2]); 741 return NULL; 742 } 743 744 request = kmalloc(sizeof(*request) + length, GFP_ATOMIC); 745 if (request == NULL) 746 return NULL; 747 748 request->response.speed = p->speed; 749 request->response.timestamp = 750 compute_split_timeout_timestamp(card, p->timestamp); 751 request->response.generation = p->generation; 752 request->response.ack = 0; 753 request->response.callback = free_response_callback; 754 request->ack = p->ack; 755 request->length = length; 756 if (data) 757 memcpy(request->data, data, length); 758 759 memcpy(request->request_header, p->header, sizeof(p->header)); 760 761 return request; 762} 763 764void fw_send_response(struct fw_card *card, 765 struct fw_request *request, int rcode) 766{ 767 if (WARN_ONCE(!request, "invalid for FCP address handlers")) 768 return; 769 770 /* unified transaction or broadcast transaction: don't respond */ 771 if (request->ack != ACK_PENDING || 772 HEADER_DESTINATION_IS_BROADCAST(request->request_header[0])) { 773 kfree(request); 774 return; 775 } 776 777 if (rcode == RCODE_COMPLETE) 778 fw_fill_response(&request->response, request->request_header, 779 rcode, request->data, 780 fw_get_response_length(request)); 781 else 782 fw_fill_response(&request->response, request->request_header, 783 rcode, NULL, 0); 784 785 card->driver->send_response(card, &request->response); 786} 787EXPORT_SYMBOL(fw_send_response); 788 789static void handle_exclusive_region_request(struct fw_card *card, 790 struct fw_packet *p, 791 struct fw_request *request, 792 unsigned long long offset) 793{ 794 struct fw_address_handler *handler; 795 unsigned long flags; 796 int tcode, destination, source; 797 798 destination = HEADER_GET_DESTINATION(p->header[0]); 799 source = HEADER_GET_SOURCE(p->header[1]); 800 tcode = HEADER_GET_TCODE(p->header[0]); 801 if (tcode == TCODE_LOCK_REQUEST) 802 tcode = 0x10 + HEADER_GET_EXTENDED_TCODE(p->header[3]); 803 804 spin_lock_irqsave(&address_handler_lock, flags); 805 handler = lookup_enclosing_address_handler(&address_handler_list, 806 offset, request->length); 807 spin_unlock_irqrestore(&address_handler_lock, flags); 808 809 810 if (handler == NULL) 811 fw_send_response(card, request, RCODE_ADDRESS_ERROR); 812 else 813 handler->address_callback(card, request, 814 tcode, destination, source, 815 p->generation, offset, 816 request->data, request->length, 817 handler->callback_data); 818} 819 820static void handle_fcp_region_request(struct fw_card *card, 821 struct fw_packet *p, 822 struct fw_request *request, 823 unsigned long long offset) 824{ 825 struct fw_address_handler *handler; 826 unsigned long flags; 827 int tcode, destination, source; 828 829 if ((offset != (CSR_REGISTER_BASE | CSR_FCP_COMMAND) && 830 offset != (CSR_REGISTER_BASE | CSR_FCP_RESPONSE)) || 831 request->length > 0x200) { 832 fw_send_response(card, request, RCODE_ADDRESS_ERROR); 833 834 return; 835 } 836 837 tcode = HEADER_GET_TCODE(p->header[0]); 838 destination = HEADER_GET_DESTINATION(p->header[0]); 839 source = HEADER_GET_SOURCE(p->header[1]); 840 841 if (tcode != TCODE_WRITE_QUADLET_REQUEST && 842 tcode != TCODE_WRITE_BLOCK_REQUEST) { 843 fw_send_response(card, request, RCODE_TYPE_ERROR); 844 845 return; 846 } 847 848 spin_lock_irqsave(&address_handler_lock, flags); 849 list_for_each_entry(handler, &address_handler_list, link) { 850 if (is_enclosing_handler(handler, offset, request->length)) 851 handler->address_callback(card, NULL, tcode, 852 destination, source, 853 p->generation, offset, 854 request->data, 855 request->length, 856 handler->callback_data); 857 } 858 spin_unlock_irqrestore(&address_handler_lock, flags); 859 860 fw_send_response(card, request, RCODE_COMPLETE); 861} 862 863void fw_core_handle_request(struct fw_card *card, struct fw_packet *p) 864{ 865 struct fw_request *request; 866 unsigned long long offset; 867 868 if (p->ack != ACK_PENDING && p->ack != ACK_COMPLETE) 869 return; 870 871 if (TCODE_IS_LINK_INTERNAL(HEADER_GET_TCODE(p->header[0]))) { 872 fw_cdev_handle_phy_packet(card, p); 873 return; 874 } 875 876 request = allocate_request(card, p); 877 if (request == NULL) { 878 return; 879 } 880 881 offset = ((u64)HEADER_GET_OFFSET_HIGH(p->header[1]) << 32) | 882 p->header[2]; 883 884 if (!is_in_fcp_region(offset, request->length)) 885 handle_exclusive_region_request(card, p, request, offset); 886 else 887 handle_fcp_region_request(card, p, request, offset); 888 889} 890EXPORT_SYMBOL(fw_core_handle_request); 891 892void fw_core_handle_response(struct fw_card *card, struct fw_packet *p) 893{ 894 struct fw_transaction *t; 895 unsigned long flags; 896 u32 *data; 897 size_t data_length; 898 int tcode, tlabel, source, rcode; 899 900 tcode = HEADER_GET_TCODE(p->header[0]); 901 tlabel = HEADER_GET_TLABEL(p->header[0]); 902 source = HEADER_GET_SOURCE(p->header[1]); 903 rcode = HEADER_GET_RCODE(p->header[1]); 904 905 spin_lock_irqsave(&card->lock, flags); 906 list_for_each_entry(t, &card->transaction_list, link) { 907 if (t->node_id == source && t->tlabel == tlabel) { 908 if (!del_timer(&t->split_timeout_timer)) { 909 spin_unlock_irqrestore(&card->lock, flags); 910 goto timed_out; 911 } 912 list_del_init(&t->link); 913 card->tlabel_mask &= ~(1ULL << t->tlabel); 914 break; 915 } 916 } 917 spin_unlock_irqrestore(&card->lock, flags); 918 919 if (&t->link == &card->transaction_list) { 920 timed_out: 921 fw_notify("Unsolicited response (source %x, tlabel %x)\n", 922 source, tlabel); 923 return; 924 } 925 926 927 switch (tcode) { 928 case TCODE_READ_QUADLET_RESPONSE: 929 data = (u32 *) &p->header[3]; 930 data_length = 4; 931 break; 932 933 case TCODE_WRITE_RESPONSE: 934 data = NULL; 935 data_length = 0; 936 break; 937 938 case TCODE_READ_BLOCK_RESPONSE: 939 case TCODE_LOCK_RESPONSE: 940 data = p->payload; 941 data_length = HEADER_GET_DATA_LENGTH(p->header[3]); 942 break; 943 944 default: 945 /* Should never happen, this is just to shut up gcc. */ 946 data = NULL; 947 data_length = 0; 948 break; 949 } 950 951 /* 952 * The response handler may be executed while the request handler 953 * is still pending. Cancel the request handler. 954 */ 955 card->driver->cancel_packet(card, &t->packet); 956 957 t->callback(card, rcode, data, data_length, t->callback_data); 958} 959EXPORT_SYMBOL(fw_core_handle_response); 960 961static const struct fw_address_region topology_map_region = 962 { .start = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP, 963 .end = CSR_REGISTER_BASE | CSR_TOPOLOGY_MAP_END, }; 964 965static void handle_topology_map(struct fw_card *card, struct fw_request *request, 966 int tcode, int destination, int source, int generation, 967 unsigned long long offset, void *payload, size_t length, 968 void *callback_data) 969{ 970 int start; 971 972 if (!TCODE_IS_READ_REQUEST(tcode)) { 973 fw_send_response(card, request, RCODE_TYPE_ERROR); 974 return; 975 } 976 977 if ((offset & 3) > 0 || (length & 3) > 0) { 978 fw_send_response(card, request, RCODE_ADDRESS_ERROR); 979 return; 980 } 981 982 start = (offset - topology_map_region.start) / 4; 983 memcpy(payload, &card->topology_map[start], length); 984 985 fw_send_response(card, request, RCODE_COMPLETE); 986} 987 988static struct fw_address_handler topology_map = { 989 .length = 0x400, 990 .address_callback = handle_topology_map, 991}; 992 993static const struct fw_address_region registers_region = 994 { .start = CSR_REGISTER_BASE, 995 .end = CSR_REGISTER_BASE | CSR_CONFIG_ROM, }; 996 997static void update_split_timeout(struct fw_card *card) 998{ 999 unsigned int cycles; 1000 1001 cycles = card->split_timeout_hi * 8000 + (card->split_timeout_lo >> 19); 1002 1003 cycles = max(cycles, 800u); /* minimum as per the spec */ 1004 cycles = min(cycles, 3u * 8000u); /* maximum OHCI timeout */ 1005 1006 card->split_timeout_cycles = cycles; 1007 card->split_timeout_jiffies = DIV_ROUND_UP(cycles * HZ, 8000); 1008} 1009 1010static void handle_registers(struct fw_card *card, struct fw_request *request, 1011 int tcode, int destination, int source, int generation, 1012 unsigned long long offset, void *payload, size_t length, 1013 void *callback_data) 1014{ 1015 int reg = offset & ~CSR_REGISTER_BASE; 1016 __be32 *data = payload; 1017 int rcode = RCODE_COMPLETE; 1018 unsigned long flags; 1019 1020 switch (reg) { 1021 case CSR_PRIORITY_BUDGET: 1022 if (!card->priority_budget_implemented) { 1023 rcode = RCODE_ADDRESS_ERROR; 1024 break; 1025 } 1026 /* else fall through */ 1027 1028 case CSR_NODE_IDS: 1029 /* 1030 * per IEEE 1394-2008 8.3.22.3, not IEEE 1394.1-2004 3.2.8 1031 * and 9.6, but interoperable with IEEE 1394.1-2004 bridges 1032 */ 1033 /* fall through */ 1034 1035 case CSR_STATE_CLEAR: 1036 case CSR_STATE_SET: 1037 case CSR_CYCLE_TIME: 1038 case CSR_BUS_TIME: 1039 case CSR_BUSY_TIMEOUT: 1040 if (tcode == TCODE_READ_QUADLET_REQUEST) 1041 *data = cpu_to_be32(card->driver->read_csr(card, reg)); 1042 else if (tcode == TCODE_WRITE_QUADLET_REQUEST) 1043 card->driver->write_csr(card, reg, be32_to_cpu(*data)); 1044 else 1045 rcode = RCODE_TYPE_ERROR; 1046 break; 1047 1048 case CSR_RESET_START: 1049 if (tcode == TCODE_WRITE_QUADLET_REQUEST) 1050 card->driver->write_csr(card, CSR_STATE_CLEAR, 1051 CSR_STATE_BIT_ABDICATE); 1052 else 1053 rcode = RCODE_TYPE_ERROR; 1054 break; 1055 1056 case CSR_SPLIT_TIMEOUT_HI: 1057 if (tcode == TCODE_READ_QUADLET_REQUEST) { 1058 *data = cpu_to_be32(card->split_timeout_hi); 1059 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) { 1060 spin_lock_irqsave(&card->lock, flags); 1061 card->split_timeout_hi = be32_to_cpu(*data) & 7; 1062 update_split_timeout(card); 1063 spin_unlock_irqrestore(&card->lock, flags); 1064 } else { 1065 rcode = RCODE_TYPE_ERROR; 1066 } 1067 break; 1068 1069 case CSR_SPLIT_TIMEOUT_LO: 1070 if (tcode == TCODE_READ_QUADLET_REQUEST) { 1071 *data = cpu_to_be32(card->split_timeout_lo); 1072 } else if (tcode == TCODE_WRITE_QUADLET_REQUEST) { 1073 spin_lock_irqsave(&card->lock, flags); 1074 card->split_timeout_lo = 1075 be32_to_cpu(*data) & 0xfff80000; 1076 update_split_timeout(card); 1077 spin_unlock_irqrestore(&card->lock, flags); 1078 } else { 1079 rcode = RCODE_TYPE_ERROR; 1080 } 1081 break; 1082 1083 case CSR_MAINT_UTILITY: 1084 if (tcode == TCODE_READ_QUADLET_REQUEST) 1085 *data = card->maint_utility_register; 1086 else if (tcode == TCODE_WRITE_QUADLET_REQUEST) 1087 card->maint_utility_register = *data; 1088 else 1089 rcode = RCODE_TYPE_ERROR; 1090 break; 1091 1092 case CSR_BROADCAST_CHANNEL: 1093 if (tcode == TCODE_READ_QUADLET_REQUEST) 1094 *data = cpu_to_be32(card->broadcast_channel); 1095 else if (tcode == TCODE_WRITE_QUADLET_REQUEST) 1096 card->broadcast_channel = 1097 (be32_to_cpu(*data) & BROADCAST_CHANNEL_VALID) | 1098 BROADCAST_CHANNEL_INITIAL; 1099 else 1100 rcode = RCODE_TYPE_ERROR; 1101 break; 1102 1103 case CSR_BUS_MANAGER_ID: 1104 case CSR_BANDWIDTH_AVAILABLE: 1105 case CSR_CHANNELS_AVAILABLE_HI: 1106 case CSR_CHANNELS_AVAILABLE_LO: 1107 BUG(); 1108 break; 1109 1110 default: 1111 rcode = RCODE_ADDRESS_ERROR; 1112 break; 1113 } 1114 1115 fw_send_response(card, request, rcode); 1116} 1117 1118static struct fw_address_handler registers = { 1119 .length = 0x400, 1120 .address_callback = handle_registers, 1121}; 1122 1123MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>"); 1124MODULE_DESCRIPTION("Core IEEE1394 transaction logic"); 1125MODULE_LICENSE("GPL"); 1126 1127static const u32 vendor_textual_descriptor[] = { 1128 /* textual descriptor leaf () */ 1129 0x00060000, 1130 0x00000000, 1131 0x00000000, 1132 0x4c696e75, /* L i n u */ 1133 0x78204669, /* x F i */ 1134 0x72657769, /* r e w i */ 1135 0x72650000, /* r e */ 1136}; 1137 1138static const u32 model_textual_descriptor[] = { 1139 /* model descriptor leaf () */ 1140 0x00030000, 1141 0x00000000, 1142 0x00000000, 1143 0x4a756a75, /* J u j u */ 1144}; 1145 1146static struct fw_descriptor vendor_id_descriptor = { 1147 .length = ARRAY_SIZE(vendor_textual_descriptor), 1148 .immediate = 0x03d00d1e, 1149 .key = 0x81000000, 1150 .data = vendor_textual_descriptor, 1151}; 1152 1153static struct fw_descriptor model_id_descriptor = { 1154 .length = ARRAY_SIZE(model_textual_descriptor), 1155 .immediate = 0x17000001, 1156 .key = 0x81000000, 1157 .data = model_textual_descriptor, 1158}; 1159 1160static int __init fw_core_init(void) 1161{ 1162 int ret; 1163 1164 ret = bus_register(&fw_bus_type); 1165 if (ret < 0) 1166 return ret; 1167 1168 fw_cdev_major = register_chrdev(0, "firewire", &fw_device_ops); 1169 if (fw_cdev_major < 0) { 1170 bus_unregister(&fw_bus_type); 1171 return fw_cdev_major; 1172 } 1173 1174 fw_core_add_address_handler(&topology_map, &topology_map_region); 1175 fw_core_add_address_handler(®isters, ®isters_region); 1176 fw_core_add_descriptor(&vendor_id_descriptor); 1177 fw_core_add_descriptor(&model_id_descriptor); 1178 1179 return 0; 1180} 1181 1182static void __exit fw_core_cleanup(void) 1183{ 1184 unregister_chrdev(fw_cdev_major, "firewire"); 1185 bus_unregister(&fw_bus_type); 1186 idr_destroy(&fw_device_idr); 1187} 1188 1189module_init(fw_core_init); 1190module_exit(fw_core_cleanup); 1191