1 /* 2 * Char device for device raw access 3 * 4 * Copyright (C) 2005-2007 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/compat.h> 23 #include <linux/delay.h> 24 #include <linux/device.h> 25 #include <linux/errno.h> 26 #include <linux/firewire.h> 27 #include <linux/firewire-cdev.h> 28 #include <linux/idr.h> 29 #include <linux/irqflags.h> 30 #include <linux/jiffies.h> 31 #include <linux/kernel.h> 32 #include <linux/kref.h> 33 #include <linux/mm.h> 34 #include <linux/module.h> 35 #include <linux/mutex.h> 36 #include <linux/poll.h> 37 #include <linux/sched.h> /* required for linux/wait.h */ 38 #include <linux/slab.h> 39 #include <linux/spinlock.h> 40 #include <linux/string.h> 41 #include <linux/time.h> 42 #include <linux/uaccess.h> 43 #include <linux/vmalloc.h> 44 #include <linux/wait.h> 45 #include <linux/workqueue.h> 46 47 #include <asm/system.h> 48 49 #include "core.h" 50 51 /* 52 * ABI version history is documented in linux/firewire-cdev.h. 53 */ 54 #define FW_CDEV_KERNEL_VERSION 5 55 #define FW_CDEV_VERSION_EVENT_REQUEST2 4 56 #define FW_CDEV_VERSION_ALLOCATE_REGION_END 4 57 58 struct client { 59 u32 version; 60 struct fw_device *device; 61 62 spinlock_t lock; 63 bool in_shutdown; 64 struct idr resource_idr; 65 struct list_head event_list; 66 wait_queue_head_t wait; 67 wait_queue_head_t tx_flush_wait; 68 u64 bus_reset_closure; 69 70 struct fw_iso_context *iso_context; 71 u64 iso_closure; 72 struct fw_iso_buffer buffer; 73 unsigned long vm_start; 74 75 struct list_head phy_receiver_link; 76 u64 phy_receiver_closure; 77 78 struct list_head link; 79 struct kref kref; 80 }; 81 82 static inline void client_get(struct client *client) 83 { 84 kref_get(&client->kref); 85 } 86 87 static void client_release(struct kref *kref) 88 { 89 struct client *client = container_of(kref, struct client, kref); 90 91 fw_device_put(client->device); 92 kfree(client); 93 } 94 95 static void client_put(struct client *client) 96 { 97 kref_put(&client->kref, client_release); 98 } 99 100 struct client_resource; 101 typedef void (*client_resource_release_fn_t)(struct client *, 102 struct client_resource *); 103 struct client_resource { 104 client_resource_release_fn_t release; 105 int handle; 106 }; 107 108 struct address_handler_resource { 109 struct client_resource resource; 110 struct fw_address_handler handler; 111 __u64 closure; 112 struct client *client; 113 }; 114 115 struct outbound_transaction_resource { 116 struct client_resource resource; 117 struct fw_transaction transaction; 118 }; 119 120 struct inbound_transaction_resource { 121 struct client_resource resource; 122 struct fw_card *card; 123 struct fw_request *request; 124 void *data; 125 size_t length; 126 }; 127 128 struct descriptor_resource { 129 struct client_resource resource; 130 struct fw_descriptor descriptor; 131 u32 data[0]; 132 }; 133 134 struct iso_resource { 135 struct client_resource resource; 136 struct client *client; 137 /* Schedule work and access todo only with client->lock held. */ 138 struct delayed_work work; 139 enum {ISO_RES_ALLOC, ISO_RES_REALLOC, ISO_RES_DEALLOC, 140 ISO_RES_ALLOC_ONCE, ISO_RES_DEALLOC_ONCE,} todo; 141 int generation; 142 u64 channels; 143 s32 bandwidth; 144 struct iso_resource_event *e_alloc, *e_dealloc; 145 }; 146 147 static void release_iso_resource(struct client *, struct client_resource *); 148 149 static void schedule_iso_resource(struct iso_resource *r, unsigned long delay) 150 { 151 client_get(r->client); 152 if (!queue_delayed_work(fw_workqueue, &r->work, delay)) 153 client_put(r->client); 154 } 155 156 static void schedule_if_iso_resource(struct client_resource *resource) 157 { 158 if (resource->release == release_iso_resource) 159 schedule_iso_resource(container_of(resource, 160 struct iso_resource, resource), 0); 161 } 162 163 /* 164 * dequeue_event() just kfree()'s the event, so the event has to be 165 * the first field in a struct XYZ_event. 166 */ 167 struct event { 168 struct { void *data; size_t size; } v[2]; 169 struct list_head link; 170 }; 171 172 struct bus_reset_event { 173 struct event event; 174 struct fw_cdev_event_bus_reset reset; 175 }; 176 177 struct outbound_transaction_event { 178 struct event event; 179 struct client *client; 180 struct outbound_transaction_resource r; 181 struct fw_cdev_event_response response; 182 }; 183 184 struct inbound_transaction_event { 185 struct event event; 186 union { 187 struct fw_cdev_event_request request; 188 struct fw_cdev_event_request2 request2; 189 } req; 190 }; 191 192 struct iso_interrupt_event { 193 struct event event; 194 struct fw_cdev_event_iso_interrupt interrupt; 195 }; 196 197 struct iso_interrupt_mc_event { 198 struct event event; 199 struct fw_cdev_event_iso_interrupt_mc interrupt; 200 }; 201 202 struct iso_resource_event { 203 struct event event; 204 struct fw_cdev_event_iso_resource iso_resource; 205 }; 206 207 struct outbound_phy_packet_event { 208 struct event event; 209 struct client *client; 210 struct fw_packet p; 211 struct fw_cdev_event_phy_packet phy_packet; 212 }; 213 214 struct inbound_phy_packet_event { 215 struct event event; 216 struct fw_cdev_event_phy_packet phy_packet; 217 }; 218 219 #ifdef CONFIG_COMPAT 220 static void __user *u64_to_uptr(u64 value) 221 { 222 if (is_compat_task()) 223 return compat_ptr(value); 224 else 225 return (void __user *)(unsigned long)value; 226 } 227 228 static u64 uptr_to_u64(void __user *ptr) 229 { 230 if (is_compat_task()) 231 return ptr_to_compat(ptr); 232 else 233 return (u64)(unsigned long)ptr; 234 } 235 #else 236 static inline void __user *u64_to_uptr(u64 value) 237 { 238 return (void __user *)(unsigned long)value; 239 } 240 241 static inline u64 uptr_to_u64(void __user *ptr) 242 { 243 return (u64)(unsigned long)ptr; 244 } 245 #endif /* CONFIG_COMPAT */ 246 247 static int fw_device_op_open(struct inode *inode, struct file *file) 248 { 249 struct fw_device *device; 250 struct client *client; 251 252 device = fw_device_get_by_devt(inode->i_rdev); 253 if (device == NULL) 254 return -ENODEV; 255 256 if (fw_device_is_shutdown(device)) { 257 fw_device_put(device); 258 return -ENODEV; 259 } 260 261 client = kzalloc(sizeof(*client), GFP_KERNEL); 262 if (client == NULL) { 263 fw_device_put(device); 264 return -ENOMEM; 265 } 266 267 client->device = device; 268 spin_lock_init(&client->lock); 269 idr_init(&client->resource_idr); 270 INIT_LIST_HEAD(&client->event_list); 271 init_waitqueue_head(&client->wait); 272 init_waitqueue_head(&client->tx_flush_wait); 273 INIT_LIST_HEAD(&client->phy_receiver_link); 274 INIT_LIST_HEAD(&client->link); 275 kref_init(&client->kref); 276 277 file->private_data = client; 278 279 return nonseekable_open(inode, file); 280 } 281 282 static void queue_event(struct client *client, struct event *event, 283 void *data0, size_t size0, void *data1, size_t size1) 284 { 285 unsigned long flags; 286 287 event->v[0].data = data0; 288 event->v[0].size = size0; 289 event->v[1].data = data1; 290 event->v[1].size = size1; 291 292 spin_lock_irqsave(&client->lock, flags); 293 if (client->in_shutdown) 294 kfree(event); 295 else 296 list_add_tail(&event->link, &client->event_list); 297 spin_unlock_irqrestore(&client->lock, flags); 298 299 wake_up_interruptible(&client->wait); 300 } 301 302 static int dequeue_event(struct client *client, 303 char __user *buffer, size_t count) 304 { 305 struct event *event; 306 size_t size, total; 307 int i, ret; 308 309 ret = wait_event_interruptible(client->wait, 310 !list_empty(&client->event_list) || 311 fw_device_is_shutdown(client->device)); 312 if (ret < 0) 313 return ret; 314 315 if (list_empty(&client->event_list) && 316 fw_device_is_shutdown(client->device)) 317 return -ENODEV; 318 319 spin_lock_irq(&client->lock); 320 event = list_first_entry(&client->event_list, struct event, link); 321 list_del(&event->link); 322 spin_unlock_irq(&client->lock); 323 324 total = 0; 325 for (i = 0; i < ARRAY_SIZE(event->v) && total < count; i++) { 326 size = min(event->v[i].size, count - total); 327 if (copy_to_user(buffer + total, event->v[i].data, size)) { 328 ret = -EFAULT; 329 goto out; 330 } 331 total += size; 332 } 333 ret = total; 334 335 out: 336 kfree(event); 337 338 return ret; 339 } 340 341 static ssize_t fw_device_op_read(struct file *file, char __user *buffer, 342 size_t count, loff_t *offset) 343 { 344 struct client *client = file->private_data; 345 346 return dequeue_event(client, buffer, count); 347 } 348 349 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset *event, 350 struct client *client) 351 { 352 struct fw_card *card = client->device->card; 353 354 spin_lock_irq(&card->lock); 355 356 event->closure = client->bus_reset_closure; 357 event->type = FW_CDEV_EVENT_BUS_RESET; 358 event->generation = client->device->generation; 359 event->node_id = client->device->node_id; 360 event->local_node_id = card->local_node->node_id; 361 event->bm_node_id = card->bm_node_id; 362 event->irm_node_id = card->irm_node->node_id; 363 event->root_node_id = card->root_node->node_id; 364 365 spin_unlock_irq(&card->lock); 366 } 367 368 static void for_each_client(struct fw_device *device, 369 void (*callback)(struct client *client)) 370 { 371 struct client *c; 372 373 mutex_lock(&device->client_list_mutex); 374 list_for_each_entry(c, &device->client_list, link) 375 callback(c); 376 mutex_unlock(&device->client_list_mutex); 377 } 378 379 static int schedule_reallocations(int id, void *p, void *data) 380 { 381 schedule_if_iso_resource(p); 382 383 return 0; 384 } 385 386 static void queue_bus_reset_event(struct client *client) 387 { 388 struct bus_reset_event *e; 389 390 e = kzalloc(sizeof(*e), GFP_KERNEL); 391 if (e == NULL) { 392 fw_notice(client->device->card, "out of memory when allocating event\n"); 393 return; 394 } 395 396 fill_bus_reset_event(&e->reset, client); 397 398 queue_event(client, &e->event, 399 &e->reset, sizeof(e->reset), NULL, 0); 400 401 spin_lock_irq(&client->lock); 402 idr_for_each(&client->resource_idr, schedule_reallocations, client); 403 spin_unlock_irq(&client->lock); 404 } 405 406 void fw_device_cdev_update(struct fw_device *device) 407 { 408 for_each_client(device, queue_bus_reset_event); 409 } 410 411 static void wake_up_client(struct client *client) 412 { 413 wake_up_interruptible(&client->wait); 414 } 415 416 void fw_device_cdev_remove(struct fw_device *device) 417 { 418 for_each_client(device, wake_up_client); 419 } 420 421 union ioctl_arg { 422 struct fw_cdev_get_info get_info; 423 struct fw_cdev_send_request send_request; 424 struct fw_cdev_allocate allocate; 425 struct fw_cdev_deallocate deallocate; 426 struct fw_cdev_send_response send_response; 427 struct fw_cdev_initiate_bus_reset initiate_bus_reset; 428 struct fw_cdev_add_descriptor add_descriptor; 429 struct fw_cdev_remove_descriptor remove_descriptor; 430 struct fw_cdev_create_iso_context create_iso_context; 431 struct fw_cdev_queue_iso queue_iso; 432 struct fw_cdev_start_iso start_iso; 433 struct fw_cdev_stop_iso stop_iso; 434 struct fw_cdev_get_cycle_timer get_cycle_timer; 435 struct fw_cdev_allocate_iso_resource allocate_iso_resource; 436 struct fw_cdev_send_stream_packet send_stream_packet; 437 struct fw_cdev_get_cycle_timer2 get_cycle_timer2; 438 struct fw_cdev_send_phy_packet send_phy_packet; 439 struct fw_cdev_receive_phy_packets receive_phy_packets; 440 struct fw_cdev_set_iso_channels set_iso_channels; 441 struct fw_cdev_flush_iso flush_iso; 442 }; 443 444 static int ioctl_get_info(struct client *client, union ioctl_arg *arg) 445 { 446 struct fw_cdev_get_info *a = &arg->get_info; 447 struct fw_cdev_event_bus_reset bus_reset; 448 unsigned long ret = 0; 449 450 client->version = a->version; 451 a->version = FW_CDEV_KERNEL_VERSION; 452 a->card = client->device->card->index; 453 454 down_read(&fw_device_rwsem); 455 456 if (a->rom != 0) { 457 size_t want = a->rom_length; 458 size_t have = client->device->config_rom_length * 4; 459 460 ret = copy_to_user(u64_to_uptr(a->rom), 461 client->device->config_rom, min(want, have)); 462 } 463 a->rom_length = client->device->config_rom_length * 4; 464 465 up_read(&fw_device_rwsem); 466 467 if (ret != 0) 468 return -EFAULT; 469 470 mutex_lock(&client->device->client_list_mutex); 471 472 client->bus_reset_closure = a->bus_reset_closure; 473 if (a->bus_reset != 0) { 474 fill_bus_reset_event(&bus_reset, client); 475 ret = copy_to_user(u64_to_uptr(a->bus_reset), 476 &bus_reset, sizeof(bus_reset)); 477 } 478 if (ret == 0 && list_empty(&client->link)) 479 list_add_tail(&client->link, &client->device->client_list); 480 481 mutex_unlock(&client->device->client_list_mutex); 482 483 return ret ? -EFAULT : 0; 484 } 485 486 static int add_client_resource(struct client *client, 487 struct client_resource *resource, gfp_t gfp_mask) 488 { 489 unsigned long flags; 490 int ret; 491 492 retry: 493 if (idr_pre_get(&client->resource_idr, gfp_mask) == 0) 494 return -ENOMEM; 495 496 spin_lock_irqsave(&client->lock, flags); 497 if (client->in_shutdown) 498 ret = -ECANCELED; 499 else 500 ret = idr_get_new(&client->resource_idr, resource, 501 &resource->handle); 502 if (ret >= 0) { 503 client_get(client); 504 schedule_if_iso_resource(resource); 505 } 506 spin_unlock_irqrestore(&client->lock, flags); 507 508 if (ret == -EAGAIN) 509 goto retry; 510 511 return ret < 0 ? ret : 0; 512 } 513 514 static int release_client_resource(struct client *client, u32 handle, 515 client_resource_release_fn_t release, 516 struct client_resource **return_resource) 517 { 518 struct client_resource *resource; 519 520 spin_lock_irq(&client->lock); 521 if (client->in_shutdown) 522 resource = NULL; 523 else 524 resource = idr_find(&client->resource_idr, handle); 525 if (resource && resource->release == release) 526 idr_remove(&client->resource_idr, handle); 527 spin_unlock_irq(&client->lock); 528 529 if (!(resource && resource->release == release)) 530 return -EINVAL; 531 532 if (return_resource) 533 *return_resource = resource; 534 else 535 resource->release(client, resource); 536 537 client_put(client); 538 539 return 0; 540 } 541 542 static void release_transaction(struct client *client, 543 struct client_resource *resource) 544 { 545 } 546 547 static void complete_transaction(struct fw_card *card, int rcode, 548 void *payload, size_t length, void *data) 549 { 550 struct outbound_transaction_event *e = data; 551 struct fw_cdev_event_response *rsp = &e->response; 552 struct client *client = e->client; 553 unsigned long flags; 554 555 if (length < rsp->length) 556 rsp->length = length; 557 if (rcode == RCODE_COMPLETE) 558 memcpy(rsp->data, payload, rsp->length); 559 560 spin_lock_irqsave(&client->lock, flags); 561 idr_remove(&client->resource_idr, e->r.resource.handle); 562 if (client->in_shutdown) 563 wake_up(&client->tx_flush_wait); 564 spin_unlock_irqrestore(&client->lock, flags); 565 566 rsp->type = FW_CDEV_EVENT_RESPONSE; 567 rsp->rcode = rcode; 568 569 /* 570 * In the case that sizeof(*rsp) doesn't align with the position of the 571 * data, and the read is short, preserve an extra copy of the data 572 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless 573 * for short reads and some apps depended on it, this is both safe 574 * and prudent for compatibility. 575 */ 576 if (rsp->length <= sizeof(*rsp) - offsetof(typeof(*rsp), data)) 577 queue_event(client, &e->event, rsp, sizeof(*rsp), 578 rsp->data, rsp->length); 579 else 580 queue_event(client, &e->event, rsp, sizeof(*rsp) + rsp->length, 581 NULL, 0); 582 583 /* Drop the idr's reference */ 584 client_put(client); 585 } 586 587 static int init_request(struct client *client, 588 struct fw_cdev_send_request *request, 589 int destination_id, int speed) 590 { 591 struct outbound_transaction_event *e; 592 int ret; 593 594 if (request->tcode != TCODE_STREAM_DATA && 595 (request->length > 4096 || request->length > 512 << speed)) 596 return -EIO; 597 598 if (request->tcode == TCODE_WRITE_QUADLET_REQUEST && 599 request->length < 4) 600 return -EINVAL; 601 602 e = kmalloc(sizeof(*e) + request->length, GFP_KERNEL); 603 if (e == NULL) 604 return -ENOMEM; 605 606 e->client = client; 607 e->response.length = request->length; 608 e->response.closure = request->closure; 609 610 if (request->data && 611 copy_from_user(e->response.data, 612 u64_to_uptr(request->data), request->length)) { 613 ret = -EFAULT; 614 goto failed; 615 } 616 617 e->r.resource.release = release_transaction; 618 ret = add_client_resource(client, &e->r.resource, GFP_KERNEL); 619 if (ret < 0) 620 goto failed; 621 622 fw_send_request(client->device->card, &e->r.transaction, 623 request->tcode, destination_id, request->generation, 624 speed, request->offset, e->response.data, 625 request->length, complete_transaction, e); 626 return 0; 627 628 failed: 629 kfree(e); 630 631 return ret; 632 } 633 634 static int ioctl_send_request(struct client *client, union ioctl_arg *arg) 635 { 636 switch (arg->send_request.tcode) { 637 case TCODE_WRITE_QUADLET_REQUEST: 638 case TCODE_WRITE_BLOCK_REQUEST: 639 case TCODE_READ_QUADLET_REQUEST: 640 case TCODE_READ_BLOCK_REQUEST: 641 case TCODE_LOCK_MASK_SWAP: 642 case TCODE_LOCK_COMPARE_SWAP: 643 case TCODE_LOCK_FETCH_ADD: 644 case TCODE_LOCK_LITTLE_ADD: 645 case TCODE_LOCK_BOUNDED_ADD: 646 case TCODE_LOCK_WRAP_ADD: 647 case TCODE_LOCK_VENDOR_DEPENDENT: 648 break; 649 default: 650 return -EINVAL; 651 } 652 653 return init_request(client, &arg->send_request, client->device->node_id, 654 client->device->max_speed); 655 } 656 657 static inline bool is_fcp_request(struct fw_request *request) 658 { 659 return request == NULL; 660 } 661 662 static void release_request(struct client *client, 663 struct client_resource *resource) 664 { 665 struct inbound_transaction_resource *r = container_of(resource, 666 struct inbound_transaction_resource, resource); 667 668 if (is_fcp_request(r->request)) 669 kfree(r->data); 670 else 671 fw_send_response(r->card, r->request, RCODE_CONFLICT_ERROR); 672 673 fw_card_put(r->card); 674 kfree(r); 675 } 676 677 static void handle_request(struct fw_card *card, struct fw_request *request, 678 int tcode, int destination, int source, 679 int generation, unsigned long long offset, 680 void *payload, size_t length, void *callback_data) 681 { 682 struct address_handler_resource *handler = callback_data; 683 struct inbound_transaction_resource *r; 684 struct inbound_transaction_event *e; 685 size_t event_size0; 686 void *fcp_frame = NULL; 687 int ret; 688 689 /* card may be different from handler->client->device->card */ 690 fw_card_get(card); 691 692 r = kmalloc(sizeof(*r), GFP_ATOMIC); 693 e = kmalloc(sizeof(*e), GFP_ATOMIC); 694 if (r == NULL || e == NULL) { 695 fw_notice(card, "out of memory when allocating event\n"); 696 goto failed; 697 } 698 r->card = card; 699 r->request = request; 700 r->data = payload; 701 r->length = length; 702 703 if (is_fcp_request(request)) { 704 /* 705 * FIXME: Let core-transaction.c manage a 706 * single reference-counted copy? 707 */ 708 fcp_frame = kmemdup(payload, length, GFP_ATOMIC); 709 if (fcp_frame == NULL) 710 goto failed; 711 712 r->data = fcp_frame; 713 } 714 715 r->resource.release = release_request; 716 ret = add_client_resource(handler->client, &r->resource, GFP_ATOMIC); 717 if (ret < 0) 718 goto failed; 719 720 if (handler->client->version < FW_CDEV_VERSION_EVENT_REQUEST2) { 721 struct fw_cdev_event_request *req = &e->req.request; 722 723 if (tcode & 0x10) 724 tcode = TCODE_LOCK_REQUEST; 725 726 req->type = FW_CDEV_EVENT_REQUEST; 727 req->tcode = tcode; 728 req->offset = offset; 729 req->length = length; 730 req->handle = r->resource.handle; 731 req->closure = handler->closure; 732 event_size0 = sizeof(*req); 733 } else { 734 struct fw_cdev_event_request2 *req = &e->req.request2; 735 736 req->type = FW_CDEV_EVENT_REQUEST2; 737 req->tcode = tcode; 738 req->offset = offset; 739 req->source_node_id = source; 740 req->destination_node_id = destination; 741 req->card = card->index; 742 req->generation = generation; 743 req->length = length; 744 req->handle = r->resource.handle; 745 req->closure = handler->closure; 746 event_size0 = sizeof(*req); 747 } 748 749 queue_event(handler->client, &e->event, 750 &e->req, event_size0, r->data, length); 751 return; 752 753 failed: 754 kfree(r); 755 kfree(e); 756 kfree(fcp_frame); 757 758 if (!is_fcp_request(request)) 759 fw_send_response(card, request, RCODE_CONFLICT_ERROR); 760 761 fw_card_put(card); 762 } 763 764 static void release_address_handler(struct client *client, 765 struct client_resource *resource) 766 { 767 struct address_handler_resource *r = 768 container_of(resource, struct address_handler_resource, resource); 769 770 fw_core_remove_address_handler(&r->handler); 771 kfree(r); 772 } 773 774 static int ioctl_allocate(struct client *client, union ioctl_arg *arg) 775 { 776 struct fw_cdev_allocate *a = &arg->allocate; 777 struct address_handler_resource *r; 778 struct fw_address_region region; 779 int ret; 780 781 r = kmalloc(sizeof(*r), GFP_KERNEL); 782 if (r == NULL) 783 return -ENOMEM; 784 785 region.start = a->offset; 786 if (client->version < FW_CDEV_VERSION_ALLOCATE_REGION_END) 787 region.end = a->offset + a->length; 788 else 789 region.end = a->region_end; 790 791 r->handler.length = a->length; 792 r->handler.address_callback = handle_request; 793 r->handler.callback_data = r; 794 r->closure = a->closure; 795 r->client = client; 796 797 ret = fw_core_add_address_handler(&r->handler, ®ion); 798 if (ret < 0) { 799 kfree(r); 800 return ret; 801 } 802 a->offset = r->handler.offset; 803 804 r->resource.release = release_address_handler; 805 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 806 if (ret < 0) { 807 release_address_handler(client, &r->resource); 808 return ret; 809 } 810 a->handle = r->resource.handle; 811 812 return 0; 813 } 814 815 static int ioctl_deallocate(struct client *client, union ioctl_arg *arg) 816 { 817 return release_client_resource(client, arg->deallocate.handle, 818 release_address_handler, NULL); 819 } 820 821 static int ioctl_send_response(struct client *client, union ioctl_arg *arg) 822 { 823 struct fw_cdev_send_response *a = &arg->send_response; 824 struct client_resource *resource; 825 struct inbound_transaction_resource *r; 826 int ret = 0; 827 828 if (release_client_resource(client, a->handle, 829 release_request, &resource) < 0) 830 return -EINVAL; 831 832 r = container_of(resource, struct inbound_transaction_resource, 833 resource); 834 if (is_fcp_request(r->request)) 835 goto out; 836 837 if (a->length != fw_get_response_length(r->request)) { 838 ret = -EINVAL; 839 kfree(r->request); 840 goto out; 841 } 842 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length)) { 843 ret = -EFAULT; 844 kfree(r->request); 845 goto out; 846 } 847 fw_send_response(r->card, r->request, a->rcode); 848 out: 849 fw_card_put(r->card); 850 kfree(r); 851 852 return ret; 853 } 854 855 static int ioctl_initiate_bus_reset(struct client *client, union ioctl_arg *arg) 856 { 857 fw_schedule_bus_reset(client->device->card, true, 858 arg->initiate_bus_reset.type == FW_CDEV_SHORT_RESET); 859 return 0; 860 } 861 862 static void release_descriptor(struct client *client, 863 struct client_resource *resource) 864 { 865 struct descriptor_resource *r = 866 container_of(resource, struct descriptor_resource, resource); 867 868 fw_core_remove_descriptor(&r->descriptor); 869 kfree(r); 870 } 871 872 static int ioctl_add_descriptor(struct client *client, union ioctl_arg *arg) 873 { 874 struct fw_cdev_add_descriptor *a = &arg->add_descriptor; 875 struct descriptor_resource *r; 876 int ret; 877 878 /* Access policy: Allow this ioctl only on local nodes' device files. */ 879 if (!client->device->is_local) 880 return -ENOSYS; 881 882 if (a->length > 256) 883 return -EINVAL; 884 885 r = kmalloc(sizeof(*r) + a->length * 4, GFP_KERNEL); 886 if (r == NULL) 887 return -ENOMEM; 888 889 if (copy_from_user(r->data, u64_to_uptr(a->data), a->length * 4)) { 890 ret = -EFAULT; 891 goto failed; 892 } 893 894 r->descriptor.length = a->length; 895 r->descriptor.immediate = a->immediate; 896 r->descriptor.key = a->key; 897 r->descriptor.data = r->data; 898 899 ret = fw_core_add_descriptor(&r->descriptor); 900 if (ret < 0) 901 goto failed; 902 903 r->resource.release = release_descriptor; 904 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 905 if (ret < 0) { 906 fw_core_remove_descriptor(&r->descriptor); 907 goto failed; 908 } 909 a->handle = r->resource.handle; 910 911 return 0; 912 failed: 913 kfree(r); 914 915 return ret; 916 } 917 918 static int ioctl_remove_descriptor(struct client *client, union ioctl_arg *arg) 919 { 920 return release_client_resource(client, arg->remove_descriptor.handle, 921 release_descriptor, NULL); 922 } 923 924 static void iso_callback(struct fw_iso_context *context, u32 cycle, 925 size_t header_length, void *header, void *data) 926 { 927 struct client *client = data; 928 struct iso_interrupt_event *e; 929 930 e = kmalloc(sizeof(*e) + header_length, GFP_ATOMIC); 931 if (e == NULL) { 932 fw_notice(context->card, "out of memory when allocating event\n"); 933 return; 934 } 935 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT; 936 e->interrupt.closure = client->iso_closure; 937 e->interrupt.cycle = cycle; 938 e->interrupt.header_length = header_length; 939 memcpy(e->interrupt.header, header, header_length); 940 queue_event(client, &e->event, &e->interrupt, 941 sizeof(e->interrupt) + header_length, NULL, 0); 942 } 943 944 static void iso_mc_callback(struct fw_iso_context *context, 945 dma_addr_t completed, void *data) 946 { 947 struct client *client = data; 948 struct iso_interrupt_mc_event *e; 949 950 e = kmalloc(sizeof(*e), GFP_ATOMIC); 951 if (e == NULL) { 952 fw_notice(context->card, "out of memory when allocating event\n"); 953 return; 954 } 955 e->interrupt.type = FW_CDEV_EVENT_ISO_INTERRUPT_MULTICHANNEL; 956 e->interrupt.closure = client->iso_closure; 957 e->interrupt.completed = fw_iso_buffer_lookup(&client->buffer, 958 completed); 959 queue_event(client, &e->event, &e->interrupt, 960 sizeof(e->interrupt), NULL, 0); 961 } 962 963 static int ioctl_create_iso_context(struct client *client, union ioctl_arg *arg) 964 { 965 struct fw_cdev_create_iso_context *a = &arg->create_iso_context; 966 struct fw_iso_context *context; 967 fw_iso_callback_t cb; 968 969 BUILD_BUG_ON(FW_CDEV_ISO_CONTEXT_TRANSMIT != FW_ISO_CONTEXT_TRANSMIT || 970 FW_CDEV_ISO_CONTEXT_RECEIVE != FW_ISO_CONTEXT_RECEIVE || 971 FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL != 972 FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL); 973 974 switch (a->type) { 975 case FW_ISO_CONTEXT_TRANSMIT: 976 if (a->speed > SCODE_3200 || a->channel > 63) 977 return -EINVAL; 978 979 cb = iso_callback; 980 break; 981 982 case FW_ISO_CONTEXT_RECEIVE: 983 if (a->header_size < 4 || (a->header_size & 3) || 984 a->channel > 63) 985 return -EINVAL; 986 987 cb = iso_callback; 988 break; 989 990 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL: 991 cb = (fw_iso_callback_t)iso_mc_callback; 992 break; 993 994 default: 995 return -EINVAL; 996 } 997 998 context = fw_iso_context_create(client->device->card, a->type, 999 a->channel, a->speed, a->header_size, cb, client); 1000 if (IS_ERR(context)) 1001 return PTR_ERR(context); 1002 1003 /* We only support one context at this time. */ 1004 spin_lock_irq(&client->lock); 1005 if (client->iso_context != NULL) { 1006 spin_unlock_irq(&client->lock); 1007 fw_iso_context_destroy(context); 1008 return -EBUSY; 1009 } 1010 client->iso_closure = a->closure; 1011 client->iso_context = context; 1012 spin_unlock_irq(&client->lock); 1013 1014 a->handle = 0; 1015 1016 return 0; 1017 } 1018 1019 static int ioctl_set_iso_channels(struct client *client, union ioctl_arg *arg) 1020 { 1021 struct fw_cdev_set_iso_channels *a = &arg->set_iso_channels; 1022 struct fw_iso_context *ctx = client->iso_context; 1023 1024 if (ctx == NULL || a->handle != 0) 1025 return -EINVAL; 1026 1027 return fw_iso_context_set_channels(ctx, &a->channels); 1028 } 1029 1030 /* Macros for decoding the iso packet control header. */ 1031 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff) 1032 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01) 1033 #define GET_SKIP(v) (((v) >> 17) & 0x01) 1034 #define GET_TAG(v) (((v) >> 18) & 0x03) 1035 #define GET_SY(v) (((v) >> 20) & 0x0f) 1036 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff) 1037 1038 static int ioctl_queue_iso(struct client *client, union ioctl_arg *arg) 1039 { 1040 struct fw_cdev_queue_iso *a = &arg->queue_iso; 1041 struct fw_cdev_iso_packet __user *p, *end, *next; 1042 struct fw_iso_context *ctx = client->iso_context; 1043 unsigned long payload, buffer_end, transmit_header_bytes = 0; 1044 u32 control; 1045 int count; 1046 struct { 1047 struct fw_iso_packet packet; 1048 u8 header[256]; 1049 } u; 1050 1051 if (ctx == NULL || a->handle != 0) 1052 return -EINVAL; 1053 1054 /* 1055 * If the user passes a non-NULL data pointer, has mmap()'ed 1056 * the iso buffer, and the pointer points inside the buffer, 1057 * we setup the payload pointers accordingly. Otherwise we 1058 * set them both to 0, which will still let packets with 1059 * payload_length == 0 through. In other words, if no packets 1060 * use the indirect payload, the iso buffer need not be mapped 1061 * and the a->data pointer is ignored. 1062 */ 1063 payload = (unsigned long)a->data - client->vm_start; 1064 buffer_end = client->buffer.page_count << PAGE_SHIFT; 1065 if (a->data == 0 || client->buffer.pages == NULL || 1066 payload >= buffer_end) { 1067 payload = 0; 1068 buffer_end = 0; 1069 } 1070 1071 if (ctx->type == FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL && payload & 3) 1072 return -EINVAL; 1073 1074 p = (struct fw_cdev_iso_packet __user *)u64_to_uptr(a->packets); 1075 if (!access_ok(VERIFY_READ, p, a->size)) 1076 return -EFAULT; 1077 1078 end = (void __user *)p + a->size; 1079 count = 0; 1080 while (p < end) { 1081 if (get_user(control, &p->control)) 1082 return -EFAULT; 1083 u.packet.payload_length = GET_PAYLOAD_LENGTH(control); 1084 u.packet.interrupt = GET_INTERRUPT(control); 1085 u.packet.skip = GET_SKIP(control); 1086 u.packet.tag = GET_TAG(control); 1087 u.packet.sy = GET_SY(control); 1088 u.packet.header_length = GET_HEADER_LENGTH(control); 1089 1090 switch (ctx->type) { 1091 case FW_ISO_CONTEXT_TRANSMIT: 1092 if (u.packet.header_length & 3) 1093 return -EINVAL; 1094 transmit_header_bytes = u.packet.header_length; 1095 break; 1096 1097 case FW_ISO_CONTEXT_RECEIVE: 1098 if (u.packet.header_length == 0 || 1099 u.packet.header_length % ctx->header_size != 0) 1100 return -EINVAL; 1101 break; 1102 1103 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL: 1104 if (u.packet.payload_length == 0 || 1105 u.packet.payload_length & 3) 1106 return -EINVAL; 1107 break; 1108 } 1109 1110 next = (struct fw_cdev_iso_packet __user *) 1111 &p->header[transmit_header_bytes / 4]; 1112 if (next > end) 1113 return -EINVAL; 1114 if (__copy_from_user 1115 (u.packet.header, p->header, transmit_header_bytes)) 1116 return -EFAULT; 1117 if (u.packet.skip && ctx->type == FW_ISO_CONTEXT_TRANSMIT && 1118 u.packet.header_length + u.packet.payload_length > 0) 1119 return -EINVAL; 1120 if (payload + u.packet.payload_length > buffer_end) 1121 return -EINVAL; 1122 1123 if (fw_iso_context_queue(ctx, &u.packet, 1124 &client->buffer, payload)) 1125 break; 1126 1127 p = next; 1128 payload += u.packet.payload_length; 1129 count++; 1130 } 1131 fw_iso_context_queue_flush(ctx); 1132 1133 a->size -= uptr_to_u64(p) - a->packets; 1134 a->packets = uptr_to_u64(p); 1135 a->data = client->vm_start + payload; 1136 1137 return count; 1138 } 1139 1140 static int ioctl_start_iso(struct client *client, union ioctl_arg *arg) 1141 { 1142 struct fw_cdev_start_iso *a = &arg->start_iso; 1143 1144 BUILD_BUG_ON( 1145 FW_CDEV_ISO_CONTEXT_MATCH_TAG0 != FW_ISO_CONTEXT_MATCH_TAG0 || 1146 FW_CDEV_ISO_CONTEXT_MATCH_TAG1 != FW_ISO_CONTEXT_MATCH_TAG1 || 1147 FW_CDEV_ISO_CONTEXT_MATCH_TAG2 != FW_ISO_CONTEXT_MATCH_TAG2 || 1148 FW_CDEV_ISO_CONTEXT_MATCH_TAG3 != FW_ISO_CONTEXT_MATCH_TAG3 || 1149 FW_CDEV_ISO_CONTEXT_MATCH_ALL_TAGS != FW_ISO_CONTEXT_MATCH_ALL_TAGS); 1150 1151 if (client->iso_context == NULL || a->handle != 0) 1152 return -EINVAL; 1153 1154 if (client->iso_context->type == FW_ISO_CONTEXT_RECEIVE && 1155 (a->tags == 0 || a->tags > 15 || a->sync > 15)) 1156 return -EINVAL; 1157 1158 return fw_iso_context_start(client->iso_context, 1159 a->cycle, a->sync, a->tags); 1160 } 1161 1162 static int ioctl_stop_iso(struct client *client, union ioctl_arg *arg) 1163 { 1164 struct fw_cdev_stop_iso *a = &arg->stop_iso; 1165 1166 if (client->iso_context == NULL || a->handle != 0) 1167 return -EINVAL; 1168 1169 return fw_iso_context_stop(client->iso_context); 1170 } 1171 1172 static int ioctl_flush_iso(struct client *client, union ioctl_arg *arg) 1173 { 1174 struct fw_cdev_flush_iso *a = &arg->flush_iso; 1175 1176 if (client->iso_context == NULL || a->handle != 0) 1177 return -EINVAL; 1178 1179 return fw_iso_context_flush_completions(client->iso_context); 1180 } 1181 1182 static int ioctl_get_cycle_timer2(struct client *client, union ioctl_arg *arg) 1183 { 1184 struct fw_cdev_get_cycle_timer2 *a = &arg->get_cycle_timer2; 1185 struct fw_card *card = client->device->card; 1186 struct timespec ts = {0, 0}; 1187 u32 cycle_time; 1188 int ret = 0; 1189 1190 local_irq_disable(); 1191 1192 cycle_time = card->driver->read_csr(card, CSR_CYCLE_TIME); 1193 1194 switch (a->clk_id) { 1195 case CLOCK_REALTIME: getnstimeofday(&ts); break; 1196 case CLOCK_MONOTONIC: do_posix_clock_monotonic_gettime(&ts); break; 1197 case CLOCK_MONOTONIC_RAW: getrawmonotonic(&ts); break; 1198 default: 1199 ret = -EINVAL; 1200 } 1201 1202 local_irq_enable(); 1203 1204 a->tv_sec = ts.tv_sec; 1205 a->tv_nsec = ts.tv_nsec; 1206 a->cycle_timer = cycle_time; 1207 1208 return ret; 1209 } 1210 1211 static int ioctl_get_cycle_timer(struct client *client, union ioctl_arg *arg) 1212 { 1213 struct fw_cdev_get_cycle_timer *a = &arg->get_cycle_timer; 1214 struct fw_cdev_get_cycle_timer2 ct2; 1215 1216 ct2.clk_id = CLOCK_REALTIME; 1217 ioctl_get_cycle_timer2(client, (union ioctl_arg *)&ct2); 1218 1219 a->local_time = ct2.tv_sec * USEC_PER_SEC + ct2.tv_nsec / NSEC_PER_USEC; 1220 a->cycle_timer = ct2.cycle_timer; 1221 1222 return 0; 1223 } 1224 1225 static void iso_resource_work(struct work_struct *work) 1226 { 1227 struct iso_resource_event *e; 1228 struct iso_resource *r = 1229 container_of(work, struct iso_resource, work.work); 1230 struct client *client = r->client; 1231 int generation, channel, bandwidth, todo; 1232 bool skip, free, success; 1233 1234 spin_lock_irq(&client->lock); 1235 generation = client->device->generation; 1236 todo = r->todo; 1237 /* Allow 1000ms grace period for other reallocations. */ 1238 if (todo == ISO_RES_ALLOC && 1239 time_before64(get_jiffies_64(), 1240 client->device->card->reset_jiffies + HZ)) { 1241 schedule_iso_resource(r, DIV_ROUND_UP(HZ, 3)); 1242 skip = true; 1243 } else { 1244 /* We could be called twice within the same generation. */ 1245 skip = todo == ISO_RES_REALLOC && 1246 r->generation == generation; 1247 } 1248 free = todo == ISO_RES_DEALLOC || 1249 todo == ISO_RES_ALLOC_ONCE || 1250 todo == ISO_RES_DEALLOC_ONCE; 1251 r->generation = generation; 1252 spin_unlock_irq(&client->lock); 1253 1254 if (skip) 1255 goto out; 1256 1257 bandwidth = r->bandwidth; 1258 1259 fw_iso_resource_manage(client->device->card, generation, 1260 r->channels, &channel, &bandwidth, 1261 todo == ISO_RES_ALLOC || 1262 todo == ISO_RES_REALLOC || 1263 todo == ISO_RES_ALLOC_ONCE); 1264 /* 1265 * Is this generation outdated already? As long as this resource sticks 1266 * in the idr, it will be scheduled again for a newer generation or at 1267 * shutdown. 1268 */ 1269 if (channel == -EAGAIN && 1270 (todo == ISO_RES_ALLOC || todo == ISO_RES_REALLOC)) 1271 goto out; 1272 1273 success = channel >= 0 || bandwidth > 0; 1274 1275 spin_lock_irq(&client->lock); 1276 /* 1277 * Transit from allocation to reallocation, except if the client 1278 * requested deallocation in the meantime. 1279 */ 1280 if (r->todo == ISO_RES_ALLOC) 1281 r->todo = ISO_RES_REALLOC; 1282 /* 1283 * Allocation or reallocation failure? Pull this resource out of the 1284 * idr and prepare for deletion, unless the client is shutting down. 1285 */ 1286 if (r->todo == ISO_RES_REALLOC && !success && 1287 !client->in_shutdown && 1288 idr_find(&client->resource_idr, r->resource.handle)) { 1289 idr_remove(&client->resource_idr, r->resource.handle); 1290 client_put(client); 1291 free = true; 1292 } 1293 spin_unlock_irq(&client->lock); 1294 1295 if (todo == ISO_RES_ALLOC && channel >= 0) 1296 r->channels = 1ULL << channel; 1297 1298 if (todo == ISO_RES_REALLOC && success) 1299 goto out; 1300 1301 if (todo == ISO_RES_ALLOC || todo == ISO_RES_ALLOC_ONCE) { 1302 e = r->e_alloc; 1303 r->e_alloc = NULL; 1304 } else { 1305 e = r->e_dealloc; 1306 r->e_dealloc = NULL; 1307 } 1308 e->iso_resource.handle = r->resource.handle; 1309 e->iso_resource.channel = channel; 1310 e->iso_resource.bandwidth = bandwidth; 1311 1312 queue_event(client, &e->event, 1313 &e->iso_resource, sizeof(e->iso_resource), NULL, 0); 1314 1315 if (free) { 1316 cancel_delayed_work(&r->work); 1317 kfree(r->e_alloc); 1318 kfree(r->e_dealloc); 1319 kfree(r); 1320 } 1321 out: 1322 client_put(client); 1323 } 1324 1325 static void release_iso_resource(struct client *client, 1326 struct client_resource *resource) 1327 { 1328 struct iso_resource *r = 1329 container_of(resource, struct iso_resource, resource); 1330 1331 spin_lock_irq(&client->lock); 1332 r->todo = ISO_RES_DEALLOC; 1333 schedule_iso_resource(r, 0); 1334 spin_unlock_irq(&client->lock); 1335 } 1336 1337 static int init_iso_resource(struct client *client, 1338 struct fw_cdev_allocate_iso_resource *request, int todo) 1339 { 1340 struct iso_resource_event *e1, *e2; 1341 struct iso_resource *r; 1342 int ret; 1343 1344 if ((request->channels == 0 && request->bandwidth == 0) || 1345 request->bandwidth > BANDWIDTH_AVAILABLE_INITIAL || 1346 request->bandwidth < 0) 1347 return -EINVAL; 1348 1349 r = kmalloc(sizeof(*r), GFP_KERNEL); 1350 e1 = kmalloc(sizeof(*e1), GFP_KERNEL); 1351 e2 = kmalloc(sizeof(*e2), GFP_KERNEL); 1352 if (r == NULL || e1 == NULL || e2 == NULL) { 1353 ret = -ENOMEM; 1354 goto fail; 1355 } 1356 1357 INIT_DELAYED_WORK(&r->work, iso_resource_work); 1358 r->client = client; 1359 r->todo = todo; 1360 r->generation = -1; 1361 r->channels = request->channels; 1362 r->bandwidth = request->bandwidth; 1363 r->e_alloc = e1; 1364 r->e_dealloc = e2; 1365 1366 e1->iso_resource.closure = request->closure; 1367 e1->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED; 1368 e2->iso_resource.closure = request->closure; 1369 e2->iso_resource.type = FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED; 1370 1371 if (todo == ISO_RES_ALLOC) { 1372 r->resource.release = release_iso_resource; 1373 ret = add_client_resource(client, &r->resource, GFP_KERNEL); 1374 if (ret < 0) 1375 goto fail; 1376 } else { 1377 r->resource.release = NULL; 1378 r->resource.handle = -1; 1379 schedule_iso_resource(r, 0); 1380 } 1381 request->handle = r->resource.handle; 1382 1383 return 0; 1384 fail: 1385 kfree(r); 1386 kfree(e1); 1387 kfree(e2); 1388 1389 return ret; 1390 } 1391 1392 static int ioctl_allocate_iso_resource(struct client *client, 1393 union ioctl_arg *arg) 1394 { 1395 return init_iso_resource(client, 1396 &arg->allocate_iso_resource, ISO_RES_ALLOC); 1397 } 1398 1399 static int ioctl_deallocate_iso_resource(struct client *client, 1400 union ioctl_arg *arg) 1401 { 1402 return release_client_resource(client, 1403 arg->deallocate.handle, release_iso_resource, NULL); 1404 } 1405 1406 static int ioctl_allocate_iso_resource_once(struct client *client, 1407 union ioctl_arg *arg) 1408 { 1409 return init_iso_resource(client, 1410 &arg->allocate_iso_resource, ISO_RES_ALLOC_ONCE); 1411 } 1412 1413 static int ioctl_deallocate_iso_resource_once(struct client *client, 1414 union ioctl_arg *arg) 1415 { 1416 return init_iso_resource(client, 1417 &arg->allocate_iso_resource, ISO_RES_DEALLOC_ONCE); 1418 } 1419 1420 /* 1421 * Returns a speed code: Maximum speed to or from this device, 1422 * limited by the device's link speed, the local node's link speed, 1423 * and all PHY port speeds between the two links. 1424 */ 1425 static int ioctl_get_speed(struct client *client, union ioctl_arg *arg) 1426 { 1427 return client->device->max_speed; 1428 } 1429 1430 static int ioctl_send_broadcast_request(struct client *client, 1431 union ioctl_arg *arg) 1432 { 1433 struct fw_cdev_send_request *a = &arg->send_request; 1434 1435 switch (a->tcode) { 1436 case TCODE_WRITE_QUADLET_REQUEST: 1437 case TCODE_WRITE_BLOCK_REQUEST: 1438 break; 1439 default: 1440 return -EINVAL; 1441 } 1442 1443 /* Security policy: Only allow accesses to Units Space. */ 1444 if (a->offset < CSR_REGISTER_BASE + CSR_CONFIG_ROM_END) 1445 return -EACCES; 1446 1447 return init_request(client, a, LOCAL_BUS | 0x3f, SCODE_100); 1448 } 1449 1450 static int ioctl_send_stream_packet(struct client *client, union ioctl_arg *arg) 1451 { 1452 struct fw_cdev_send_stream_packet *a = &arg->send_stream_packet; 1453 struct fw_cdev_send_request request; 1454 int dest; 1455 1456 if (a->speed > client->device->card->link_speed || 1457 a->length > 1024 << a->speed) 1458 return -EIO; 1459 1460 if (a->tag > 3 || a->channel > 63 || a->sy > 15) 1461 return -EINVAL; 1462 1463 dest = fw_stream_packet_destination_id(a->tag, a->channel, a->sy); 1464 request.tcode = TCODE_STREAM_DATA; 1465 request.length = a->length; 1466 request.closure = a->closure; 1467 request.data = a->data; 1468 request.generation = a->generation; 1469 1470 return init_request(client, &request, dest, a->speed); 1471 } 1472 1473 static void outbound_phy_packet_callback(struct fw_packet *packet, 1474 struct fw_card *card, int status) 1475 { 1476 struct outbound_phy_packet_event *e = 1477 container_of(packet, struct outbound_phy_packet_event, p); 1478 1479 switch (status) { 1480 /* expected: */ 1481 case ACK_COMPLETE: e->phy_packet.rcode = RCODE_COMPLETE; break; 1482 /* should never happen with PHY packets: */ 1483 case ACK_PENDING: e->phy_packet.rcode = RCODE_COMPLETE; break; 1484 case ACK_BUSY_X: 1485 case ACK_BUSY_A: 1486 case ACK_BUSY_B: e->phy_packet.rcode = RCODE_BUSY; break; 1487 case ACK_DATA_ERROR: e->phy_packet.rcode = RCODE_DATA_ERROR; break; 1488 case ACK_TYPE_ERROR: e->phy_packet.rcode = RCODE_TYPE_ERROR; break; 1489 /* stale generation; cancelled; on certain controllers: no ack */ 1490 default: e->phy_packet.rcode = status; break; 1491 } 1492 e->phy_packet.data[0] = packet->timestamp; 1493 1494 queue_event(e->client, &e->event, &e->phy_packet, 1495 sizeof(e->phy_packet) + e->phy_packet.length, NULL, 0); 1496 client_put(e->client); 1497 } 1498 1499 static int ioctl_send_phy_packet(struct client *client, union ioctl_arg *arg) 1500 { 1501 struct fw_cdev_send_phy_packet *a = &arg->send_phy_packet; 1502 struct fw_card *card = client->device->card; 1503 struct outbound_phy_packet_event *e; 1504 1505 /* Access policy: Allow this ioctl only on local nodes' device files. */ 1506 if (!client->device->is_local) 1507 return -ENOSYS; 1508 1509 e = kzalloc(sizeof(*e) + 4, GFP_KERNEL); 1510 if (e == NULL) 1511 return -ENOMEM; 1512 1513 client_get(client); 1514 e->client = client; 1515 e->p.speed = SCODE_100; 1516 e->p.generation = a->generation; 1517 e->p.header[0] = TCODE_LINK_INTERNAL << 4; 1518 e->p.header[1] = a->data[0]; 1519 e->p.header[2] = a->data[1]; 1520 e->p.header_length = 12; 1521 e->p.callback = outbound_phy_packet_callback; 1522 e->phy_packet.closure = a->closure; 1523 e->phy_packet.type = FW_CDEV_EVENT_PHY_PACKET_SENT; 1524 if (is_ping_packet(a->data)) 1525 e->phy_packet.length = 4; 1526 1527 card->driver->send_request(card, &e->p); 1528 1529 return 0; 1530 } 1531 1532 static int ioctl_receive_phy_packets(struct client *client, union ioctl_arg *arg) 1533 { 1534 struct fw_cdev_receive_phy_packets *a = &arg->receive_phy_packets; 1535 struct fw_card *card = client->device->card; 1536 1537 /* Access policy: Allow this ioctl only on local nodes' device files. */ 1538 if (!client->device->is_local) 1539 return -ENOSYS; 1540 1541 spin_lock_irq(&card->lock); 1542 1543 list_move_tail(&client->phy_receiver_link, &card->phy_receiver_list); 1544 client->phy_receiver_closure = a->closure; 1545 1546 spin_unlock_irq(&card->lock); 1547 1548 return 0; 1549 } 1550 1551 void fw_cdev_handle_phy_packet(struct fw_card *card, struct fw_packet *p) 1552 { 1553 struct client *client; 1554 struct inbound_phy_packet_event *e; 1555 unsigned long flags; 1556 1557 spin_lock_irqsave(&card->lock, flags); 1558 1559 list_for_each_entry(client, &card->phy_receiver_list, phy_receiver_link) { 1560 e = kmalloc(sizeof(*e) + 8, GFP_ATOMIC); 1561 if (e == NULL) { 1562 fw_notice(card, "out of memory when allocating event\n"); 1563 break; 1564 } 1565 e->phy_packet.closure = client->phy_receiver_closure; 1566 e->phy_packet.type = FW_CDEV_EVENT_PHY_PACKET_RECEIVED; 1567 e->phy_packet.rcode = RCODE_COMPLETE; 1568 e->phy_packet.length = 8; 1569 e->phy_packet.data[0] = p->header[1]; 1570 e->phy_packet.data[1] = p->header[2]; 1571 queue_event(client, &e->event, 1572 &e->phy_packet, sizeof(e->phy_packet) + 8, NULL, 0); 1573 } 1574 1575 spin_unlock_irqrestore(&card->lock, flags); 1576 } 1577 1578 static int (* const ioctl_handlers[])(struct client *, union ioctl_arg *) = { 1579 [0x00] = ioctl_get_info, 1580 [0x01] = ioctl_send_request, 1581 [0x02] = ioctl_allocate, 1582 [0x03] = ioctl_deallocate, 1583 [0x04] = ioctl_send_response, 1584 [0x05] = ioctl_initiate_bus_reset, 1585 [0x06] = ioctl_add_descriptor, 1586 [0x07] = ioctl_remove_descriptor, 1587 [0x08] = ioctl_create_iso_context, 1588 [0x09] = ioctl_queue_iso, 1589 [0x0a] = ioctl_start_iso, 1590 [0x0b] = ioctl_stop_iso, 1591 [0x0c] = ioctl_get_cycle_timer, 1592 [0x0d] = ioctl_allocate_iso_resource, 1593 [0x0e] = ioctl_deallocate_iso_resource, 1594 [0x0f] = ioctl_allocate_iso_resource_once, 1595 [0x10] = ioctl_deallocate_iso_resource_once, 1596 [0x11] = ioctl_get_speed, 1597 [0x12] = ioctl_send_broadcast_request, 1598 [0x13] = ioctl_send_stream_packet, 1599 [0x14] = ioctl_get_cycle_timer2, 1600 [0x15] = ioctl_send_phy_packet, 1601 [0x16] = ioctl_receive_phy_packets, 1602 [0x17] = ioctl_set_iso_channels, 1603 [0x18] = ioctl_flush_iso, 1604 }; 1605 1606 static int dispatch_ioctl(struct client *client, 1607 unsigned int cmd, void __user *arg) 1608 { 1609 union ioctl_arg buffer; 1610 int ret; 1611 1612 if (fw_device_is_shutdown(client->device)) 1613 return -ENODEV; 1614 1615 if (_IOC_TYPE(cmd) != '#' || 1616 _IOC_NR(cmd) >= ARRAY_SIZE(ioctl_handlers) || 1617 _IOC_SIZE(cmd) > sizeof(buffer)) 1618 return -ENOTTY; 1619 1620 if (_IOC_DIR(cmd) == _IOC_READ) 1621 memset(&buffer, 0, _IOC_SIZE(cmd)); 1622 1623 if (_IOC_DIR(cmd) & _IOC_WRITE) 1624 if (copy_from_user(&buffer, arg, _IOC_SIZE(cmd))) 1625 return -EFAULT; 1626 1627 ret = ioctl_handlers[_IOC_NR(cmd)](client, &buffer); 1628 if (ret < 0) 1629 return ret; 1630 1631 if (_IOC_DIR(cmd) & _IOC_READ) 1632 if (copy_to_user(arg, &buffer, _IOC_SIZE(cmd))) 1633 return -EFAULT; 1634 1635 return ret; 1636 } 1637 1638 static long fw_device_op_ioctl(struct file *file, 1639 unsigned int cmd, unsigned long arg) 1640 { 1641 return dispatch_ioctl(file->private_data, cmd, (void __user *)arg); 1642 } 1643 1644 #ifdef CONFIG_COMPAT 1645 static long fw_device_op_compat_ioctl(struct file *file, 1646 unsigned int cmd, unsigned long arg) 1647 { 1648 return dispatch_ioctl(file->private_data, cmd, compat_ptr(arg)); 1649 } 1650 #endif 1651 1652 static int fw_device_op_mmap(struct file *file, struct vm_area_struct *vma) 1653 { 1654 struct client *client = file->private_data; 1655 enum dma_data_direction direction; 1656 unsigned long size; 1657 int page_count, ret; 1658 1659 if (fw_device_is_shutdown(client->device)) 1660 return -ENODEV; 1661 1662 /* FIXME: We could support multiple buffers, but we don't. */ 1663 if (client->buffer.pages != NULL) 1664 return -EBUSY; 1665 1666 if (!(vma->vm_flags & VM_SHARED)) 1667 return -EINVAL; 1668 1669 if (vma->vm_start & ~PAGE_MASK) 1670 return -EINVAL; 1671 1672 client->vm_start = vma->vm_start; 1673 size = vma->vm_end - vma->vm_start; 1674 page_count = size >> PAGE_SHIFT; 1675 if (size & ~PAGE_MASK) 1676 return -EINVAL; 1677 1678 if (vma->vm_flags & VM_WRITE) 1679 direction = DMA_TO_DEVICE; 1680 else 1681 direction = DMA_FROM_DEVICE; 1682 1683 ret = fw_iso_buffer_init(&client->buffer, client->device->card, 1684 page_count, direction); 1685 if (ret < 0) 1686 return ret; 1687 1688 ret = fw_iso_buffer_map(&client->buffer, vma); 1689 if (ret < 0) 1690 fw_iso_buffer_destroy(&client->buffer, client->device->card); 1691 1692 return ret; 1693 } 1694 1695 static int is_outbound_transaction_resource(int id, void *p, void *data) 1696 { 1697 struct client_resource *resource = p; 1698 1699 return resource->release == release_transaction; 1700 } 1701 1702 static int has_outbound_transactions(struct client *client) 1703 { 1704 int ret; 1705 1706 spin_lock_irq(&client->lock); 1707 ret = idr_for_each(&client->resource_idr, 1708 is_outbound_transaction_resource, NULL); 1709 spin_unlock_irq(&client->lock); 1710 1711 return ret; 1712 } 1713 1714 static int shutdown_resource(int id, void *p, void *data) 1715 { 1716 struct client_resource *resource = p; 1717 struct client *client = data; 1718 1719 resource->release(client, resource); 1720 client_put(client); 1721 1722 return 0; 1723 } 1724 1725 static int fw_device_op_release(struct inode *inode, struct file *file) 1726 { 1727 struct client *client = file->private_data; 1728 struct event *event, *next_event; 1729 1730 spin_lock_irq(&client->device->card->lock); 1731 list_del(&client->phy_receiver_link); 1732 spin_unlock_irq(&client->device->card->lock); 1733 1734 mutex_lock(&client->device->client_list_mutex); 1735 list_del(&client->link); 1736 mutex_unlock(&client->device->client_list_mutex); 1737 1738 if (client->iso_context) 1739 fw_iso_context_destroy(client->iso_context); 1740 1741 if (client->buffer.pages) 1742 fw_iso_buffer_destroy(&client->buffer, client->device->card); 1743 1744 /* Freeze client->resource_idr and client->event_list */ 1745 spin_lock_irq(&client->lock); 1746 client->in_shutdown = true; 1747 spin_unlock_irq(&client->lock); 1748 1749 wait_event(client->tx_flush_wait, !has_outbound_transactions(client)); 1750 1751 idr_for_each(&client->resource_idr, shutdown_resource, client); 1752 idr_remove_all(&client->resource_idr); 1753 idr_destroy(&client->resource_idr); 1754 1755 list_for_each_entry_safe(event, next_event, &client->event_list, link) 1756 kfree(event); 1757 1758 client_put(client); 1759 1760 return 0; 1761 } 1762 1763 static unsigned int fw_device_op_poll(struct file *file, poll_table * pt) 1764 { 1765 struct client *client = file->private_data; 1766 unsigned int mask = 0; 1767 1768 poll_wait(file, &client->wait, pt); 1769 1770 if (fw_device_is_shutdown(client->device)) 1771 mask |= POLLHUP | POLLERR; 1772 if (!list_empty(&client->event_list)) 1773 mask |= POLLIN | POLLRDNORM; 1774 1775 return mask; 1776 } 1777 1778 const struct file_operations fw_device_ops = { 1779 .owner = THIS_MODULE, 1780 .llseek = no_llseek, 1781 .open = fw_device_op_open, 1782 .read = fw_device_op_read, 1783 .unlocked_ioctl = fw_device_op_ioctl, 1784 .mmap = fw_device_op_mmap, 1785 .release = fw_device_op_release, 1786 .poll = fw_device_op_poll, 1787 #ifdef CONFIG_COMPAT 1788 .compat_ioctl = fw_device_op_compat_ioctl, 1789 #endif 1790 }; 1791