1 /* -*- c-basic-offset: 8 -*-
3 * fw-device-cdev.c - Char device for device raw access
5 * Copyright (C) 2005-2006 Kristian Hoegsberg <krh@bitplanet.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software Foundation,
19 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/wait.h>
25 #include <linux/errno.h>
26 #include <linux/device.h>
27 #include <linux/vmalloc.h>
28 #include <linux/poll.h>
29 #include <linux/delay.h>
31 #include <linux/idr.h>
32 #include <linux/compat.h>
33 #include <asm/uaccess.h>
34 #include "fw-transaction.h"
35 #include "fw-topology.h"
36 #include "fw-device.h"
37 #include "fw-device-cdev.h"
39 /* dequeue_event() just kfree()'s the event, so the event has to be
40 * the first field in the struct. */
43 struct client_resource
{
44 struct list_head link
;
45 void (*release
)(struct client
*client
, struct client_resource
*r
);
50 struct { void *data
; size_t size
; } v
[2];
51 struct list_head link
;
56 struct fw_cdev_event_bus_reset reset
;
61 struct fw_transaction transaction
;
62 struct client
*client
;
63 struct client_resource resource
;
64 struct fw_cdev_event_response response
;
67 struct iso_interrupt
{
69 struct fw_cdev_event_iso_interrupt interrupt
;
74 struct fw_device
*device
;
77 struct list_head resource_list
;
78 struct list_head event_list
;
79 wait_queue_head_t wait
;
80 u64 bus_reset_closure
;
82 struct fw_iso_context
*iso_context
;
84 struct fw_iso_buffer buffer
;
85 unsigned long vm_start
;
87 struct list_head link
;
90 static inline void __user
*
91 u64_to_uptr(__u64 value
)
93 return (void __user
*)(unsigned long)value
;
97 uptr_to_u64(void __user
*ptr
)
99 return (__u64
)(unsigned long)ptr
;
102 static int fw_device_op_open(struct inode
*inode
, struct file
*file
)
104 struct fw_device
*device
;
105 struct client
*client
;
108 device
= fw_device_from_devt(inode
->i_rdev
);
112 client
= kzalloc(sizeof *client
, GFP_KERNEL
);
116 client
->device
= fw_device_get(device
);
117 INIT_LIST_HEAD(&client
->event_list
);
118 INIT_LIST_HEAD(&client
->resource_list
);
119 spin_lock_init(&client
->lock
);
120 init_waitqueue_head(&client
->wait
);
122 file
->private_data
= client
;
124 spin_lock_irqsave(&device
->card
->lock
, flags
);
125 list_add_tail(&client
->link
, &device
->client_list
);
126 spin_unlock_irqrestore(&device
->card
->lock
, flags
);
131 static void queue_event(struct client
*client
, struct event
*event
,
132 void *data0
, size_t size0
, void *data1
, size_t size1
)
136 event
->v
[0].data
= data0
;
137 event
->v
[0].size
= size0
;
138 event
->v
[1].data
= data1
;
139 event
->v
[1].size
= size1
;
141 spin_lock_irqsave(&client
->lock
, flags
);
143 list_add_tail(&event
->link
, &client
->event_list
);
144 wake_up_interruptible(&client
->wait
);
146 spin_unlock_irqrestore(&client
->lock
, flags
);
150 dequeue_event(struct client
*client
, char __user
*buffer
, size_t count
)
157 retval
= wait_event_interruptible(client
->wait
,
158 !list_empty(&client
->event_list
) ||
159 fw_device_is_shutdown(client
->device
));
163 if (list_empty(&client
->event_list
) &&
164 fw_device_is_shutdown(client
->device
))
167 spin_lock_irqsave(&client
->lock
, flags
);
168 event
= container_of(client
->event_list
.next
, struct event
, link
);
169 list_del(&event
->link
);
170 spin_unlock_irqrestore(&client
->lock
, flags
);
173 for (i
= 0; i
< ARRAY_SIZE(event
->v
) && total
< count
; i
++) {
174 size
= min(event
->v
[i
].size
, count
- total
);
175 if (copy_to_user(buffer
+ total
, event
->v
[i
].data
, size
)) {
190 fw_device_op_read(struct file
*file
,
191 char __user
*buffer
, size_t count
, loff_t
*offset
)
193 struct client
*client
= file
->private_data
;
195 return dequeue_event(client
, buffer
, count
);
199 fill_bus_reset_event(struct fw_cdev_event_bus_reset
*event
,
200 struct client
*client
)
202 struct fw_card
*card
= client
->device
->card
;
204 event
->closure
= client
->bus_reset_closure
;
205 event
->type
= FW_CDEV_EVENT_BUS_RESET
;
206 event
->node_id
= client
->device
->node_id
;
207 event
->local_node_id
= card
->local_node
->node_id
;
208 event
->bm_node_id
= 0; /* FIXME: We don't track the BM. */
209 event
->irm_node_id
= card
->irm_node
->node_id
;
210 event
->root_node_id
= card
->root_node
->node_id
;
211 event
->generation
= card
->generation
;
215 for_each_client(struct fw_device
*device
,
216 void (*callback
)(struct client
*client
))
218 struct fw_card
*card
= device
->card
;
222 spin_lock_irqsave(&card
->lock
, flags
);
224 list_for_each_entry(c
, &device
->client_list
, link
)
227 spin_unlock_irqrestore(&card
->lock
, flags
);
231 queue_bus_reset_event(struct client
*client
)
233 struct bus_reset
*bus_reset
;
235 bus_reset
= kzalloc(sizeof *bus_reset
, GFP_ATOMIC
);
236 if (bus_reset
== NULL
) {
237 fw_notify("Out of memory when allocating bus reset event\n");
241 fill_bus_reset_event(&bus_reset
->reset
, client
);
243 queue_event(client
, &bus_reset
->event
,
244 &bus_reset
->reset
, sizeof bus_reset
->reset
, NULL
, 0);
247 void fw_device_cdev_update(struct fw_device
*device
)
249 for_each_client(device
, queue_bus_reset_event
);
252 static void wake_up_client(struct client
*client
)
254 wake_up_interruptible(&client
->wait
);
257 void fw_device_cdev_remove(struct fw_device
*device
)
259 for_each_client(device
, wake_up_client
);
262 static int ioctl_get_info(struct client
*client
, void *buffer
)
264 struct fw_cdev_get_info
*get_info
= buffer
;
265 struct fw_cdev_event_bus_reset bus_reset
;
267 client
->version
= get_info
->version
;
268 get_info
->version
= FW_CDEV_VERSION
;
270 if (get_info
->rom
!= 0) {
271 void __user
*uptr
= u64_to_uptr(get_info
->rom
);
272 size_t want
= get_info
->rom_length
;
273 size_t have
= client
->device
->config_rom_length
* 4;
275 if (copy_to_user(uptr
, client
->device
->config_rom
,
279 get_info
->rom_length
= client
->device
->config_rom_length
* 4;
281 client
->bus_reset_closure
= get_info
->bus_reset_closure
;
282 if (get_info
->bus_reset
!= 0) {
283 void __user
*uptr
= u64_to_uptr(get_info
->bus_reset
);
285 fill_bus_reset_event(&bus_reset
, client
);
286 if (copy_to_user(uptr
, &bus_reset
, sizeof bus_reset
))
290 get_info
->card
= client
->device
->card
->index
;
296 add_client_resource(struct client
*client
, struct client_resource
*resource
)
300 spin_lock_irqsave(&client
->lock
, flags
);
301 list_add_tail(&resource
->link
, &client
->resource_list
);
302 resource
->handle
= client
->resource_handle
++;
303 spin_unlock_irqrestore(&client
->lock
, flags
);
307 release_client_resource(struct client
*client
, u32 handle
,
308 struct client_resource
**resource
)
310 struct client_resource
*r
;
313 spin_lock_irqsave(&client
->lock
, flags
);
314 list_for_each_entry(r
, &client
->resource_list
, link
) {
315 if (r
->handle
== handle
) {
320 spin_unlock_irqrestore(&client
->lock
, flags
);
322 if (&r
->link
== &client
->resource_list
)
328 r
->release(client
, r
);
334 release_transaction(struct client
*client
, struct client_resource
*resource
)
336 struct response
*response
=
337 container_of(resource
, struct response
, resource
);
339 fw_cancel_transaction(client
->device
->card
, &response
->transaction
);
343 complete_transaction(struct fw_card
*card
, int rcode
,
344 void *payload
, size_t length
, void *data
)
346 struct response
*response
= data
;
347 struct client
*client
= response
->client
;
350 if (length
< response
->response
.length
)
351 response
->response
.length
= length
;
352 if (rcode
== RCODE_COMPLETE
)
353 memcpy(response
->response
.data
, payload
,
354 response
->response
.length
);
356 spin_lock_irqsave(&client
->lock
, flags
);
357 list_del(&response
->resource
.link
);
358 spin_unlock_irqrestore(&client
->lock
, flags
);
360 response
->response
.type
= FW_CDEV_EVENT_RESPONSE
;
361 response
->response
.rcode
= rcode
;
362 queue_event(client
, &response
->event
,
363 &response
->response
, sizeof response
->response
,
364 response
->response
.data
, response
->response
.length
);
367 static ssize_t
ioctl_send_request(struct client
*client
, void *buffer
)
369 struct fw_device
*device
= client
->device
;
370 struct fw_cdev_send_request
*request
= buffer
;
371 struct response
*response
;
373 /* What is the biggest size we'll accept, really? */
374 if (request
->length
> 4096)
377 response
= kmalloc(sizeof *response
+ request
->length
, GFP_KERNEL
);
378 if (response
== NULL
)
381 response
->client
= client
;
382 response
->response
.length
= request
->length
;
383 response
->response
.closure
= request
->closure
;
386 copy_from_user(response
->response
.data
,
387 u64_to_uptr(request
->data
), request
->length
)) {
392 response
->resource
.release
= release_transaction
;
393 add_client_resource(client
, &response
->resource
);
395 fw_send_request(device
->card
, &response
->transaction
,
396 request
->tcode
& 0x1f,
397 device
->node
->node_id
,
399 device
->node
->max_speed
,
401 response
->response
.data
, request
->length
,
402 complete_transaction
, response
);
405 return sizeof request
+ request
->length
;
407 return sizeof request
;
410 struct address_handler
{
411 struct fw_address_handler handler
;
413 struct client
*client
;
414 struct client_resource resource
;
418 struct fw_request
*request
;
421 struct client_resource resource
;
424 struct request_event
{
426 struct fw_cdev_event_request request
;
430 release_request(struct client
*client
, struct client_resource
*resource
)
432 struct request
*request
=
433 container_of(resource
, struct request
, resource
);
435 fw_send_response(client
->device
->card
, request
->request
,
436 RCODE_CONFLICT_ERROR
);
441 handle_request(struct fw_card
*card
, struct fw_request
*r
,
442 int tcode
, int destination
, int source
,
443 int generation
, int speed
,
444 unsigned long long offset
,
445 void *payload
, size_t length
, void *callback_data
)
447 struct address_handler
*handler
= callback_data
;
448 struct request
*request
;
449 struct request_event
*e
;
450 struct client
*client
= handler
->client
;
452 request
= kmalloc(sizeof *request
, GFP_ATOMIC
);
453 e
= kmalloc(sizeof *e
, GFP_ATOMIC
);
454 if (request
== NULL
|| e
== NULL
) {
457 fw_send_response(card
, r
, RCODE_CONFLICT_ERROR
);
461 request
->request
= r
;
462 request
->data
= payload
;
463 request
->length
= length
;
465 request
->resource
.release
= release_request
;
466 add_client_resource(client
, &request
->resource
);
468 e
->request
.type
= FW_CDEV_EVENT_REQUEST
;
469 e
->request
.tcode
= tcode
;
470 e
->request
.offset
= offset
;
471 e
->request
.length
= length
;
472 e
->request
.handle
= request
->resource
.handle
;
473 e
->request
.closure
= handler
->closure
;
475 queue_event(client
, &e
->event
,
476 &e
->request
, sizeof e
->request
, payload
, length
);
480 release_address_handler(struct client
*client
,
481 struct client_resource
*resource
)
483 struct address_handler
*handler
=
484 container_of(resource
, struct address_handler
, resource
);
486 fw_core_remove_address_handler(&handler
->handler
);
490 static int ioctl_allocate(struct client
*client
, void *buffer
)
492 struct fw_cdev_allocate
*request
= buffer
;
493 struct address_handler
*handler
;
494 struct fw_address_region region
;
496 handler
= kmalloc(sizeof *handler
, GFP_KERNEL
);
500 region
.start
= request
->offset
;
501 region
.end
= request
->offset
+ request
->length
;
502 handler
->handler
.length
= request
->length
;
503 handler
->handler
.address_callback
= handle_request
;
504 handler
->handler
.callback_data
= handler
;
505 handler
->closure
= request
->closure
;
506 handler
->client
= client
;
508 if (fw_core_add_address_handler(&handler
->handler
, ®ion
) < 0) {
513 handler
->resource
.release
= release_address_handler
;
514 add_client_resource(client
, &handler
->resource
);
515 request
->handle
= handler
->resource
.handle
;
520 static int ioctl_deallocate(struct client
*client
, void *buffer
)
522 struct fw_cdev_deallocate
*request
= buffer
;
524 return release_client_resource(client
, request
->handle
, NULL
);
527 static int ioctl_send_response(struct client
*client
, void *buffer
)
529 struct fw_cdev_send_response
*request
= buffer
;
530 struct client_resource
*resource
;
533 if (release_client_resource(client
, request
->handle
, &resource
) < 0)
535 r
= container_of(resource
, struct request
, resource
);
536 if (request
->length
< r
->length
)
537 r
->length
= request
->length
;
538 if (copy_from_user(r
->data
, u64_to_uptr(request
->data
), r
->length
))
541 fw_send_response(client
->device
->card
, r
->request
, request
->rcode
);
547 static int ioctl_initiate_bus_reset(struct client
*client
, void *buffer
)
549 struct fw_cdev_initiate_bus_reset
*request
= buffer
;
552 short_reset
= (request
->type
== FW_CDEV_SHORT_RESET
);
554 return fw_core_initiate_bus_reset(client
->device
->card
, short_reset
);
558 struct fw_descriptor d
;
559 struct client_resource resource
;
563 static void release_descriptor(struct client
*client
,
564 struct client_resource
*resource
)
566 struct descriptor
*descriptor
=
567 container_of(resource
, struct descriptor
, resource
);
569 fw_core_remove_descriptor(&descriptor
->d
);
573 static int ioctl_add_descriptor(struct client
*client
, void *buffer
)
575 struct fw_cdev_add_descriptor
*request
= buffer
;
576 struct descriptor
*descriptor
;
579 if (request
->length
> 256)
583 kmalloc(sizeof *descriptor
+ request
->length
* 4, GFP_KERNEL
);
584 if (descriptor
== NULL
)
587 if (copy_from_user(descriptor
->data
,
588 u64_to_uptr(request
->data
), request
->length
* 4)) {
593 descriptor
->d
.length
= request
->length
;
594 descriptor
->d
.immediate
= request
->immediate
;
595 descriptor
->d
.key
= request
->key
;
596 descriptor
->d
.data
= descriptor
->data
;
598 retval
= fw_core_add_descriptor(&descriptor
->d
);
604 descriptor
->resource
.release
= release_descriptor
;
605 add_client_resource(client
, &descriptor
->resource
);
606 request
->handle
= descriptor
->resource
.handle
;
611 static int ioctl_remove_descriptor(struct client
*client
, void *buffer
)
613 struct fw_cdev_remove_descriptor
*request
= buffer
;
615 return release_client_resource(client
, request
->handle
, NULL
);
619 iso_callback(struct fw_iso_context
*context
, u32 cycle
,
620 size_t header_length
, void *header
, void *data
)
622 struct client
*client
= data
;
623 struct iso_interrupt
*interrupt
;
625 interrupt
= kzalloc(sizeof *interrupt
+ header_length
, GFP_ATOMIC
);
626 if (interrupt
== NULL
)
629 interrupt
->interrupt
.type
= FW_CDEV_EVENT_ISO_INTERRUPT
;
630 interrupt
->interrupt
.closure
= client
->iso_closure
;
631 interrupt
->interrupt
.cycle
= cycle
;
632 interrupt
->interrupt
.header_length
= header_length
;
633 memcpy(interrupt
->interrupt
.header
, header
, header_length
);
634 queue_event(client
, &interrupt
->event
,
635 &interrupt
->interrupt
,
636 sizeof interrupt
->interrupt
+ header_length
, NULL
, 0);
639 static int ioctl_create_iso_context(struct client
*client
, void *buffer
)
641 struct fw_cdev_create_iso_context
*request
= buffer
;
643 if (request
->channel
> 63)
646 switch (request
->type
) {
647 case FW_ISO_CONTEXT_RECEIVE
:
648 if (request
->header_size
< 4 || (request
->header_size
& 3))
653 case FW_ISO_CONTEXT_TRANSMIT
:
654 if (request
->speed
> SCODE_3200
)
663 client
->iso_closure
= request
->closure
;
664 client
->iso_context
= fw_iso_context_create(client
->device
->card
,
668 request
->header_size
,
669 iso_callback
, client
);
670 if (IS_ERR(client
->iso_context
))
671 return PTR_ERR(client
->iso_context
);
673 /* We only support one context at this time. */
679 static int ioctl_queue_iso(struct client
*client
, void *buffer
)
681 struct fw_cdev_queue_iso
*request
= buffer
;
682 struct fw_cdev_iso_packet __user
*p
, *end
, *next
;
683 struct fw_iso_context
*ctx
= client
->iso_context
;
684 unsigned long payload
, buffer_end
, header_length
;
687 struct fw_iso_packet packet
;
691 if (ctx
== NULL
|| request
->handle
!= 0)
694 /* If the user passes a non-NULL data pointer, has mmap()'ed
695 * the iso buffer, and the pointer points inside the buffer,
696 * we setup the payload pointers accordingly. Otherwise we
697 * set them both to 0, which will still let packets with
698 * payload_length == 0 through. In other words, if no packets
699 * use the indirect payload, the iso buffer need not be mapped
700 * and the request->data pointer is ignored.*/
702 payload
= (unsigned long)request
->data
- client
->vm_start
;
703 buffer_end
= client
->buffer
.page_count
<< PAGE_SHIFT
;
704 if (request
->data
== 0 || client
->buffer
.pages
== NULL
||
705 payload
>= buffer_end
) {
710 if (!access_ok(VERIFY_READ
, request
->packets
, request
->size
))
713 p
= (struct fw_cdev_iso_packet __user
*)u64_to_uptr(request
->packets
);
714 end
= (void __user
*)p
+ request
->size
;
717 if (__copy_from_user(&u
.packet
, p
, sizeof *p
))
720 if (ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
) {
721 header_length
= u
.packet
.header_length
;
723 /* We require that header_length is a multiple of
724 * the fixed header size, ctx->header_size */
725 if (ctx
->header_size
== 0) {
726 if (u
.packet
.header_length
> 0)
728 } else if (u
.packet
.header_length
% ctx
->header_size
!= 0) {
734 next
= (struct fw_cdev_iso_packet __user
*)
735 &p
->header
[header_length
/ 4];
739 (u
.packet
.header
, p
->header
, header_length
))
741 if (u
.packet
.skip
&& ctx
->type
== FW_ISO_CONTEXT_TRANSMIT
&&
742 u
.packet
.header_length
+ u
.packet
.payload_length
> 0)
744 if (payload
+ u
.packet
.payload_length
> buffer_end
)
747 if (fw_iso_context_queue(ctx
, &u
.packet
,
748 &client
->buffer
, payload
))
752 payload
+= u
.packet
.payload_length
;
756 request
->size
-= uptr_to_u64(p
) - request
->packets
;
757 request
->packets
= uptr_to_u64(p
);
758 request
->data
= client
->vm_start
+ payload
;
763 static int ioctl_start_iso(struct client
*client
, void *buffer
)
765 struct fw_cdev_start_iso
*request
= buffer
;
767 if (request
->handle
!= 0)
769 if (client
->iso_context
->type
== FW_ISO_CONTEXT_RECEIVE
) {
770 if (request
->tags
== 0 || request
->tags
> 15)
773 if (request
->sync
> 15)
777 return fw_iso_context_start(client
->iso_context
, request
->cycle
,
778 request
->sync
, request
->tags
);
781 static int ioctl_stop_iso(struct client
*client
, void *buffer
)
783 struct fw_cdev_stop_iso
*request
= buffer
;
785 if (request
->handle
!= 0)
788 return fw_iso_context_stop(client
->iso_context
);
791 static int (* const ioctl_handlers
[])(struct client
*client
, void *buffer
) = {
797 ioctl_initiate_bus_reset
,
798 ioctl_add_descriptor
,
799 ioctl_remove_descriptor
,
800 ioctl_create_iso_context
,
807 dispatch_ioctl(struct client
*client
, unsigned int cmd
, void __user
*arg
)
812 if (_IOC_TYPE(cmd
) != '#' ||
813 _IOC_NR(cmd
) >= ARRAY_SIZE(ioctl_handlers
))
816 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
817 if (_IOC_SIZE(cmd
) > sizeof buffer
||
818 copy_from_user(buffer
, arg
, _IOC_SIZE(cmd
)))
822 retval
= ioctl_handlers
[_IOC_NR(cmd
)](client
, buffer
);
826 if (_IOC_DIR(cmd
) & _IOC_READ
) {
827 if (_IOC_SIZE(cmd
) > sizeof buffer
||
828 copy_to_user(arg
, buffer
, _IOC_SIZE(cmd
)))
836 fw_device_op_ioctl(struct file
*file
,
837 unsigned int cmd
, unsigned long arg
)
839 struct client
*client
= file
->private_data
;
841 return dispatch_ioctl(client
, cmd
, (void __user
*) arg
);
846 fw_device_op_compat_ioctl(struct file
*file
,
847 unsigned int cmd
, unsigned long arg
)
849 struct client
*client
= file
->private_data
;
851 return dispatch_ioctl(client
, cmd
, compat_ptr(arg
));
855 static int fw_device_op_mmap(struct file
*file
, struct vm_area_struct
*vma
)
857 struct client
*client
= file
->private_data
;
858 enum dma_data_direction direction
;
860 int page_count
, retval
;
862 /* FIXME: We could support multiple buffers, but we don't. */
863 if (client
->buffer
.pages
!= NULL
)
866 if (!(vma
->vm_flags
& VM_SHARED
))
869 if (vma
->vm_start
& ~PAGE_MASK
)
872 client
->vm_start
= vma
->vm_start
;
873 size
= vma
->vm_end
- vma
->vm_start
;
874 page_count
= size
>> PAGE_SHIFT
;
875 if (size
& ~PAGE_MASK
)
878 if (vma
->vm_flags
& VM_WRITE
)
879 direction
= DMA_TO_DEVICE
;
881 direction
= DMA_FROM_DEVICE
;
883 retval
= fw_iso_buffer_init(&client
->buffer
, client
->device
->card
,
884 page_count
, direction
);
888 retval
= fw_iso_buffer_map(&client
->buffer
, vma
);
890 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
895 static int fw_device_op_release(struct inode
*inode
, struct file
*file
)
897 struct client
*client
= file
->private_data
;
898 struct event
*e
, *next_e
;
899 struct client_resource
*r
, *next_r
;
902 if (client
->buffer
.pages
)
903 fw_iso_buffer_destroy(&client
->buffer
, client
->device
->card
);
905 if (client
->iso_context
)
906 fw_iso_context_destroy(client
->iso_context
);
908 list_for_each_entry_safe(r
, next_r
, &client
->resource_list
, link
)
909 r
->release(client
, r
);
911 /* FIXME: We should wait for the async tasklets to stop
912 * running before freeing the memory. */
914 list_for_each_entry_safe(e
, next_e
, &client
->event_list
, link
)
917 spin_lock_irqsave(&client
->device
->card
->lock
, flags
);
918 list_del(&client
->link
);
919 spin_unlock_irqrestore(&client
->device
->card
->lock
, flags
);
921 fw_device_put(client
->device
);
927 static unsigned int fw_device_op_poll(struct file
*file
, poll_table
* pt
)
929 struct client
*client
= file
->private_data
;
930 unsigned int mask
= 0;
932 poll_wait(file
, &client
->wait
, pt
);
934 if (fw_device_is_shutdown(client
->device
))
935 mask
|= POLLHUP
| POLLERR
;
936 if (!list_empty(&client
->event_list
))
937 mask
|= POLLIN
| POLLRDNORM
;
942 const struct file_operations fw_device_ops
= {
943 .owner
= THIS_MODULE
,
944 .open
= fw_device_op_open
,
945 .read
= fw_device_op_read
,
946 .unlocked_ioctl
= fw_device_op_ioctl
,
947 .poll
= fw_device_op_poll
,
948 .release
= fw_device_op_release
,
949 .mmap
= fw_device_op_mmap
,
952 .compat_ioctl
= fw_device_op_compat_ioctl
,