2 * Char device for device raw access
4 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include <linux/compat.h>
22 #include <linux/delay.h>
23 #include <linux/device.h>
24 #include <linux/errno.h>
25 #include <linux/firewire-cdev.h>
26 #include <linux/idr.h>
27 #include <linux/jiffies.h>
28 #include <linux/kernel.h>
29 #include <linux/kref.h>
31 #include <linux/module.h>
32 #include <linux/mutex.h>
33 #include <linux/poll.h>
34 #include <linux/preempt.h>
35 #include <linux/spinlock.h>
36 #include <linux/time.h>
37 #include <linux/vmalloc.h>
38 #include <linux/wait.h>
39 #include <linux/workqueue.h>
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
44 #include "fw-device.h"
45 #include "fw-topology.h"
46 #include "fw-transaction.h"
50 struct fw_device
*device
;
54 struct idr resource_idr
;
55 struct list_head event_list
;
56 wait_queue_head_t wait
;
57 u64 bus_reset_closure
;
59 struct fw_iso_context
*iso_context
;
61 struct fw_iso_buffer buffer
;
62 unsigned long vm_start
;
64 struct list_head link
;
68 static inline void client_get(struct client
*client
)
70 kref_get(&client
->kref
);
73 static void client_release(struct kref
*kref
)
75 struct client
*client
= container_of(kref
, struct client
, kref
);
77 fw_device_put(client
->device
);
81 static void client_put(struct client
*client
)
83 kref_put(&client
->kref
, client_release
);
86 struct client_resource
;
87 typedef void (*client_resource_release_fn_t
)(struct client
*,
88 struct client_resource
*);
89 struct client_resource
{
90 client_resource_release_fn_t release
;
94 struct address_handler_resource
{
95 struct client_resource resource
;
96 struct fw_address_handler handler
;
98 struct client
*client
;
101 struct outbound_transaction_resource
{
102 struct client_resource resource
;
103 struct fw_transaction transaction
;
106 struct inbound_transaction_resource
{
107 struct client_resource resource
;
108 struct fw_request
*request
;
113 struct descriptor_resource
{
114 struct client_resource resource
;
115 struct fw_descriptor descriptor
;
119 struct iso_resource
{
120 struct client_resource resource
;
121 struct client
*client
;
122 /* Schedule work and access todo only with client->lock held. */
123 struct delayed_work work
;
124 enum {ISO_RES_ALLOC
, ISO_RES_REALLOC
, ISO_RES_DEALLOC
,
125 ISO_RES_ALLOC_ONCE
, ISO_RES_DEALLOC_ONCE
,} todo
;
129 struct iso_resource_event
*e_alloc
, *e_dealloc
;
132 static void schedule_iso_resource(struct iso_resource
*);
133 static void release_iso_resource(struct client
*, struct client_resource
*);
136 * dequeue_event() just kfree()'s the event, so the event has to be
137 * the first field in a struct XYZ_event.
140 struct { void *data
; size_t size
; } v
[2];
141 struct list_head link
;
144 struct bus_reset_event
{
146 struct fw_cdev_event_bus_reset reset
;
149 struct outbound_transaction_event
{
151 struct client
*client
;
152 struct outbound_transaction_resource r
;
153 struct fw_cdev_event_response response
;
156 struct inbound_transaction_event
{
158 struct fw_cdev_event_request request
;
161 struct iso_interrupt_event
{
163 struct fw_cdev_event_iso_interrupt interrupt
;
166 struct iso_resource_event
{
168 struct fw_cdev_event_iso_resource resource
;
171 static inline void __user
*u64_to_uptr(__u64 value
)
173 return (void __user
*)(unsigned long)value
;
176 static inline __u64
uptr_to_u64(void __user
*ptr
)
178 return (__u64
)(unsigned long)ptr
;
181 static int fw_device_op_open(struct inode
*inode
, struct file
*file
)
183 struct fw_device
*device
;
184 struct client
*client
;
186 device
= fw_device_get_by_devt(inode
->i_rdev
);
190 if (fw_device_is_shutdown(device
)) {
191 fw_device_put(device
);
195 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
196 if (client
== NULL
) {
197 fw_device_put(device
);
201 client
->device
= device
;
202 spin_lock_init(&client
->lock
);
203 idr_init(&client
->resource_idr
);
204 INIT_LIST_HEAD(&client
->event_list
);
205 init_waitqueue_head(&client
->wait
);
206 kref_init(&client
->kref
);
208 file
->private_data
= client
;
210 mutex_lock(&device
->client_list_mutex
);
211 list_add_tail(&client
->link
, &device
->client_list
);
212 mutex_unlock(&device
->client_list_mutex
);
217 static void queue_event(struct client
*client
, struct event
*event
,
218 void *data0
, size_t size0
, void *data1
, size_t size1
)
222 event
->v
[0].data
= data0
;
223 event
->v
[0].size
= size0
;
224 event
->v
[1].data
= data1
;
225 event
->v
[1].size
= size1
;
227 spin_lock_irqsave(&client
->lock
, flags
);
228 if (client
->in_shutdown
)
231 list_add_tail(&event
->link
, &client
->event_list
);
232 spin_unlock_irqrestore(&client
->lock
, flags
);
234 wake_up_interruptible(&client
->wait
);
237 static int dequeue_event(struct client
*client
,
238 char __user
*buffer
, size_t count
)
244 ret
= wait_event_interruptible(client
->wait
,
245 !list_empty(&client
->event_list
) ||
246 fw_device_is_shutdown(client
->device
));
250 if (list_empty(&client
->event_list
) &&
251 fw_device_is_shutdown(client
->device
))
254 spin_lock_irq(&client
->lock
);
255 event
= list_first_entry(&client
->event_list
, struct event
, link
);
256 list_del(&event
->link
);
257 spin_unlock_irq(&client
->lock
);
260 for (i
= 0; i
< ARRAY_SIZE(event
->v
) && total
< count
; i
++) {
261 size
= min(event
->v
[i
].size
, count
- total
);
262 if (copy_to_user(buffer
+ total
, event
->v
[i
].data
, size
)) {
276 static ssize_t
fw_device_op_read(struct file
*file
, char __user
*buffer
,
277 size_t count
, loff_t
*offset
)
279 struct client
*client
= file
->private_data
;
281 return dequeue_event(client
, buffer
, count
);
284 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset
*event
,
285 struct client
*client
)
287 struct fw_card
*card
= client
->device
->card
;
289 spin_lock_irq(&card
->lock
);
291 event
->closure
= client
->bus_reset_closure
;
292 event
->type
= FW_CDEV_EVENT_BUS_RESET
;
293 event
->generation
= client
->device
->generation
;
294 event
->node_id
= client
->device
->node_id
;
295 event
->local_node_id
= card
->local_node
->node_id
;
296 event
->bm_node_id
= 0; /* FIXME: We don't track the BM. */
297 event
->irm_node_id
= card
->irm_node
->node_id
;
298 event
->root_node_id
= card
->root_node
->node_id
;
300 spin_unlock_irq(&card
->lock
);
303 static void for_each_client(struct fw_device
*device
,
304 void (*callback
)(struct client
*client
))
308 mutex_lock(&device
->client_list_mutex
);
309 list_for_each_entry(c
, &device
->client_list
, link
)
311 mutex_unlock(&device
->client_list_mutex
);
314 static int schedule_reallocations(int id
, void *p
, void *data
)
316 struct client_resource
*r
= p
;
318 if (r
->release
== release_iso_resource
)
319 schedule_iso_resource(container_of(r
,
320 struct iso_resource
, resource
));
324 static void queue_bus_reset_event(struct client
*client
)
326 struct bus_reset_event
*e
;
328 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
330 fw_notify("Out of memory when allocating bus reset event\n");
334 fill_bus_reset_event(&e
->reset
, client
);
336 queue_event(client
, &e
->event
,
337 &e
->reset
, sizeof(e
->reset
), NULL
, 0);
339 spin_lock_irq(&client
->lock
);
340 idr_for_each(&client
->resource_idr
, schedule_reallocations
, client
);
341 spin_unlock_irq(&client
->lock
);
344 void fw_device_cdev_update(struct fw_device
*device
)
346 for_each_client(device
, queue_bus_reset_event
);
349 static void wake_up_client(struct client
*client
)
351 wake_up_interruptible(&client
->wait
);
354 void fw_device_cdev_remove(struct fw_device
*device
)
356 for_each_client(device
, wake_up_client
);
359 static int ioctl_get_info(struct client
*client
, void *buffer
)
361 struct fw_cdev_get_info
*get_info
= buffer
;
362 struct fw_cdev_event_bus_reset bus_reset
;
363 unsigned long ret
= 0;
365 client
->version
= get_info
->version
;
366 get_info
->version
= FW_CDEV_VERSION
;
367 get_info
->card
= client
->device
->card
->index
;
369 down_read(&fw_device_rwsem
);
371 if (get_info
->rom
!= 0) {
372 void __user
*uptr
= u64_to_uptr(get_info
->rom
);
373 size_t want
= get_info
->rom_length
;
374 size_t have
= client
->device
->config_rom_length
* 4;
376 ret
= copy_to_user(uptr
, client
->device
->config_rom
,
379 get_info
->rom_length
= client
->device
->config_rom_length
* 4;
381 up_read(&fw_device_rwsem
);
386 client
->bus_reset_closure
= get_info
->bus_reset_closure
;
387 if (get_info
->bus_reset
!= 0) {
388 void __user
*uptr
= u64_to_uptr(get_info
->bus_reset
);
390 fill_bus_reset_event(&bus_reset
, client
);
391 if (copy_to_user(uptr
, &bus_reset
, sizeof(bus_reset
)))
398 static int add_client_resource(struct client
*client
,
399 struct client_resource
*resource
, gfp_t gfp_mask
)
405 if (idr_pre_get(&client
->resource_idr
, gfp_mask
) == 0)
408 spin_lock_irqsave(&client
->lock
, flags
);
409 if (client
->in_shutdown
)
412 ret
= idr_get_new(&client
->resource_idr
, resource
,
416 if (resource
->release
== release_iso_resource
)
417 schedule_iso_resource(container_of(resource
,
418 struct iso_resource
, resource
));
420 spin_unlock_irqrestore(&client
->lock
, flags
);
425 return ret
< 0 ? ret
: 0;
428 static int release_client_resource(struct client
*client
, u32 handle
,
429 client_resource_release_fn_t release
,
430 struct client_resource
**resource
)
432 struct client_resource
*r
;
434 spin_lock_irq(&client
->lock
);
435 if (client
->in_shutdown
)
438 r
= idr_find(&client
->resource_idr
, handle
);
439 if (r
&& r
->release
== release
)
440 idr_remove(&client
->resource_idr
, handle
);
441 spin_unlock_irq(&client
->lock
);
443 if (!(r
&& r
->release
== release
))
449 r
->release(client
, r
);
456 static void release_transaction(struct client
*client
,
457 struct client_resource
*resource
)
459 struct outbound_transaction_resource
*r
= container_of(resource
,
460 struct outbound_transaction_resource
, resource
);
462 fw_cancel_transaction(client
->device
->card
, &r
->transaction
);
465 static void complete_transaction(struct fw_card
*card
, int rcode
,
466 void *payload
, size_t length
, void *data
)
468 struct outbound_transaction_event
*e
= data
;
469 struct fw_cdev_event_response
*rsp
= &e
->response
;
470 struct client
*client
= e
->client
;
473 if (length
< rsp
->length
)
474 rsp
->length
= length
;
475 if (rcode
== RCODE_COMPLETE
)
476 memcpy(rsp
->data
, payload
, rsp
->length
);
478 spin_lock_irqsave(&client
->lock
, flags
);
480 * 1. If called while in shutdown, the idr tree must be left untouched.
481 * The idr handle will be removed and the client reference will be
483 * 2. If the call chain was release_client_resource ->
484 * release_transaction -> complete_transaction (instead of a normal
485 * conclusion of the transaction), i.e. if this resource was already
486 * unregistered from the idr, the client reference will be dropped
487 * by release_client_resource and we must not drop it here.
489 if (!client
->in_shutdown
&&
490 idr_find(&client
->resource_idr
, e
->r
.resource
.handle
)) {
491 idr_remove(&client
->resource_idr
, e
->r
.resource
.handle
);
492 /* Drop the idr's reference */
495 spin_unlock_irqrestore(&client
->lock
, flags
);
497 rsp
->type
= FW_CDEV_EVENT_RESPONSE
;
501 * In the case that sizeof(*rsp) doesn't align with the position of the
502 * data, and the read is short, preserve an extra copy of the data
503 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless
504 * for short reads and some apps depended on it, this is both safe
505 * and prudent for compatibility.
507 if (rsp
->length
<= sizeof(*rsp
) - offsetof(typeof(*rsp
), data
))
508 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
),
509 rsp
->data
, rsp
->length
);
511 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
) + rsp
->length
,
514 /* Drop the transaction callback's reference */
518 static int init_request(struct client
*client
,
519 struct fw_cdev_send_request
*request
,
520 int destination_id
, int speed
)
522 struct outbound_transaction_event
*e
;
525 if (request
->length
> 4096 || request
->length
> 512 << speed
)
528 e
= kmalloc(sizeof(*e
) + request
->length
, GFP_KERNEL
);
533 e
->response
.length
= request
->length
;
534 e
->response
.closure
= request
->closure
;
537 copy_from_user(e
->response
.data
,
538 u64_to_uptr(request
->data
), request
->length
)) {
543 e
->r
.resource
.release
= release_transaction
;
544 ret
= add_client_resource(client
, &e
->r
.resource
, GFP_KERNEL
);
548 /* Get a reference for the transaction callback */
551 fw_send_request(client
->device
->card
, &e
->r
.transaction
,
552 request
->tcode
& 0x1f, destination_id
,
553 request
->generation
, speed
, request
->offset
,
554 e
->response
.data
, request
->length
,
555 complete_transaction
, e
);
558 return sizeof(request
) + request
->length
;
560 return sizeof(request
);
567 static int ioctl_send_request(struct client
*client
, void *buffer
)
569 struct fw_cdev_send_request
*request
= buffer
;
571 switch (request
->tcode
) {
572 case TCODE_WRITE_QUADLET_REQUEST
:
573 case TCODE_WRITE_BLOCK_REQUEST
:
574 case TCODE_READ_QUADLET_REQUEST
:
575 case TCODE_READ_BLOCK_REQUEST
:
576 case TCODE_LOCK_MASK_SWAP
:
577 case TCODE_LOCK_COMPARE_SWAP
:
578 case TCODE_LOCK_FETCH_ADD
:
579 case TCODE_LOCK_LITTLE_ADD
:
580 case TCODE_LOCK_BOUNDED_ADD
:
581 case TCODE_LOCK_WRAP_ADD
:
582 case TCODE_LOCK_VENDOR_DEPENDENT
:
588 return init_request(client
, request
, client
->device
->node_id
,
589 client
->device
->max_speed
);
592 static void release_request(struct client
*client
,
593 struct client_resource
*resource
)
595 struct inbound_transaction_resource
*r
= container_of(resource
,
596 struct inbound_transaction_resource
, resource
);
598 fw_send_response(client
->device
->card
, r
->request
,
599 RCODE_CONFLICT_ERROR
);
603 static void handle_request(struct fw_card
*card
, struct fw_request
*request
,
604 int tcode
, int destination
, int source
,
605 int generation
, int speed
,
606 unsigned long long offset
,
607 void *payload
, size_t length
, void *callback_data
)
609 struct address_handler_resource
*handler
= callback_data
;
610 struct inbound_transaction_resource
*r
;
611 struct inbound_transaction_event
*e
;
614 r
= kmalloc(sizeof(*r
), GFP_ATOMIC
);
615 e
= kmalloc(sizeof(*e
), GFP_ATOMIC
);
616 if (r
== NULL
|| e
== NULL
)
619 r
->request
= request
;
623 r
->resource
.release
= release_request
;
624 ret
= add_client_resource(handler
->client
, &r
->resource
, GFP_ATOMIC
);
628 e
->request
.type
= FW_CDEV_EVENT_REQUEST
;
629 e
->request
.tcode
= tcode
;
630 e
->request
.offset
= offset
;
631 e
->request
.length
= length
;
632 e
->request
.handle
= r
->resource
.handle
;
633 e
->request
.closure
= handler
->closure
;
635 queue_event(handler
->client
, &e
->event
,
636 &e
->request
, sizeof(e
->request
), payload
, length
);
642 fw_send_response(card
, request
, RCODE_CONFLICT_ERROR
);
645 static void release_address_handler(struct client
*client
,
646 struct client_resource
*resource
)
648 struct address_handler_resource
*r
=
649 container_of(resource
, struct address_handler_resource
, resource
);
651 fw_core_remove_address_handler(&r
->handler
);
655 static int ioctl_allocate(struct client
*client
, void *buffer
)
657 struct fw_cdev_allocate
*request
= buffer
;
658 struct address_handler_resource
*r
;
659 struct fw_address_region region
;
662 r
= kmalloc(sizeof(*r
), GFP_KERNEL
);
666 region
.start
= request
->offset
;
667 region
.end
= request
->offset
+ request
->length
;
668 r
->handler
.length
= request
->length
;
669 r
->handler
.address_callback
= handle_request
;
670 r
->handler
.callback_data
= r
;
671 r
->closure
= request
->closure
;
674 ret
= fw_core_add_address_handler(&r
->handler
, ®ion
);
680 r
->resource
.release
= release_address_handler
;
681 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
683 release_address_handler(client
, &r
->resource
);
686 request
->handle
= r
->resource
.handle
;
691 static int ioctl_deallocate(struct client
*client
, void *buffer
)
693 struct fw_cdev_deallocate
*request
= buffer
;
695 return release_client_resource(client
, request
->handle
,
696 release_address_handler
, NULL
);
699 static int ioctl_send_response(struct client
*client
, void *buffer
)
701 struct fw_cdev_send_response
*request
= buffer
;
702 struct client_resource
*resource
;
703 struct inbound_transaction_resource
*r
;
705 if (release_client_resource(client
, request
->handle
,
706 release_request
, &resource
) < 0)
709 r
= container_of(resource
, struct inbound_transaction_resource
,
711 if (request
->length
< r
->length
)
712 r
->length
= request
->length
;
713 if (copy_from_user(r
->data
, u64_to_uptr(request
->data
), r
->length
))
716 fw_send_response(client
->device
->card
, r
->request
, request
->rcode
);
722 static int ioctl_initiate_bus_reset(struct client
*client
, void *buffer
)
724 struct fw_cdev_initiate_bus_reset
*request
= buffer
;
727 short_reset
= (request
->type
== FW_CDEV_SHORT_RESET
);
729 return fw_core_initiate_bus_reset(client
->device
->card
, short_reset
);
732 static void release_descriptor(struct client
*client
,
733 struct client_resource
*resource
)
735 struct descriptor_resource
*r
=
736 container_of(resource
, struct descriptor_resource
, resource
);
738 fw_core_remove_descriptor(&r
->descriptor
);
742 static int ioctl_add_descriptor(struct client
*client
, void *buffer
)
744 struct fw_cdev_add_descriptor
*request
= buffer
;
745 struct fw_card
*card
= client
->device
->card
;
746 struct descriptor_resource
*r
;
749 /* Access policy: Allow this ioctl only on local nodes' device files. */
750 spin_lock_irq(&card
->lock
);
751 ret
= client
->device
->node_id
!= card
->local_node
->node_id
;
752 spin_unlock_irq(&card
->lock
);
756 if (request
->length
> 256)
759 r
= kmalloc(sizeof(*r
) + request
->length
* 4, GFP_KERNEL
);
763 if (copy_from_user(r
->data
,
764 u64_to_uptr(request
->data
), request
->length
* 4)) {
769 r
->descriptor
.length
= request
->length
;
770 r
->descriptor
.immediate
= request
->immediate
;
771 r
->descriptor
.key
= request
->key
;
772 r
->descriptor
.data
= r
->data
;
774 ret
= fw_core_add_descriptor(&r
->descriptor
);
778 r
->resource
.release
= release_descriptor
;
779 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
781 fw_core_remove_descriptor(&r
->descriptor
);
784 request
->handle
= r
->resource
.handle
;
793 static int ioctl_remove_descriptor(struct client
*client
, void *buffer
)
795 struct fw_cdev_remove_descriptor
*request
= buffer
;
797 return release_client_resource(client
, request
->handle
,
798 release_descriptor
, NULL
);
801 static void iso_callback(struct fw_iso_context
*context
, u32 cycle
,
802 size_t header_length
, void *header
, void *data
)
804 struct client
*client
= data
;
805 struct iso_interrupt_event
*e
;
807 e
= kzalloc(sizeof(*e
) + header_length
, GFP_ATOMIC
);
811 e
->interrupt
.type
= FW_CDEV_EVENT_ISO_INTERRUPT
;
812 e
->interrupt
.closure
= client
->iso_closure
;
813 e
->interrupt
.cycle
= cycle
;
814 e
->interrupt
.header_length
= header_length
;
815 memcpy(e
->interrupt
.header
, header
, header_length
);
816 queue_event(client
, &e
->event
, &e
->interrupt
,
817 sizeof(e
->interrupt
) + header_length
, NULL
, 0);
820 static int ioctl_create_iso_context(struct client
*client
, void *buffer
)
822 struct fw_cdev_create_iso_context
*request
= buffer
;
823 struct fw_iso_context
*context
;
825 /* We only support one context at this time. */
826 if (client
->iso_context
!= NULL
)
829 if (request
->channel
> 63)
832 switch (request
->type
) {
833 case FW_ISO_CONTEXT_RECEIVE
:
834 if (request
->header_size
< 4 || (request
->header_size
& 3))
839 case FW_ISO_CONTEXT_TRANSMIT
:
840 if (request
->speed
> SCODE_3200
)
849 context
= fw_iso_context_create(client
->device
->card
,
853 request
->header_size
,
854 iso_callback
, client
);
856 return PTR_ERR(context
);
858 client
->iso_closure
= request
->closure
;
859 client
->iso_context
= context
;
861 /* We only support one context at this time. */
867 /* Macros for decoding the iso packet control header. */
868 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff)
869 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01)
870 #define GET_SKIP(v) (((v) >> 17) & 0x01)
871 #define GET_TAG(v) (((v) >> 18) & 0x03)
872 #define GET_SY(v) (((v) >> 20) & 0x0f)
873 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff)
875 static int ioctl_queue_iso(struct client
*client
, void *buffer
)
877 struct fw_cdev_queue_iso
*request
= buffer
;
878 struct fw_cdev_iso_packet __user
*p
, *end
, *next
;
879 struct fw_iso_context
*ctx
= client
->iso_context
;
880 unsigned long payload
, buffer_end
, header_length
;
884 struct fw_iso_packet packet
;
888 if (ctx
== NULL
|| request
->handle
!= 0)
892 * If the user passes a non-NULL data pointer, has mmap()'ed
893 * the iso buffer, and the pointer points inside the buffer,
894 * we setup the payload pointers accordingly. Otherwise we
895 * set them both to 0, which will still let packets with
896 * payload_length == 0 through. In other words, if no packets
897 * use the indirect payload, the iso buffer need not be mapped
898 * and the request->data pointer is ignored.
901 payload
= (unsigned long)request
->data
- client
->vm_start
;
902 buffer_end
= client
->buffer
.page_count
<< PAGE_SHIFT
;
903 if (request
->data
== 0 || client
->buffer
.pages
== NULL
||
904 payload
>= buffer_end
) {
909 p
= (struct fw_cdev_iso_packet __user
*)u64_to_uptr(request
->packets
);
911 if (!access_ok(VERIFY_READ
, p
, request
->size
))
914 end
= (void __user
*)p
+ request
->size
;
917 if (get_user(control
, &p
->control
))
919 u
.packet
.payload_length
= GET_PAYLOAD_LENGTH(control
);
920 u
.packet
.interrupt
= GET_INTERRUPT(control
);
921 u
.packet
.skip
= GET_SKIP(control
);
922 u
.packet
.tag
= GET_TAG(control
);
923 u
.packet
.sy
= GET_SY(control
);
924 u
.packet
.header_length
= GET_HEADER_LENGTH(control
);
926 if (ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
) {
927 header_length
= u
.packet
.header_length
;
930 * We require that header_length is a multiple of
931 * the fixed header size, ctx->header_size.
933 if (ctx
->header_size
== 0) {
934 if (u
.packet
.header_length
> 0)
936 } else if (u
.packet
.header_length
% ctx
->header_size
!= 0) {
942 next
= (struct fw_cdev_iso_packet __user
*)
943 &p
->header
[header_length
/ 4];
947 (u
.packet
.header
, p
->header
, header_length
))
949 if (u
.packet
.skip
&& ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
&&
950 u
.packet
.header_length
+ u
.packet
.payload_length
> 0)
952 if (payload
+ u
.packet
.payload_length
> buffer_end
)
955 if (fw_iso_context_queue(ctx
, &u
.packet
,
956 &client
->buffer
, payload
))
960 payload
+= u
.packet
.payload_length
;
964 request
->size
-= uptr_to_u64(p
) - request
->packets
;
965 request
->packets
= uptr_to_u64(p
);
966 request
->data
= client
->vm_start
+ payload
;
971 static int ioctl_start_iso(struct client
*client
, void *buffer
)
973 struct fw_cdev_start_iso
*request
= buffer
;
975 if (client
->iso_context
== NULL
|| request
->handle
!= 0)
978 if (client
->iso_context
->type
== FW_ISO_CONTEXT_RECEIVE
) {
979 if (request
->tags
== 0 || request
->tags
> 15)
982 if (request
->sync
> 15)
986 return fw_iso_context_start(client
->iso_context
, request
->cycle
,
987 request
->sync
, request
->tags
);
990 static int ioctl_stop_iso(struct client
*client
, void *buffer
)
992 struct fw_cdev_stop_iso
*request
= buffer
;
994 if (client
->iso_context
== NULL
|| request
->handle
!= 0)
997 return fw_iso_context_stop(client
->iso_context
);
1000 static int ioctl_get_cycle_timer(struct client
*client
, void *buffer
)
1002 struct fw_cdev_get_cycle_timer
*request
= buffer
;
1003 struct fw_card
*card
= client
->device
->card
;
1004 unsigned long long bus_time
;
1006 unsigned long flags
;
1009 local_irq_save(flags
);
1011 bus_time
= card
->driver
->get_bus_time(card
);
1012 do_gettimeofday(&tv
);
1014 local_irq_restore(flags
);
1017 request
->local_time
= tv
.tv_sec
* 1000000ULL + tv
.tv_usec
;
1018 request
->cycle_timer
= bus_time
& 0xffffffff;
1022 static void iso_resource_work(struct work_struct
*work
)
1024 struct iso_resource_event
*e
;
1025 struct iso_resource
*r
=
1026 container_of(work
, struct iso_resource
, work
.work
);
1027 struct client
*client
= r
->client
;
1028 int generation
, channel
, bandwidth
, todo
;
1029 bool skip
, free
, success
;
1031 spin_lock_irq(&client
->lock
);
1032 generation
= client
->device
->generation
;
1034 /* Allow 1000ms grace period for other reallocations. */
1035 if (todo
== ISO_RES_ALLOC
&&
1036 time_is_after_jiffies(client
->device
->card
->reset_jiffies
+ HZ
)) {
1037 if (schedule_delayed_work(&r
->work
, DIV_ROUND_UP(HZ
, 3)))
1041 /* We could be called twice within the same generation. */
1042 skip
= todo
== ISO_RES_REALLOC
&&
1043 r
->generation
== generation
;
1045 free
= todo
== ISO_RES_DEALLOC
||
1046 todo
== ISO_RES_ALLOC_ONCE
||
1047 todo
== ISO_RES_DEALLOC_ONCE
;
1048 r
->generation
= generation
;
1049 spin_unlock_irq(&client
->lock
);
1054 bandwidth
= r
->bandwidth
;
1056 fw_iso_resource_manage(client
->device
->card
, generation
,
1057 r
->channels
, &channel
, &bandwidth
,
1058 todo
== ISO_RES_ALLOC
||
1059 todo
== ISO_RES_REALLOC
||
1060 todo
== ISO_RES_ALLOC_ONCE
);
1062 * Is this generation outdated already? As long as this resource sticks
1063 * in the idr, it will be scheduled again for a newer generation or at
1066 if (channel
== -EAGAIN
&&
1067 (todo
== ISO_RES_ALLOC
|| todo
== ISO_RES_REALLOC
))
1070 success
= channel
>= 0 || bandwidth
> 0;
1072 spin_lock_irq(&client
->lock
);
1074 * Transit from allocation to reallocation, except if the client
1075 * requested deallocation in the meantime.
1077 if (r
->todo
== ISO_RES_ALLOC
)
1078 r
->todo
= ISO_RES_REALLOC
;
1080 * Allocation or reallocation failure? Pull this resource out of the
1081 * idr and prepare for deletion, unless the client is shutting down.
1083 if (r
->todo
== ISO_RES_REALLOC
&& !success
&&
1084 !client
->in_shutdown
&&
1085 idr_find(&client
->resource_idr
, r
->resource
.handle
)) {
1086 idr_remove(&client
->resource_idr
, r
->resource
.handle
);
1090 spin_unlock_irq(&client
->lock
);
1092 if (todo
== ISO_RES_ALLOC
&& channel
>= 0)
1093 r
->channels
= 1ULL << channel
;
1095 if (todo
== ISO_RES_REALLOC
&& success
)
1098 if (todo
== ISO_RES_ALLOC
|| todo
== ISO_RES_ALLOC_ONCE
) {
1103 r
->e_dealloc
= NULL
;
1105 e
->resource
.handle
= r
->resource
.handle
;
1106 e
->resource
.channel
= channel
;
1107 e
->resource
.bandwidth
= bandwidth
;
1109 queue_event(client
, &e
->event
,
1110 &e
->resource
, sizeof(e
->resource
), NULL
, 0);
1113 cancel_delayed_work(&r
->work
);
1115 kfree(r
->e_dealloc
);
1122 static void schedule_iso_resource(struct iso_resource
*r
)
1124 client_get(r
->client
);
1125 if (!schedule_delayed_work(&r
->work
, 0))
1126 client_put(r
->client
);
1129 static void release_iso_resource(struct client
*client
,
1130 struct client_resource
*resource
)
1132 struct iso_resource
*r
=
1133 container_of(resource
, struct iso_resource
, resource
);
1135 spin_lock_irq(&client
->lock
);
1136 r
->todo
= ISO_RES_DEALLOC
;
1137 schedule_iso_resource(r
);
1138 spin_unlock_irq(&client
->lock
);
1141 static int init_iso_resource(struct client
*client
,
1142 struct fw_cdev_allocate_iso_resource
*request
, int todo
)
1144 struct iso_resource_event
*e1
, *e2
;
1145 struct iso_resource
*r
;
1148 if ((request
->channels
== 0 && request
->bandwidth
== 0) ||
1149 request
->bandwidth
> BANDWIDTH_AVAILABLE_INITIAL
||
1150 request
->bandwidth
< 0)
1153 r
= kmalloc(sizeof(*r
), GFP_KERNEL
);
1154 e1
= kmalloc(sizeof(*e1
), GFP_KERNEL
);
1155 e2
= kmalloc(sizeof(*e2
), GFP_KERNEL
);
1156 if (r
== NULL
|| e1
== NULL
|| e2
== NULL
) {
1161 INIT_DELAYED_WORK(&r
->work
, iso_resource_work
);
1165 r
->channels
= request
->channels
;
1166 r
->bandwidth
= request
->bandwidth
;
1170 e1
->resource
.closure
= request
->closure
;
1171 e1
->resource
.type
= FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED
;
1172 e2
->resource
.closure
= request
->closure
;
1173 e2
->resource
.type
= FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED
;
1175 if (todo
== ISO_RES_ALLOC
) {
1176 r
->resource
.release
= release_iso_resource
;
1177 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
1181 r
->resource
.release
= NULL
;
1182 r
->resource
.handle
= -1;
1183 schedule_iso_resource(r
);
1185 request
->handle
= r
->resource
.handle
;
1196 static int ioctl_allocate_iso_resource(struct client
*client
, void *buffer
)
1198 struct fw_cdev_allocate_iso_resource
*request
= buffer
;
1200 return init_iso_resource(client
, request
, ISO_RES_ALLOC
);
1203 static int ioctl_deallocate_iso_resource(struct client
*client
, void *buffer
)
1205 struct fw_cdev_deallocate
*request
= buffer
;
1207 return release_client_resource(client
, request
->handle
,
1208 release_iso_resource
, NULL
);
1211 static int ioctl_allocate_iso_resource_once(struct client
*client
, void *buffer
)
1213 struct fw_cdev_allocate_iso_resource
*request
= buffer
;
1215 return init_iso_resource(client
, request
, ISO_RES_ALLOC_ONCE
);
1218 static int ioctl_deallocate_iso_resource_once(struct client
*client
, void *buffer
)
1220 struct fw_cdev_allocate_iso_resource
*request
= buffer
;
1222 return init_iso_resource(client
, request
, ISO_RES_DEALLOC_ONCE
);
1226 * Returns a speed code: Maximum speed to or from this device,
1227 * limited by the device's link speed, the local node's link speed,
1228 * and all PHY port speeds between the two links.
1230 static int ioctl_get_speed(struct client
*client
, void *buffer
)
1232 return client
->device
->max_speed
;
1235 static int ioctl_send_broadcast_request(struct client
*client
, void *buffer
)
1237 struct fw_cdev_send_request
*request
= buffer
;
1239 switch (request
->tcode
) {
1240 case TCODE_WRITE_QUADLET_REQUEST
:
1241 case TCODE_WRITE_BLOCK_REQUEST
:
1247 /* Security policy: Only allow accesses to Units Space. */
1248 if (request
->offset
< CSR_REGISTER_BASE
+ CSR_CONFIG_ROM_END
)
1251 return init_request(client
, request
, LOCAL_BUS
| 0x3f, SCODE_100
);
1254 struct stream_packet
{
1255 struct fw_packet packet
;
1259 static void send_stream_packet_done(struct fw_packet
*packet
,
1260 struct fw_card
*card
, int status
)
1262 kfree(container_of(packet
, struct stream_packet
, packet
));
1265 static int ioctl_send_stream_packet(struct client
*client
, void *buffer
)
1267 struct fw_cdev_send_stream_packet
*request
= buffer
;
1268 struct stream_packet
*p
;
1270 p
= kmalloc(sizeof(*p
) + request
->size
, GFP_KERNEL
);
1274 if (request
->data
&&
1275 copy_from_user(p
->data
, u64_to_uptr(request
->data
), request
->size
)) {
1279 fw_send_stream_packet(client
->device
->card
, &p
->packet
,
1280 request
->generation
, request
->speed
,
1281 request
->channel
, request
->sy
, request
->tag
,
1282 p
->data
, request
->size
, send_stream_packet_done
);
1286 static int (* const ioctl_handlers
[])(struct client
*client
, void *buffer
) = {
1291 ioctl_send_response
,
1292 ioctl_initiate_bus_reset
,
1293 ioctl_add_descriptor
,
1294 ioctl_remove_descriptor
,
1295 ioctl_create_iso_context
,
1299 ioctl_get_cycle_timer
,
1300 ioctl_allocate_iso_resource
,
1301 ioctl_deallocate_iso_resource
,
1302 ioctl_allocate_iso_resource_once
,
1303 ioctl_deallocate_iso_resource_once
,
1305 ioctl_send_broadcast_request
,
1306 ioctl_send_stream_packet
,
1309 static int dispatch_ioctl(struct client
*client
,
1310 unsigned int cmd
, void __user
*arg
)
1315 if (_IOC_TYPE(cmd
) != '#' ||
1316 _IOC_NR(cmd
) >= ARRAY_SIZE(ioctl_handlers
))
1319 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
1320 if (_IOC_SIZE(cmd
) > sizeof(buffer
) ||
1321 copy_from_user(buffer
, arg
, _IOC_SIZE(cmd
)))
1325 ret
= ioctl_handlers
[_IOC_NR(cmd
)](client
, buffer
);
1329 if (_IOC_DIR(cmd
) & _IOC_READ
) {
1330 if (_IOC_SIZE(cmd
) > sizeof(buffer
) ||
1331 copy_to_user(arg
, buffer
, _IOC_SIZE(cmd
)))
1338 static long fw_device_op_ioctl(struct file
*file
,
1339 unsigned int cmd
, unsigned long arg
)
1341 struct client
*client
= file
->private_data
;
1343 if (fw_device_is_shutdown(client
->device
))
1346 return dispatch_ioctl(client
, cmd
, (void __user
*) arg
);
1349 #ifdef CONFIG_COMPAT
1350 static long fw_device_op_compat_ioctl(struct file
*file
,
1351 unsigned int cmd
, unsigned long arg
)
1353 struct client
*client
= file
->private_data
;
1355 if (fw_device_is_shutdown(client
->device
))
1358 return dispatch_ioctl(client
, cmd
, compat_ptr(arg
));
1362 static int fw_device_op_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1364 struct client
*client
= file
->private_data
;
1365 enum dma_data_direction direction
;
1367 int page_count
, ret
;
1369 if (fw_device_is_shutdown(client
->device
))
1372 /* FIXME: We could support multiple buffers, but we don't. */
1373 if (client
->buffer
.pages
!= NULL
)
1376 if (!(vma
->vm_flags
& VM_SHARED
))
1379 if (vma
->vm_start
& ~PAGE_MASK
)
1382 client
->vm_start
= vma
->vm_start
;
1383 size
= vma
->vm_end
- vma
->vm_start
;
1384 page_count
= size
>> PAGE_SHIFT
;
1385 if (size
& ~PAGE_MASK
)
1388 if (vma
->vm_flags
& VM_WRITE
)
1389 direction
= DMA_TO_DEVICE
;
1391 direction
= DMA_FROM_DEVICE
;
1393 ret
= fw_iso_buffer_init(&client
->buffer
, client
->device
->card
,
1394 page_count
, direction
);
1398 ret
= fw_iso_buffer_map(&client
->buffer
, vma
);
1400 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1405 static int shutdown_resource(int id
, void *p
, void *data
)
1407 struct client_resource
*r
= p
;
1408 struct client
*client
= data
;
1410 r
->release(client
, r
);
1416 static int fw_device_op_release(struct inode
*inode
, struct file
*file
)
1418 struct client
*client
= file
->private_data
;
1419 struct event
*e
, *next_e
;
1421 mutex_lock(&client
->device
->client_list_mutex
);
1422 list_del(&client
->link
);
1423 mutex_unlock(&client
->device
->client_list_mutex
);
1425 if (client
->iso_context
)
1426 fw_iso_context_destroy(client
->iso_context
);
1428 if (client
->buffer
.pages
)
1429 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1431 /* Freeze client->resource_idr and client->event_list */
1432 spin_lock_irq(&client
->lock
);
1433 client
->in_shutdown
= true;
1434 spin_unlock_irq(&client
->lock
);
1436 idr_for_each(&client
->resource_idr
, shutdown_resource
, client
);
1437 idr_remove_all(&client
->resource_idr
);
1438 idr_destroy(&client
->resource_idr
);
1440 list_for_each_entry_safe(e
, next_e
, &client
->event_list
, link
)
1448 static unsigned int fw_device_op_poll(struct file
*file
, poll_table
* pt
)
1450 struct client
*client
= file
->private_data
;
1451 unsigned int mask
= 0;
1453 poll_wait(file
, &client
->wait
, pt
);
1455 if (fw_device_is_shutdown(client
->device
))
1456 mask
|= POLLHUP
| POLLERR
;
1457 if (!list_empty(&client
->event_list
))
1458 mask
|= POLLIN
| POLLRDNORM
;
1463 const struct file_operations fw_device_ops
= {
1464 .owner
= THIS_MODULE
,
1465 .open
= fw_device_op_open
,
1466 .read
= fw_device_op_read
,
1467 .unlocked_ioctl
= fw_device_op_ioctl
,
1468 .poll
= fw_device_op_poll
,
1469 .release
= fw_device_op_release
,
1470 .mmap
= fw_device_op_mmap
,
1472 #ifdef CONFIG_COMPAT
1473 .compat_ioctl
= fw_device_op_compat_ioctl
,