4 * Raw interface to the bus
6 * Copyright (C) 1999, 2000 Andreas E. Bombe
7 * 2001, 2002 Manfred Weihs <weihs@ict.tuwien.ac.at>
8 * 2002 Christian Toegel <christian.toegel@gmx.at>
10 * This code is licensed under the GPL. See the file COPYING in the root
11 * directory of the kernel sources for details.
16 * Manfred Weihs <weihs@ict.tuwien.ac.at>
17 * configuration ROM manipulation
18 * address range mapping
19 * adaptation for new (transparent) loopback mechanism
20 * sending of arbitrary async packets
21 * Christian Toegel <christian.toegel@gmx.at>
22 * address range mapping
24 * transmit physical packet
25 * busreset notification control (switch on/off)
26 * busreset with selection of type (short/long)
30 #include <linux/kernel.h>
31 #include <linux/list.h>
32 #include <linux/string.h>
33 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/interrupt.h>
39 #include <linux/vmalloc.h>
40 #include <linux/cdev.h>
41 #include <asm/uaccess.h>
42 #include <asm/atomic.h>
43 #include <linux/compat.h>
46 #include "highlevel.h"
49 #include "ieee1394_core.h"
50 #include "ieee1394_hotplug.h"
51 #include "ieee1394_transactions.h"
52 #include "ieee1394_types.h"
56 #include "raw1394-private.h"
58 #define int2ptr(x) ((void __user *)(unsigned long)x)
59 #define ptr2int(x) ((u64)(unsigned long)(void __user *)x)
61 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
66 #define DBGMSG(fmt, args...) \
67 printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
69 #define DBGMSG(fmt, args...) do {} while (0)
72 static LIST_HEAD(host_info_list
);
73 static int host_count
;
74 static DEFINE_SPINLOCK(host_info_lock
);
75 static atomic_t internal_generation
= ATOMIC_INIT(0);
77 static atomic_t iso_buffer_size
;
78 static const int iso_buffer_max
= 4 * 1024 * 1024; /* 4 MB */
80 static struct hpsb_highlevel raw1394_highlevel
;
82 static int arm_read(struct hpsb_host
*host
, int nodeid
, quadlet_t
* buffer
,
83 u64 addr
, size_t length
, u16 flags
);
84 static int arm_write(struct hpsb_host
*host
, int nodeid
, int destid
,
85 quadlet_t
* data
, u64 addr
, size_t length
, u16 flags
);
86 static int arm_lock(struct hpsb_host
*host
, int nodeid
, quadlet_t
* store
,
87 u64 addr
, quadlet_t data
, quadlet_t arg
, int ext_tcode
,
89 static int arm_lock64(struct hpsb_host
*host
, int nodeid
, octlet_t
* store
,
90 u64 addr
, octlet_t data
, octlet_t arg
, int ext_tcode
,
92 static struct hpsb_address_ops arm_ops
= {
99 static void queue_complete_cb(struct pending_request
*req
);
101 #include <asm/current.h>
102 static void print_old_iso_deprecation(void)
106 if (p
== current
->pid
)
109 printk(KERN_WARNING
"raw1394: WARNING - Program \"%s\" uses unsupported"
110 " isochronous request types which will be removed in a next"
111 " kernel release\n", current
->comm
);
112 printk(KERN_WARNING
"raw1394: Update your software to use libraw1394's"
113 " newer interface\n");
116 static struct pending_request
*__alloc_pending_request(gfp_t flags
)
118 struct pending_request
*req
;
120 req
= kzalloc(sizeof(*req
), flags
);
122 INIT_LIST_HEAD(&req
->list
);
127 static inline struct pending_request
*alloc_pending_request(void)
129 return __alloc_pending_request(GFP_KERNEL
);
132 static void free_pending_request(struct pending_request
*req
)
135 if (atomic_dec_and_test(&req
->ibs
->refcount
)) {
136 atomic_sub(req
->ibs
->data_size
, &iso_buffer_size
);
139 } else if (req
->free_data
) {
142 hpsb_free_packet(req
->packet
);
146 /* fi->reqlists_lock must be taken */
147 static void __queue_complete_req(struct pending_request
*req
)
149 struct file_info
*fi
= req
->file_info
;
151 list_move_tail(&req
->list
, &fi
->req_complete
);
152 wake_up(&fi
->wait_complete
);
155 static void queue_complete_req(struct pending_request
*req
)
158 struct file_info
*fi
= req
->file_info
;
160 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
161 __queue_complete_req(req
);
162 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
165 static void queue_complete_cb(struct pending_request
*req
)
167 struct hpsb_packet
*packet
= req
->packet
;
168 int rcode
= (packet
->header
[1] >> 12) & 0xf;
170 switch (packet
->ack_code
) {
172 case ACKX_SEND_ERROR
:
173 req
->req
.error
= RAW1394_ERROR_SEND_ERROR
;
176 req
->req
.error
= RAW1394_ERROR_ABORTED
;
179 req
->req
.error
= RAW1394_ERROR_TIMEOUT
;
182 req
->req
.error
= (packet
->ack_code
<< 16) | rcode
;
186 if (!((packet
->ack_code
== ACK_PENDING
) && (rcode
== RCODE_COMPLETE
))) {
190 if ((req
->req
.type
== RAW1394_REQ_ASYNC_READ
) ||
191 (req
->req
.type
== RAW1394_REQ_ASYNC_WRITE
) ||
192 (req
->req
.type
== RAW1394_REQ_ASYNC_STREAM
) ||
193 (req
->req
.type
== RAW1394_REQ_LOCK
) ||
194 (req
->req
.type
== RAW1394_REQ_LOCK64
))
195 hpsb_free_tlabel(packet
);
197 queue_complete_req(req
);
200 static void add_host(struct hpsb_host
*host
)
202 struct host_info
*hi
;
205 hi
= kmalloc(sizeof(*hi
), GFP_KERNEL
);
208 INIT_LIST_HEAD(&hi
->list
);
210 INIT_LIST_HEAD(&hi
->file_info_list
);
212 spin_lock_irqsave(&host_info_lock
, flags
);
213 list_add_tail(&hi
->list
, &host_info_list
);
215 spin_unlock_irqrestore(&host_info_lock
, flags
);
218 atomic_inc(&internal_generation
);
221 static struct host_info
*find_host_info(struct hpsb_host
*host
)
223 struct host_info
*hi
;
225 list_for_each_entry(hi
, &host_info_list
, list
)
226 if (hi
->host
== host
)
232 static void remove_host(struct hpsb_host
*host
)
234 struct host_info
*hi
;
237 spin_lock_irqsave(&host_info_lock
, flags
);
238 hi
= find_host_info(host
);
244 FIXME: address ranges should be removed
245 and fileinfo states should be initialized
246 (including setting generation to
247 internal-generation ...)
250 spin_unlock_irqrestore(&host_info_lock
, flags
);
253 printk(KERN_ERR
"raw1394: attempt to remove unknown host "
260 atomic_inc(&internal_generation
);
263 static void host_reset(struct hpsb_host
*host
)
266 struct host_info
*hi
;
267 struct file_info
*fi
;
268 struct pending_request
*req
;
270 spin_lock_irqsave(&host_info_lock
, flags
);
271 hi
= find_host_info(host
);
274 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
275 if (fi
->notification
== RAW1394_NOTIFY_ON
) {
276 req
= __alloc_pending_request(GFP_ATOMIC
);
280 req
->req
.type
= RAW1394_REQ_BUS_RESET
;
281 req
->req
.generation
=
282 get_hpsb_generation(host
);
283 req
->req
.misc
= (host
->node_id
<< 16)
285 if (fi
->protocol_version
> 3) {
292 queue_complete_req(req
);
297 spin_unlock_irqrestore(&host_info_lock
, flags
);
300 static void iso_receive(struct hpsb_host
*host
, int channel
, quadlet_t
* data
,
304 struct host_info
*hi
;
305 struct file_info
*fi
;
306 struct pending_request
*req
, *req_next
;
307 struct iso_block_store
*ibs
= NULL
;
310 if ((atomic_read(&iso_buffer_size
) + length
) > iso_buffer_max
) {
311 HPSB_INFO("dropped iso packet");
315 spin_lock_irqsave(&host_info_lock
, flags
);
316 hi
= find_host_info(host
);
319 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
320 if (!(fi
->listen_channels
& (1ULL << channel
)))
323 req
= __alloc_pending_request(GFP_ATOMIC
);
328 ibs
= kmalloc(sizeof(*ibs
) + length
,
335 atomic_add(length
, &iso_buffer_size
);
336 atomic_set(&ibs
->refcount
, 0);
337 ibs
->data_size
= length
;
338 memcpy(ibs
->data
, data
, length
);
341 atomic_inc(&ibs
->refcount
);
345 req
->data
= ibs
->data
;
346 req
->req
.type
= RAW1394_REQ_ISO_RECEIVE
;
347 req
->req
.generation
= get_hpsb_generation(host
);
349 req
->req
.recvb
= ptr2int(fi
->iso_buffer
);
350 req
->req
.length
= min(length
, fi
->iso_buffer_length
);
352 list_add_tail(&req
->list
, &reqs
);
355 spin_unlock_irqrestore(&host_info_lock
, flags
);
357 list_for_each_entry_safe(req
, req_next
, &reqs
, list
)
358 queue_complete_req(req
);
361 static void fcp_request(struct hpsb_host
*host
, int nodeid
, int direction
,
362 int cts
, u8
* data
, size_t length
)
365 struct host_info
*hi
;
366 struct file_info
*fi
;
367 struct pending_request
*req
, *req_next
;
368 struct iso_block_store
*ibs
= NULL
;
371 if ((atomic_read(&iso_buffer_size
) + length
) > iso_buffer_max
) {
372 HPSB_INFO("dropped fcp request");
376 spin_lock_irqsave(&host_info_lock
, flags
);
377 hi
= find_host_info(host
);
380 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
384 req
= __alloc_pending_request(GFP_ATOMIC
);
389 ibs
= kmalloc(sizeof(*ibs
) + length
,
396 atomic_add(length
, &iso_buffer_size
);
397 atomic_set(&ibs
->refcount
, 0);
398 ibs
->data_size
= length
;
399 memcpy(ibs
->data
, data
, length
);
402 atomic_inc(&ibs
->refcount
);
406 req
->data
= ibs
->data
;
407 req
->req
.type
= RAW1394_REQ_FCP_REQUEST
;
408 req
->req
.generation
= get_hpsb_generation(host
);
409 req
->req
.misc
= nodeid
| (direction
<< 16);
410 req
->req
.recvb
= ptr2int(fi
->fcp_buffer
);
411 req
->req
.length
= length
;
413 list_add_tail(&req
->list
, &reqs
);
416 spin_unlock_irqrestore(&host_info_lock
, flags
);
418 list_for_each_entry_safe(req
, req_next
, &reqs
, list
)
419 queue_complete_req(req
);
423 struct compat_raw1394_req
{
438 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
439 __attribute__((packed
))
443 static const char __user
*raw1394_compat_write(const char __user
*buf
)
445 struct compat_raw1394_req __user
*cr
= (typeof(cr
)) buf
;
446 struct raw1394_request __user
*r
;
447 r
= compat_alloc_user_space(sizeof(struct raw1394_request
));
449 #define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x))
451 if (copy_in_user(r
, cr
, sizeof(struct compat_raw1394_req
)) ||
456 return ERR_PTR(-EFAULT
);
457 return (const char __user
*)r
;
461 #define P(x) __put_user(r->x, &cr->x)
464 raw1394_compat_read(const char __user
*buf
, struct raw1394_request
*r
)
466 struct compat_raw1394_req __user
*cr
= (typeof(cr
)) buf
;
467 if (!access_ok(VERIFY_WRITE
, cr
, sizeof(struct compat_raw1394_req
)) ||
478 return sizeof(struct compat_raw1394_req
);
484 /* get next completed request (caller must hold fi->reqlists_lock) */
485 static inline struct pending_request
*__next_complete_req(struct file_info
*fi
)
487 struct list_head
*lh
;
488 struct pending_request
*req
= NULL
;
490 if (!list_empty(&fi
->req_complete
)) {
491 lh
= fi
->req_complete
.next
;
493 req
= list_entry(lh
, struct pending_request
, list
);
498 /* atomically get next completed request */
499 static struct pending_request
*next_complete_req(struct file_info
*fi
)
502 struct pending_request
*req
;
504 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
505 req
= __next_complete_req(fi
);
506 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
510 static ssize_t
raw1394_read(struct file
*file
, char __user
* buffer
,
511 size_t count
, loff_t
* offset_is_ignored
)
513 struct file_info
*fi
= (struct file_info
*)file
->private_data
;
514 struct pending_request
*req
;
518 if (count
== sizeof(struct compat_raw1394_req
)) {
522 if (count
!= sizeof(struct raw1394_request
)) {
526 if (!access_ok(VERIFY_WRITE
, buffer
, count
)) {
530 if (file
->f_flags
& O_NONBLOCK
) {
531 if (!(req
= next_complete_req(fi
)))
535 * NB: We call the macro wait_event_interruptible() with a
536 * condition argument with side effect. This is only possible
537 * because the side effect does not occur until the condition
538 * became true, and wait_event_interruptible() won't evaluate
539 * the condition again after that.
541 if (wait_event_interruptible(fi
->wait_complete
,
542 (req
= next_complete_req(fi
))))
546 if (req
->req
.length
) {
547 if (copy_to_user(int2ptr(req
->req
.recvb
), req
->data
,
549 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
554 if (count
== sizeof(struct compat_raw1394_req
) &&
555 sizeof(struct compat_raw1394_req
) !=
556 sizeof(struct raw1394_request
)) {
557 ret
= raw1394_compat_read(buffer
, &req
->req
);
561 if (copy_to_user(buffer
, &req
->req
, sizeof(req
->req
))) {
565 ret
= (ssize_t
) sizeof(struct raw1394_request
);
568 free_pending_request(req
);
572 static int state_opened(struct file_info
*fi
, struct pending_request
*req
)
574 if (req
->req
.type
== RAW1394_REQ_INITIALIZE
) {
575 switch (req
->req
.misc
) {
576 case RAW1394_KERNELAPI_VERSION
:
578 fi
->state
= initialized
;
579 fi
->protocol_version
= req
->req
.misc
;
580 req
->req
.error
= RAW1394_ERROR_NONE
;
581 req
->req
.generation
= atomic_read(&internal_generation
);
585 req
->req
.error
= RAW1394_ERROR_COMPAT
;
586 req
->req
.misc
= RAW1394_KERNELAPI_VERSION
;
589 req
->req
.error
= RAW1394_ERROR_STATE_ORDER
;
593 queue_complete_req(req
);
597 static int state_initialized(struct file_info
*fi
, struct pending_request
*req
)
600 struct host_info
*hi
;
601 struct raw1394_khost_list
*khl
;
603 if (req
->req
.generation
!= atomic_read(&internal_generation
)) {
604 req
->req
.error
= RAW1394_ERROR_GENERATION
;
605 req
->req
.generation
= atomic_read(&internal_generation
);
607 queue_complete_req(req
);
611 switch (req
->req
.type
) {
612 case RAW1394_REQ_LIST_CARDS
:
613 spin_lock_irqsave(&host_info_lock
, flags
);
614 khl
= kmalloc(sizeof(*khl
) * host_count
, GFP_ATOMIC
);
617 req
->req
.misc
= host_count
;
618 req
->data
= (quadlet_t
*) khl
;
620 list_for_each_entry(hi
, &host_info_list
, list
) {
621 khl
->nodes
= hi
->host
->node_count
;
622 strcpy(khl
->name
, hi
->host
->driver
->name
);
626 spin_unlock_irqrestore(&host_info_lock
, flags
);
629 req
->req
.error
= RAW1394_ERROR_NONE
;
630 req
->req
.length
= min(req
->req
.length
,
632 (struct raw1394_khost_list
)
640 case RAW1394_REQ_SET_CARD
:
641 spin_lock_irqsave(&host_info_lock
, flags
);
642 if (req
->req
.misc
>= host_count
) {
643 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
646 list_for_each_entry(hi
, &host_info_list
, list
)
647 if (!req
->req
.misc
--)
649 get_device(&hi
->host
->device
); /* FIXME handle failure case */
650 list_add_tail(&fi
->list
, &hi
->file_info_list
);
652 /* prevent unloading of the host's low-level driver */
653 if (!try_module_get(hi
->host
->driver
->owner
)) {
654 req
->req
.error
= RAW1394_ERROR_ABORTED
;
659 fi
->state
= connected
;
661 req
->req
.error
= RAW1394_ERROR_NONE
;
662 req
->req
.generation
= get_hpsb_generation(fi
->host
);
663 req
->req
.misc
= (fi
->host
->node_id
<< 16)
664 | fi
->host
->node_count
;
665 if (fi
->protocol_version
> 3)
666 req
->req
.misc
|= NODEID_TO_NODE(fi
->host
->irm_id
) << 8;
668 spin_unlock_irqrestore(&host_info_lock
, flags
);
674 req
->req
.error
= RAW1394_ERROR_STATE_ORDER
;
679 queue_complete_req(req
);
683 static void handle_iso_listen(struct file_info
*fi
, struct pending_request
*req
)
685 int channel
= req
->req
.misc
;
687 if ((channel
> 63) || (channel
< -64)) {
688 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
689 } else if (channel
>= 0) {
690 /* allocate channel req.misc */
691 if (fi
->listen_channels
& (1ULL << channel
)) {
692 req
->req
.error
= RAW1394_ERROR_ALREADY
;
694 if (hpsb_listen_channel
695 (&raw1394_highlevel
, fi
->host
, channel
)) {
696 req
->req
.error
= RAW1394_ERROR_ALREADY
;
698 fi
->listen_channels
|= 1ULL << channel
;
699 fi
->iso_buffer
= int2ptr(req
->req
.recvb
);
700 fi
->iso_buffer_length
= req
->req
.length
;
704 /* deallocate channel (one's complement neg) req.misc */
707 if (fi
->listen_channels
& (1ULL << channel
)) {
708 hpsb_unlisten_channel(&raw1394_highlevel
, fi
->host
,
710 fi
->listen_channels
&= ~(1ULL << channel
);
712 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
717 queue_complete_req(req
);
720 static void handle_fcp_listen(struct file_info
*fi
, struct pending_request
*req
)
723 if (fi
->fcp_buffer
) {
724 req
->req
.error
= RAW1394_ERROR_ALREADY
;
726 fi
->fcp_buffer
= int2ptr(req
->req
.recvb
);
729 if (!fi
->fcp_buffer
) {
730 req
->req
.error
= RAW1394_ERROR_ALREADY
;
732 fi
->fcp_buffer
= NULL
;
737 queue_complete_req(req
);
740 static int handle_async_request(struct file_info
*fi
,
741 struct pending_request
*req
, int node
)
744 struct hpsb_packet
*packet
= NULL
;
745 u64 addr
= req
->req
.address
& 0xffffffffffffULL
;
747 switch (req
->req
.type
) {
748 case RAW1394_REQ_ASYNC_READ
:
749 DBGMSG("read_request called");
751 hpsb_make_readpacket(fi
->host
, node
, addr
, req
->req
.length
);
756 if (req
->req
.length
== 4)
757 req
->data
= &packet
->header
[3];
759 req
->data
= packet
->data
;
763 case RAW1394_REQ_ASYNC_WRITE
:
764 DBGMSG("write_request called");
766 packet
= hpsb_make_writepacket(fi
->host
, node
, addr
, NULL
,
771 if (req
->req
.length
== 4) {
773 (&packet
->header
[3], int2ptr(req
->req
.sendb
),
775 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
778 (packet
->data
, int2ptr(req
->req
.sendb
),
780 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
786 case RAW1394_REQ_ASYNC_STREAM
:
787 DBGMSG("stream_request called");
790 hpsb_make_streampacket(fi
->host
, NULL
, req
->req
.length
,
791 node
& 0x3f /*channel */ ,
792 (req
->req
.misc
>> 16) & 0x3,
793 req
->req
.misc
& 0xf);
797 if (copy_from_user(packet
->data
, int2ptr(req
->req
.sendb
),
799 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
804 case RAW1394_REQ_LOCK
:
805 DBGMSG("lock_request called");
806 if ((req
->req
.misc
== EXTCODE_FETCH_ADD
)
807 || (req
->req
.misc
== EXTCODE_LITTLE_ADD
)) {
808 if (req
->req
.length
!= 4) {
809 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
813 if (req
->req
.length
!= 8) {
814 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
819 packet
= hpsb_make_lockpacket(fi
->host
, node
, addr
,
820 req
->req
.misc
, NULL
, 0);
824 if (copy_from_user(packet
->data
, int2ptr(req
->req
.sendb
),
826 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
830 req
->data
= packet
->data
;
834 case RAW1394_REQ_LOCK64
:
835 DBGMSG("lock64_request called");
836 if ((req
->req
.misc
== EXTCODE_FETCH_ADD
)
837 || (req
->req
.misc
== EXTCODE_LITTLE_ADD
)) {
838 if (req
->req
.length
!= 8) {
839 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
843 if (req
->req
.length
!= 16) {
844 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
848 packet
= hpsb_make_lock64packet(fi
->host
, node
, addr
,
849 req
->req
.misc
, NULL
, 0);
853 if (copy_from_user(packet
->data
, int2ptr(req
->req
.sendb
),
855 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
859 req
->data
= packet
->data
;
864 req
->req
.error
= RAW1394_ERROR_STATE_ORDER
;
867 req
->packet
= packet
;
869 if (req
->req
.error
) {
871 queue_complete_req(req
);
875 hpsb_set_packet_complete_task(packet
,
876 (void (*)(void *))queue_complete_cb
, req
);
878 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
879 list_add_tail(&req
->list
, &fi
->req_pending
);
880 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
882 packet
->generation
= req
->req
.generation
;
884 if (hpsb_send_packet(packet
) < 0) {
885 req
->req
.error
= RAW1394_ERROR_SEND_ERROR
;
887 hpsb_free_tlabel(packet
);
888 queue_complete_req(req
);
893 static int handle_iso_send(struct file_info
*fi
, struct pending_request
*req
,
897 struct hpsb_packet
*packet
;
899 packet
= hpsb_make_isopacket(fi
->host
, req
->req
.length
, channel
& 0x3f,
900 (req
->req
.misc
>> 16) & 0x3,
901 req
->req
.misc
& 0xf);
905 packet
->speed_code
= req
->req
.address
& 0x3;
907 req
->packet
= packet
;
909 if (copy_from_user(packet
->data
, int2ptr(req
->req
.sendb
),
911 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
913 queue_complete_req(req
);
918 hpsb_set_packet_complete_task(packet
,
919 (void (*)(void *))queue_complete_req
,
922 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
923 list_add_tail(&req
->list
, &fi
->req_pending
);
924 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
926 /* Update the generation of the packet just before sending. */
927 packet
->generation
= req
->req
.generation
;
929 if (hpsb_send_packet(packet
) < 0) {
930 req
->req
.error
= RAW1394_ERROR_SEND_ERROR
;
931 queue_complete_req(req
);
937 static int handle_async_send(struct file_info
*fi
, struct pending_request
*req
)
940 struct hpsb_packet
*packet
;
941 int header_length
= req
->req
.misc
& 0xffff;
942 int expect_response
= req
->req
.misc
>> 16;
945 if (header_length
> req
->req
.length
|| header_length
< 12 ||
946 header_length
> FIELD_SIZEOF(struct hpsb_packet
, header
)) {
947 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
949 queue_complete_req(req
);
953 data_size
= req
->req
.length
- header_length
;
954 packet
= hpsb_alloc_packet(data_size
);
955 req
->packet
= packet
;
959 if (copy_from_user(packet
->header
, int2ptr(req
->req
.sendb
),
961 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
963 queue_complete_req(req
);
968 (packet
->data
, int2ptr(req
->req
.sendb
) + header_length
,
970 req
->req
.error
= RAW1394_ERROR_MEMFAULT
;
972 queue_complete_req(req
);
976 packet
->type
= hpsb_async
;
977 packet
->node_id
= packet
->header
[0] >> 16;
978 packet
->tcode
= (packet
->header
[0] >> 4) & 0xf;
979 packet
->tlabel
= (packet
->header
[0] >> 10) & 0x3f;
980 packet
->host
= fi
->host
;
981 packet
->expect_response
= expect_response
;
982 packet
->header_size
= header_length
;
983 packet
->data_size
= data_size
;
986 hpsb_set_packet_complete_task(packet
,
987 (void (*)(void *))queue_complete_cb
, req
);
989 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
990 list_add_tail(&req
->list
, &fi
->req_pending
);
991 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
993 /* Update the generation of the packet just before sending. */
994 packet
->generation
= req
->req
.generation
;
996 if (hpsb_send_packet(packet
) < 0) {
997 req
->req
.error
= RAW1394_ERROR_SEND_ERROR
;
998 queue_complete_req(req
);
1004 static int arm_read(struct hpsb_host
*host
, int nodeid
, quadlet_t
* buffer
,
1005 u64 addr
, size_t length
, u16 flags
)
1007 unsigned long irqflags
;
1008 struct pending_request
*req
;
1009 struct host_info
*hi
;
1010 struct file_info
*fi
= NULL
;
1011 struct list_head
*entry
;
1012 struct arm_addr
*arm_addr
= NULL
;
1013 struct arm_request
*arm_req
= NULL
;
1014 struct arm_response
*arm_resp
= NULL
;
1015 int found
= 0, size
= 0, rcode
= -1;
1016 struct arm_request_response
*arm_req_resp
= NULL
;
1018 DBGMSG("arm_read called by node: %X"
1019 "addr: %4.4x %8.8x length: %Zu", nodeid
,
1020 (u16
) ((addr
>> 32) & 0xFFFF), (u32
) (addr
& 0xFFFFFFFF),
1022 spin_lock_irqsave(&host_info_lock
, irqflags
);
1023 hi
= find_host_info(host
); /* search address-entry */
1025 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
1026 entry
= fi
->addr_list
.next
;
1027 while (entry
!= &(fi
->addr_list
)) {
1029 list_entry(entry
, struct arm_addr
,
1031 if (((arm_addr
->start
) <= (addr
))
1032 && ((arm_addr
->end
) >= (addr
+ length
))) {
1036 entry
= entry
->next
;
1045 printk(KERN_ERR
"raw1394: arm_read FAILED addr_entry not found"
1046 " -> rcode_address_error\n");
1047 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1048 return (RCODE_ADDRESS_ERROR
);
1050 DBGMSG("arm_read addr_entry FOUND");
1052 if (arm_addr
->rec_length
< length
) {
1053 DBGMSG("arm_read blocklength too big -> rcode_data_error");
1054 rcode
= RCODE_DATA_ERROR
; /* hardware error, data is unavailable */
1057 if (arm_addr
->access_rights
& ARM_READ
) {
1058 if (!(arm_addr
->client_transactions
& ARM_READ
)) {
1060 (arm_addr
->addr_space_buffer
) + (addr
-
1064 DBGMSG("arm_read -> (rcode_complete)");
1065 rcode
= RCODE_COMPLETE
;
1068 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1069 DBGMSG("arm_read -> rcode_type_error (access denied)");
1072 if (arm_addr
->notification_options
& ARM_READ
) {
1073 DBGMSG("arm_read -> entering notification-section");
1074 req
= __alloc_pending_request(GFP_ATOMIC
);
1076 DBGMSG("arm_read -> rcode_conflict_error");
1077 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1078 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1079 The request may be retried */
1081 if (rcode
== RCODE_COMPLETE
) {
1083 sizeof(struct arm_request
) +
1084 sizeof(struct arm_response
) +
1085 length
* sizeof(byte_t
) +
1086 sizeof(struct arm_request_response
);
1089 sizeof(struct arm_request
) +
1090 sizeof(struct arm_response
) +
1091 sizeof(struct arm_request_response
);
1093 req
->data
= kmalloc(size
, GFP_ATOMIC
);
1095 free_pending_request(req
);
1096 DBGMSG("arm_read -> rcode_conflict_error");
1097 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1098 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1099 The request may be retried */
1102 req
->file_info
= fi
;
1103 req
->req
.type
= RAW1394_REQ_ARM
;
1104 req
->req
.generation
= get_hpsb_generation(host
);
1106 (((length
<< 16) & (0xFFFF0000)) | (ARM_READ
& 0xFF));
1107 req
->req
.tag
= arm_addr
->arm_tag
;
1108 req
->req
.recvb
= arm_addr
->recvb
;
1109 req
->req
.length
= size
;
1110 arm_req_resp
= (struct arm_request_response
*)(req
->data
);
1111 arm_req
= (struct arm_request
*)((byte_t
*) (req
->data
) +
1114 arm_request_response
)));
1116 (struct arm_response
*)((byte_t
*) (arm_req
) +
1117 (sizeof(struct arm_request
)));
1118 arm_req
->buffer
= NULL
;
1119 arm_resp
->buffer
= NULL
;
1120 if (rcode
== RCODE_COMPLETE
) {
1122 (byte_t
*) arm_resp
+ sizeof(struct arm_response
);
1124 (arm_addr
->addr_space_buffer
) + (addr
-
1129 int2ptr((arm_addr
->recvb
) +
1130 sizeof(struct arm_request_response
) +
1131 sizeof(struct arm_request
) +
1132 sizeof(struct arm_response
));
1134 arm_resp
->buffer_length
=
1135 (rcode
== RCODE_COMPLETE
) ? length
: 0;
1136 arm_resp
->response_code
= rcode
;
1137 arm_req
->buffer_length
= 0;
1138 arm_req
->generation
= req
->req
.generation
;
1139 arm_req
->extended_transaction_code
= 0;
1140 arm_req
->destination_offset
= addr
;
1141 arm_req
->source_nodeid
= nodeid
;
1142 arm_req
->destination_nodeid
= host
->node_id
;
1143 arm_req
->tlabel
= (flags
>> 10) & 0x3f;
1144 arm_req
->tcode
= (flags
>> 4) & 0x0f;
1145 arm_req_resp
->request
= int2ptr((arm_addr
->recvb
) +
1147 arm_request_response
));
1148 arm_req_resp
->response
=
1149 int2ptr((arm_addr
->recvb
) +
1150 sizeof(struct arm_request_response
) +
1151 sizeof(struct arm_request
));
1152 queue_complete_req(req
);
1154 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1158 static int arm_write(struct hpsb_host
*host
, int nodeid
, int destid
,
1159 quadlet_t
* data
, u64 addr
, size_t length
, u16 flags
)
1161 unsigned long irqflags
;
1162 struct pending_request
*req
;
1163 struct host_info
*hi
;
1164 struct file_info
*fi
= NULL
;
1165 struct list_head
*entry
;
1166 struct arm_addr
*arm_addr
= NULL
;
1167 struct arm_request
*arm_req
= NULL
;
1168 struct arm_response
*arm_resp
= NULL
;
1169 int found
= 0, size
= 0, rcode
= -1, length_conflict
= 0;
1170 struct arm_request_response
*arm_req_resp
= NULL
;
1172 DBGMSG("arm_write called by node: %X"
1173 "addr: %4.4x %8.8x length: %Zu", nodeid
,
1174 (u16
) ((addr
>> 32) & 0xFFFF), (u32
) (addr
& 0xFFFFFFFF),
1176 spin_lock_irqsave(&host_info_lock
, irqflags
);
1177 hi
= find_host_info(host
); /* search address-entry */
1179 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
1180 entry
= fi
->addr_list
.next
;
1181 while (entry
!= &(fi
->addr_list
)) {
1183 list_entry(entry
, struct arm_addr
,
1185 if (((arm_addr
->start
) <= (addr
))
1186 && ((arm_addr
->end
) >= (addr
+ length
))) {
1190 entry
= entry
->next
;
1199 printk(KERN_ERR
"raw1394: arm_write FAILED addr_entry not found"
1200 " -> rcode_address_error\n");
1201 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1202 return (RCODE_ADDRESS_ERROR
);
1204 DBGMSG("arm_write addr_entry FOUND");
1206 if (arm_addr
->rec_length
< length
) {
1207 DBGMSG("arm_write blocklength too big -> rcode_data_error");
1208 length_conflict
= 1;
1209 rcode
= RCODE_DATA_ERROR
; /* hardware error, data is unavailable */
1212 if (arm_addr
->access_rights
& ARM_WRITE
) {
1213 if (!(arm_addr
->client_transactions
& ARM_WRITE
)) {
1214 memcpy((arm_addr
->addr_space_buffer
) +
1215 (addr
- (arm_addr
->start
)), data
,
1217 DBGMSG("arm_write -> (rcode_complete)");
1218 rcode
= RCODE_COMPLETE
;
1221 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1222 DBGMSG("arm_write -> rcode_type_error (access denied)");
1225 if (arm_addr
->notification_options
& ARM_WRITE
) {
1226 DBGMSG("arm_write -> entering notification-section");
1227 req
= __alloc_pending_request(GFP_ATOMIC
);
1229 DBGMSG("arm_write -> rcode_conflict_error");
1230 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1231 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1232 The request my be retried */
1235 sizeof(struct arm_request
) + sizeof(struct arm_response
) +
1236 (length
) * sizeof(byte_t
) +
1237 sizeof(struct arm_request_response
);
1238 req
->data
= kmalloc(size
, GFP_ATOMIC
);
1240 free_pending_request(req
);
1241 DBGMSG("arm_write -> rcode_conflict_error");
1242 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1243 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1244 The request may be retried */
1247 req
->file_info
= fi
;
1248 req
->req
.type
= RAW1394_REQ_ARM
;
1249 req
->req
.generation
= get_hpsb_generation(host
);
1251 (((length
<< 16) & (0xFFFF0000)) | (ARM_WRITE
& 0xFF));
1252 req
->req
.tag
= arm_addr
->arm_tag
;
1253 req
->req
.recvb
= arm_addr
->recvb
;
1254 req
->req
.length
= size
;
1255 arm_req_resp
= (struct arm_request_response
*)(req
->data
);
1256 arm_req
= (struct arm_request
*)((byte_t
*) (req
->data
) +
1259 arm_request_response
)));
1261 (struct arm_response
*)((byte_t
*) (arm_req
) +
1262 (sizeof(struct arm_request
)));
1263 arm_resp
->buffer
= NULL
;
1264 memcpy((byte_t
*) arm_resp
+ sizeof(struct arm_response
),
1266 arm_req
->buffer
= int2ptr((arm_addr
->recvb
) +
1267 sizeof(struct arm_request_response
) +
1268 sizeof(struct arm_request
) +
1269 sizeof(struct arm_response
));
1270 arm_req
->buffer_length
= length
;
1271 arm_req
->generation
= req
->req
.generation
;
1272 arm_req
->extended_transaction_code
= 0;
1273 arm_req
->destination_offset
= addr
;
1274 arm_req
->source_nodeid
= nodeid
;
1275 arm_req
->destination_nodeid
= destid
;
1276 arm_req
->tlabel
= (flags
>> 10) & 0x3f;
1277 arm_req
->tcode
= (flags
>> 4) & 0x0f;
1278 arm_resp
->buffer_length
= 0;
1279 arm_resp
->response_code
= rcode
;
1280 arm_req_resp
->request
= int2ptr((arm_addr
->recvb
) +
1282 arm_request_response
));
1283 arm_req_resp
->response
=
1284 int2ptr((arm_addr
->recvb
) +
1285 sizeof(struct arm_request_response
) +
1286 sizeof(struct arm_request
));
1287 queue_complete_req(req
);
1289 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1293 static int arm_lock(struct hpsb_host
*host
, int nodeid
, quadlet_t
* store
,
1294 u64 addr
, quadlet_t data
, quadlet_t arg
, int ext_tcode
,
1297 unsigned long irqflags
;
1298 struct pending_request
*req
;
1299 struct host_info
*hi
;
1300 struct file_info
*fi
= NULL
;
1301 struct list_head
*entry
;
1302 struct arm_addr
*arm_addr
= NULL
;
1303 struct arm_request
*arm_req
= NULL
;
1304 struct arm_response
*arm_resp
= NULL
;
1305 int found
= 0, size
= 0, rcode
= -1;
1307 struct arm_request_response
*arm_req_resp
= NULL
;
1309 if (((ext_tcode
& 0xFF) == EXTCODE_FETCH_ADD
) ||
1310 ((ext_tcode
& 0xFF) == EXTCODE_LITTLE_ADD
)) {
1311 DBGMSG("arm_lock called by node: %X "
1312 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
1313 nodeid
, (u16
) ((addr
>> 32) & 0xFFFF),
1314 (u32
) (addr
& 0xFFFFFFFF), ext_tcode
& 0xFF,
1317 DBGMSG("arm_lock called by node: %X "
1318 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
1319 nodeid
, (u16
) ((addr
>> 32) & 0xFFFF),
1320 (u32
) (addr
& 0xFFFFFFFF), ext_tcode
& 0xFF,
1321 be32_to_cpu(data
), be32_to_cpu(arg
));
1323 spin_lock_irqsave(&host_info_lock
, irqflags
);
1324 hi
= find_host_info(host
); /* search address-entry */
1326 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
1327 entry
= fi
->addr_list
.next
;
1328 while (entry
!= &(fi
->addr_list
)) {
1330 list_entry(entry
, struct arm_addr
,
1332 if (((arm_addr
->start
) <= (addr
))
1333 && ((arm_addr
->end
) >=
1334 (addr
+ sizeof(*store
)))) {
1338 entry
= entry
->next
;
1347 printk(KERN_ERR
"raw1394: arm_lock FAILED addr_entry not found"
1348 " -> rcode_address_error\n");
1349 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1350 return (RCODE_ADDRESS_ERROR
);
1352 DBGMSG("arm_lock addr_entry FOUND");
1355 if (arm_addr
->access_rights
& ARM_LOCK
) {
1356 if (!(arm_addr
->client_transactions
& ARM_LOCK
)) {
1358 (arm_addr
->addr_space_buffer
) + (addr
-
1362 switch (ext_tcode
) {
1363 case (EXTCODE_MASK_SWAP
):
1364 new = data
| (old
& ~arg
);
1366 case (EXTCODE_COMPARE_SWAP
):
1373 case (EXTCODE_FETCH_ADD
):
1375 cpu_to_be32(be32_to_cpu(data
) +
1378 case (EXTCODE_LITTLE_ADD
):
1380 cpu_to_le32(le32_to_cpu(data
) +
1383 case (EXTCODE_BOUNDED_ADD
):
1386 cpu_to_be32(be32_to_cpu
1394 case (EXTCODE_WRAP_ADD
):
1397 cpu_to_be32(be32_to_cpu
1406 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1408 "raw1394: arm_lock FAILED "
1409 "ext_tcode not allowed -> rcode_type_error\n");
1413 DBGMSG("arm_lock -> (rcode_complete)");
1414 rcode
= RCODE_COMPLETE
;
1415 memcpy(store
, &old
, sizeof(*store
));
1416 memcpy((arm_addr
->addr_space_buffer
) +
1417 (addr
- (arm_addr
->start
)),
1418 &new, sizeof(*store
));
1422 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1423 DBGMSG("arm_lock -> rcode_type_error (access denied)");
1426 if (arm_addr
->notification_options
& ARM_LOCK
) {
1427 byte_t
*buf1
, *buf2
;
1428 DBGMSG("arm_lock -> entering notification-section");
1429 req
= __alloc_pending_request(GFP_ATOMIC
);
1431 DBGMSG("arm_lock -> rcode_conflict_error");
1432 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1433 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1434 The request may be retried */
1436 size
= sizeof(struct arm_request
) + sizeof(struct arm_response
) + 3 * sizeof(*store
) + sizeof(struct arm_request_response
); /* maximum */
1437 req
->data
= kmalloc(size
, GFP_ATOMIC
);
1439 free_pending_request(req
);
1440 DBGMSG("arm_lock -> rcode_conflict_error");
1441 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1442 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1443 The request may be retried */
1446 arm_req_resp
= (struct arm_request_response
*)(req
->data
);
1447 arm_req
= (struct arm_request
*)((byte_t
*) (req
->data
) +
1450 arm_request_response
)));
1452 (struct arm_response
*)((byte_t
*) (arm_req
) +
1453 (sizeof(struct arm_request
)));
1454 buf1
= (byte_t
*) arm_resp
+ sizeof(struct arm_response
);
1455 buf2
= buf1
+ 2 * sizeof(*store
);
1456 if ((ext_tcode
== EXTCODE_FETCH_ADD
) ||
1457 (ext_tcode
== EXTCODE_LITTLE_ADD
)) {
1458 arm_req
->buffer_length
= sizeof(*store
);
1459 memcpy(buf1
, &data
, sizeof(*store
));
1462 arm_req
->buffer_length
= 2 * sizeof(*store
);
1463 memcpy(buf1
, &arg
, sizeof(*store
));
1464 memcpy(buf1
+ sizeof(*store
), &data
, sizeof(*store
));
1466 if (rcode
== RCODE_COMPLETE
) {
1467 arm_resp
->buffer_length
= sizeof(*store
);
1468 memcpy(buf2
, &old
, sizeof(*store
));
1470 arm_resp
->buffer_length
= 0;
1472 req
->file_info
= fi
;
1473 req
->req
.type
= RAW1394_REQ_ARM
;
1474 req
->req
.generation
= get_hpsb_generation(host
);
1475 req
->req
.misc
= ((((sizeof(*store
)) << 16) & (0xFFFF0000)) |
1477 req
->req
.tag
= arm_addr
->arm_tag
;
1478 req
->req
.recvb
= arm_addr
->recvb
;
1479 req
->req
.length
= size
;
1480 arm_req
->generation
= req
->req
.generation
;
1481 arm_req
->extended_transaction_code
= ext_tcode
;
1482 arm_req
->destination_offset
= addr
;
1483 arm_req
->source_nodeid
= nodeid
;
1484 arm_req
->destination_nodeid
= host
->node_id
;
1485 arm_req
->tlabel
= (flags
>> 10) & 0x3f;
1486 arm_req
->tcode
= (flags
>> 4) & 0x0f;
1487 arm_resp
->response_code
= rcode
;
1488 arm_req_resp
->request
= int2ptr((arm_addr
->recvb
) +
1490 arm_request_response
));
1491 arm_req_resp
->response
=
1492 int2ptr((arm_addr
->recvb
) +
1493 sizeof(struct arm_request_response
) +
1494 sizeof(struct arm_request
));
1496 int2ptr((arm_addr
->recvb
) +
1497 sizeof(struct arm_request_response
) +
1498 sizeof(struct arm_request
) +
1499 sizeof(struct arm_response
));
1501 int2ptr((arm_addr
->recvb
) +
1502 sizeof(struct arm_request_response
) +
1503 sizeof(struct arm_request
) +
1504 sizeof(struct arm_response
) + 2 * sizeof(*store
));
1505 queue_complete_req(req
);
1507 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1511 static int arm_lock64(struct hpsb_host
*host
, int nodeid
, octlet_t
* store
,
1512 u64 addr
, octlet_t data
, octlet_t arg
, int ext_tcode
,
1515 unsigned long irqflags
;
1516 struct pending_request
*req
;
1517 struct host_info
*hi
;
1518 struct file_info
*fi
= NULL
;
1519 struct list_head
*entry
;
1520 struct arm_addr
*arm_addr
= NULL
;
1521 struct arm_request
*arm_req
= NULL
;
1522 struct arm_response
*arm_resp
= NULL
;
1523 int found
= 0, size
= 0, rcode
= -1;
1525 struct arm_request_response
*arm_req_resp
= NULL
;
1527 if (((ext_tcode
& 0xFF) == EXTCODE_FETCH_ADD
) ||
1528 ((ext_tcode
& 0xFF) == EXTCODE_LITTLE_ADD
)) {
1529 DBGMSG("arm_lock64 called by node: %X "
1530 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
1531 nodeid
, (u16
) ((addr
>> 32) & 0xFFFF),
1532 (u32
) (addr
& 0xFFFFFFFF),
1534 (u32
) ((be64_to_cpu(data
) >> 32) & 0xFFFFFFFF),
1535 (u32
) (be64_to_cpu(data
) & 0xFFFFFFFF));
1537 DBGMSG("arm_lock64 called by node: %X "
1538 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
1540 nodeid
, (u16
) ((addr
>> 32) & 0xFFFF),
1541 (u32
) (addr
& 0xFFFFFFFF),
1543 (u32
) ((be64_to_cpu(data
) >> 32) & 0xFFFFFFFF),
1544 (u32
) (be64_to_cpu(data
) & 0xFFFFFFFF),
1545 (u32
) ((be64_to_cpu(arg
) >> 32) & 0xFFFFFFFF),
1546 (u32
) (be64_to_cpu(arg
) & 0xFFFFFFFF));
1548 spin_lock_irqsave(&host_info_lock
, irqflags
);
1549 hi
= find_host_info(host
); /* search addressentry in file_info's for host */
1551 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
1552 entry
= fi
->addr_list
.next
;
1553 while (entry
!= &(fi
->addr_list
)) {
1555 list_entry(entry
, struct arm_addr
,
1557 if (((arm_addr
->start
) <= (addr
))
1558 && ((arm_addr
->end
) >=
1559 (addr
+ sizeof(*store
)))) {
1563 entry
= entry
->next
;
1573 "raw1394: arm_lock64 FAILED addr_entry not found"
1574 " -> rcode_address_error\n");
1575 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1576 return (RCODE_ADDRESS_ERROR
);
1578 DBGMSG("arm_lock64 addr_entry FOUND");
1581 if (arm_addr
->access_rights
& ARM_LOCK
) {
1582 if (!(arm_addr
->client_transactions
& ARM_LOCK
)) {
1584 (arm_addr
->addr_space_buffer
) + (addr
-
1588 switch (ext_tcode
) {
1589 case (EXTCODE_MASK_SWAP
):
1590 new = data
| (old
& ~arg
);
1592 case (EXTCODE_COMPARE_SWAP
):
1599 case (EXTCODE_FETCH_ADD
):
1601 cpu_to_be64(be64_to_cpu(data
) +
1604 case (EXTCODE_LITTLE_ADD
):
1606 cpu_to_le64(le64_to_cpu(data
) +
1609 case (EXTCODE_BOUNDED_ADD
):
1612 cpu_to_be64(be64_to_cpu
1620 case (EXTCODE_WRAP_ADD
):
1623 cpu_to_be64(be64_to_cpu
1633 "raw1394: arm_lock64 FAILED "
1634 "ext_tcode not allowed -> rcode_type_error\n");
1635 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1640 ("arm_lock64 -> (rcode_complete)");
1641 rcode
= RCODE_COMPLETE
;
1642 memcpy(store
, &old
, sizeof(*store
));
1643 memcpy((arm_addr
->addr_space_buffer
) +
1644 (addr
- (arm_addr
->start
)),
1645 &new, sizeof(*store
));
1649 rcode
= RCODE_TYPE_ERROR
; /* function not allowed */
1651 ("arm_lock64 -> rcode_type_error (access denied)");
1654 if (arm_addr
->notification_options
& ARM_LOCK
) {
1655 byte_t
*buf1
, *buf2
;
1656 DBGMSG("arm_lock64 -> entering notification-section");
1657 req
= __alloc_pending_request(GFP_ATOMIC
);
1659 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1660 DBGMSG("arm_lock64 -> rcode_conflict_error");
1661 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1662 The request may be retried */
1664 size
= sizeof(struct arm_request
) + sizeof(struct arm_response
) + 3 * sizeof(*store
) + sizeof(struct arm_request_response
); /* maximum */
1665 req
->data
= kmalloc(size
, GFP_ATOMIC
);
1667 free_pending_request(req
);
1668 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1669 DBGMSG("arm_lock64 -> rcode_conflict_error");
1670 return (RCODE_CONFLICT_ERROR
); /* A resource conflict was detected.
1671 The request may be retried */
1674 arm_req_resp
= (struct arm_request_response
*)(req
->data
);
1675 arm_req
= (struct arm_request
*)((byte_t
*) (req
->data
) +
1678 arm_request_response
)));
1680 (struct arm_response
*)((byte_t
*) (arm_req
) +
1681 (sizeof(struct arm_request
)));
1682 buf1
= (byte_t
*) arm_resp
+ sizeof(struct arm_response
);
1683 buf2
= buf1
+ 2 * sizeof(*store
);
1684 if ((ext_tcode
== EXTCODE_FETCH_ADD
) ||
1685 (ext_tcode
== EXTCODE_LITTLE_ADD
)) {
1686 arm_req
->buffer_length
= sizeof(*store
);
1687 memcpy(buf1
, &data
, sizeof(*store
));
1690 arm_req
->buffer_length
= 2 * sizeof(*store
);
1691 memcpy(buf1
, &arg
, sizeof(*store
));
1692 memcpy(buf1
+ sizeof(*store
), &data
, sizeof(*store
));
1694 if (rcode
== RCODE_COMPLETE
) {
1695 arm_resp
->buffer_length
= sizeof(*store
);
1696 memcpy(buf2
, &old
, sizeof(*store
));
1698 arm_resp
->buffer_length
= 0;
1700 req
->file_info
= fi
;
1701 req
->req
.type
= RAW1394_REQ_ARM
;
1702 req
->req
.generation
= get_hpsb_generation(host
);
1703 req
->req
.misc
= ((((sizeof(*store
)) << 16) & (0xFFFF0000)) |
1705 req
->req
.tag
= arm_addr
->arm_tag
;
1706 req
->req
.recvb
= arm_addr
->recvb
;
1707 req
->req
.length
= size
;
1708 arm_req
->generation
= req
->req
.generation
;
1709 arm_req
->extended_transaction_code
= ext_tcode
;
1710 arm_req
->destination_offset
= addr
;
1711 arm_req
->source_nodeid
= nodeid
;
1712 arm_req
->destination_nodeid
= host
->node_id
;
1713 arm_req
->tlabel
= (flags
>> 10) & 0x3f;
1714 arm_req
->tcode
= (flags
>> 4) & 0x0f;
1715 arm_resp
->response_code
= rcode
;
1716 arm_req_resp
->request
= int2ptr((arm_addr
->recvb
) +
1718 arm_request_response
));
1719 arm_req_resp
->response
=
1720 int2ptr((arm_addr
->recvb
) +
1721 sizeof(struct arm_request_response
) +
1722 sizeof(struct arm_request
));
1724 int2ptr((arm_addr
->recvb
) +
1725 sizeof(struct arm_request_response
) +
1726 sizeof(struct arm_request
) +
1727 sizeof(struct arm_response
));
1729 int2ptr((arm_addr
->recvb
) +
1730 sizeof(struct arm_request_response
) +
1731 sizeof(struct arm_request
) +
1732 sizeof(struct arm_response
) + 2 * sizeof(*store
));
1733 queue_complete_req(req
);
1735 spin_unlock_irqrestore(&host_info_lock
, irqflags
);
1739 static int arm_register(struct file_info
*fi
, struct pending_request
*req
)
1742 struct arm_addr
*addr
;
1743 struct host_info
*hi
;
1744 struct file_info
*fi_hlp
= NULL
;
1745 struct list_head
*entry
;
1746 struct arm_addr
*arm_addr
= NULL
;
1747 int same_host
, another_host
;
1748 unsigned long flags
;
1750 DBGMSG("arm_register called "
1751 "addr(Offset): %8.8x %8.8x length: %u "
1752 "rights: %2.2X notify: %2.2X "
1753 "max_blk_len: %4.4X",
1754 (u32
) ((req
->req
.address
>> 32) & 0xFFFF),
1755 (u32
) (req
->req
.address
& 0xFFFFFFFF),
1756 req
->req
.length
, ((req
->req
.misc
>> 8) & 0xFF),
1757 (req
->req
.misc
& 0xFF), ((req
->req
.misc
>> 16) & 0xFFFF));
1758 /* check addressrange */
1759 if ((((req
->req
.address
) & ~(0xFFFFFFFFFFFFULL
)) != 0) ||
1760 (((req
->req
.address
+ req
->req
.length
) & ~(0xFFFFFFFFFFFFULL
)) !=
1762 req
->req
.length
= 0;
1765 /* addr-list-entry for fileinfo */
1766 addr
= kmalloc(sizeof(*addr
), GFP_KERNEL
);
1768 req
->req
.length
= 0;
1771 /* allocation of addr_space_buffer */
1772 addr
->addr_space_buffer
= vmalloc(req
->req
.length
);
1773 if (!(addr
->addr_space_buffer
)) {
1775 req
->req
.length
= 0;
1778 /* initialization of addr_space_buffer */
1779 if ((req
->req
.sendb
) == (unsigned long)NULL
) {
1781 memset(addr
->addr_space_buffer
, 0, req
->req
.length
);
1783 /* init: user -> kernel */
1785 (addr
->addr_space_buffer
, int2ptr(req
->req
.sendb
),
1787 vfree(addr
->addr_space_buffer
);
1792 INIT_LIST_HEAD(&addr
->addr_list
);
1793 addr
->arm_tag
= req
->req
.tag
;
1794 addr
->start
= req
->req
.address
;
1795 addr
->end
= req
->req
.address
+ req
->req
.length
;
1796 addr
->access_rights
= (u8
) (req
->req
.misc
& 0x0F);
1797 addr
->notification_options
= (u8
) ((req
->req
.misc
>> 4) & 0x0F);
1798 addr
->client_transactions
= (u8
) ((req
->req
.misc
>> 8) & 0x0F);
1799 addr
->access_rights
|= addr
->client_transactions
;
1800 addr
->notification_options
|= addr
->client_transactions
;
1801 addr
->recvb
= req
->req
.recvb
;
1802 addr
->rec_length
= (u16
) ((req
->req
.misc
>> 16) & 0xFFFF);
1804 spin_lock_irqsave(&host_info_lock
, flags
);
1805 hi
= find_host_info(fi
->host
);
1808 /* same host with address-entry containing same addressrange ? */
1809 list_for_each_entry(fi_hlp
, &hi
->file_info_list
, list
) {
1810 entry
= fi_hlp
->addr_list
.next
;
1811 while (entry
!= &(fi_hlp
->addr_list
)) {
1813 list_entry(entry
, struct arm_addr
, addr_list
);
1814 if ((arm_addr
->start
== addr
->start
)
1815 && (arm_addr
->end
== addr
->end
)) {
1816 DBGMSG("same host ownes same "
1817 "addressrange -> EALREADY");
1821 entry
= entry
->next
;
1828 /* addressrange occupied by same host */
1829 spin_unlock_irqrestore(&host_info_lock
, flags
);
1830 vfree(addr
->addr_space_buffer
);
1834 /* another host with valid address-entry containing same addressrange */
1835 list_for_each_entry(hi
, &host_info_list
, list
) {
1836 if (hi
->host
!= fi
->host
) {
1837 list_for_each_entry(fi_hlp
, &hi
->file_info_list
, list
) {
1838 entry
= fi_hlp
->addr_list
.next
;
1839 while (entry
!= &(fi_hlp
->addr_list
)) {
1841 list_entry(entry
, struct arm_addr
,
1843 if ((arm_addr
->start
== addr
->start
)
1844 && (arm_addr
->end
== addr
->end
)) {
1846 ("another host ownes same "
1851 entry
= entry
->next
;
1859 spin_unlock_irqrestore(&host_info_lock
, flags
);
1862 DBGMSG("another hosts entry is valid -> SUCCESS");
1863 if (copy_to_user(int2ptr(req
->req
.recvb
),
1864 &addr
->start
, sizeof(u64
))) {
1865 printk(KERN_ERR
"raw1394: arm_register failed "
1866 " address-range-entry is invalid -> EFAULT !!!\n");
1867 vfree(addr
->addr_space_buffer
);
1871 free_pending_request(req
); /* immediate success or fail */
1873 spin_lock_irqsave(&host_info_lock
, flags
);
1874 list_add_tail(&addr
->addr_list
, &fi
->addr_list
);
1875 spin_unlock_irqrestore(&host_info_lock
, flags
);
1879 hpsb_register_addrspace(&raw1394_highlevel
, fi
->host
, &arm_ops
,
1881 req
->req
.address
+ req
->req
.length
);
1884 spin_lock_irqsave(&host_info_lock
, flags
);
1885 list_add_tail(&addr
->addr_list
, &fi
->addr_list
);
1886 spin_unlock_irqrestore(&host_info_lock
, flags
);
1888 DBGMSG("arm_register failed errno: %d \n", retval
);
1889 vfree(addr
->addr_space_buffer
);
1893 free_pending_request(req
); /* immediate success or fail */
1897 static int arm_unregister(struct file_info
*fi
, struct pending_request
*req
)
1901 struct list_head
*entry
;
1902 struct arm_addr
*addr
= NULL
;
1903 struct host_info
*hi
;
1904 struct file_info
*fi_hlp
= NULL
;
1905 struct arm_addr
*arm_addr
= NULL
;
1907 unsigned long flags
;
1909 DBGMSG("arm_Unregister called addr(Offset): "
1911 (u32
) ((req
->req
.address
>> 32) & 0xFFFF),
1912 (u32
) (req
->req
.address
& 0xFFFFFFFF));
1913 spin_lock_irqsave(&host_info_lock
, flags
);
1915 entry
= fi
->addr_list
.next
;
1916 while (entry
!= &(fi
->addr_list
)) {
1917 addr
= list_entry(entry
, struct arm_addr
, addr_list
);
1918 if (addr
->start
== req
->req
.address
) {
1922 entry
= entry
->next
;
1925 DBGMSG("arm_Unregister addr not found");
1926 spin_unlock_irqrestore(&host_info_lock
, flags
);
1929 DBGMSG("arm_Unregister addr found");
1931 /* another host with valid address-entry containing
1932 same addressrange */
1933 list_for_each_entry(hi
, &host_info_list
, list
) {
1934 if (hi
->host
!= fi
->host
) {
1935 list_for_each_entry(fi_hlp
, &hi
->file_info_list
, list
) {
1936 entry
= fi_hlp
->addr_list
.next
;
1937 while (entry
!= &(fi_hlp
->addr_list
)) {
1938 arm_addr
= list_entry(entry
,
1941 if (arm_addr
->start
== addr
->start
) {
1942 DBGMSG("another host ownes "
1943 "same addressrange");
1947 entry
= entry
->next
;
1956 DBGMSG("delete entry from list -> success");
1957 list_del(&addr
->addr_list
);
1958 spin_unlock_irqrestore(&host_info_lock
, flags
);
1959 vfree(addr
->addr_space_buffer
);
1961 free_pending_request(req
); /* immediate success or fail */
1965 hpsb_unregister_addrspace(&raw1394_highlevel
, fi
->host
,
1968 printk(KERN_ERR
"raw1394: arm_Unregister failed -> EINVAL\n");
1969 spin_unlock_irqrestore(&host_info_lock
, flags
);
1972 DBGMSG("delete entry from list -> success");
1973 list_del(&addr
->addr_list
);
1974 spin_unlock_irqrestore(&host_info_lock
, flags
);
1975 vfree(addr
->addr_space_buffer
);
1977 free_pending_request(req
); /* immediate success or fail */
1981 /* Copy data from ARM buffer(s) to user buffer. */
1982 static int arm_get_buf(struct file_info
*fi
, struct pending_request
*req
)
1984 struct arm_addr
*arm_addr
= NULL
;
1985 unsigned long flags
;
1986 unsigned long offset
;
1988 struct list_head
*entry
;
1990 DBGMSG("arm_get_buf "
1991 "addr(Offset): %04X %08X length: %u",
1992 (u32
) ((req
->req
.address
>> 32) & 0xFFFF),
1993 (u32
) (req
->req
.address
& 0xFFFFFFFF), (u32
) req
->req
.length
);
1995 spin_lock_irqsave(&host_info_lock
, flags
);
1996 entry
= fi
->addr_list
.next
;
1997 while (entry
!= &(fi
->addr_list
)) {
1998 arm_addr
= list_entry(entry
, struct arm_addr
, addr_list
);
1999 if ((arm_addr
->start
<= req
->req
.address
) &&
2000 (arm_addr
->end
> req
->req
.address
)) {
2001 if (req
->req
.address
+ req
->req
.length
<= arm_addr
->end
) {
2002 offset
= req
->req
.address
- arm_addr
->start
;
2003 spin_unlock_irqrestore(&host_info_lock
, flags
);
2006 ("arm_get_buf copy_to_user( %08X, %p, %u )",
2007 (u32
) req
->req
.recvb
,
2008 arm_addr
->addr_space_buffer
+ offset
,
2009 (u32
) req
->req
.length
);
2011 (int2ptr(req
->req
.recvb
),
2012 arm_addr
->addr_space_buffer
+ offset
,
2016 /* We have to free the request, because we
2017 * queue no response, and therefore nobody
2019 free_pending_request(req
);
2022 DBGMSG("arm_get_buf request exceeded mapping");
2023 spin_unlock_irqrestore(&host_info_lock
, flags
);
2027 entry
= entry
->next
;
2029 spin_unlock_irqrestore(&host_info_lock
, flags
);
2033 /* Copy data from user buffer to ARM buffer(s). */
2034 static int arm_set_buf(struct file_info
*fi
, struct pending_request
*req
)
2036 struct arm_addr
*arm_addr
= NULL
;
2037 unsigned long flags
;
2038 unsigned long offset
;
2040 struct list_head
*entry
;
2042 DBGMSG("arm_set_buf "
2043 "addr(Offset): %04X %08X length: %u",
2044 (u32
) ((req
->req
.address
>> 32) & 0xFFFF),
2045 (u32
) (req
->req
.address
& 0xFFFFFFFF), (u32
) req
->req
.length
);
2047 spin_lock_irqsave(&host_info_lock
, flags
);
2048 entry
= fi
->addr_list
.next
;
2049 while (entry
!= &(fi
->addr_list
)) {
2050 arm_addr
= list_entry(entry
, struct arm_addr
, addr_list
);
2051 if ((arm_addr
->start
<= req
->req
.address
) &&
2052 (arm_addr
->end
> req
->req
.address
)) {
2053 if (req
->req
.address
+ req
->req
.length
<= arm_addr
->end
) {
2054 offset
= req
->req
.address
- arm_addr
->start
;
2055 spin_unlock_irqrestore(&host_info_lock
, flags
);
2058 ("arm_set_buf copy_from_user( %p, %08X, %u )",
2059 arm_addr
->addr_space_buffer
+ offset
,
2060 (u32
) req
->req
.sendb
,
2061 (u32
) req
->req
.length
);
2063 (arm_addr
->addr_space_buffer
+ offset
,
2064 int2ptr(req
->req
.sendb
),
2068 /* We have to free the request, because we
2069 * queue no response, and therefore nobody
2071 free_pending_request(req
);
2074 DBGMSG("arm_set_buf request exceeded mapping");
2075 spin_unlock_irqrestore(&host_info_lock
, flags
);
2079 entry
= entry
->next
;
2081 spin_unlock_irqrestore(&host_info_lock
, flags
);
2085 static int reset_notification(struct file_info
*fi
, struct pending_request
*req
)
2087 DBGMSG("reset_notification called - switch %s ",
2088 (req
->req
.misc
== RAW1394_NOTIFY_OFF
) ? "OFF" : "ON");
2089 if ((req
->req
.misc
== RAW1394_NOTIFY_OFF
) ||
2090 (req
->req
.misc
== RAW1394_NOTIFY_ON
)) {
2091 fi
->notification
= (u8
) req
->req
.misc
;
2092 free_pending_request(req
); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2095 /* error EINVAL (22) invalid argument */
2099 static int write_phypacket(struct file_info
*fi
, struct pending_request
*req
)
2101 struct hpsb_packet
*packet
= NULL
;
2104 unsigned long flags
;
2106 data
= be32_to_cpu((u32
) req
->req
.sendb
);
2107 DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data
);
2108 packet
= hpsb_make_phypacket(fi
->host
, data
);
2111 req
->req
.length
= 0;
2112 req
->packet
= packet
;
2113 hpsb_set_packet_complete_task(packet
,
2114 (void (*)(void *))queue_complete_cb
, req
);
2115 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
2116 list_add_tail(&req
->list
, &fi
->req_pending
);
2117 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
2118 packet
->generation
= req
->req
.generation
;
2119 retval
= hpsb_send_packet(packet
);
2120 DBGMSG("write_phypacket send_packet called => retval: %d ", retval
);
2122 req
->req
.error
= RAW1394_ERROR_SEND_ERROR
;
2123 req
->req
.length
= 0;
2124 queue_complete_req(req
);
2129 static int get_config_rom(struct file_info
*fi
, struct pending_request
*req
)
2132 quadlet_t
*data
= kmalloc(req
->req
.length
, GFP_KERNEL
);
2139 csr1212_read(fi
->host
->csr
.rom
, CSR1212_CONFIG_ROM_SPACE_OFFSET
,
2140 data
, req
->req
.length
);
2141 if (copy_to_user(int2ptr(req
->req
.recvb
), data
, req
->req
.length
))
2144 (int2ptr(req
->req
.tag
), &fi
->host
->csr
.rom
->cache_head
->len
,
2145 sizeof(fi
->host
->csr
.rom
->cache_head
->len
)))
2147 if (copy_to_user(int2ptr(req
->req
.address
), &fi
->host
->csr
.generation
,
2148 sizeof(fi
->host
->csr
.generation
)))
2150 if (copy_to_user(int2ptr(req
->req
.sendb
), &status
, sizeof(status
)))
2154 free_pending_request(req
); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2159 static int update_config_rom(struct file_info
*fi
, struct pending_request
*req
)
2162 quadlet_t
*data
= kmalloc(req
->req
.length
, GFP_KERNEL
);
2165 if (copy_from_user(data
, int2ptr(req
->req
.sendb
), req
->req
.length
)) {
2168 int status
= hpsb_update_config_rom(fi
->host
,
2169 data
, req
->req
.length
,
2170 (unsigned char)req
->req
.
2173 (int2ptr(req
->req
.recvb
), &status
, sizeof(status
)))
2178 free_pending_request(req
); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2184 static int modify_config_rom(struct file_info
*fi
, struct pending_request
*req
)
2186 struct csr1212_keyval
*kv
;
2187 struct csr1212_csr_rom_cache
*cache
;
2188 struct csr1212_dentry
*dentry
;
2192 if (req
->req
.misc
== ~0) {
2193 if (req
->req
.length
== 0)
2196 /* Find an unused slot */
2198 dr
< RAW1394_MAX_USER_CSR_DIRS
&& fi
->csr1212_dirs
[dr
];
2201 if (dr
== RAW1394_MAX_USER_CSR_DIRS
)
2204 fi
->csr1212_dirs
[dr
] =
2205 csr1212_new_directory(CSR1212_KV_ID_VENDOR
);
2206 if (!fi
->csr1212_dirs
[dr
])
2210 if (!fi
->csr1212_dirs
[dr
])
2213 /* Delete old stuff */
2215 fi
->csr1212_dirs
[dr
]->value
.directory
.dentries_head
;
2216 dentry
; dentry
= dentry
->next
) {
2217 csr1212_detach_keyval_from_directory(fi
->host
->csr
.rom
->
2222 if (req
->req
.length
== 0) {
2223 csr1212_release_keyval(fi
->csr1212_dirs
[dr
]);
2224 fi
->csr1212_dirs
[dr
] = NULL
;
2226 hpsb_update_config_rom_image(fi
->host
);
2227 free_pending_request(req
);
2232 cache
= csr1212_rom_cache_malloc(0, req
->req
.length
);
2234 csr1212_release_keyval(fi
->csr1212_dirs
[dr
]);
2235 fi
->csr1212_dirs
[dr
] = NULL
;
2239 cache
->filled_head
= kmalloc(sizeof(*cache
->filled_head
), GFP_KERNEL
);
2240 if (!cache
->filled_head
) {
2241 csr1212_release_keyval(fi
->csr1212_dirs
[dr
]);
2242 fi
->csr1212_dirs
[dr
] = NULL
;
2243 CSR1212_FREE(cache
);
2246 cache
->filled_tail
= cache
->filled_head
;
2248 if (copy_from_user(cache
->data
, int2ptr(req
->req
.sendb
),
2250 csr1212_release_keyval(fi
->csr1212_dirs
[dr
]);
2251 fi
->csr1212_dirs
[dr
] = NULL
;
2254 cache
->len
= req
->req
.length
;
2255 cache
->filled_head
->offset_start
= 0;
2256 cache
->filled_head
->offset_end
= cache
->size
- 1;
2258 cache
->layout_head
= cache
->layout_tail
= fi
->csr1212_dirs
[dr
];
2260 ret
= CSR1212_SUCCESS
;
2261 /* parse all the items */
2262 for (kv
= cache
->layout_head
; ret
== CSR1212_SUCCESS
&& kv
;
2264 ret
= csr1212_parse_keyval(kv
, cache
);
2267 /* attach top level items to the root directory */
2269 fi
->csr1212_dirs
[dr
]->value
.directory
.dentries_head
;
2270 ret
== CSR1212_SUCCESS
&& dentry
; dentry
= dentry
->next
) {
2272 csr1212_attach_keyval_to_directory(fi
->host
->csr
.
2277 if (ret
== CSR1212_SUCCESS
) {
2278 ret
= hpsb_update_config_rom_image(fi
->host
);
2280 if (ret
>= 0 && copy_to_user(int2ptr(req
->req
.recvb
),
2286 kfree(cache
->filled_head
);
2287 CSR1212_FREE(cache
);
2290 /* we have to free the request, because we queue no response,
2291 * and therefore nobody will free it */
2292 free_pending_request(req
);
2296 fi
->csr1212_dirs
[dr
]->value
.directory
.dentries_head
;
2297 dentry
; dentry
= dentry
->next
) {
2298 csr1212_detach_keyval_from_directory(fi
->host
->csr
.rom
->
2302 csr1212_release_keyval(fi
->csr1212_dirs
[dr
]);
2303 fi
->csr1212_dirs
[dr
] = NULL
;
2308 static int state_connected(struct file_info
*fi
, struct pending_request
*req
)
2310 int node
= req
->req
.address
>> 48;
2312 req
->req
.error
= RAW1394_ERROR_NONE
;
2314 switch (req
->req
.type
) {
2316 case RAW1394_REQ_ECHO
:
2317 queue_complete_req(req
);
2320 case RAW1394_REQ_ISO_SEND
:
2321 print_old_iso_deprecation();
2322 return handle_iso_send(fi
, req
, node
);
2324 case RAW1394_REQ_ARM_REGISTER
:
2325 return arm_register(fi
, req
);
2327 case RAW1394_REQ_ARM_UNREGISTER
:
2328 return arm_unregister(fi
, req
);
2330 case RAW1394_REQ_ARM_SET_BUF
:
2331 return arm_set_buf(fi
, req
);
2333 case RAW1394_REQ_ARM_GET_BUF
:
2334 return arm_get_buf(fi
, req
);
2336 case RAW1394_REQ_RESET_NOTIFY
:
2337 return reset_notification(fi
, req
);
2339 case RAW1394_REQ_ISO_LISTEN
:
2340 print_old_iso_deprecation();
2341 handle_iso_listen(fi
, req
);
2344 case RAW1394_REQ_FCP_LISTEN
:
2345 handle_fcp_listen(fi
, req
);
2348 case RAW1394_REQ_RESET_BUS
:
2349 if (req
->req
.misc
== RAW1394_LONG_RESET
) {
2350 DBGMSG("busreset called (type: LONG)");
2351 hpsb_reset_bus(fi
->host
, LONG_RESET
);
2352 free_pending_request(req
); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2355 if (req
->req
.misc
== RAW1394_SHORT_RESET
) {
2356 DBGMSG("busreset called (type: SHORT)");
2357 hpsb_reset_bus(fi
->host
, SHORT_RESET
);
2358 free_pending_request(req
); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2361 /* error EINVAL (22) invalid argument */
2363 case RAW1394_REQ_GET_ROM
:
2364 return get_config_rom(fi
, req
);
2366 case RAW1394_REQ_UPDATE_ROM
:
2367 return update_config_rom(fi
, req
);
2369 case RAW1394_REQ_MODIFY_ROM
:
2370 return modify_config_rom(fi
, req
);
2373 if (req
->req
.generation
!= get_hpsb_generation(fi
->host
)) {
2374 req
->req
.error
= RAW1394_ERROR_GENERATION
;
2375 req
->req
.generation
= get_hpsb_generation(fi
->host
);
2376 req
->req
.length
= 0;
2377 queue_complete_req(req
);
2381 switch (req
->req
.type
) {
2382 case RAW1394_REQ_PHYPACKET
:
2383 return write_phypacket(fi
, req
);
2384 case RAW1394_REQ_ASYNC_SEND
:
2385 return handle_async_send(fi
, req
);
2388 if (req
->req
.length
== 0) {
2389 req
->req
.error
= RAW1394_ERROR_INVALID_ARG
;
2390 queue_complete_req(req
);
2394 return handle_async_request(fi
, req
, node
);
2397 static ssize_t
raw1394_write(struct file
*file
, const char __user
* buffer
,
2398 size_t count
, loff_t
* offset_is_ignored
)
2400 struct file_info
*fi
= (struct file_info
*)file
->private_data
;
2401 struct pending_request
*req
;
2402 ssize_t retval
= -EBADFD
;
2404 #ifdef CONFIG_COMPAT
2405 if (count
== sizeof(struct compat_raw1394_req
) &&
2406 sizeof(struct compat_raw1394_req
) !=
2407 sizeof(struct raw1394_request
)) {
2408 buffer
= raw1394_compat_write(buffer
);
2410 return PTR_ERR(buffer
);
2413 if (count
!= sizeof(struct raw1394_request
)) {
2417 req
= alloc_pending_request();
2421 req
->file_info
= fi
;
2423 if (copy_from_user(&req
->req
, buffer
, sizeof(struct raw1394_request
))) {
2424 free_pending_request(req
);
2428 switch (fi
->state
) {
2430 retval
= state_opened(fi
, req
);
2434 retval
= state_initialized(fi
, req
);
2438 retval
= state_connected(fi
, req
);
2443 free_pending_request(req
);
2452 /* rawiso operations */
2454 /* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
2455 * completion queue (reqlists_lock must be taken) */
2456 static inline int __rawiso_event_in_queue(struct file_info
*fi
)
2458 struct pending_request
*req
;
2460 list_for_each_entry(req
, &fi
->req_complete
, list
)
2461 if (req
->req
.type
== RAW1394_REQ_RAWISO_ACTIVITY
)
2467 /* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
2468 static void queue_rawiso_event(struct file_info
*fi
)
2470 unsigned long flags
;
2472 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
2474 /* only one ISO activity event may be in the queue */
2475 if (!__rawiso_event_in_queue(fi
)) {
2476 struct pending_request
*req
=
2477 __alloc_pending_request(GFP_ATOMIC
);
2480 req
->file_info
= fi
;
2481 req
->req
.type
= RAW1394_REQ_RAWISO_ACTIVITY
;
2482 req
->req
.generation
= get_hpsb_generation(fi
->host
);
2483 __queue_complete_req(req
);
2485 /* on allocation failure, signal an overflow */
2486 if (fi
->iso_handle
) {
2487 atomic_inc(&fi
->iso_handle
->overflows
);
2491 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
2494 static void rawiso_activity_cb(struct hpsb_iso
*iso
)
2496 unsigned long flags
;
2497 struct host_info
*hi
;
2498 struct file_info
*fi
;
2500 spin_lock_irqsave(&host_info_lock
, flags
);
2501 hi
= find_host_info(iso
->host
);
2504 list_for_each_entry(fi
, &hi
->file_info_list
, list
) {
2505 if (fi
->iso_handle
== iso
)
2506 queue_rawiso_event(fi
);
2510 spin_unlock_irqrestore(&host_info_lock
, flags
);
2513 /* helper function - gather all the kernel iso status bits for returning to user-space */
2514 static void raw1394_iso_fill_status(struct hpsb_iso
*iso
,
2515 struct raw1394_iso_status
*stat
)
2517 stat
->config
.data_buf_size
= iso
->buf_size
;
2518 stat
->config
.buf_packets
= iso
->buf_packets
;
2519 stat
->config
.channel
= iso
->channel
;
2520 stat
->config
.speed
= iso
->speed
;
2521 stat
->config
.irq_interval
= iso
->irq_interval
;
2522 stat
->n_packets
= hpsb_iso_n_ready(iso
);
2523 stat
->overflows
= atomic_read(&iso
->overflows
);
2524 stat
->xmit_cycle
= iso
->xmit_cycle
;
2527 static int raw1394_iso_xmit_init(struct file_info
*fi
, void __user
* uaddr
)
2529 struct raw1394_iso_status stat
;
2534 if (copy_from_user(&stat
, uaddr
, sizeof(stat
)))
2537 fi
->iso_handle
= hpsb_iso_xmit_init(fi
->host
,
2538 stat
.config
.data_buf_size
,
2539 stat
.config
.buf_packets
,
2540 stat
.config
.channel
,
2542 stat
.config
.irq_interval
,
2543 rawiso_activity_cb
);
2544 if (!fi
->iso_handle
)
2547 fi
->iso_state
= RAW1394_ISO_XMIT
;
2549 raw1394_iso_fill_status(fi
->iso_handle
, &stat
);
2550 if (copy_to_user(uaddr
, &stat
, sizeof(stat
)))
2553 /* queue an event to get things started */
2554 rawiso_activity_cb(fi
->iso_handle
);
2559 static int raw1394_iso_recv_init(struct file_info
*fi
, void __user
* uaddr
)
2561 struct raw1394_iso_status stat
;
2566 if (copy_from_user(&stat
, uaddr
, sizeof(stat
)))
2569 fi
->iso_handle
= hpsb_iso_recv_init(fi
->host
,
2570 stat
.config
.data_buf_size
,
2571 stat
.config
.buf_packets
,
2572 stat
.config
.channel
,
2573 stat
.config
.dma_mode
,
2574 stat
.config
.irq_interval
,
2575 rawiso_activity_cb
);
2576 if (!fi
->iso_handle
)
2579 fi
->iso_state
= RAW1394_ISO_RECV
;
2581 raw1394_iso_fill_status(fi
->iso_handle
, &stat
);
2582 if (copy_to_user(uaddr
, &stat
, sizeof(stat
)))
2587 static int raw1394_iso_get_status(struct file_info
*fi
, void __user
* uaddr
)
2589 struct raw1394_iso_status stat
;
2590 struct hpsb_iso
*iso
= fi
->iso_handle
;
2592 raw1394_iso_fill_status(fi
->iso_handle
, &stat
);
2593 if (copy_to_user(uaddr
, &stat
, sizeof(stat
)))
2596 /* reset overflow counter */
2597 atomic_set(&iso
->overflows
, 0);
2602 /* copy N packet_infos out of the ringbuffer into user-supplied array */
2603 static int raw1394_iso_recv_packets(struct file_info
*fi
, void __user
* uaddr
)
2605 struct raw1394_iso_packets upackets
;
2606 unsigned int packet
= fi
->iso_handle
->first_packet
;
2609 if (copy_from_user(&upackets
, uaddr
, sizeof(upackets
)))
2612 if (upackets
.n_packets
> hpsb_iso_n_ready(fi
->iso_handle
))
2615 /* ensure user-supplied buffer is accessible and big enough */
2616 if (!access_ok(VERIFY_WRITE
, upackets
.infos
,
2617 upackets
.n_packets
*
2618 sizeof(struct raw1394_iso_packet_info
)))
2621 /* copy the packet_infos out */
2622 for (i
= 0; i
< upackets
.n_packets
; i
++) {
2623 if (__copy_to_user(&upackets
.infos
[i
],
2624 &fi
->iso_handle
->infos
[packet
],
2625 sizeof(struct raw1394_iso_packet_info
)))
2628 packet
= (packet
+ 1) % fi
->iso_handle
->buf_packets
;
2634 /* copy N packet_infos from user to ringbuffer, and queue them for transmission */
2635 static int raw1394_iso_send_packets(struct file_info
*fi
, void __user
* uaddr
)
2637 struct raw1394_iso_packets upackets
;
2640 if (copy_from_user(&upackets
, uaddr
, sizeof(upackets
)))
2643 if (upackets
.n_packets
>= fi
->iso_handle
->buf_packets
)
2646 if (upackets
.n_packets
>= hpsb_iso_n_ready(fi
->iso_handle
))
2649 /* ensure user-supplied buffer is accessible and big enough */
2650 if (!access_ok(VERIFY_READ
, upackets
.infos
,
2651 upackets
.n_packets
*
2652 sizeof(struct raw1394_iso_packet_info
)))
2655 /* copy the infos structs in and queue the packets */
2656 for (i
= 0; i
< upackets
.n_packets
; i
++) {
2657 struct raw1394_iso_packet_info info
;
2659 if (__copy_from_user(&info
, &upackets
.infos
[i
],
2660 sizeof(struct raw1394_iso_packet_info
)))
2663 rv
= hpsb_iso_xmit_queue_packet(fi
->iso_handle
, info
.offset
,
2664 info
.len
, info
.tag
, info
.sy
);
2672 static void raw1394_iso_shutdown(struct file_info
*fi
)
2675 hpsb_iso_shutdown(fi
->iso_handle
);
2677 fi
->iso_handle
= NULL
;
2678 fi
->iso_state
= RAW1394_ISO_INACTIVE
;
2681 static int raw1394_read_cycle_timer(struct file_info
*fi
, void __user
* uaddr
)
2683 struct raw1394_cycle_timer ct
;
2686 err
= hpsb_read_cycle_timer(fi
->host
, &ct
.cycle_timer
, &ct
.local_time
);
2688 if (copy_to_user(uaddr
, &ct
, sizeof(ct
)))
2693 /* mmap the rawiso xmit/recv buffer */
2694 static int raw1394_mmap(struct file
*file
, struct vm_area_struct
*vma
)
2696 struct file_info
*fi
= file
->private_data
;
2698 if (fi
->iso_state
== RAW1394_ISO_INACTIVE
)
2701 return dma_region_mmap(&fi
->iso_handle
->data_buf
, file
, vma
);
2704 /* ioctl is only used for rawiso operations */
2705 static int raw1394_ioctl(struct inode
*inode
, struct file
*file
,
2706 unsigned int cmd
, unsigned long arg
)
2708 struct file_info
*fi
= file
->private_data
;
2709 void __user
*argp
= (void __user
*)arg
;
2711 switch (fi
->iso_state
) {
2712 case RAW1394_ISO_INACTIVE
:
2714 case RAW1394_IOC_ISO_XMIT_INIT
:
2715 return raw1394_iso_xmit_init(fi
, argp
);
2716 case RAW1394_IOC_ISO_RECV_INIT
:
2717 return raw1394_iso_recv_init(fi
, argp
);
2722 case RAW1394_ISO_RECV
:
2724 case RAW1394_IOC_ISO_RECV_START
:{
2725 /* copy args from user-space */
2728 (&args
[0], argp
, sizeof(args
)))
2730 return hpsb_iso_recv_start(fi
->iso_handle
,
2734 case RAW1394_IOC_ISO_XMIT_RECV_STOP
:
2735 hpsb_iso_stop(fi
->iso_handle
);
2737 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL
:
2738 return hpsb_iso_recv_listen_channel(fi
->iso_handle
,
2740 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL
:
2741 return hpsb_iso_recv_unlisten_channel(fi
->iso_handle
,
2743 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK
:{
2744 /* copy the u64 from user-space */
2746 if (copy_from_user(&mask
, argp
, sizeof(mask
)))
2748 return hpsb_iso_recv_set_channel_mask(fi
->
2752 case RAW1394_IOC_ISO_GET_STATUS
:
2753 return raw1394_iso_get_status(fi
, argp
);
2754 case RAW1394_IOC_ISO_RECV_PACKETS
:
2755 return raw1394_iso_recv_packets(fi
, argp
);
2756 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS
:
2757 return hpsb_iso_recv_release_packets(fi
->iso_handle
,
2759 case RAW1394_IOC_ISO_RECV_FLUSH
:
2760 return hpsb_iso_recv_flush(fi
->iso_handle
);
2761 case RAW1394_IOC_ISO_SHUTDOWN
:
2762 raw1394_iso_shutdown(fi
);
2764 case RAW1394_IOC_ISO_QUEUE_ACTIVITY
:
2765 queue_rawiso_event(fi
);
2769 case RAW1394_ISO_XMIT
:
2771 case RAW1394_IOC_ISO_XMIT_START
:{
2772 /* copy two ints from user-space */
2775 (&args
[0], argp
, sizeof(args
)))
2777 return hpsb_iso_xmit_start(fi
->iso_handle
,
2780 case RAW1394_IOC_ISO_XMIT_SYNC
:
2781 return hpsb_iso_xmit_sync(fi
->iso_handle
);
2782 case RAW1394_IOC_ISO_XMIT_RECV_STOP
:
2783 hpsb_iso_stop(fi
->iso_handle
);
2785 case RAW1394_IOC_ISO_GET_STATUS
:
2786 return raw1394_iso_get_status(fi
, argp
);
2787 case RAW1394_IOC_ISO_XMIT_PACKETS
:
2788 return raw1394_iso_send_packets(fi
, argp
);
2789 case RAW1394_IOC_ISO_SHUTDOWN
:
2790 raw1394_iso_shutdown(fi
);
2792 case RAW1394_IOC_ISO_QUEUE_ACTIVITY
:
2793 queue_rawiso_event(fi
);
2801 /* state-independent commands */
2803 case RAW1394_IOC_GET_CYCLE_TIMER
:
2804 return raw1394_read_cycle_timer(fi
, argp
);
2812 #ifdef CONFIG_COMPAT
2813 struct raw1394_iso_packets32
{
2815 compat_uptr_t infos
;
2816 } __attribute__((packed
));
2818 struct raw1394_cycle_timer32
{
2822 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
2823 __attribute__((packed
))
2827 #define RAW1394_IOC_ISO_RECV_PACKETS32 \
2828 _IOW ('#', 0x25, struct raw1394_iso_packets32)
2829 #define RAW1394_IOC_ISO_XMIT_PACKETS32 \
2830 _IOW ('#', 0x27, struct raw1394_iso_packets32)
2831 #define RAW1394_IOC_GET_CYCLE_TIMER32 \
2832 _IOR ('#', 0x30, struct raw1394_cycle_timer32)
2834 static long raw1394_iso_xmit_recv_packets32(struct file
*file
, unsigned int cmd
,
2835 struct raw1394_iso_packets32 __user
*arg
)
2837 compat_uptr_t infos32
;
2840 struct raw1394_iso_packets __user
*dst
= compat_alloc_user_space(sizeof(struct raw1394_iso_packets
));
2842 if (!copy_in_user(&dst
->n_packets
, &arg
->n_packets
, sizeof arg
->n_packets
) &&
2843 !copy_from_user(&infos32
, &arg
->infos
, sizeof infos32
)) {
2844 infos
= compat_ptr(infos32
);
2845 if (!copy_to_user(&dst
->infos
, &infos
, sizeof infos
))
2846 err
= raw1394_ioctl(NULL
, file
, cmd
, (unsigned long)dst
);
2851 static long raw1394_read_cycle_timer32(struct file_info
*fi
, void __user
* uaddr
)
2853 struct raw1394_cycle_timer32 ct
;
2856 err
= hpsb_read_cycle_timer(fi
->host
, &ct
.cycle_timer
, &ct
.local_time
);
2858 if (copy_to_user(uaddr
, &ct
, sizeof(ct
)))
2863 static long raw1394_compat_ioctl(struct file
*file
,
2864 unsigned int cmd
, unsigned long arg
)
2866 struct file_info
*fi
= file
->private_data
;
2867 void __user
*argp
= (void __user
*)arg
;
2872 /* These requests have same format as long as 'int' has same size. */
2873 case RAW1394_IOC_ISO_RECV_INIT
:
2874 case RAW1394_IOC_ISO_RECV_START
:
2875 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL
:
2876 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL
:
2877 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK
:
2878 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS
:
2879 case RAW1394_IOC_ISO_RECV_FLUSH
:
2880 case RAW1394_IOC_ISO_XMIT_RECV_STOP
:
2881 case RAW1394_IOC_ISO_XMIT_INIT
:
2882 case RAW1394_IOC_ISO_XMIT_START
:
2883 case RAW1394_IOC_ISO_XMIT_SYNC
:
2884 case RAW1394_IOC_ISO_GET_STATUS
:
2885 case RAW1394_IOC_ISO_SHUTDOWN
:
2886 case RAW1394_IOC_ISO_QUEUE_ACTIVITY
:
2887 err
= raw1394_ioctl(NULL
, file
, cmd
, arg
);
2889 /* These request have different format. */
2890 case RAW1394_IOC_ISO_RECV_PACKETS32
:
2891 err
= raw1394_iso_xmit_recv_packets32(file
, RAW1394_IOC_ISO_RECV_PACKETS
, argp
);
2893 case RAW1394_IOC_ISO_XMIT_PACKETS32
:
2894 err
= raw1394_iso_xmit_recv_packets32(file
, RAW1394_IOC_ISO_XMIT_PACKETS
, argp
);
2896 case RAW1394_IOC_GET_CYCLE_TIMER32
:
2897 err
= raw1394_read_cycle_timer32(fi
, argp
);
2909 static unsigned int raw1394_poll(struct file
*file
, poll_table
* pt
)
2911 struct file_info
*fi
= file
->private_data
;
2912 unsigned int mask
= POLLOUT
| POLLWRNORM
;
2913 unsigned long flags
;
2915 poll_wait(file
, &fi
->wait_complete
, pt
);
2917 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
2918 if (!list_empty(&fi
->req_complete
)) {
2919 mask
|= POLLIN
| POLLRDNORM
;
2921 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
2926 static int raw1394_open(struct inode
*inode
, struct file
*file
)
2928 struct file_info
*fi
;
2930 fi
= kzalloc(sizeof(*fi
), GFP_KERNEL
);
2934 fi
->notification
= (u8
) RAW1394_NOTIFY_ON
; /* busreset notification */
2936 INIT_LIST_HEAD(&fi
->list
);
2938 INIT_LIST_HEAD(&fi
->req_pending
);
2939 INIT_LIST_HEAD(&fi
->req_complete
);
2940 spin_lock_init(&fi
->reqlists_lock
);
2941 init_waitqueue_head(&fi
->wait_complete
);
2942 INIT_LIST_HEAD(&fi
->addr_list
);
2944 file
->private_data
= fi
;
2949 static int raw1394_release(struct inode
*inode
, struct file
*file
)
2951 struct file_info
*fi
= file
->private_data
;
2952 struct list_head
*lh
;
2953 struct pending_request
*req
;
2956 struct list_head
*entry
;
2957 struct arm_addr
*addr
= NULL
;
2958 struct host_info
*hi
;
2959 struct file_info
*fi_hlp
= NULL
;
2960 struct arm_addr
*arm_addr
= NULL
;
2963 unsigned long flags
;
2965 if (fi
->iso_state
!= RAW1394_ISO_INACTIVE
)
2966 raw1394_iso_shutdown(fi
);
2968 for (i
= 0; i
< 64; i
++) {
2969 if (fi
->listen_channels
& (1ULL << i
)) {
2970 hpsb_unlisten_channel(&raw1394_highlevel
, fi
->host
, i
);
2974 spin_lock_irqsave(&host_info_lock
, flags
);
2975 fi
->listen_channels
= 0;
2978 /* set address-entries invalid */
2980 while (!list_empty(&fi
->addr_list
)) {
2982 lh
= fi
->addr_list
.next
;
2983 addr
= list_entry(lh
, struct arm_addr
, addr_list
);
2984 /* another host with valid address-entry containing
2985 same addressrange? */
2986 list_for_each_entry(hi
, &host_info_list
, list
) {
2987 if (hi
->host
!= fi
->host
) {
2988 list_for_each_entry(fi_hlp
, &hi
->file_info_list
,
2990 entry
= fi_hlp
->addr_list
.next
;
2991 while (entry
!= &(fi_hlp
->addr_list
)) {
2992 arm_addr
= list_entry(entry
, struct
2995 if (arm_addr
->start
==
2998 ("raw1394_release: "
2999 "another host ownes "
3000 "same addressrange");
3004 entry
= entry
->next
;
3012 if (!another_host
) {
3013 DBGMSG("raw1394_release: call hpsb_arm_unregister");
3015 hpsb_unregister_addrspace(&raw1394_highlevel
,
3016 fi
->host
, addr
->start
);
3020 "raw1394_release arm_Unregister failed\n");
3023 DBGMSG("raw1394_release: delete addr_entry from list");
3024 list_del(&addr
->addr_list
);
3025 vfree(addr
->addr_space_buffer
);
3028 spin_unlock_irqrestore(&host_info_lock
, flags
);
3030 printk(KERN_ERR
"raw1394: during addr_list-release "
3031 "error(s) occurred \n");
3035 /* This locked section guarantees that neither
3036 * complete nor pending requests exist once i!=0 */
3037 spin_lock_irqsave(&fi
->reqlists_lock
, flags
);
3038 while ((req
= __next_complete_req(fi
)))
3039 free_pending_request(req
);
3041 i
= list_empty(&fi
->req_pending
);
3042 spin_unlock_irqrestore(&fi
->reqlists_lock
, flags
);
3047 * Sleep until more requests can be freed.
3049 * NB: We call the macro wait_event() with a condition argument
3050 * with side effect. This is only possible because the side
3051 * effect does not occur until the condition became true, and
3052 * wait_event() won't evaluate the condition again after that.
3054 wait_event(fi
->wait_complete
, (req
= next_complete_req(fi
)));
3055 free_pending_request(req
);
3058 /* Remove any sub-trees left by user space programs */
3059 for (i
= 0; i
< RAW1394_MAX_USER_CSR_DIRS
; i
++) {
3060 struct csr1212_dentry
*dentry
;
3061 if (!fi
->csr1212_dirs
[i
])
3064 fi
->csr1212_dirs
[i
]->value
.directory
.dentries_head
; dentry
;
3065 dentry
= dentry
->next
) {
3066 csr1212_detach_keyval_from_directory(fi
->host
->csr
.rom
->
3070 csr1212_release_keyval(fi
->csr1212_dirs
[i
]);
3071 fi
->csr1212_dirs
[i
] = NULL
;
3075 if ((csr_mod
|| fi
->cfgrom_upd
)
3076 && hpsb_update_config_rom_image(fi
->host
) < 0)
3078 ("Failed to generate Configuration ROM image for host %d",
3081 if (fi
->state
== connected
) {
3082 spin_lock_irqsave(&host_info_lock
, flags
);
3083 list_del(&fi
->list
);
3084 spin_unlock_irqrestore(&host_info_lock
, flags
);
3086 put_device(&fi
->host
->device
);
3089 spin_lock_irqsave(&host_info_lock
, flags
);
3091 module_put(fi
->host
->driver
->owner
);
3092 spin_unlock_irqrestore(&host_info_lock
, flags
);
3099 /*** HOTPLUG STUFF **********************************************************/
3101 * Export information about protocols/devices supported by this driver.
3103 static struct ieee1394_device_id raw1394_id_table
[] = {
3105 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
| IEEE1394_MATCH_VERSION
,
3106 .specifier_id
= AVC_UNIT_SPEC_ID_ENTRY
& 0xffffff,
3107 .version
= AVC_SW_VERSION_ENTRY
& 0xffffff},
3109 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
| IEEE1394_MATCH_VERSION
,
3110 .specifier_id
= CAMERA_UNIT_SPEC_ID_ENTRY
& 0xffffff,
3111 .version
= CAMERA_SW_VERSION_ENTRY
& 0xffffff},
3113 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
| IEEE1394_MATCH_VERSION
,
3114 .specifier_id
= CAMERA_UNIT_SPEC_ID_ENTRY
& 0xffffff,
3115 .version
= (CAMERA_SW_VERSION_ENTRY
+ 1) & 0xffffff},
3117 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
| IEEE1394_MATCH_VERSION
,
3118 .specifier_id
= CAMERA_UNIT_SPEC_ID_ENTRY
& 0xffffff,
3119 .version
= (CAMERA_SW_VERSION_ENTRY
+ 2) & 0xffffff},
3123 MODULE_DEVICE_TABLE(ieee1394
, raw1394_id_table
);
3125 static struct hpsb_protocol_driver raw1394_driver
= {
3127 .id_table
= raw1394_id_table
,
3130 /******************************************************************************/
3132 static struct hpsb_highlevel raw1394_highlevel
= {
3133 .name
= RAW1394_DEVICE_NAME
,
3134 .add_host
= add_host
,
3135 .remove_host
= remove_host
,
3136 .host_reset
= host_reset
,
3137 .iso_receive
= iso_receive
,
3138 .fcp_request
= fcp_request
,
3141 static struct cdev raw1394_cdev
;
3142 static const struct file_operations raw1394_fops
= {
3143 .owner
= THIS_MODULE
,
3144 .read
= raw1394_read
,
3145 .write
= raw1394_write
,
3146 .mmap
= raw1394_mmap
,
3147 .ioctl
= raw1394_ioctl
,
3148 #ifdef CONFIG_COMPAT
3149 .compat_ioctl
= raw1394_compat_ioctl
,
3151 .poll
= raw1394_poll
,
3152 .open
= raw1394_open
,
3153 .release
= raw1394_release
,
3156 static int __init
init_raw1394(void)
3160 hpsb_register_highlevel(&raw1394_highlevel
);
3164 hpsb_protocol_class
, NULL
,
3165 MKDEV(IEEE1394_MAJOR
, IEEE1394_MINOR_BLOCK_RAW1394
* 16),
3166 RAW1394_DEVICE_NAME
))) {
3171 cdev_init(&raw1394_cdev
, &raw1394_fops
);
3172 raw1394_cdev
.owner
= THIS_MODULE
;
3173 kobject_set_name(&raw1394_cdev
.kobj
, RAW1394_DEVICE_NAME
);
3174 ret
= cdev_add(&raw1394_cdev
, IEEE1394_RAW1394_DEV
, 1);
3176 HPSB_ERR("raw1394 failed to register minor device block");
3180 HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME
);
3182 ret
= hpsb_register_protocol(&raw1394_driver
);
3184 HPSB_ERR("raw1394: failed to register protocol");
3185 cdev_del(&raw1394_cdev
);
3192 device_destroy(hpsb_protocol_class
,
3193 MKDEV(IEEE1394_MAJOR
,
3194 IEEE1394_MINOR_BLOCK_RAW1394
* 16));
3196 hpsb_unregister_highlevel(&raw1394_highlevel
);
3201 static void __exit
cleanup_raw1394(void)
3203 device_destroy(hpsb_protocol_class
,
3204 MKDEV(IEEE1394_MAJOR
,
3205 IEEE1394_MINOR_BLOCK_RAW1394
* 16));
3206 cdev_del(&raw1394_cdev
);
3207 hpsb_unregister_highlevel(&raw1394_highlevel
);
3208 hpsb_unregister_protocol(&raw1394_driver
);
3211 module_init(init_raw1394
);
3212 module_exit(cleanup_raw1394
);
3213 MODULE_LICENSE("GPL");