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/bug.h>
22 #include <linux/compat.h>
23 #include <linux/delay.h>
24 #include <linux/device.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/errno.h>
27 #include <linux/firewire.h>
28 #include <linux/firewire-cdev.h>
29 #include <linux/idr.h>
30 #include <linux/irqflags.h>
31 #include <linux/jiffies.h>
32 #include <linux/kernel.h>
33 #include <linux/kref.h>
35 #include <linux/module.h>
36 #include <linux/mutex.h>
37 #include <linux/poll.h>
38 #include <linux/sched.h> /* required for linux/wait.h */
39 #include <linux/slab.h>
40 #include <linux/spinlock.h>
41 #include <linux/string.h>
42 #include <linux/time.h>
43 #include <linux/uaccess.h>
44 #include <linux/vmalloc.h>
45 #include <linux/wait.h>
46 #include <linux/workqueue.h>
52 * ABI version history is documented in linux/firewire-cdev.h.
54 #define FW_CDEV_KERNEL_VERSION 5
55 #define FW_CDEV_VERSION_EVENT_REQUEST2 4
56 #define FW_CDEV_VERSION_ALLOCATE_REGION_END 4
60 struct fw_device
*device
;
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
;
70 struct fw_iso_context
*iso_context
;
72 struct fw_iso_buffer buffer
;
73 unsigned long vm_start
;
74 bool buffer_is_mapped
;
76 struct list_head phy_receiver_link
;
77 u64 phy_receiver_closure
;
79 struct list_head link
;
83 static inline void client_get(struct client
*client
)
85 kref_get(&client
->kref
);
88 static void client_release(struct kref
*kref
)
90 struct client
*client
= container_of(kref
, struct client
, kref
);
92 fw_device_put(client
->device
);
96 static void client_put(struct client
*client
)
98 kref_put(&client
->kref
, client_release
);
101 struct client_resource
;
102 typedef void (*client_resource_release_fn_t
)(struct client
*,
103 struct client_resource
*);
104 struct client_resource
{
105 client_resource_release_fn_t release
;
109 struct address_handler_resource
{
110 struct client_resource resource
;
111 struct fw_address_handler handler
;
113 struct client
*client
;
116 struct outbound_transaction_resource
{
117 struct client_resource resource
;
118 struct fw_transaction transaction
;
121 struct inbound_transaction_resource
{
122 struct client_resource resource
;
123 struct fw_card
*card
;
124 struct fw_request
*request
;
129 struct descriptor_resource
{
130 struct client_resource resource
;
131 struct fw_descriptor descriptor
;
135 struct iso_resource
{
136 struct client_resource resource
;
137 struct client
*client
;
138 /* Schedule work and access todo only with client->lock held. */
139 struct delayed_work work
;
140 enum {ISO_RES_ALLOC
, ISO_RES_REALLOC
, ISO_RES_DEALLOC
,
141 ISO_RES_ALLOC_ONCE
, ISO_RES_DEALLOC_ONCE
,} todo
;
145 struct iso_resource_event
*e_alloc
, *e_dealloc
;
148 static void release_iso_resource(struct client
*, struct client_resource
*);
150 static void schedule_iso_resource(struct iso_resource
*r
, unsigned long delay
)
152 client_get(r
->client
);
153 if (!queue_delayed_work(fw_workqueue
, &r
->work
, delay
))
154 client_put(r
->client
);
157 static void schedule_if_iso_resource(struct client_resource
*resource
)
159 if (resource
->release
== release_iso_resource
)
160 schedule_iso_resource(container_of(resource
,
161 struct iso_resource
, resource
), 0);
165 * dequeue_event() just kfree()'s the event, so the event has to be
166 * the first field in a struct XYZ_event.
169 struct { void *data
; size_t size
; } v
[2];
170 struct list_head link
;
173 struct bus_reset_event
{
175 struct fw_cdev_event_bus_reset reset
;
178 struct outbound_transaction_event
{
180 struct client
*client
;
181 struct outbound_transaction_resource r
;
182 struct fw_cdev_event_response response
;
185 struct inbound_transaction_event
{
188 struct fw_cdev_event_request request
;
189 struct fw_cdev_event_request2 request2
;
193 struct iso_interrupt_event
{
195 struct fw_cdev_event_iso_interrupt interrupt
;
198 struct iso_interrupt_mc_event
{
200 struct fw_cdev_event_iso_interrupt_mc interrupt
;
203 struct iso_resource_event
{
205 struct fw_cdev_event_iso_resource iso_resource
;
208 struct outbound_phy_packet_event
{
210 struct client
*client
;
212 struct fw_cdev_event_phy_packet phy_packet
;
215 struct inbound_phy_packet_event
{
217 struct fw_cdev_event_phy_packet phy_packet
;
221 static void __user
*u64_to_uptr(u64 value
)
223 if (is_compat_task())
224 return compat_ptr(value
);
226 return (void __user
*)(unsigned long)value
;
229 static u64
uptr_to_u64(void __user
*ptr
)
231 if (is_compat_task())
232 return ptr_to_compat(ptr
);
234 return (u64
)(unsigned long)ptr
;
237 static inline void __user
*u64_to_uptr(u64 value
)
239 return (void __user
*)(unsigned long)value
;
242 static inline u64
uptr_to_u64(void __user
*ptr
)
244 return (u64
)(unsigned long)ptr
;
246 #endif /* CONFIG_COMPAT */
248 static int fw_device_op_open(struct inode
*inode
, struct file
*file
)
250 struct fw_device
*device
;
251 struct client
*client
;
253 device
= fw_device_get_by_devt(inode
->i_rdev
);
257 if (fw_device_is_shutdown(device
)) {
258 fw_device_put(device
);
262 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
263 if (client
== NULL
) {
264 fw_device_put(device
);
268 client
->device
= device
;
269 spin_lock_init(&client
->lock
);
270 idr_init(&client
->resource_idr
);
271 INIT_LIST_HEAD(&client
->event_list
);
272 init_waitqueue_head(&client
->wait
);
273 init_waitqueue_head(&client
->tx_flush_wait
);
274 INIT_LIST_HEAD(&client
->phy_receiver_link
);
275 INIT_LIST_HEAD(&client
->link
);
276 kref_init(&client
->kref
);
278 file
->private_data
= client
;
280 return nonseekable_open(inode
, file
);
283 static void queue_event(struct client
*client
, struct event
*event
,
284 void *data0
, size_t size0
, void *data1
, size_t size1
)
288 event
->v
[0].data
= data0
;
289 event
->v
[0].size
= size0
;
290 event
->v
[1].data
= data1
;
291 event
->v
[1].size
= size1
;
293 spin_lock_irqsave(&client
->lock
, flags
);
294 if (client
->in_shutdown
)
297 list_add_tail(&event
->link
, &client
->event_list
);
298 spin_unlock_irqrestore(&client
->lock
, flags
);
300 wake_up_interruptible(&client
->wait
);
303 static int dequeue_event(struct client
*client
,
304 char __user
*buffer
, size_t count
)
310 ret
= wait_event_interruptible(client
->wait
,
311 !list_empty(&client
->event_list
) ||
312 fw_device_is_shutdown(client
->device
));
316 if (list_empty(&client
->event_list
) &&
317 fw_device_is_shutdown(client
->device
))
320 spin_lock_irq(&client
->lock
);
321 event
= list_first_entry(&client
->event_list
, struct event
, link
);
322 list_del(&event
->link
);
323 spin_unlock_irq(&client
->lock
);
326 for (i
= 0; i
< ARRAY_SIZE(event
->v
) && total
< count
; i
++) {
327 size
= min(event
->v
[i
].size
, count
- total
);
328 if (copy_to_user(buffer
+ total
, event
->v
[i
].data
, size
)) {
342 static ssize_t
fw_device_op_read(struct file
*file
, char __user
*buffer
,
343 size_t count
, loff_t
*offset
)
345 struct client
*client
= file
->private_data
;
347 return dequeue_event(client
, buffer
, count
);
350 static void fill_bus_reset_event(struct fw_cdev_event_bus_reset
*event
,
351 struct client
*client
)
353 struct fw_card
*card
= client
->device
->card
;
355 spin_lock_irq(&card
->lock
);
357 event
->closure
= client
->bus_reset_closure
;
358 event
->type
= FW_CDEV_EVENT_BUS_RESET
;
359 event
->generation
= client
->device
->generation
;
360 event
->node_id
= client
->device
->node_id
;
361 event
->local_node_id
= card
->local_node
->node_id
;
362 event
->bm_node_id
= card
->bm_node_id
;
363 event
->irm_node_id
= card
->irm_node
->node_id
;
364 event
->root_node_id
= card
->root_node
->node_id
;
366 spin_unlock_irq(&card
->lock
);
369 static void for_each_client(struct fw_device
*device
,
370 void (*callback
)(struct client
*client
))
374 mutex_lock(&device
->client_list_mutex
);
375 list_for_each_entry(c
, &device
->client_list
, link
)
377 mutex_unlock(&device
->client_list_mutex
);
380 static int schedule_reallocations(int id
, void *p
, void *data
)
382 schedule_if_iso_resource(p
);
387 static void queue_bus_reset_event(struct client
*client
)
389 struct bus_reset_event
*e
;
391 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
393 fw_notice(client
->device
->card
, "out of memory when allocating event\n");
397 fill_bus_reset_event(&e
->reset
, client
);
399 queue_event(client
, &e
->event
,
400 &e
->reset
, sizeof(e
->reset
), NULL
, 0);
402 spin_lock_irq(&client
->lock
);
403 idr_for_each(&client
->resource_idr
, schedule_reallocations
, client
);
404 spin_unlock_irq(&client
->lock
);
407 void fw_device_cdev_update(struct fw_device
*device
)
409 for_each_client(device
, queue_bus_reset_event
);
412 static void wake_up_client(struct client
*client
)
414 wake_up_interruptible(&client
->wait
);
417 void fw_device_cdev_remove(struct fw_device
*device
)
419 for_each_client(device
, wake_up_client
);
423 struct fw_cdev_get_info get_info
;
424 struct fw_cdev_send_request send_request
;
425 struct fw_cdev_allocate allocate
;
426 struct fw_cdev_deallocate deallocate
;
427 struct fw_cdev_send_response send_response
;
428 struct fw_cdev_initiate_bus_reset initiate_bus_reset
;
429 struct fw_cdev_add_descriptor add_descriptor
;
430 struct fw_cdev_remove_descriptor remove_descriptor
;
431 struct fw_cdev_create_iso_context create_iso_context
;
432 struct fw_cdev_queue_iso queue_iso
;
433 struct fw_cdev_start_iso start_iso
;
434 struct fw_cdev_stop_iso stop_iso
;
435 struct fw_cdev_get_cycle_timer get_cycle_timer
;
436 struct fw_cdev_allocate_iso_resource allocate_iso_resource
;
437 struct fw_cdev_send_stream_packet send_stream_packet
;
438 struct fw_cdev_get_cycle_timer2 get_cycle_timer2
;
439 struct fw_cdev_send_phy_packet send_phy_packet
;
440 struct fw_cdev_receive_phy_packets receive_phy_packets
;
441 struct fw_cdev_set_iso_channels set_iso_channels
;
442 struct fw_cdev_flush_iso flush_iso
;
445 static int ioctl_get_info(struct client
*client
, union ioctl_arg
*arg
)
447 struct fw_cdev_get_info
*a
= &arg
->get_info
;
448 struct fw_cdev_event_bus_reset bus_reset
;
449 unsigned long ret
= 0;
451 client
->version
= a
->version
;
452 a
->version
= FW_CDEV_KERNEL_VERSION
;
453 a
->card
= client
->device
->card
->index
;
455 down_read(&fw_device_rwsem
);
458 size_t want
= a
->rom_length
;
459 size_t have
= client
->device
->config_rom_length
* 4;
461 ret
= copy_to_user(u64_to_uptr(a
->rom
),
462 client
->device
->config_rom
, min(want
, have
));
464 a
->rom_length
= client
->device
->config_rom_length
* 4;
466 up_read(&fw_device_rwsem
);
471 mutex_lock(&client
->device
->client_list_mutex
);
473 client
->bus_reset_closure
= a
->bus_reset_closure
;
474 if (a
->bus_reset
!= 0) {
475 fill_bus_reset_event(&bus_reset
, client
);
476 /* unaligned size of bus_reset is 36 bytes */
477 ret
= copy_to_user(u64_to_uptr(a
->bus_reset
), &bus_reset
, 36);
479 if (ret
== 0 && list_empty(&client
->link
))
480 list_add_tail(&client
->link
, &client
->device
->client_list
);
482 mutex_unlock(&client
->device
->client_list_mutex
);
484 return ret
? -EFAULT
: 0;
487 static int add_client_resource(struct client
*client
,
488 struct client_resource
*resource
, gfp_t gfp_mask
)
490 bool preload
= gfp_mask
& __GFP_WAIT
;
495 idr_preload(gfp_mask
);
496 spin_lock_irqsave(&client
->lock
, flags
);
498 if (client
->in_shutdown
)
501 ret
= idr_alloc(&client
->resource_idr
, resource
, 0, 0,
504 resource
->handle
= ret
;
506 schedule_if_iso_resource(resource
);
509 spin_unlock_irqrestore(&client
->lock
, flags
);
513 return ret
< 0 ? ret
: 0;
516 static int release_client_resource(struct client
*client
, u32 handle
,
517 client_resource_release_fn_t release
,
518 struct client_resource
**return_resource
)
520 struct client_resource
*resource
;
522 spin_lock_irq(&client
->lock
);
523 if (client
->in_shutdown
)
526 resource
= idr_find(&client
->resource_idr
, handle
);
527 if (resource
&& resource
->release
== release
)
528 idr_remove(&client
->resource_idr
, handle
);
529 spin_unlock_irq(&client
->lock
);
531 if (!(resource
&& resource
->release
== release
))
535 *return_resource
= resource
;
537 resource
->release(client
, resource
);
544 static void release_transaction(struct client
*client
,
545 struct client_resource
*resource
)
549 static void complete_transaction(struct fw_card
*card
, int rcode
,
550 void *payload
, size_t length
, void *data
)
552 struct outbound_transaction_event
*e
= data
;
553 struct fw_cdev_event_response
*rsp
= &e
->response
;
554 struct client
*client
= e
->client
;
557 if (length
< rsp
->length
)
558 rsp
->length
= length
;
559 if (rcode
== RCODE_COMPLETE
)
560 memcpy(rsp
->data
, payload
, rsp
->length
);
562 spin_lock_irqsave(&client
->lock
, flags
);
563 idr_remove(&client
->resource_idr
, e
->r
.resource
.handle
);
564 if (client
->in_shutdown
)
565 wake_up(&client
->tx_flush_wait
);
566 spin_unlock_irqrestore(&client
->lock
, flags
);
568 rsp
->type
= FW_CDEV_EVENT_RESPONSE
;
572 * In the case that sizeof(*rsp) doesn't align with the position of the
573 * data, and the read is short, preserve an extra copy of the data
574 * to stay compatible with a pre-2.6.27 bug. Since the bug is harmless
575 * for short reads and some apps depended on it, this is both safe
576 * and prudent for compatibility.
578 if (rsp
->length
<= sizeof(*rsp
) - offsetof(typeof(*rsp
), data
))
579 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
),
580 rsp
->data
, rsp
->length
);
582 queue_event(client
, &e
->event
, rsp
, sizeof(*rsp
) + rsp
->length
,
585 /* Drop the idr's reference */
589 static int init_request(struct client
*client
,
590 struct fw_cdev_send_request
*request
,
591 int destination_id
, int speed
)
593 struct outbound_transaction_event
*e
;
596 if (request
->tcode
!= TCODE_STREAM_DATA
&&
597 (request
->length
> 4096 || request
->length
> 512 << speed
))
600 if (request
->tcode
== TCODE_WRITE_QUADLET_REQUEST
&&
604 e
= kmalloc(sizeof(*e
) + request
->length
, GFP_KERNEL
);
609 e
->response
.length
= request
->length
;
610 e
->response
.closure
= request
->closure
;
613 copy_from_user(e
->response
.data
,
614 u64_to_uptr(request
->data
), request
->length
)) {
619 e
->r
.resource
.release
= release_transaction
;
620 ret
= add_client_resource(client
, &e
->r
.resource
, GFP_KERNEL
);
624 fw_send_request(client
->device
->card
, &e
->r
.transaction
,
625 request
->tcode
, destination_id
, request
->generation
,
626 speed
, request
->offset
, e
->response
.data
,
627 request
->length
, complete_transaction
, e
);
636 static int ioctl_send_request(struct client
*client
, union ioctl_arg
*arg
)
638 switch (arg
->send_request
.tcode
) {
639 case TCODE_WRITE_QUADLET_REQUEST
:
640 case TCODE_WRITE_BLOCK_REQUEST
:
641 case TCODE_READ_QUADLET_REQUEST
:
642 case TCODE_READ_BLOCK_REQUEST
:
643 case TCODE_LOCK_MASK_SWAP
:
644 case TCODE_LOCK_COMPARE_SWAP
:
645 case TCODE_LOCK_FETCH_ADD
:
646 case TCODE_LOCK_LITTLE_ADD
:
647 case TCODE_LOCK_BOUNDED_ADD
:
648 case TCODE_LOCK_WRAP_ADD
:
649 case TCODE_LOCK_VENDOR_DEPENDENT
:
655 return init_request(client
, &arg
->send_request
, client
->device
->node_id
,
656 client
->device
->max_speed
);
659 static inline bool is_fcp_request(struct fw_request
*request
)
661 return request
== NULL
;
664 static void release_request(struct client
*client
,
665 struct client_resource
*resource
)
667 struct inbound_transaction_resource
*r
= container_of(resource
,
668 struct inbound_transaction_resource
, resource
);
670 if (is_fcp_request(r
->request
))
673 fw_send_response(r
->card
, r
->request
, RCODE_CONFLICT_ERROR
);
675 fw_card_put(r
->card
);
679 static void handle_request(struct fw_card
*card
, struct fw_request
*request
,
680 int tcode
, int destination
, int source
,
681 int generation
, unsigned long long offset
,
682 void *payload
, size_t length
, void *callback_data
)
684 struct address_handler_resource
*handler
= callback_data
;
685 struct inbound_transaction_resource
*r
;
686 struct inbound_transaction_event
*e
;
688 void *fcp_frame
= NULL
;
691 /* card may be different from handler->client->device->card */
694 r
= kmalloc(sizeof(*r
), GFP_ATOMIC
);
695 e
= kmalloc(sizeof(*e
), GFP_ATOMIC
);
696 if (r
== NULL
|| e
== NULL
) {
697 fw_notice(card
, "out of memory when allocating event\n");
701 r
->request
= request
;
705 if (is_fcp_request(request
)) {
707 * FIXME: Let core-transaction.c manage a
708 * single reference-counted copy?
710 fcp_frame
= kmemdup(payload
, length
, GFP_ATOMIC
);
711 if (fcp_frame
== NULL
)
717 r
->resource
.release
= release_request
;
718 ret
= add_client_resource(handler
->client
, &r
->resource
, GFP_ATOMIC
);
722 if (handler
->client
->version
< FW_CDEV_VERSION_EVENT_REQUEST2
) {
723 struct fw_cdev_event_request
*req
= &e
->req
.request
;
726 tcode
= TCODE_LOCK_REQUEST
;
728 req
->type
= FW_CDEV_EVENT_REQUEST
;
730 req
->offset
= offset
;
731 req
->length
= length
;
732 req
->handle
= r
->resource
.handle
;
733 req
->closure
= handler
->closure
;
734 event_size0
= sizeof(*req
);
736 struct fw_cdev_event_request2
*req
= &e
->req
.request2
;
738 req
->type
= FW_CDEV_EVENT_REQUEST2
;
740 req
->offset
= offset
;
741 req
->source_node_id
= source
;
742 req
->destination_node_id
= destination
;
743 req
->card
= card
->index
;
744 req
->generation
= generation
;
745 req
->length
= length
;
746 req
->handle
= r
->resource
.handle
;
747 req
->closure
= handler
->closure
;
748 event_size0
= sizeof(*req
);
751 queue_event(handler
->client
, &e
->event
,
752 &e
->req
, event_size0
, r
->data
, length
);
760 if (!is_fcp_request(request
))
761 fw_send_response(card
, request
, RCODE_CONFLICT_ERROR
);
766 static void release_address_handler(struct client
*client
,
767 struct client_resource
*resource
)
769 struct address_handler_resource
*r
=
770 container_of(resource
, struct address_handler_resource
, resource
);
772 fw_core_remove_address_handler(&r
->handler
);
776 static int ioctl_allocate(struct client
*client
, union ioctl_arg
*arg
)
778 struct fw_cdev_allocate
*a
= &arg
->allocate
;
779 struct address_handler_resource
*r
;
780 struct fw_address_region region
;
783 r
= kmalloc(sizeof(*r
), GFP_KERNEL
);
787 region
.start
= a
->offset
;
788 if (client
->version
< FW_CDEV_VERSION_ALLOCATE_REGION_END
)
789 region
.end
= a
->offset
+ a
->length
;
791 region
.end
= a
->region_end
;
793 r
->handler
.length
= a
->length
;
794 r
->handler
.address_callback
= handle_request
;
795 r
->handler
.callback_data
= r
;
796 r
->closure
= a
->closure
;
799 ret
= fw_core_add_address_handler(&r
->handler
, ®ion
);
804 a
->offset
= r
->handler
.offset
;
806 r
->resource
.release
= release_address_handler
;
807 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
809 release_address_handler(client
, &r
->resource
);
812 a
->handle
= r
->resource
.handle
;
817 static int ioctl_deallocate(struct client
*client
, union ioctl_arg
*arg
)
819 return release_client_resource(client
, arg
->deallocate
.handle
,
820 release_address_handler
, NULL
);
823 static int ioctl_send_response(struct client
*client
, union ioctl_arg
*arg
)
825 struct fw_cdev_send_response
*a
= &arg
->send_response
;
826 struct client_resource
*resource
;
827 struct inbound_transaction_resource
*r
;
830 if (release_client_resource(client
, a
->handle
,
831 release_request
, &resource
) < 0)
834 r
= container_of(resource
, struct inbound_transaction_resource
,
836 if (is_fcp_request(r
->request
))
839 if (a
->length
!= fw_get_response_length(r
->request
)) {
844 if (copy_from_user(r
->data
, u64_to_uptr(a
->data
), a
->length
)) {
849 fw_send_response(r
->card
, r
->request
, a
->rcode
);
851 fw_card_put(r
->card
);
857 static int ioctl_initiate_bus_reset(struct client
*client
, union ioctl_arg
*arg
)
859 fw_schedule_bus_reset(client
->device
->card
, true,
860 arg
->initiate_bus_reset
.type
== FW_CDEV_SHORT_RESET
);
864 static void release_descriptor(struct client
*client
,
865 struct client_resource
*resource
)
867 struct descriptor_resource
*r
=
868 container_of(resource
, struct descriptor_resource
, resource
);
870 fw_core_remove_descriptor(&r
->descriptor
);
874 static int ioctl_add_descriptor(struct client
*client
, union ioctl_arg
*arg
)
876 struct fw_cdev_add_descriptor
*a
= &arg
->add_descriptor
;
877 struct descriptor_resource
*r
;
880 /* Access policy: Allow this ioctl only on local nodes' device files. */
881 if (!client
->device
->is_local
)
887 r
= kmalloc(sizeof(*r
) + a
->length
* 4, GFP_KERNEL
);
891 if (copy_from_user(r
->data
, u64_to_uptr(a
->data
), a
->length
* 4)) {
896 r
->descriptor
.length
= a
->length
;
897 r
->descriptor
.immediate
= a
->immediate
;
898 r
->descriptor
.key
= a
->key
;
899 r
->descriptor
.data
= r
->data
;
901 ret
= fw_core_add_descriptor(&r
->descriptor
);
905 r
->resource
.release
= release_descriptor
;
906 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
908 fw_core_remove_descriptor(&r
->descriptor
);
911 a
->handle
= r
->resource
.handle
;
920 static int ioctl_remove_descriptor(struct client
*client
, union ioctl_arg
*arg
)
922 return release_client_resource(client
, arg
->remove_descriptor
.handle
,
923 release_descriptor
, NULL
);
926 static void iso_callback(struct fw_iso_context
*context
, u32 cycle
,
927 size_t header_length
, void *header
, void *data
)
929 struct client
*client
= data
;
930 struct iso_interrupt_event
*e
;
932 e
= kmalloc(sizeof(*e
) + header_length
, GFP_ATOMIC
);
934 fw_notice(context
->card
, "out of memory when allocating event\n");
937 e
->interrupt
.type
= FW_CDEV_EVENT_ISO_INTERRUPT
;
938 e
->interrupt
.closure
= client
->iso_closure
;
939 e
->interrupt
.cycle
= cycle
;
940 e
->interrupt
.header_length
= header_length
;
941 memcpy(e
->interrupt
.header
, header
, header_length
);
942 queue_event(client
, &e
->event
, &e
->interrupt
,
943 sizeof(e
->interrupt
) + header_length
, NULL
, 0);
946 static void iso_mc_callback(struct fw_iso_context
*context
,
947 dma_addr_t completed
, void *data
)
949 struct client
*client
= data
;
950 struct iso_interrupt_mc_event
*e
;
952 e
= kmalloc(sizeof(*e
), GFP_ATOMIC
);
954 fw_notice(context
->card
, "out of memory when allocating event\n");
957 e
->interrupt
.type
= FW_CDEV_EVENT_ISO_INTERRUPT_MULTICHANNEL
;
958 e
->interrupt
.closure
= client
->iso_closure
;
959 e
->interrupt
.completed
= fw_iso_buffer_lookup(&client
->buffer
,
961 queue_event(client
, &e
->event
, &e
->interrupt
,
962 sizeof(e
->interrupt
), NULL
, 0);
965 static enum dma_data_direction
iso_dma_direction(struct fw_iso_context
*context
)
967 if (context
->type
== FW_ISO_CONTEXT_TRANSMIT
)
968 return DMA_TO_DEVICE
;
970 return DMA_FROM_DEVICE
;
973 static int ioctl_create_iso_context(struct client
*client
, union ioctl_arg
*arg
)
975 struct fw_cdev_create_iso_context
*a
= &arg
->create_iso_context
;
976 struct fw_iso_context
*context
;
977 fw_iso_callback_t cb
;
980 BUILD_BUG_ON(FW_CDEV_ISO_CONTEXT_TRANSMIT
!= FW_ISO_CONTEXT_TRANSMIT
||
981 FW_CDEV_ISO_CONTEXT_RECEIVE
!= FW_ISO_CONTEXT_RECEIVE
||
982 FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL
!=
983 FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL
);
986 case FW_ISO_CONTEXT_TRANSMIT
:
987 if (a
->speed
> SCODE_3200
|| a
->channel
> 63)
993 case FW_ISO_CONTEXT_RECEIVE
:
994 if (a
->header_size
< 4 || (a
->header_size
& 3) ||
1001 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL
:
1002 cb
= (fw_iso_callback_t
)iso_mc_callback
;
1009 context
= fw_iso_context_create(client
->device
->card
, a
->type
,
1010 a
->channel
, a
->speed
, a
->header_size
, cb
, client
);
1011 if (IS_ERR(context
))
1012 return PTR_ERR(context
);
1014 /* We only support one context at this time. */
1015 spin_lock_irq(&client
->lock
);
1016 if (client
->iso_context
!= NULL
) {
1017 spin_unlock_irq(&client
->lock
);
1018 fw_iso_context_destroy(context
);
1022 if (!client
->buffer_is_mapped
) {
1023 ret
= fw_iso_buffer_map_dma(&client
->buffer
,
1024 client
->device
->card
,
1025 iso_dma_direction(context
));
1027 spin_unlock_irq(&client
->lock
);
1028 fw_iso_context_destroy(context
);
1032 client
->buffer_is_mapped
= true;
1034 client
->iso_closure
= a
->closure
;
1035 client
->iso_context
= context
;
1036 spin_unlock_irq(&client
->lock
);
1043 static int ioctl_set_iso_channels(struct client
*client
, union ioctl_arg
*arg
)
1045 struct fw_cdev_set_iso_channels
*a
= &arg
->set_iso_channels
;
1046 struct fw_iso_context
*ctx
= client
->iso_context
;
1048 if (ctx
== NULL
|| a
->handle
!= 0)
1051 return fw_iso_context_set_channels(ctx
, &a
->channels
);
1054 /* Macros for decoding the iso packet control header. */
1055 #define GET_PAYLOAD_LENGTH(v) ((v) & 0xffff)
1056 #define GET_INTERRUPT(v) (((v) >> 16) & 0x01)
1057 #define GET_SKIP(v) (((v) >> 17) & 0x01)
1058 #define GET_TAG(v) (((v) >> 18) & 0x03)
1059 #define GET_SY(v) (((v) >> 20) & 0x0f)
1060 #define GET_HEADER_LENGTH(v) (((v) >> 24) & 0xff)
1062 static int ioctl_queue_iso(struct client
*client
, union ioctl_arg
*arg
)
1064 struct fw_cdev_queue_iso
*a
= &arg
->queue_iso
;
1065 struct fw_cdev_iso_packet __user
*p
, *end
, *next
;
1066 struct fw_iso_context
*ctx
= client
->iso_context
;
1067 unsigned long payload
, buffer_end
, transmit_header_bytes
= 0;
1071 struct fw_iso_packet packet
;
1075 if (ctx
== NULL
|| a
->handle
!= 0)
1079 * If the user passes a non-NULL data pointer, has mmap()'ed
1080 * the iso buffer, and the pointer points inside the buffer,
1081 * we setup the payload pointers accordingly. Otherwise we
1082 * set them both to 0, which will still let packets with
1083 * payload_length == 0 through. In other words, if no packets
1084 * use the indirect payload, the iso buffer need not be mapped
1085 * and the a->data pointer is ignored.
1087 payload
= (unsigned long)a
->data
- client
->vm_start
;
1088 buffer_end
= client
->buffer
.page_count
<< PAGE_SHIFT
;
1089 if (a
->data
== 0 || client
->buffer
.pages
== NULL
||
1090 payload
>= buffer_end
) {
1095 if (ctx
->type
== FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL
&& payload
& 3)
1098 p
= (struct fw_cdev_iso_packet __user
*)u64_to_uptr(a
->packets
);
1099 if (!access_ok(VERIFY_READ
, p
, a
->size
))
1102 end
= (void __user
*)p
+ a
->size
;
1105 if (get_user(control
, &p
->control
))
1107 u
.packet
.payload_length
= GET_PAYLOAD_LENGTH(control
);
1108 u
.packet
.interrupt
= GET_INTERRUPT(control
);
1109 u
.packet
.skip
= GET_SKIP(control
);
1110 u
.packet
.tag
= GET_TAG(control
);
1111 u
.packet
.sy
= GET_SY(control
);
1112 u
.packet
.header_length
= GET_HEADER_LENGTH(control
);
1114 switch (ctx
->type
) {
1115 case FW_ISO_CONTEXT_TRANSMIT
:
1116 if (u
.packet
.header_length
& 3)
1118 transmit_header_bytes
= u
.packet
.header_length
;
1121 case FW_ISO_CONTEXT_RECEIVE
:
1122 if (u
.packet
.header_length
== 0 ||
1123 u
.packet
.header_length
% ctx
->header_size
!= 0)
1127 case FW_ISO_CONTEXT_RECEIVE_MULTICHANNEL
:
1128 if (u
.packet
.payload_length
== 0 ||
1129 u
.packet
.payload_length
& 3)
1134 next
= (struct fw_cdev_iso_packet __user
*)
1135 &p
->header
[transmit_header_bytes
/ 4];
1138 if (__copy_from_user
1139 (u
.packet
.header
, p
->header
, transmit_header_bytes
))
1141 if (u
.packet
.skip
&& ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
&&
1142 u
.packet
.header_length
+ u
.packet
.payload_length
> 0)
1144 if (payload
+ u
.packet
.payload_length
> buffer_end
)
1147 if (fw_iso_context_queue(ctx
, &u
.packet
,
1148 &client
->buffer
, payload
))
1152 payload
+= u
.packet
.payload_length
;
1155 fw_iso_context_queue_flush(ctx
);
1157 a
->size
-= uptr_to_u64(p
) - a
->packets
;
1158 a
->packets
= uptr_to_u64(p
);
1159 a
->data
= client
->vm_start
+ payload
;
1164 static int ioctl_start_iso(struct client
*client
, union ioctl_arg
*arg
)
1166 struct fw_cdev_start_iso
*a
= &arg
->start_iso
;
1169 FW_CDEV_ISO_CONTEXT_MATCH_TAG0
!= FW_ISO_CONTEXT_MATCH_TAG0
||
1170 FW_CDEV_ISO_CONTEXT_MATCH_TAG1
!= FW_ISO_CONTEXT_MATCH_TAG1
||
1171 FW_CDEV_ISO_CONTEXT_MATCH_TAG2
!= FW_ISO_CONTEXT_MATCH_TAG2
||
1172 FW_CDEV_ISO_CONTEXT_MATCH_TAG3
!= FW_ISO_CONTEXT_MATCH_TAG3
||
1173 FW_CDEV_ISO_CONTEXT_MATCH_ALL_TAGS
!= FW_ISO_CONTEXT_MATCH_ALL_TAGS
);
1175 if (client
->iso_context
== NULL
|| a
->handle
!= 0)
1178 if (client
->iso_context
->type
== FW_ISO_CONTEXT_RECEIVE
&&
1179 (a
->tags
== 0 || a
->tags
> 15 || a
->sync
> 15))
1182 return fw_iso_context_start(client
->iso_context
,
1183 a
->cycle
, a
->sync
, a
->tags
);
1186 static int ioctl_stop_iso(struct client
*client
, union ioctl_arg
*arg
)
1188 struct fw_cdev_stop_iso
*a
= &arg
->stop_iso
;
1190 if (client
->iso_context
== NULL
|| a
->handle
!= 0)
1193 return fw_iso_context_stop(client
->iso_context
);
1196 static int ioctl_flush_iso(struct client
*client
, union ioctl_arg
*arg
)
1198 struct fw_cdev_flush_iso
*a
= &arg
->flush_iso
;
1200 if (client
->iso_context
== NULL
|| a
->handle
!= 0)
1203 return fw_iso_context_flush_completions(client
->iso_context
);
1206 static int ioctl_get_cycle_timer2(struct client
*client
, union ioctl_arg
*arg
)
1208 struct fw_cdev_get_cycle_timer2
*a
= &arg
->get_cycle_timer2
;
1209 struct fw_card
*card
= client
->device
->card
;
1210 struct timespec ts
= {0, 0};
1214 local_irq_disable();
1216 cycle_time
= card
->driver
->read_csr(card
, CSR_CYCLE_TIME
);
1218 switch (a
->clk_id
) {
1219 case CLOCK_REALTIME
: getnstimeofday(&ts
); break;
1220 case CLOCK_MONOTONIC
: do_posix_clock_monotonic_gettime(&ts
); break;
1221 case CLOCK_MONOTONIC_RAW
: getrawmonotonic(&ts
); break;
1228 a
->tv_sec
= ts
.tv_sec
;
1229 a
->tv_nsec
= ts
.tv_nsec
;
1230 a
->cycle_timer
= cycle_time
;
1235 static int ioctl_get_cycle_timer(struct client
*client
, union ioctl_arg
*arg
)
1237 struct fw_cdev_get_cycle_timer
*a
= &arg
->get_cycle_timer
;
1238 struct fw_cdev_get_cycle_timer2 ct2
;
1240 ct2
.clk_id
= CLOCK_REALTIME
;
1241 ioctl_get_cycle_timer2(client
, (union ioctl_arg
*)&ct2
);
1243 a
->local_time
= ct2
.tv_sec
* USEC_PER_SEC
+ ct2
.tv_nsec
/ NSEC_PER_USEC
;
1244 a
->cycle_timer
= ct2
.cycle_timer
;
1249 static void iso_resource_work(struct work_struct
*work
)
1251 struct iso_resource_event
*e
;
1252 struct iso_resource
*r
=
1253 container_of(work
, struct iso_resource
, work
.work
);
1254 struct client
*client
= r
->client
;
1255 int generation
, channel
, bandwidth
, todo
;
1256 bool skip
, free
, success
;
1258 spin_lock_irq(&client
->lock
);
1259 generation
= client
->device
->generation
;
1261 /* Allow 1000ms grace period for other reallocations. */
1262 if (todo
== ISO_RES_ALLOC
&&
1263 time_before64(get_jiffies_64(),
1264 client
->device
->card
->reset_jiffies
+ HZ
)) {
1265 schedule_iso_resource(r
, DIV_ROUND_UP(HZ
, 3));
1268 /* We could be called twice within the same generation. */
1269 skip
= todo
== ISO_RES_REALLOC
&&
1270 r
->generation
== generation
;
1272 free
= todo
== ISO_RES_DEALLOC
||
1273 todo
== ISO_RES_ALLOC_ONCE
||
1274 todo
== ISO_RES_DEALLOC_ONCE
;
1275 r
->generation
= generation
;
1276 spin_unlock_irq(&client
->lock
);
1281 bandwidth
= r
->bandwidth
;
1283 fw_iso_resource_manage(client
->device
->card
, generation
,
1284 r
->channels
, &channel
, &bandwidth
,
1285 todo
== ISO_RES_ALLOC
||
1286 todo
== ISO_RES_REALLOC
||
1287 todo
== ISO_RES_ALLOC_ONCE
);
1289 * Is this generation outdated already? As long as this resource sticks
1290 * in the idr, it will be scheduled again for a newer generation or at
1293 if (channel
== -EAGAIN
&&
1294 (todo
== ISO_RES_ALLOC
|| todo
== ISO_RES_REALLOC
))
1297 success
= channel
>= 0 || bandwidth
> 0;
1299 spin_lock_irq(&client
->lock
);
1301 * Transit from allocation to reallocation, except if the client
1302 * requested deallocation in the meantime.
1304 if (r
->todo
== ISO_RES_ALLOC
)
1305 r
->todo
= ISO_RES_REALLOC
;
1307 * Allocation or reallocation failure? Pull this resource out of the
1308 * idr and prepare for deletion, unless the client is shutting down.
1310 if (r
->todo
== ISO_RES_REALLOC
&& !success
&&
1311 !client
->in_shutdown
&&
1312 idr_find(&client
->resource_idr
, r
->resource
.handle
)) {
1313 idr_remove(&client
->resource_idr
, r
->resource
.handle
);
1317 spin_unlock_irq(&client
->lock
);
1319 if (todo
== ISO_RES_ALLOC
&& channel
>= 0)
1320 r
->channels
= 1ULL << channel
;
1322 if (todo
== ISO_RES_REALLOC
&& success
)
1325 if (todo
== ISO_RES_ALLOC
|| todo
== ISO_RES_ALLOC_ONCE
) {
1330 r
->e_dealloc
= NULL
;
1332 e
->iso_resource
.handle
= r
->resource
.handle
;
1333 e
->iso_resource
.channel
= channel
;
1334 e
->iso_resource
.bandwidth
= bandwidth
;
1336 queue_event(client
, &e
->event
,
1337 &e
->iso_resource
, sizeof(e
->iso_resource
), NULL
, 0);
1340 cancel_delayed_work(&r
->work
);
1342 kfree(r
->e_dealloc
);
1349 static void release_iso_resource(struct client
*client
,
1350 struct client_resource
*resource
)
1352 struct iso_resource
*r
=
1353 container_of(resource
, struct iso_resource
, resource
);
1355 spin_lock_irq(&client
->lock
);
1356 r
->todo
= ISO_RES_DEALLOC
;
1357 schedule_iso_resource(r
, 0);
1358 spin_unlock_irq(&client
->lock
);
1361 static int init_iso_resource(struct client
*client
,
1362 struct fw_cdev_allocate_iso_resource
*request
, int todo
)
1364 struct iso_resource_event
*e1
, *e2
;
1365 struct iso_resource
*r
;
1368 if ((request
->channels
== 0 && request
->bandwidth
== 0) ||
1369 request
->bandwidth
> BANDWIDTH_AVAILABLE_INITIAL
||
1370 request
->bandwidth
< 0)
1373 r
= kmalloc(sizeof(*r
), GFP_KERNEL
);
1374 e1
= kmalloc(sizeof(*e1
), GFP_KERNEL
);
1375 e2
= kmalloc(sizeof(*e2
), GFP_KERNEL
);
1376 if (r
== NULL
|| e1
== NULL
|| e2
== NULL
) {
1381 INIT_DELAYED_WORK(&r
->work
, iso_resource_work
);
1385 r
->channels
= request
->channels
;
1386 r
->bandwidth
= request
->bandwidth
;
1390 e1
->iso_resource
.closure
= request
->closure
;
1391 e1
->iso_resource
.type
= FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED
;
1392 e2
->iso_resource
.closure
= request
->closure
;
1393 e2
->iso_resource
.type
= FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED
;
1395 if (todo
== ISO_RES_ALLOC
) {
1396 r
->resource
.release
= release_iso_resource
;
1397 ret
= add_client_resource(client
, &r
->resource
, GFP_KERNEL
);
1401 r
->resource
.release
= NULL
;
1402 r
->resource
.handle
= -1;
1403 schedule_iso_resource(r
, 0);
1405 request
->handle
= r
->resource
.handle
;
1416 static int ioctl_allocate_iso_resource(struct client
*client
,
1417 union ioctl_arg
*arg
)
1419 return init_iso_resource(client
,
1420 &arg
->allocate_iso_resource
, ISO_RES_ALLOC
);
1423 static int ioctl_deallocate_iso_resource(struct client
*client
,
1424 union ioctl_arg
*arg
)
1426 return release_client_resource(client
,
1427 arg
->deallocate
.handle
, release_iso_resource
, NULL
);
1430 static int ioctl_allocate_iso_resource_once(struct client
*client
,
1431 union ioctl_arg
*arg
)
1433 return init_iso_resource(client
,
1434 &arg
->allocate_iso_resource
, ISO_RES_ALLOC_ONCE
);
1437 static int ioctl_deallocate_iso_resource_once(struct client
*client
,
1438 union ioctl_arg
*arg
)
1440 return init_iso_resource(client
,
1441 &arg
->allocate_iso_resource
, ISO_RES_DEALLOC_ONCE
);
1445 * Returns a speed code: Maximum speed to or from this device,
1446 * limited by the device's link speed, the local node's link speed,
1447 * and all PHY port speeds between the two links.
1449 static int ioctl_get_speed(struct client
*client
, union ioctl_arg
*arg
)
1451 return client
->device
->max_speed
;
1454 static int ioctl_send_broadcast_request(struct client
*client
,
1455 union ioctl_arg
*arg
)
1457 struct fw_cdev_send_request
*a
= &arg
->send_request
;
1460 case TCODE_WRITE_QUADLET_REQUEST
:
1461 case TCODE_WRITE_BLOCK_REQUEST
:
1467 /* Security policy: Only allow accesses to Units Space. */
1468 if (a
->offset
< CSR_REGISTER_BASE
+ CSR_CONFIG_ROM_END
)
1471 return init_request(client
, a
, LOCAL_BUS
| 0x3f, SCODE_100
);
1474 static int ioctl_send_stream_packet(struct client
*client
, union ioctl_arg
*arg
)
1476 struct fw_cdev_send_stream_packet
*a
= &arg
->send_stream_packet
;
1477 struct fw_cdev_send_request request
;
1480 if (a
->speed
> client
->device
->card
->link_speed
||
1481 a
->length
> 1024 << a
->speed
)
1484 if (a
->tag
> 3 || a
->channel
> 63 || a
->sy
> 15)
1487 dest
= fw_stream_packet_destination_id(a
->tag
, a
->channel
, a
->sy
);
1488 request
.tcode
= TCODE_STREAM_DATA
;
1489 request
.length
= a
->length
;
1490 request
.closure
= a
->closure
;
1491 request
.data
= a
->data
;
1492 request
.generation
= a
->generation
;
1494 return init_request(client
, &request
, dest
, a
->speed
);
1497 static void outbound_phy_packet_callback(struct fw_packet
*packet
,
1498 struct fw_card
*card
, int status
)
1500 struct outbound_phy_packet_event
*e
=
1501 container_of(packet
, struct outbound_phy_packet_event
, p
);
1505 case ACK_COMPLETE
: e
->phy_packet
.rcode
= RCODE_COMPLETE
; break;
1506 /* should never happen with PHY packets: */
1507 case ACK_PENDING
: e
->phy_packet
.rcode
= RCODE_COMPLETE
; break;
1510 case ACK_BUSY_B
: e
->phy_packet
.rcode
= RCODE_BUSY
; break;
1511 case ACK_DATA_ERROR
: e
->phy_packet
.rcode
= RCODE_DATA_ERROR
; break;
1512 case ACK_TYPE_ERROR
: e
->phy_packet
.rcode
= RCODE_TYPE_ERROR
; break;
1513 /* stale generation; cancelled; on certain controllers: no ack */
1514 default: e
->phy_packet
.rcode
= status
; break;
1516 e
->phy_packet
.data
[0] = packet
->timestamp
;
1518 queue_event(e
->client
, &e
->event
, &e
->phy_packet
,
1519 sizeof(e
->phy_packet
) + e
->phy_packet
.length
, NULL
, 0);
1520 client_put(e
->client
);
1523 static int ioctl_send_phy_packet(struct client
*client
, union ioctl_arg
*arg
)
1525 struct fw_cdev_send_phy_packet
*a
= &arg
->send_phy_packet
;
1526 struct fw_card
*card
= client
->device
->card
;
1527 struct outbound_phy_packet_event
*e
;
1529 /* Access policy: Allow this ioctl only on local nodes' device files. */
1530 if (!client
->device
->is_local
)
1533 e
= kzalloc(sizeof(*e
) + 4, GFP_KERNEL
);
1539 e
->p
.speed
= SCODE_100
;
1540 e
->p
.generation
= a
->generation
;
1541 e
->p
.header
[0] = TCODE_LINK_INTERNAL
<< 4;
1542 e
->p
.header
[1] = a
->data
[0];
1543 e
->p
.header
[2] = a
->data
[1];
1544 e
->p
.header_length
= 12;
1545 e
->p
.callback
= outbound_phy_packet_callback
;
1546 e
->phy_packet
.closure
= a
->closure
;
1547 e
->phy_packet
.type
= FW_CDEV_EVENT_PHY_PACKET_SENT
;
1548 if (is_ping_packet(a
->data
))
1549 e
->phy_packet
.length
= 4;
1551 card
->driver
->send_request(card
, &e
->p
);
1556 static int ioctl_receive_phy_packets(struct client
*client
, union ioctl_arg
*arg
)
1558 struct fw_cdev_receive_phy_packets
*a
= &arg
->receive_phy_packets
;
1559 struct fw_card
*card
= client
->device
->card
;
1561 /* Access policy: Allow this ioctl only on local nodes' device files. */
1562 if (!client
->device
->is_local
)
1565 spin_lock_irq(&card
->lock
);
1567 list_move_tail(&client
->phy_receiver_link
, &card
->phy_receiver_list
);
1568 client
->phy_receiver_closure
= a
->closure
;
1570 spin_unlock_irq(&card
->lock
);
1575 void fw_cdev_handle_phy_packet(struct fw_card
*card
, struct fw_packet
*p
)
1577 struct client
*client
;
1578 struct inbound_phy_packet_event
*e
;
1579 unsigned long flags
;
1581 spin_lock_irqsave(&card
->lock
, flags
);
1583 list_for_each_entry(client
, &card
->phy_receiver_list
, phy_receiver_link
) {
1584 e
= kmalloc(sizeof(*e
) + 8, GFP_ATOMIC
);
1586 fw_notice(card
, "out of memory when allocating event\n");
1589 e
->phy_packet
.closure
= client
->phy_receiver_closure
;
1590 e
->phy_packet
.type
= FW_CDEV_EVENT_PHY_PACKET_RECEIVED
;
1591 e
->phy_packet
.rcode
= RCODE_COMPLETE
;
1592 e
->phy_packet
.length
= 8;
1593 e
->phy_packet
.data
[0] = p
->header
[1];
1594 e
->phy_packet
.data
[1] = p
->header
[2];
1595 queue_event(client
, &e
->event
,
1596 &e
->phy_packet
, sizeof(e
->phy_packet
) + 8, NULL
, 0);
1599 spin_unlock_irqrestore(&card
->lock
, flags
);
1602 static int (* const ioctl_handlers
[])(struct client
*, union ioctl_arg
*) = {
1603 [0x00] = ioctl_get_info
,
1604 [0x01] = ioctl_send_request
,
1605 [0x02] = ioctl_allocate
,
1606 [0x03] = ioctl_deallocate
,
1607 [0x04] = ioctl_send_response
,
1608 [0x05] = ioctl_initiate_bus_reset
,
1609 [0x06] = ioctl_add_descriptor
,
1610 [0x07] = ioctl_remove_descriptor
,
1611 [0x08] = ioctl_create_iso_context
,
1612 [0x09] = ioctl_queue_iso
,
1613 [0x0a] = ioctl_start_iso
,
1614 [0x0b] = ioctl_stop_iso
,
1615 [0x0c] = ioctl_get_cycle_timer
,
1616 [0x0d] = ioctl_allocate_iso_resource
,
1617 [0x0e] = ioctl_deallocate_iso_resource
,
1618 [0x0f] = ioctl_allocate_iso_resource_once
,
1619 [0x10] = ioctl_deallocate_iso_resource_once
,
1620 [0x11] = ioctl_get_speed
,
1621 [0x12] = ioctl_send_broadcast_request
,
1622 [0x13] = ioctl_send_stream_packet
,
1623 [0x14] = ioctl_get_cycle_timer2
,
1624 [0x15] = ioctl_send_phy_packet
,
1625 [0x16] = ioctl_receive_phy_packets
,
1626 [0x17] = ioctl_set_iso_channels
,
1627 [0x18] = ioctl_flush_iso
,
1630 static int dispatch_ioctl(struct client
*client
,
1631 unsigned int cmd
, void __user
*arg
)
1633 union ioctl_arg buffer
;
1636 if (fw_device_is_shutdown(client
->device
))
1639 if (_IOC_TYPE(cmd
) != '#' ||
1640 _IOC_NR(cmd
) >= ARRAY_SIZE(ioctl_handlers
) ||
1641 _IOC_SIZE(cmd
) > sizeof(buffer
))
1644 if (_IOC_DIR(cmd
) == _IOC_READ
)
1645 memset(&buffer
, 0, _IOC_SIZE(cmd
));
1647 if (_IOC_DIR(cmd
) & _IOC_WRITE
)
1648 if (copy_from_user(&buffer
, arg
, _IOC_SIZE(cmd
)))
1651 ret
= ioctl_handlers
[_IOC_NR(cmd
)](client
, &buffer
);
1655 if (_IOC_DIR(cmd
) & _IOC_READ
)
1656 if (copy_to_user(arg
, &buffer
, _IOC_SIZE(cmd
)))
1662 static long fw_device_op_ioctl(struct file
*file
,
1663 unsigned int cmd
, unsigned long arg
)
1665 return dispatch_ioctl(file
->private_data
, cmd
, (void __user
*)arg
);
1668 #ifdef CONFIG_COMPAT
1669 static long fw_device_op_compat_ioctl(struct file
*file
,
1670 unsigned int cmd
, unsigned long arg
)
1672 return dispatch_ioctl(file
->private_data
, cmd
, compat_ptr(arg
));
1676 static int fw_device_op_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1678 struct client
*client
= file
->private_data
;
1680 int page_count
, ret
;
1682 if (fw_device_is_shutdown(client
->device
))
1685 /* FIXME: We could support multiple buffers, but we don't. */
1686 if (client
->buffer
.pages
!= NULL
)
1689 if (!(vma
->vm_flags
& VM_SHARED
))
1692 if (vma
->vm_start
& ~PAGE_MASK
)
1695 client
->vm_start
= vma
->vm_start
;
1696 size
= vma
->vm_end
- vma
->vm_start
;
1697 page_count
= size
>> PAGE_SHIFT
;
1698 if (size
& ~PAGE_MASK
)
1701 ret
= fw_iso_buffer_alloc(&client
->buffer
, page_count
);
1705 spin_lock_irq(&client
->lock
);
1706 if (client
->iso_context
) {
1707 ret
= fw_iso_buffer_map_dma(&client
->buffer
,
1708 client
->device
->card
,
1709 iso_dma_direction(client
->iso_context
));
1710 client
->buffer_is_mapped
= (ret
== 0);
1712 spin_unlock_irq(&client
->lock
);
1716 ret
= fw_iso_buffer_map_vma(&client
->buffer
, vma
);
1722 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1726 static int is_outbound_transaction_resource(int id
, void *p
, void *data
)
1728 struct client_resource
*resource
= p
;
1730 return resource
->release
== release_transaction
;
1733 static int has_outbound_transactions(struct client
*client
)
1737 spin_lock_irq(&client
->lock
);
1738 ret
= idr_for_each(&client
->resource_idr
,
1739 is_outbound_transaction_resource
, NULL
);
1740 spin_unlock_irq(&client
->lock
);
1745 static int shutdown_resource(int id
, void *p
, void *data
)
1747 struct client_resource
*resource
= p
;
1748 struct client
*client
= data
;
1750 resource
->release(client
, resource
);
1756 static int fw_device_op_release(struct inode
*inode
, struct file
*file
)
1758 struct client
*client
= file
->private_data
;
1759 struct event
*event
, *next_event
;
1761 spin_lock_irq(&client
->device
->card
->lock
);
1762 list_del(&client
->phy_receiver_link
);
1763 spin_unlock_irq(&client
->device
->card
->lock
);
1765 mutex_lock(&client
->device
->client_list_mutex
);
1766 list_del(&client
->link
);
1767 mutex_unlock(&client
->device
->client_list_mutex
);
1769 if (client
->iso_context
)
1770 fw_iso_context_destroy(client
->iso_context
);
1772 if (client
->buffer
.pages
)
1773 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
1775 /* Freeze client->resource_idr and client->event_list */
1776 spin_lock_irq(&client
->lock
);
1777 client
->in_shutdown
= true;
1778 spin_unlock_irq(&client
->lock
);
1780 wait_event(client
->tx_flush_wait
, !has_outbound_transactions(client
));
1782 idr_for_each(&client
->resource_idr
, shutdown_resource
, client
);
1783 idr_destroy(&client
->resource_idr
);
1785 list_for_each_entry_safe(event
, next_event
, &client
->event_list
, link
)
1793 static unsigned int fw_device_op_poll(struct file
*file
, poll_table
* pt
)
1795 struct client
*client
= file
->private_data
;
1796 unsigned int mask
= 0;
1798 poll_wait(file
, &client
->wait
, pt
);
1800 if (fw_device_is_shutdown(client
->device
))
1801 mask
|= POLLHUP
| POLLERR
;
1802 if (!list_empty(&client
->event_list
))
1803 mask
|= POLLIN
| POLLRDNORM
;
1808 const struct file_operations fw_device_ops
= {
1809 .owner
= THIS_MODULE
,
1810 .llseek
= no_llseek
,
1811 .open
= fw_device_op_open
,
1812 .read
= fw_device_op_read
,
1813 .unlocked_ioctl
= fw_device_op_ioctl
,
1814 .mmap
= fw_device_op_mmap
,
1815 .release
= fw_device_op_release
,
1816 .poll
= fw_device_op_poll
,
1817 #ifdef CONFIG_COMPAT
1818 .compat_ioctl
= fw_device_op_compat_ioctl
,