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/module.h>
22 #include <linux/kernel.h>
23 #include <linux/kref.h>
24 #include <linux/wait.h>
25 #include <linux/errno.h>
26 #include <linux/device.h>
27 #include <linux/vmalloc.h>
28 #include <linux/mutex.h>
29 #include <linux/poll.h>
30 #include <linux/preempt.h>
31 #include <linux/time.h>
32 #include <linux/spinlock.h>
33 #include <linux/delay.h>
35 #include <linux/idr.h>
36 #include <linux/compat.h>
37 #include <linux/firewire-cdev.h>
38 #include <asm/system.h>
39 #include <asm/uaccess.h>
40 #include "fw-transaction.h"
41 #include "fw-topology.h"
42 #include "fw-device.h"
46 struct fw_device
*device
;
50 struct idr resource_idr
;
51 struct list_head event_list
;
52 wait_queue_head_t wait
;
53 u64 bus_reset_closure
;
55 struct fw_iso_context
*iso_context
;
57 struct fw_iso_buffer buffer
;
58 unsigned long vm_start
;
60 struct list_head link
;
64 static inline void client_get(struct client
*client
)
66 kref_get(&client
->kref
);
69 static void client_release(struct kref
*kref
)
71 struct client
*client
= container_of(kref
, struct client
, kref
);
73 fw_device_put(client
->device
);
77 static void client_put(struct client
*client
)
79 kref_put(&client
->kref
, client_release
);
82 struct client_resource
;
83 typedef void (*client_resource_release_fn_t
)(struct client
*,
84 struct client_resource
*);
85 struct client_resource
{
86 client_resource_release_fn_t release
;
90 struct address_handler_resource
{
91 struct client_resource resource
;
92 struct fw_address_handler handler
;
94 struct client
*client
;
97 struct outbound_transaction_resource
{
98 struct client_resource resource
;
99 struct fw_transaction transaction
;
102 struct inbound_transaction_resource
{
103 struct client_resource resource
;
104 struct fw_request
*request
;
109 struct descriptor_resource
{
110 struct client_resource resource
;
111 struct fw_descriptor descriptor
;
116 * dequeue_event() just kfree()'s the event, so the event has to be
117 * the first field in a struct XYZ_event.
120 struct { void *data
; size_t size
; } v
[2];
121 struct list_head link
;
124 struct bus_reset_event
{
126 struct fw_cdev_event_bus_reset reset
;
129 struct outbound_transaction_event
{
131 struct client
*client
;
132 struct outbound_transaction_resource r
;
133 struct fw_cdev_event_response response
;
136 struct inbound_transaction_event
{
138 struct fw_cdev_event_request request
;
141 struct iso_interrupt_event
{
143 struct fw_cdev_event_iso_interrupt interrupt
;
146 static inline void __user
*u64_to_uptr(__u64 value
)
148 return (void __user
*)(unsigned long)value
;
151 static inline __u64
uptr_to_u64(void __user
*ptr
)
153 return (__u64
)(unsigned long)ptr
;
156 static int fw_device_op_open(struct inode
*inode
, struct file
*file
)
158 struct fw_device
*device
;
159 struct client
*client
;
161 device
= fw_device_get_by_devt(inode
->i_rdev
);
165 if (fw_device_is_shutdown(device
)) {
166 fw_device_put(device
);
170 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
171 if (client
== NULL
) {
172 fw_device_put(device
);
176 client
->device
= device
;
177 spin_lock_init(&client
->lock
);
178 idr_init(&client
->resource_idr
);
179 INIT_LIST_HEAD(&client
->event_list
);
180 init_waitqueue_head(&client
->wait
);
181 kref_init(&client
->kref
);
183 file
->private_data
= client
;
185 mutex_lock(&device
->client_list_mutex
);
186 list_add_tail(&client
->link
, &device
->client_list
);
187 mutex_unlock(&device
->client_list_mutex
);
192 static void queue_event(struct client
*client
, struct event
*event
,
193 void *data0
, size_t size0
, void *data1
, size_t size1
)
197 event
->v
[0].data
= data0
;
198 event
->v
[0].size
= size0
;
199 event
->v
[1].data
= data1
;
200 event
->v
[1].size
= size1
;
202 spin_lock_irqsave(&client
->lock
, flags
);
203 if (client
->in_shutdown
)
206 list_add_tail(&event
->link
, &client
->event_list
);
207 spin_unlock_irqrestore(&client
->lock
, flags
);
209 wake_up_interruptible(&client
->wait
);
212 static int dequeue_event(struct client
*client
,
213 char __user
*buffer
, size_t count
)
220 ret
= wait_event_interruptible(client
->wait
,
221 !list_empty(&client
->event_list
) ||
222 fw_device_is_shutdown(client
->device
));
226 if (list_empty(&client
->event_list
) &&
227 fw_device_is_shutdown(client
->device
))
230 spin_lock_irqsave(&client
->lock
, flags
);
231 event
= list_first_entry(&client
->event_list
, struct event
, link
);
232 list_del(&event
->link
);
233 spin_unlock_irqrestore(&client
->lock
, flags
);
236 for (i
= 0; i
< ARRAY_SIZE(event
->v
) && total
< count
; i
++) {
237 size
= min(event
->v
[i
].size
, count
- total
);
238 if (copy_to_user(buffer
+ total
, event
->v
[i
].data
, size
)) {
252 static ssize_t
fw_device_op_read(struct file
*file
, char __user
*buffer
,
253 size_t count
, loff_t
*offset
)
255 struct client
*client
= file
->private_data
;
257 return dequeue_event(client
, buffer
, count
);
260 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset
*event
,
261 struct client
*client
)
263 struct fw_card
*card
= client
->device
->card
;
266 spin_lock_irqsave(&card
->lock
, flags
);
268 event
->closure
= client
->bus_reset_closure
;
269 event
->type
= FW_CDEV_EVENT_BUS_RESET
;
270 event
->generation
= client
->device
->generation
;
271 event
->node_id
= client
->device
->node_id
;
272 event
->local_node_id
= card
->local_node
->node_id
;
273 event
->bm_node_id
= 0; /* FIXME: We don't track the BM. */
274 event
->irm_node_id
= card
->irm_node
->node_id
;
275 event
->root_node_id
= card
->root_node
->node_id
;
277 spin_unlock_irqrestore(&card
->lock
, flags
);
280 static void for_each_client(struct fw_device
*device
,
281 void (*callback
)(struct client
*client
))
285 mutex_lock(&device
->client_list_mutex
);
286 list_for_each_entry(c
, &device
->client_list
, link
)
288 mutex_unlock(&device
->client_list_mutex
);
291 static void queue_bus_reset_event(struct client
*client
)
293 struct bus_reset_event
*e
;
295 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
297 fw_notify("Out of memory when allocating bus reset event\n");
301 fill_bus_reset_event(&e
->reset
, client
);
303 queue_event(client
, &e
->event
,
304 &e
->reset
, sizeof(e
->reset
), NULL
, 0);
307 void fw_device_cdev_update(struct fw_device
*device
)
309 for_each_client(device
, queue_bus_reset_event
);
312 static void wake_up_client(struct client
*client
)
314 wake_up_interruptible(&client
->wait
);
317 void fw_device_cdev_remove(struct fw_device
*device
)
319 for_each_client(device
, wake_up_client
);
322 static int ioctl_get_info(struct client
*client
, void *buffer
)
324 struct fw_cdev_get_info
*get_info
= buffer
;
325 struct fw_cdev_event_bus_reset bus_reset
;
326 unsigned long ret
= 0;
328 client
->version
= get_info
->version
;
329 get_info
->version
= FW_CDEV_VERSION
;
330 get_info
->card
= client
->device
->card
->index
;
332 down_read(&fw_device_rwsem
);
334 if (get_info
->rom
!= 0) {
335 void __user
*uptr
= u64_to_uptr(get_info
->rom
);
336 size_t want
= get_info
->rom_length
;
337 size_t have
= client
->device
->config_rom_length
* 4;
339 ret
= copy_to_user(uptr
, client
->device
->config_rom
,
342 get_info
->rom_length
= client
->device
->config_rom_length
* 4;
344 up_read(&fw_device_rwsem
);
349 client
->bus_reset_closure
= get_info
->bus_reset_closure
;
350 if (get_info
->bus_reset
!= 0) {
351 void __user
*uptr
= u64_to_uptr(get_info
->bus_reset
);
353 fill_bus_reset_event(&bus_reset
, client
);
354 if (copy_to_user(uptr
, &bus_reset
, sizeof(bus_reset
)))
361 static int add_client_resource(struct client
*client
,
362 struct client_resource
*resource
, gfp_t gfp_mask
)
368 if (idr_pre_get(&client
->resource_idr
, gfp_mask
) == 0)
371 spin_lock_irqsave(&client
->lock
, flags
);
372 if (client
->in_shutdown
)
375 ret
= idr_get_new(&client
->resource_idr
, resource
,
379 spin_unlock_irqrestore(&client
->lock
, flags
);
384 return ret
< 0 ? ret
: 0;
387 static int release_client_resource(struct client
*client
, u32 handle
,
388 client_resource_release_fn_t release
,
389 struct client_resource
**resource
)
391 struct client_resource
*r
;
394 spin_lock_irqsave(&client
->lock
, flags
);
395 if (client
->in_shutdown
)
398 r
= idr_find(&client
->resource_idr
, handle
);
399 if (r
&& r
->release
== release
)
400 idr_remove(&client
->resource_idr
, handle
);
401 spin_unlock_irqrestore(&client
->lock
, flags
);
403 if (!(r
&& r
->release
== release
))
409 r
->release(client
, r
);
416 static void release_transaction(struct client
*client
,
417 struct client_resource
*resource
)
419 struct outbound_transaction_resource
*r
= container_of(resource
,
420 struct outbound_transaction_resource
, resource
);
422 fw_cancel_transaction(client
->device
->card
, &r
->transaction
);
425 static void complete_transaction(struct fw_card
*card
, int rcode
,
426 void *payload
, size_t length
, void *data
)
428 struct outbound_transaction_event
*e
= data
;
429 struct fw_cdev_event_response
*rsp
= &e
->response
;
430 struct client
*client
= e
->client
;
433 if (length
< rsp
->length
)
434 rsp
->length
= length
;
435 if (rcode
== RCODE_COMPLETE
)
436 memcpy(rsp
->data
, payload
, rsp
->length
);
438 spin_lock_irqsave(&client
->lock
, flags
);
440 * 1. If called while in shutdown, the idr tree must be left untouched.
441 * The idr handle will be removed and the client reference will be
443 * 2. If the call chain was release_client_resource ->
444 * release_transaction -> complete_transaction (instead of a normal
445 * conclusion of the transaction), i.e. if this resource was already
446 * unregistered from the idr, the client reference will be dropped
447 * by release_client_resource and we must not drop it here.
449 if (!client
->in_shutdown
&&
450 idr_find(&client
->resource_idr
, e
->r
.resource
.handle
)) {
451 idr_remove(&client
->resource_idr
, e
->r
.resource
.handle
);
452 /* Drop the idr's reference */
455 spin_unlock_irqrestore(&client
->lock
, flags
);
457 rsp
->type
= FW_CDEV_EVENT_RESPONSE
;
461 * In the case that sizeof(*rsp) doesn't align with the position of the
462 * data, and the read is short, preserve an extra copy of the data
463 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless
464 * for short reads and some apps depended on it, this is both safe
465 * and prudent for compatibility.
467 if (rsp
->length
<= sizeof(*rsp
) - offsetof(typeof(*rsp
), data
))
468 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
),
469 rsp
->data
, rsp
->length
);
471 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
) + rsp
->length
,
474 /* Drop the transaction callback's reference */
478 static int ioctl_send_request(struct client
*client
, void *buffer
)
480 struct fw_device
*device
= client
->device
;
481 struct fw_cdev_send_request
*request
= buffer
;
482 struct outbound_transaction_event
*e
;
485 /* What is the biggest size we'll accept, really? */
486 if (request
->length
> 4096)
489 e
= kmalloc(sizeof(*e
) + request
->length
, GFP_KERNEL
);
494 e
->response
.length
= request
->length
;
495 e
->response
.closure
= request
->closure
;
498 copy_from_user(e
->response
.data
,
499 u64_to_uptr(request
->data
), request
->length
)) {
504 switch (request
->tcode
) {
505 case TCODE_WRITE_QUADLET_REQUEST
:
506 case TCODE_WRITE_BLOCK_REQUEST
:
507 case TCODE_READ_QUADLET_REQUEST
:
508 case TCODE_READ_BLOCK_REQUEST
:
509 case TCODE_LOCK_MASK_SWAP
:
510 case TCODE_LOCK_COMPARE_SWAP
:
511 case TCODE_LOCK_FETCH_ADD
:
512 case TCODE_LOCK_LITTLE_ADD
:
513 case TCODE_LOCK_BOUNDED_ADD
:
514 case TCODE_LOCK_WRAP_ADD
:
515 case TCODE_LOCK_VENDOR_DEPENDENT
:
522 e
->r
.resource
.release
= release_transaction
;
523 ret
= add_client_resource(client
, &e
->r
.resource
, GFP_KERNEL
);
527 /* Get a reference for the transaction callback */
530 fw_send_request(device
->card
, &e
->r
.transaction
,
531 request
->tcode
& 0x1f,
532 device
->node
->node_id
,
536 e
->response
.data
, request
->length
,
537 complete_transaction
, e
);
540 return sizeof(request
) + request
->length
;
542 return sizeof(request
);
549 static void release_request(struct client
*client
,
550 struct client_resource
*resource
)
552 struct inbound_transaction_resource
*r
= container_of(resource
,
553 struct inbound_transaction_resource
, resource
);
555 fw_send_response(client
->device
->card
, r
->request
,
556 RCODE_CONFLICT_ERROR
);
560 static void handle_request(struct fw_card
*card
, struct fw_request
*request
,
561 int tcode
, int destination
, int source
,
562 int generation
, int speed
,
563 unsigned long long offset
,
564 void *payload
, size_t length
, void *callback_data
)
566 struct address_handler_resource
*handler
= callback_data
;
567 struct inbound_transaction_resource
*r
;
568 struct inbound_transaction_event
*e
;
571 r
= kmalloc(sizeof(*r
), GFP_ATOMIC
);
572 e
= kmalloc(sizeof(*e
), GFP_ATOMIC
);
573 if (r
== NULL
|| e
== NULL
)
576 r
->request
= request
;
580 r
->resource
.release
= release_request
;
581 ret
= add_client_resource(handler
->client
, &r
->resource
, GFP_ATOMIC
);
585 e
->request
.type
= FW_CDEV_EVENT_REQUEST
;
586 e
->request
.tcode
= tcode
;
587 e
->request
.offset
= offset
;
588 e
->request
.length
= length
;
589 e
->request
.handle
= r
->resource
.handle
;
590 e
->request
.closure
= handler
->closure
;
592 queue_event(handler
->client
, &e
->event
,
593 &e
->request
, sizeof(e
->request
), payload
, length
);
599 fw_send_response(card
, request
, RCODE_CONFLICT_ERROR
);
602 static void release_address_handler(struct client
*client
,
603 struct client_resource
*resource
)
605 struct address_handler_resource
*r
=
606 container_of(resource
, struct address_handler_resource
, resource
);
608 fw_core_remove_address_handler(&r
->handler
);
612 static int ioctl_allocate(struct client
*client
, void *buffer
)
614 struct fw_cdev_allocate
*request
= buffer
;
615 struct address_handler_resource
*r
;
616 struct fw_address_region region
;
619 r
= kmalloc(sizeof(*r
), GFP_KERNEL
);
623 region
.start
= request
->offset
;
624 region
.end
= request
->offset
+ request
->length
;
625 r
->handler
.length
= request
->length
;
626 r
->handler
.address_callback
= handle_request
;
627 r
->handler
.callback_data
= r
;
628 r
->closure
= request
->closure
;
631 ret
= fw_core_add_address_handler(&r
->handler
, ®ion
);
637 r
->resource
.release
= release_address_handler
;
638 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
640 release_address_handler(client
, &r
->resource
);
643 request
->handle
= r
->resource
.handle
;
648 static int ioctl_deallocate(struct client
*client
, void *buffer
)
650 struct fw_cdev_deallocate
*request
= buffer
;
652 return release_client_resource(client
, request
->handle
,
653 release_address_handler
, NULL
);
656 static int ioctl_send_response(struct client
*client
, void *buffer
)
658 struct fw_cdev_send_response
*request
= buffer
;
659 struct client_resource
*resource
;
660 struct inbound_transaction_resource
*r
;
662 if (release_client_resource(client
, request
->handle
,
663 release_request
, &resource
) < 0)
666 r
= container_of(resource
, struct inbound_transaction_resource
,
668 if (request
->length
< r
->length
)
669 r
->length
= request
->length
;
670 if (copy_from_user(r
->data
, u64_to_uptr(request
->data
), r
->length
))
673 fw_send_response(client
->device
->card
, r
->request
, request
->rcode
);
679 static int ioctl_initiate_bus_reset(struct client
*client
, void *buffer
)
681 struct fw_cdev_initiate_bus_reset
*request
= buffer
;
684 short_reset
= (request
->type
== FW_CDEV_SHORT_RESET
);
686 return fw_core_initiate_bus_reset(client
->device
->card
, short_reset
);
689 static void release_descriptor(struct client
*client
,
690 struct client_resource
*resource
)
692 struct descriptor_resource
*r
=
693 container_of(resource
, struct descriptor_resource
, resource
);
695 fw_core_remove_descriptor(&r
->descriptor
);
699 static int ioctl_add_descriptor(struct client
*client
, void *buffer
)
701 struct fw_cdev_add_descriptor
*request
= buffer
;
702 struct descriptor_resource
*r
;
705 if (request
->length
> 256)
708 r
= kmalloc(sizeof(*r
) + request
->length
* 4, GFP_KERNEL
);
712 if (copy_from_user(r
->data
,
713 u64_to_uptr(request
->data
), request
->length
* 4)) {
718 r
->descriptor
.length
= request
->length
;
719 r
->descriptor
.immediate
= request
->immediate
;
720 r
->descriptor
.key
= request
->key
;
721 r
->descriptor
.data
= r
->data
;
723 ret
= fw_core_add_descriptor(&r
->descriptor
);
727 r
->resource
.release
= release_descriptor
;
728 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
730 fw_core_remove_descriptor(&r
->descriptor
);
733 request
->handle
= r
->resource
.handle
;
742 static int ioctl_remove_descriptor(struct client
*client
, void *buffer
)
744 struct fw_cdev_remove_descriptor
*request
= buffer
;
746 return release_client_resource(client
, request
->handle
,
747 release_descriptor
, NULL
);
750 static void iso_callback(struct fw_iso_context
*context
, u32 cycle
,
751 size_t header_length
, void *header
, void *data
)
753 struct client
*client
= data
;
754 struct iso_interrupt_event
*e
;
756 e
= kzalloc(sizeof(*e
) + header_length
, GFP_ATOMIC
);
760 e
->interrupt
.type
= FW_CDEV_EVENT_ISO_INTERRUPT
;
761 e
->interrupt
.closure
= client
->iso_closure
;
762 e
->interrupt
.cycle
= cycle
;
763 e
->interrupt
.header_length
= header_length
;
764 memcpy(e
->interrupt
.header
, header
, header_length
);
765 queue_event(client
, &e
->event
, &e
->interrupt
,
766 sizeof(e
->interrupt
) + header_length
, NULL
, 0);
769 static int ioctl_create_iso_context(struct client
*client
, void *buffer
)
771 struct fw_cdev_create_iso_context
*request
= buffer
;
772 struct fw_iso_context
*context
;
774 /* We only support one context at this time. */
775 if (client
->iso_context
!= NULL
)
778 if (request
->channel
> 63)
781 switch (request
->type
) {
782 case FW_ISO_CONTEXT_RECEIVE
:
783 if (request
->header_size
< 4 || (request
->header_size
& 3))
788 case FW_ISO_CONTEXT_TRANSMIT
:
789 if (request
->speed
> SCODE_3200
)
798 context
= fw_iso_context_create(client
->device
->card
,
802 request
->header_size
,
803 iso_callback
, client
);
805 return PTR_ERR(context
);
807 client
->iso_closure
= request
->closure
;
808 client
->iso_context
= context
;
810 /* We only support one context at this time. */
816 /* Macros for decoding the iso packet control header. */
817 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff)
818 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01)
819 #define GET_SKIP(v) (((v) >> 17) & 0x01)
820 #define GET_TAG(v) (((v) >> 18) & 0x03)
821 #define GET_SY(v) (((v) >> 20) & 0x0f)
822 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff)
824 static int ioctl_queue_iso(struct client
*client
, void *buffer
)
826 struct fw_cdev_queue_iso
*request
= buffer
;
827 struct fw_cdev_iso_packet __user
*p
, *end
, *next
;
828 struct fw_iso_context
*ctx
= client
->iso_context
;
829 unsigned long payload
, buffer_end
, header_length
;
833 struct fw_iso_packet packet
;
837 if (ctx
== NULL
|| request
->handle
!= 0)
841 * If the user passes a non-NULL data pointer, has mmap()'ed
842 * the iso buffer, and the pointer points inside the buffer,
843 * we setup the payload pointers accordingly. Otherwise we
844 * set them both to 0, which will still let packets with
845 * payload_length == 0 through. In other words, if no packets
846 * use the indirect payload, the iso buffer need not be mapped
847 * and the request->data pointer is ignored.
850 payload
= (unsigned long)request
->data
- client
->vm_start
;
851 buffer_end
= client
->buffer
.page_count
<< PAGE_SHIFT
;
852 if (request
->data
== 0 || client
->buffer
.pages
== NULL
||
853 payload
>= buffer_end
) {
858 p
= (struct fw_cdev_iso_packet __user
*)u64_to_uptr(request
->packets
);
860 if (!access_ok(VERIFY_READ
, p
, request
->size
))
863 end
= (void __user
*)p
+ request
->size
;
866 if (get_user(control
, &p
->control
))
868 u
.packet
.payload_length
= GET_PAYLOAD_LENGTH(control
);
869 u
.packet
.interrupt
= GET_INTERRUPT(control
);
870 u
.packet
.skip
= GET_SKIP(control
);
871 u
.packet
.tag
= GET_TAG(control
);
872 u
.packet
.sy
= GET_SY(control
);
873 u
.packet
.header_length
= GET_HEADER_LENGTH(control
);
875 if (ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
) {
876 header_length
= u
.packet
.header_length
;
879 * We require that header_length is a multiple of
880 * the fixed header size, ctx->header_size.
882 if (ctx
->header_size
== 0) {
883 if (u
.packet
.header_length
> 0)
885 } else if (u
.packet
.header_length
% ctx
->header_size
!= 0) {
891 next
= (struct fw_cdev_iso_packet __user
*)
892 &p
->header
[header_length
/ 4];
896 (u
.packet
.header
, p
->header
, header_length
))
898 if (u
.packet
.skip
&& ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
&&
899 u
.packet
.header_length
+ u
.packet
.payload_length
> 0)
901 if (payload
+ u
.packet
.payload_length
> buffer_end
)
904 if (fw_iso_context_queue(ctx
, &u
.packet
,
905 &client
->buffer
, payload
))
909 payload
+= u
.packet
.payload_length
;
913 request
->size
-= uptr_to_u64(p
) - request
->packets
;
914 request
->packets
= uptr_to_u64(p
);
915 request
->data
= client
->vm_start
+ payload
;
920 static int ioctl_start_iso(struct client
*client
, void *buffer
)
922 struct fw_cdev_start_iso
*request
= buffer
;
924 if (client
->iso_context
== NULL
|| request
->handle
!= 0)
927 if (client
->iso_context
->type
== FW_ISO_CONTEXT_RECEIVE
) {
928 if (request
->tags
== 0 || request
->tags
> 15)
931 if (request
->sync
> 15)
935 return fw_iso_context_start(client
->iso_context
, request
->cycle
,
936 request
->sync
, request
->tags
);
939 static int ioctl_stop_iso(struct client
*client
, void *buffer
)
941 struct fw_cdev_stop_iso
*request
= buffer
;
943 if (client
->iso_context
== NULL
|| request
->handle
!= 0)
946 return fw_iso_context_stop(client
->iso_context
);
949 static int ioctl_get_cycle_timer(struct client
*client
, void *buffer
)
951 struct fw_cdev_get_cycle_timer
*request
= buffer
;
952 struct fw_card
*card
= client
->device
->card
;
953 unsigned long long bus_time
;
958 local_irq_save(flags
);
960 bus_time
= card
->driver
->get_bus_time(card
);
961 do_gettimeofday(&tv
);
963 local_irq_restore(flags
);
966 request
->local_time
= tv
.tv_sec
* 1000000ULL + tv
.tv_usec
;
967 request
->cycle_timer
= bus_time
& 0xffffffff;
971 static int (* const ioctl_handlers
[])(struct client
*client
, void *buffer
) = {
977 ioctl_initiate_bus_reset
,
978 ioctl_add_descriptor
,
979 ioctl_remove_descriptor
,
980 ioctl_create_iso_context
,
984 ioctl_get_cycle_timer
,
987 static int dispatch_ioctl(struct client
*client
,
988 unsigned int cmd
, void __user
*arg
)
993 if (_IOC_TYPE(cmd
) != '#' ||
994 _IOC_NR(cmd
) >= ARRAY_SIZE(ioctl_handlers
))
997 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
998 if (_IOC_SIZE(cmd
) > sizeof(buffer
) ||
999 copy_from_user(buffer
, arg
, _IOC_SIZE(cmd
)))
1003 ret
= ioctl_handlers
[_IOC_NR(cmd
)](client
, buffer
);
1007 if (_IOC_DIR(cmd
) & _IOC_READ
) {
1008 if (_IOC_SIZE(cmd
) > sizeof(buffer
) ||
1009 copy_to_user(arg
, buffer
, _IOC_SIZE(cmd
)))
1016 static long fw_device_op_ioctl(struct file
*file
,
1017 unsigned int cmd
, unsigned long arg
)
1019 struct client
*client
= file
->private_data
;
1021 if (fw_device_is_shutdown(client
->device
))
1024 return dispatch_ioctl(client
, cmd
, (void __user
*) arg
);
1027 #ifdef CONFIG_COMPAT
1028 static long fw_device_op_compat_ioctl(struct file
*file
,
1029 unsigned int cmd
, unsigned long arg
)
1031 struct client
*client
= file
->private_data
;
1033 if (fw_device_is_shutdown(client
->device
))
1036 return dispatch_ioctl(client
, cmd
, compat_ptr(arg
));
1040 static int fw_device_op_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1042 struct client
*client
= file
->private_data
;
1043 enum dma_data_direction direction
;
1045 int page_count
, ret
;
1047 if (fw_device_is_shutdown(client
->device
))
1050 /* FIXME: We could support multiple buffers, but we don't. */
1051 if (client
->buffer
.pages
!= NULL
)
1054 if (!(vma
->vm_flags
& VM_SHARED
))
1057 if (vma
->vm_start
& ~PAGE_MASK
)
1060 client
->vm_start
= vma
->vm_start
;
1061 size
= vma
->vm_end
- vma
->vm_start
;
1062 page_count
= size
>> PAGE_SHIFT
;
1063 if (size
& ~PAGE_MASK
)
1066 if (vma
->vm_flags
& VM_WRITE
)
1067 direction
= DMA_TO_DEVICE
;
1069 direction
= DMA_FROM_DEVICE
;
1071 ret
= fw_iso_buffer_init(&client
->buffer
, client
->device
->card
,
1072 page_count
, direction
);
1076 ret
= fw_iso_buffer_map(&client
->buffer
, vma
);
1078 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1083 static int shutdown_resource(int id
, void *p
, void *data
)
1085 struct client_resource
*r
= p
;
1086 struct client
*client
= data
;
1088 r
->release(client
, r
);
1094 static int fw_device_op_release(struct inode
*inode
, struct file
*file
)
1096 struct client
*client
= file
->private_data
;
1097 struct event
*e
, *next_e
;
1098 unsigned long flags
;
1100 mutex_lock(&client
->device
->client_list_mutex
);
1101 list_del(&client
->link
);
1102 mutex_unlock(&client
->device
->client_list_mutex
);
1104 if (client
->buffer
.pages
)
1105 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1107 if (client
->iso_context
)
1108 fw_iso_context_destroy(client
->iso_context
);
1110 /* Freeze client->resource_idr and client->event_list */
1111 spin_lock_irqsave(&client
->lock
, flags
);
1112 client
->in_shutdown
= true;
1113 spin_unlock_irqrestore(&client
->lock
, flags
);
1115 idr_for_each(&client
->resource_idr
, shutdown_resource
, client
);
1116 idr_remove_all(&client
->resource_idr
);
1117 idr_destroy(&client
->resource_idr
);
1119 list_for_each_entry_safe(e
, next_e
, &client
->event_list
, link
)
1127 static unsigned int fw_device_op_poll(struct file
*file
, poll_table
* pt
)
1129 struct client
*client
= file
->private_data
;
1130 unsigned int mask
= 0;
1132 poll_wait(file
, &client
->wait
, pt
);
1134 if (fw_device_is_shutdown(client
->device
))
1135 mask
|= POLLHUP
| POLLERR
;
1136 if (!list_empty(&client
->event_list
))
1137 mask
|= POLLIN
| POLLRDNORM
;
1142 const struct file_operations fw_device_ops
= {
1143 .owner
= THIS_MODULE
,
1144 .open
= fw_device_op_open
,
1145 .read
= fw_device_op_read
,
1146 .unlocked_ioctl
= fw_device_op_ioctl
,
1147 .poll
= fw_device_op_poll
,
1148 .release
= fw_device_op_release
,
1149 .mmap
= fw_device_op_mmap
,
1151 #ifdef CONFIG_COMPAT
1152 .compat_ioctl
= fw_device_op_compat_ioctl
,