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/smp_lock.h>
39 #include <linux/interrupt.h>
40 #include <linux/vmalloc.h>
41 #include <linux/cdev.h>
42 #include <asm/uaccess.h>
43 #include <asm/atomic.h>
44 #include <linux/devfs_fs_kernel.h>
48 #include "ieee1394_types.h"
49 #include "ieee1394_core.h"
52 #include "highlevel.h"
54 #include "ieee1394_transactions.h"
56 #include "raw1394-private.h"
58 #if BITS_PER_LONG == 64
59 #define int2ptr(x) ((void *)x)
60 #define ptr2int(x) ((u64)x)
62 #define int2ptr(x) ((void *)(u32)x)
63 #define ptr2int(x) ((u64)(u32)x)
66 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
71 #define DBGMSG(fmt, args...) \
72 printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
74 #define DBGMSG(fmt, args...)
77 static LIST_HEAD(host_info_list);
78 static int host_count;
79 static spinlock_t host_info_lock = SPIN_LOCK_UNLOCKED;
80 static atomic_t internal_generation = ATOMIC_INIT(0);
82 static atomic_t iso_buffer_size;
83 static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
85 static struct hpsb_highlevel raw1394_highlevel;
87 static int arm_read (struct hpsb_host *host, int nodeid, quadlet_t *buffer,
88 u64 addr, size_t length, u16 flags);
89 static int arm_write (struct hpsb_host *host, int nodeid, int destid,
90 quadlet_t *data, u64 addr, size_t length, u16 flags);
91 static int arm_lock (struct hpsb_host *host, int nodeid, quadlet_t *store,
92 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags);
93 static int arm_lock64 (struct hpsb_host *host, int nodeid, octlet_t *store,
94 u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags);
95 static struct hpsb_address_ops arm_ops = {
102 static void queue_complete_cb(struct pending_request *req);
104 static struct pending_request *__alloc_pending_request(int flags)
106 struct pending_request *req;
108 req = (struct pending_request *)kmalloc(sizeof(struct pending_request),
111 memset(req, 0, sizeof(struct pending_request));
112 INIT_LIST_HEAD(&req->list);
118 static inline struct pending_request *alloc_pending_request(void)
120 return __alloc_pending_request(SLAB_KERNEL);
123 static void free_pending_request(struct pending_request *req)
126 if (atomic_dec_and_test(&req->ibs->refcount)) {
127 atomic_sub(req->ibs->data_size, &iso_buffer_size);
130 } else if (req->free_data) {
133 hpsb_free_packet(req->packet);
137 /* fi->reqlists_lock must be taken */
138 static void __queue_complete_req(struct pending_request *req)
140 struct file_info *fi = req->file_info;
141 list_del(&req->list);
142 list_add_tail(&req->list, &fi->req_complete);
144 up(&fi->complete_sem);
145 wake_up_interruptible(&fi->poll_wait_complete);
148 static void queue_complete_req(struct pending_request *req)
151 struct file_info *fi = req->file_info;
153 spin_lock_irqsave(&fi->reqlists_lock, flags);
154 __queue_complete_req(req);
155 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
158 static void queue_complete_cb(struct pending_request *req)
160 struct hpsb_packet *packet = req->packet;
161 int rcode = (packet->header[1] >> 12) & 0xf;
163 switch (packet->ack_code) {
165 case ACKX_SEND_ERROR:
166 req->req.error = RAW1394_ERROR_SEND_ERROR;
169 req->req.error = RAW1394_ERROR_ABORTED;
172 req->req.error = RAW1394_ERROR_TIMEOUT;
175 req->req.error = (packet->ack_code << 16) | rcode;
179 if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
183 if ((req->req.type == RAW1394_REQ_ASYNC_READ) ||
184 (req->req.type == RAW1394_REQ_ASYNC_WRITE) ||
185 (req->req.type == RAW1394_REQ_ASYNC_STREAM) ||
186 (req->req.type == RAW1394_REQ_LOCK) ||
187 (req->req.type == RAW1394_REQ_LOCK64))
188 hpsb_free_tlabel(packet);
190 queue_complete_req(req);
194 static void add_host(struct hpsb_host *host)
196 struct host_info *hi;
199 hi = (struct host_info *)kmalloc(sizeof(struct host_info), GFP_KERNEL);
202 INIT_LIST_HEAD(&hi->list);
204 INIT_LIST_HEAD(&hi->file_info_list);
206 spin_lock_irqsave(&host_info_lock, flags);
207 list_add_tail(&hi->list, &host_info_list);
209 spin_unlock_irqrestore(&host_info_lock, flags);
212 atomic_inc(&internal_generation);
216 static struct host_info *find_host_info(struct hpsb_host *host)
218 struct host_info *hi;
220 list_for_each_entry(hi, &host_info_list, list)
221 if (hi->host == host)
227 static void remove_host(struct hpsb_host *host)
229 struct host_info *hi;
232 spin_lock_irqsave(&host_info_lock, flags);
233 hi = find_host_info(host);
239 FIXME: address ranges should be removed
240 and fileinfo states should be initialized
241 (including setting generation to
242 internal-generation ...)
245 spin_unlock_irqrestore(&host_info_lock, flags);
248 printk(KERN_ERR "raw1394: attempt to remove unknown host "
255 atomic_inc(&internal_generation);
258 static void host_reset(struct hpsb_host *host)
261 struct host_info *hi;
262 struct file_info *fi;
263 struct pending_request *req;
265 spin_lock_irqsave(&host_info_lock, flags);
266 hi = find_host_info(host);
269 list_for_each_entry(fi, &hi->file_info_list, list) {
270 if (fi->notification == RAW1394_NOTIFY_ON) {
271 req = __alloc_pending_request(SLAB_ATOMIC);
275 req->req.type = RAW1394_REQ_BUS_RESET;
276 req->req.generation = get_hpsb_generation(host);
277 req->req.misc = (host->node_id << 16)
279 if (fi->protocol_version > 3) {
280 req->req.misc |= (NODEID_TO_NODE(host->irm_id)
284 queue_complete_req(req);
289 spin_unlock_irqrestore(&host_info_lock, flags);
292 static void iso_receive(struct hpsb_host *host, int channel, quadlet_t *data,
296 struct host_info *hi;
297 struct file_info *fi;
298 struct pending_request *req, *req_next;
299 struct iso_block_store *ibs = NULL;
302 if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
303 HPSB_INFO("dropped iso packet");
307 spin_lock_irqsave(&host_info_lock, flags);
308 hi = find_host_info(host);
311 list_for_each_entry(fi, &hi->file_info_list, list) {
312 if (!(fi->listen_channels & (1ULL << channel)))
315 req = __alloc_pending_request(SLAB_ATOMIC);
319 ibs = kmalloc(sizeof(struct iso_block_store)
320 + length, SLAB_ATOMIC);
326 atomic_add(length, &iso_buffer_size);
327 atomic_set(&ibs->refcount, 0);
328 ibs->data_size = length;
329 memcpy(ibs->data, data, length);
332 atomic_inc(&ibs->refcount);
336 req->data = ibs->data;
337 req->req.type = RAW1394_REQ_ISO_RECEIVE;
338 req->req.generation = get_hpsb_generation(host);
340 req->req.recvb = ptr2int(fi->iso_buffer);
341 req->req.length = min(length, fi->iso_buffer_length);
343 list_add_tail(&req->list, &reqs);
346 spin_unlock_irqrestore(&host_info_lock, flags);
348 list_for_each_entry_safe(req, req_next, &reqs, list)
349 queue_complete_req(req);
352 static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
353 int cts, u8 *data, size_t length)
356 struct host_info *hi;
357 struct file_info *fi;
358 struct pending_request *req, *req_next;
359 struct iso_block_store *ibs = NULL;
362 if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
363 HPSB_INFO("dropped fcp request");
367 spin_lock_irqsave(&host_info_lock, flags);
368 hi = find_host_info(host);
371 list_for_each_entry(fi, &hi->file_info_list, list) {
375 req = __alloc_pending_request(SLAB_ATOMIC);
379 ibs = kmalloc(sizeof(struct iso_block_store)
380 + length, SLAB_ATOMIC);
386 atomic_add(length, &iso_buffer_size);
387 atomic_set(&ibs->refcount, 0);
388 ibs->data_size = length;
389 memcpy(ibs->data, data, length);
392 atomic_inc(&ibs->refcount);
396 req->data = ibs->data;
397 req->req.type = RAW1394_REQ_FCP_REQUEST;
398 req->req.generation = get_hpsb_generation(host);
399 req->req.misc = nodeid | (direction << 16);
400 req->req.recvb = ptr2int(fi->fcp_buffer);
401 req->req.length = length;
403 list_add_tail(&req->list, &reqs);
406 spin_unlock_irqrestore(&host_info_lock, flags);
408 list_for_each_entry_safe(req, req_next, &reqs, list)
409 queue_complete_req(req);
413 static ssize_t raw1394_read(struct file *file, char *buffer, size_t count,
414 loff_t *offset_is_ignored)
416 struct file_info *fi = (struct file_info *)file->private_data;
417 struct list_head *lh;
418 struct pending_request *req;
420 if (count != sizeof(struct raw1394_request)) {
424 if (!access_ok(VERIFY_WRITE, buffer, count)) {
428 if (file->f_flags & O_NONBLOCK) {
429 if (down_trylock(&fi->complete_sem)) {
433 if (down_interruptible(&fi->complete_sem)) {
438 spin_lock_irq(&fi->reqlists_lock);
439 lh = fi->req_complete.next;
441 spin_unlock_irq(&fi->reqlists_lock);
443 req = list_entry(lh, struct pending_request, list);
445 if (req->req.length) {
446 if (copy_to_user(int2ptr(req->req.recvb), req->data,
448 req->req.error = RAW1394_ERROR_MEMFAULT;
451 __copy_to_user(buffer, &req->req, sizeof(req->req));
453 free_pending_request(req);
454 return sizeof(struct raw1394_request);
458 static int state_opened(struct file_info *fi, struct pending_request *req)
460 if (req->req.type == RAW1394_REQ_INITIALIZE) {
461 switch (req->req.misc) {
462 case RAW1394_KERNELAPI_VERSION:
464 fi->state = initialized;
465 fi->protocol_version = req->req.misc;
466 req->req.error = RAW1394_ERROR_NONE;
467 req->req.generation = atomic_read(&internal_generation);
471 req->req.error = RAW1394_ERROR_COMPAT;
472 req->req.misc = RAW1394_KERNELAPI_VERSION;
475 req->req.error = RAW1394_ERROR_STATE_ORDER;
479 queue_complete_req(req);
480 return sizeof(struct raw1394_request);
483 static int state_initialized(struct file_info *fi, struct pending_request *req)
485 struct host_info *hi;
486 struct raw1394_khost_list *khl;
488 if (req->req.generation != atomic_read(&internal_generation)) {
489 req->req.error = RAW1394_ERROR_GENERATION;
490 req->req.generation = atomic_read(&internal_generation);
492 queue_complete_req(req);
493 return sizeof(struct raw1394_request);
496 switch (req->req.type) {
497 case RAW1394_REQ_LIST_CARDS:
498 spin_lock_irq(&host_info_lock);
499 khl = kmalloc(sizeof(struct raw1394_khost_list) * host_count,
503 req->req.misc = host_count;
504 req->data = (quadlet_t *)khl;
506 list_for_each_entry(hi, &host_info_list, list) {
507 khl->nodes = hi->host->node_count;
508 strcpy(khl->name, hi->host->driver->name);
512 spin_unlock_irq(&host_info_lock);
515 req->req.error = RAW1394_ERROR_NONE;
516 req->req.length = min(req->req.length,
517 (u32)(sizeof(struct raw1394_khost_list)
525 case RAW1394_REQ_SET_CARD:
526 spin_lock_irq(&host_info_lock);
527 if (req->req.misc < host_count) {
528 list_for_each_entry(hi, &host_info_list, list) {
529 if (!req->req.misc--)
532 get_device(&hi->host->device); // XXX Need to handle failure case
533 list_add_tail(&fi->list, &hi->file_info_list);
535 fi->state = connected;
537 req->req.error = RAW1394_ERROR_NONE;
538 req->req.generation = get_hpsb_generation(fi->host);
539 req->req.misc = (fi->host->node_id << 16)
540 | fi->host->node_count;
541 if (fi->protocol_version > 3) {
542 req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8;
545 req->req.error = RAW1394_ERROR_INVALID_ARG;
547 spin_unlock_irq(&host_info_lock);
553 req->req.error = RAW1394_ERROR_STATE_ORDER;
558 queue_complete_req(req);
559 return sizeof(struct raw1394_request);
562 static void handle_iso_listen(struct file_info *fi, struct pending_request *req)
564 int channel = req->req.misc;
566 spin_lock_irq(&host_info_lock);
567 if ((channel > 63) || (channel < -64)) {
568 req->req.error = RAW1394_ERROR_INVALID_ARG;
569 } else if (channel >= 0) {
570 /* allocate channel req.misc */
571 if (fi->listen_channels & (1ULL << channel)) {
572 req->req.error = RAW1394_ERROR_ALREADY;
574 if (hpsb_listen_channel(&raw1394_highlevel, fi->host, channel)) {
575 req->req.error = RAW1394_ERROR_ALREADY;
577 fi->listen_channels |= 1ULL << channel;
578 fi->iso_buffer = int2ptr(req->req.recvb);
579 fi->iso_buffer_length = req->req.length;
583 /* deallocate channel (one's complement neg) req.misc */
586 if (fi->listen_channels & (1ULL << channel)) {
587 hpsb_unlisten_channel(&raw1394_highlevel, fi->host, channel);
588 fi->listen_channels &= ~(1ULL << channel);
590 req->req.error = RAW1394_ERROR_INVALID_ARG;
595 queue_complete_req(req);
596 spin_unlock_irq(&host_info_lock);
599 static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
602 if (fi->fcp_buffer) {
603 req->req.error = RAW1394_ERROR_ALREADY;
605 fi->fcp_buffer = (u8 *)int2ptr(req->req.recvb);
608 if (!fi->fcp_buffer) {
609 req->req.error = RAW1394_ERROR_ALREADY;
611 fi->fcp_buffer = NULL;
616 queue_complete_req(req);
620 static int handle_async_request(struct file_info *fi,
621 struct pending_request *req, int node)
623 struct hpsb_packet *packet = NULL;
624 u64 addr = req->req.address & 0xffffffffffffULL;
626 switch (req->req.type) {
627 case RAW1394_REQ_ASYNC_READ:
628 DBGMSG("read_request called");
629 packet = hpsb_make_readpacket(fi->host, node, addr, req->req.length);
634 if (req->req.length == 4)
635 req->data = &packet->header[3];
637 req->data = packet->data;
641 case RAW1394_REQ_ASYNC_WRITE:
642 DBGMSG("write_request called");
644 packet = hpsb_make_writepacket(fi->host, node, addr, NULL,
649 if (req->req.length == 4) {
650 if (copy_from_user(&packet->header[3], int2ptr(req->req.sendb),
652 req->req.error = RAW1394_ERROR_MEMFAULT;
654 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
656 req->req.error = RAW1394_ERROR_MEMFAULT;
662 case RAW1394_REQ_ASYNC_STREAM:
663 DBGMSG("stream_request called");
665 packet = hpsb_make_streampacket(fi->host, NULL, req->req.length, node & 0x3f/*channel*/,
666 (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
670 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
672 req->req.error = RAW1394_ERROR_MEMFAULT;
677 case RAW1394_REQ_LOCK:
678 DBGMSG("lock_request called");
679 if ((req->req.misc == EXTCODE_FETCH_ADD)
680 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
681 if (req->req.length != 4) {
682 req->req.error = RAW1394_ERROR_INVALID_ARG;
686 if (req->req.length != 8) {
687 req->req.error = RAW1394_ERROR_INVALID_ARG;
692 packet = hpsb_make_lockpacket(fi->host, node, addr,
693 req->req.misc, NULL, 0);
694 if (!packet) return -ENOMEM;
696 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
698 req->req.error = RAW1394_ERROR_MEMFAULT;
702 req->data = packet->data;
706 case RAW1394_REQ_LOCK64:
707 DBGMSG("lock64_request called");
708 if ((req->req.misc == EXTCODE_FETCH_ADD)
709 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
710 if (req->req.length != 8) {
711 req->req.error = RAW1394_ERROR_INVALID_ARG;
715 if (req->req.length != 16) {
716 req->req.error = RAW1394_ERROR_INVALID_ARG;
720 packet = hpsb_make_lock64packet(fi->host, node, addr,
721 req->req.misc, NULL, 0);
722 if (!packet) return -ENOMEM;
724 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
726 req->req.error = RAW1394_ERROR_MEMFAULT;
730 req->data = packet->data;
735 req->req.error = RAW1394_ERROR_STATE_ORDER;
738 req->packet = packet;
740 if (req->req.error) {
742 queue_complete_req(req);
743 return sizeof(struct raw1394_request);
746 hpsb_set_packet_complete_task(packet, (void(*)(void*))queue_complete_cb, req);
748 spin_lock_irq(&fi->reqlists_lock);
749 list_add_tail(&req->list, &fi->req_pending);
750 spin_unlock_irq(&fi->reqlists_lock);
752 packet->generation = req->req.generation;
754 if (hpsb_send_packet(packet) < 0) {
755 req->req.error = RAW1394_ERROR_SEND_ERROR;
757 hpsb_free_tlabel(packet);
758 queue_complete_req(req);
760 return sizeof(struct raw1394_request);
763 static int handle_iso_send(struct file_info *fi, struct pending_request *req,
766 struct hpsb_packet *packet;
768 packet = hpsb_make_isopacket(fi->host, req->req.length, channel & 0x3f,
769 (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
773 packet->speed_code = req->req.address & 0x3;
775 req->packet = packet;
777 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
779 req->req.error = RAW1394_ERROR_MEMFAULT;
781 queue_complete_req(req);
782 return sizeof(struct raw1394_request);
786 hpsb_set_packet_complete_task(packet, (void (*)(void*))queue_complete_req, req);
788 spin_lock_irq(&fi->reqlists_lock);
789 list_add_tail(&req->list, &fi->req_pending);
790 spin_unlock_irq(&fi->reqlists_lock);
792 /* Update the generation of the packet just before sending. */
793 packet->generation = req->req.generation;
795 if (hpsb_send_packet(packet) < 0) {
796 req->req.error = RAW1394_ERROR_SEND_ERROR;
797 queue_complete_req(req);
800 return sizeof(struct raw1394_request);
803 static int handle_async_send(struct file_info *fi, struct pending_request *req)
805 struct hpsb_packet *packet;
806 int header_length = req->req.misc & 0xffff;
807 int expect_response = req->req.misc >> 16;
809 if ((header_length > req->req.length) ||
810 (header_length < 12)) {
811 req->req.error = RAW1394_ERROR_INVALID_ARG;
813 queue_complete_req(req);
814 return sizeof(struct raw1394_request);
817 packet = hpsb_alloc_packet(req->req.length-header_length);
818 req->packet = packet;
819 if (!packet) return -ENOMEM;
821 if (copy_from_user(packet->header, int2ptr(req->req.sendb),
823 req->req.error = RAW1394_ERROR_MEMFAULT;
825 queue_complete_req(req);
826 return sizeof(struct raw1394_request);
829 if (copy_from_user(packet->data, ((u8*) int2ptr(req->req.sendb)) + header_length,
830 packet->data_size)) {
831 req->req.error = RAW1394_ERROR_MEMFAULT;
833 queue_complete_req(req);
834 return sizeof(struct raw1394_request);
837 packet->type = hpsb_async;
838 packet->node_id = packet->header[0] >> 16;
839 packet->tcode = (packet->header[0] >> 4) & 0xf;
840 packet->tlabel = (packet->header[0] >> 10) &0x3f;
841 packet->host = fi->host;
842 packet->expect_response = expect_response;
843 packet->header_size=header_length;
844 packet->data_size=req->req.length-header_length;
847 hpsb_set_packet_complete_task(packet, (void(*)(void*))queue_complete_cb, req);
849 spin_lock_irq(&fi->reqlists_lock);
850 list_add_tail(&req->list, &fi->req_pending);
851 spin_unlock_irq(&fi->reqlists_lock);
853 /* Update the generation of the packet just before sending. */
854 packet->generation = req->req.generation;
856 if (hpsb_send_packet(packet) < 0) {
857 req->req.error = RAW1394_ERROR_SEND_ERROR;
858 queue_complete_req(req);
861 return sizeof(struct raw1394_request);
864 static int arm_read (struct hpsb_host *host, int nodeid, quadlet_t *buffer,
865 u64 addr, size_t length, u16 flags)
867 struct pending_request *req;
868 struct host_info *hi;
869 struct file_info *fi = NULL;
870 struct list_head *entry;
871 struct arm_addr *arm_addr = NULL;
872 struct arm_request *arm_req = NULL;
873 struct arm_response *arm_resp = NULL;
874 int found=0, size=0, rcode=-1;
875 struct arm_request_response *arm_req_resp = NULL;
877 DBGMSG("arm_read called by node: %X"
878 "addr: %4.4x %8.8x length: %Zu", nodeid,
879 (u16) ((addr >>32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
881 spin_lock(&host_info_lock);
882 hi = find_host_info(host); /* search address-entry */
884 list_for_each_entry(fi, &hi->file_info_list, list) {
885 entry = fi->addr_list.next;
886 while (entry != &(fi->addr_list)) {
887 arm_addr = list_entry(entry, struct arm_addr, addr_list);
888 if (((arm_addr->start) <= (addr)) &&
889 ((arm_addr->end) >= (addr+length))) {
902 printk(KERN_ERR "raw1394: arm_read FAILED addr_entry not found"
903 " -> rcode_address_error\n");
904 spin_unlock(&host_info_lock);
905 return (RCODE_ADDRESS_ERROR);
907 DBGMSG("arm_read addr_entry FOUND");
909 if (arm_addr->rec_length < length) {
910 DBGMSG("arm_read blocklength too big -> rcode_data_error");
911 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
914 if (arm_addr->access_rights & ARM_READ) {
915 if (!(arm_addr->client_transactions & ARM_READ)) {
916 memcpy(buffer,(arm_addr->addr_space_buffer)+(addr-(arm_addr->start)),
918 DBGMSG("arm_read -> (rcode_complete)");
919 rcode = RCODE_COMPLETE;
922 rcode = RCODE_TYPE_ERROR; /* function not allowed */
923 DBGMSG("arm_read -> rcode_type_error (access denied)");
926 if (arm_addr->notification_options & ARM_READ) {
927 DBGMSG("arm_read -> entering notification-section");
928 req = __alloc_pending_request(SLAB_ATOMIC);
930 DBGMSG("arm_read -> rcode_conflict_error");
931 spin_unlock(&host_info_lock);
932 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
933 The request may be retried */
935 if (rcode == RCODE_COMPLETE) {
936 size = sizeof(struct arm_request)+sizeof(struct arm_response) +
937 length * sizeof(byte_t) +
938 sizeof (struct arm_request_response);
940 size = sizeof(struct arm_request)+sizeof(struct arm_response) +
941 sizeof (struct arm_request_response);
943 req->data = kmalloc(size, SLAB_ATOMIC);
945 free_pending_request(req);
946 DBGMSG("arm_read -> rcode_conflict_error");
947 spin_unlock(&host_info_lock);
948 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
949 The request may be retried */
953 req->req.type = RAW1394_REQ_ARM;
954 req->req.generation = get_hpsb_generation(host);
955 req->req.misc = ( ((length << 16) & (0xFFFF0000)) | (ARM_READ & 0xFF));
956 req->req.tag = arm_addr->arm_tag;
957 req->req.recvb = arm_addr->recvb;
958 req->req.length = size;
959 arm_req_resp = (struct arm_request_response *) (req->data);
960 arm_req = (struct arm_request *) ((byte_t *)(req->data) +
961 (sizeof (struct arm_request_response)));
962 arm_resp = (struct arm_response *) ((byte_t *)(arm_req) +
963 (sizeof(struct arm_request)));
964 arm_req->buffer = NULL;
965 arm_resp->buffer = NULL;
966 if (rcode == RCODE_COMPLETE) {
967 arm_resp->buffer = ((byte_t *)(arm_resp) +
968 (sizeof(struct arm_response)));
969 memcpy (arm_resp->buffer,
970 (arm_addr->addr_space_buffer)+(addr-(arm_addr->start)),
972 arm_resp->buffer = int2ptr((arm_addr->recvb) +
973 sizeof (struct arm_request_response) +
974 sizeof (struct arm_request) +
975 sizeof (struct arm_response));
977 arm_resp->buffer_length = (rcode == RCODE_COMPLETE) ? length : 0;
978 arm_resp->response_code = rcode;
979 arm_req->buffer_length = 0;
980 arm_req->generation = req->req.generation;
981 arm_req->extended_transaction_code = 0;
982 arm_req->destination_offset = addr;
983 arm_req->source_nodeid = nodeid;
984 arm_req->destination_nodeid = host->node_id;
985 arm_req->tlabel = (flags >> 10) & 0x3f;
986 arm_req->tcode = (flags >> 4) & 0x0f;
987 arm_req_resp->request = int2ptr((arm_addr->recvb) +
988 sizeof (struct arm_request_response));
989 arm_req_resp->response = int2ptr((arm_addr->recvb) +
990 sizeof (struct arm_request_response) +
991 sizeof (struct arm_request));
992 queue_complete_req(req);
994 spin_unlock(&host_info_lock);
998 static int arm_write (struct hpsb_host *host, int nodeid, int destid,
999 quadlet_t *data, u64 addr, size_t length, u16 flags)
1001 struct pending_request *req;
1002 struct host_info *hi;
1003 struct file_info *fi = NULL;
1004 struct list_head *entry;
1005 struct arm_addr *arm_addr = NULL;
1006 struct arm_request *arm_req = NULL;
1007 struct arm_response *arm_resp = NULL;
1008 int found=0, size=0, rcode=-1, length_conflict=0;
1009 struct arm_request_response *arm_req_resp = NULL;
1011 DBGMSG("arm_write called by node: %X"
1012 "addr: %4.4x %8.8x length: %Zu", nodeid,
1013 (u16) ((addr >>32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
1015 spin_lock(&host_info_lock);
1016 hi = find_host_info(host); /* search address-entry */
1018 list_for_each_entry(fi, &hi->file_info_list, list) {
1019 entry = fi->addr_list.next;
1020 while (entry != &(fi->addr_list)) {
1021 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1022 if (((arm_addr->start) <= (addr)) &&
1023 ((arm_addr->end) >= (addr+length))) {
1027 entry = entry->next;
1036 printk(KERN_ERR "raw1394: arm_write FAILED addr_entry not found"
1037 " -> rcode_address_error\n");
1038 spin_unlock(&host_info_lock);
1039 return (RCODE_ADDRESS_ERROR);
1041 DBGMSG("arm_write addr_entry FOUND");
1043 if (arm_addr->rec_length < length) {
1044 DBGMSG("arm_write blocklength too big -> rcode_data_error");
1045 length_conflict = 1;
1046 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
1049 if (arm_addr->access_rights & ARM_WRITE) {
1050 if (!(arm_addr->client_transactions & ARM_WRITE)) {
1051 memcpy((arm_addr->addr_space_buffer)+(addr-(arm_addr->start)),
1053 DBGMSG("arm_write -> (rcode_complete)");
1054 rcode = RCODE_COMPLETE;
1057 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1058 DBGMSG("arm_write -> rcode_type_error (access denied)");
1061 if (arm_addr->notification_options & ARM_WRITE) {
1062 DBGMSG("arm_write -> entering notification-section");
1063 req = __alloc_pending_request(SLAB_ATOMIC);
1065 DBGMSG("arm_write -> rcode_conflict_error");
1066 spin_unlock(&host_info_lock);
1067 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1068 The request my be retried */
1070 size = sizeof(struct arm_request)+sizeof(struct arm_response) +
1071 (length) * sizeof(byte_t) +
1072 sizeof (struct arm_request_response);
1073 req->data = kmalloc(size, SLAB_ATOMIC);
1075 free_pending_request(req);
1076 DBGMSG("arm_write -> rcode_conflict_error");
1077 spin_unlock(&host_info_lock);
1078 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1079 The request may be retried */
1082 req->file_info = fi;
1083 req->req.type = RAW1394_REQ_ARM;
1084 req->req.generation = get_hpsb_generation(host);
1085 req->req.misc = ( ((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF));
1086 req->req.tag = arm_addr->arm_tag;
1087 req->req.recvb = arm_addr->recvb;
1088 req->req.length = size;
1089 arm_req_resp = (struct arm_request_response *) (req->data);
1090 arm_req = (struct arm_request *) ((byte_t *)(req->data) +
1091 (sizeof (struct arm_request_response)));
1092 arm_resp = (struct arm_response *) ((byte_t *)(arm_req) +
1093 (sizeof(struct arm_request)));
1094 arm_req->buffer = ((byte_t *)(arm_resp) +
1095 (sizeof(struct arm_response)));
1096 arm_resp->buffer = NULL;
1097 memcpy (arm_req->buffer, data, length);
1098 arm_req->buffer = int2ptr((arm_addr->recvb) +
1099 sizeof (struct arm_request_response) +
1100 sizeof (struct arm_request) +
1101 sizeof (struct arm_response));
1102 arm_req->buffer_length = length;
1103 arm_req->generation = req->req.generation;
1104 arm_req->extended_transaction_code = 0;
1105 arm_req->destination_offset = addr;
1106 arm_req->source_nodeid = nodeid;
1107 arm_req->destination_nodeid = destid;
1108 arm_req->tlabel = (flags >> 10) & 0x3f;
1109 arm_req->tcode = (flags >> 4) & 0x0f;
1110 arm_resp->buffer_length = 0;
1111 arm_resp->response_code = rcode;
1112 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1113 sizeof (struct arm_request_response));
1114 arm_req_resp->response = int2ptr((arm_addr->recvb) +
1115 sizeof (struct arm_request_response) +
1116 sizeof (struct arm_request));
1117 queue_complete_req(req);
1119 spin_unlock(&host_info_lock);
1123 static int arm_lock (struct hpsb_host *host, int nodeid, quadlet_t *store,
1124 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags)
1126 struct pending_request *req;
1127 struct host_info *hi;
1128 struct file_info *fi = NULL;
1129 struct list_head *entry;
1130 struct arm_addr *arm_addr = NULL;
1131 struct arm_request *arm_req = NULL;
1132 struct arm_response *arm_resp = NULL;
1133 int found=0, size=0, rcode=-1;
1135 struct arm_request_response *arm_req_resp = NULL;
1137 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1138 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1139 DBGMSG("arm_lock called by node: %X "
1140 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
1141 nodeid, (u16) ((addr >>32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
1142 ext_tcode & 0xFF , be32_to_cpu(data));
1144 DBGMSG("arm_lock called by node: %X "
1145 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
1146 nodeid, (u16) ((addr >>32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
1147 ext_tcode & 0xFF , be32_to_cpu(data), be32_to_cpu(arg));
1149 spin_lock(&host_info_lock);
1150 hi = find_host_info(host); /* search address-entry */
1152 list_for_each_entry(fi, &hi->file_info_list, list) {
1153 entry = fi->addr_list.next;
1154 while (entry != &(fi->addr_list)) {
1155 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1156 if (((arm_addr->start) <= (addr)) &&
1157 ((arm_addr->end) >= (addr+sizeof(*store)))) {
1161 entry = entry->next;
1170 printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found"
1171 " -> rcode_address_error\n");
1172 spin_unlock(&host_info_lock);
1173 return (RCODE_ADDRESS_ERROR);
1175 DBGMSG("arm_lock addr_entry FOUND");
1178 if (arm_addr->access_rights & ARM_LOCK) {
1179 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1180 memcpy(&old,(arm_addr->addr_space_buffer)+(addr-(arm_addr->start)),
1182 switch (ext_tcode) {
1183 case (EXTCODE_MASK_SWAP):
1184 new = data | (old & ~arg);
1186 case (EXTCODE_COMPARE_SWAP):
1193 case (EXTCODE_FETCH_ADD):
1194 new = cpu_to_be32(be32_to_cpu(data) + be32_to_cpu(old));
1196 case (EXTCODE_LITTLE_ADD):
1197 new = cpu_to_le32(le32_to_cpu(data) + le32_to_cpu(old));
1199 case (EXTCODE_BOUNDED_ADD):
1201 new = cpu_to_be32(be32_to_cpu(data) +
1207 case (EXTCODE_WRAP_ADD):
1209 new = cpu_to_be32(be32_to_cpu(data) +
1216 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1217 printk(KERN_ERR "raw1394: arm_lock FAILED "
1218 "ext_tcode not allowed -> rcode_type_error\n");
1222 DBGMSG("arm_lock -> (rcode_complete)");
1223 rcode = RCODE_COMPLETE;
1224 memcpy (store, &old, sizeof(*store));
1225 memcpy ((arm_addr->addr_space_buffer)+
1226 (addr-(arm_addr->start)),
1227 &new, sizeof(*store));
1231 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1232 DBGMSG("arm_lock -> rcode_type_error (access denied)");
1235 if (arm_addr->notification_options & ARM_LOCK) {
1236 DBGMSG("arm_lock -> entering notification-section");
1237 req = __alloc_pending_request(SLAB_ATOMIC);
1239 DBGMSG("arm_lock -> rcode_conflict_error");
1240 spin_unlock(&host_info_lock);
1241 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1242 The request may be retried */
1244 size = sizeof(struct arm_request)+sizeof(struct arm_response) +
1245 3 * sizeof(*store) +
1246 sizeof (struct arm_request_response); /* maximum */
1247 req->data = kmalloc(size, SLAB_ATOMIC);
1249 free_pending_request(req);
1250 DBGMSG("arm_lock -> rcode_conflict_error");
1251 spin_unlock(&host_info_lock);
1252 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1253 The request may be retried */
1256 arm_req_resp = (struct arm_request_response *) (req->data);
1257 arm_req = (struct arm_request *) ((byte_t *)(req->data) +
1258 (sizeof (struct arm_request_response)));
1259 arm_resp = (struct arm_response *) ((byte_t *)(arm_req) +
1260 (sizeof(struct arm_request)));
1261 arm_req->buffer = ((byte_t *)(arm_resp) +
1262 (sizeof(struct arm_response)));
1263 arm_resp->buffer = ((byte_t *)(arm_req->buffer) +
1264 (2* sizeof(*store)));
1265 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1266 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1267 arm_req->buffer_length = sizeof(*store);
1268 memcpy (arm_req->buffer, &data, sizeof(*store));
1271 arm_req->buffer_length = 2 * sizeof(*store);
1272 memcpy (arm_req->buffer, &arg, sizeof(*store));
1273 memcpy (((arm_req->buffer) + sizeof(*store)),
1274 &data, sizeof(*store));
1276 if (rcode == RCODE_COMPLETE) {
1277 arm_resp->buffer_length = sizeof(*store);
1278 memcpy (arm_resp->buffer, &old, sizeof(*store));
1280 arm_resp->buffer = NULL;
1281 arm_resp->buffer_length = 0;
1283 req->file_info = fi;
1284 req->req.type = RAW1394_REQ_ARM;
1285 req->req.generation = get_hpsb_generation(host);
1286 req->req.misc = ( (((sizeof(*store)) << 16) & (0xFFFF0000)) |
1288 req->req.tag = arm_addr->arm_tag;
1289 req->req.recvb = arm_addr->recvb;
1290 req->req.length = size;
1291 arm_req->generation = req->req.generation;
1292 arm_req->extended_transaction_code = ext_tcode;
1293 arm_req->destination_offset = addr;
1294 arm_req->source_nodeid = nodeid;
1295 arm_req->destination_nodeid = host->node_id;
1296 arm_req->tlabel = (flags >> 10) & 0x3f;
1297 arm_req->tcode = (flags >> 4) & 0x0f;
1298 arm_resp->response_code = rcode;
1299 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1300 sizeof (struct arm_request_response));
1301 arm_req_resp->response = int2ptr((arm_addr->recvb) +
1302 sizeof (struct arm_request_response) +
1303 sizeof (struct arm_request));
1304 arm_req->buffer = int2ptr((arm_addr->recvb) +
1305 sizeof (struct arm_request_response) +
1306 sizeof (struct arm_request) +
1307 sizeof (struct arm_response));
1308 arm_resp->buffer = int2ptr((arm_addr->recvb) +
1309 sizeof (struct arm_request_response) +
1310 sizeof (struct arm_request) +
1311 sizeof (struct arm_response) +
1312 2* sizeof (*store));
1313 queue_complete_req(req);
1315 spin_unlock(&host_info_lock);
1319 static int arm_lock64 (struct hpsb_host *host, int nodeid, octlet_t *store,
1320 u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags)
1322 struct pending_request *req;
1323 struct host_info *hi;
1324 struct file_info *fi = NULL;
1325 struct list_head *entry;
1326 struct arm_addr *arm_addr = NULL;
1327 struct arm_request *arm_req = NULL;
1328 struct arm_response *arm_resp = NULL;
1329 int found=0, size=0, rcode=-1;
1331 struct arm_request_response *arm_req_resp = NULL;
1333 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1334 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1335 DBGMSG("arm_lock64 called by node: %X "
1336 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
1337 nodeid, (u16) ((addr >>32) & 0xFFFF),
1338 (u32) (addr & 0xFFFFFFFF),
1340 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1341 (u32) (be64_to_cpu(data) & 0xFFFFFFFF));
1343 DBGMSG("arm_lock64 called by node: %X "
1344 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
1346 nodeid, (u16) ((addr >>32) & 0xFFFF),
1347 (u32) (addr & 0xFFFFFFFF),
1349 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1350 (u32) (be64_to_cpu(data) & 0xFFFFFFFF),
1351 (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF),
1352 (u32) (be64_to_cpu(arg) & 0xFFFFFFFF));
1354 spin_lock(&host_info_lock);
1355 hi = find_host_info(host); /* search addressentry in file_info's for host */
1357 list_for_each_entry(fi, &hi->file_info_list, list) {
1358 entry = fi->addr_list.next;
1359 while (entry != &(fi->addr_list)) {
1360 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1361 if (((arm_addr->start) <= (addr)) &&
1362 ((arm_addr->end) >= (addr+sizeof(*store)))) {
1366 entry = entry->next;
1375 printk(KERN_ERR "raw1394: arm_lock64 FAILED addr_entry not found"
1376 " -> rcode_address_error\n");
1377 spin_unlock(&host_info_lock);
1378 return (RCODE_ADDRESS_ERROR);
1380 DBGMSG("arm_lock64 addr_entry FOUND");
1383 if (arm_addr->access_rights & ARM_LOCK) {
1384 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1385 memcpy(&old,(arm_addr->addr_space_buffer)+(addr-(arm_addr->start)),
1387 switch (ext_tcode) {
1388 case (EXTCODE_MASK_SWAP):
1389 new = data | (old & ~arg);
1391 case (EXTCODE_COMPARE_SWAP):
1398 case (EXTCODE_FETCH_ADD):
1399 new = cpu_to_be64(be64_to_cpu(data) + be64_to_cpu(old));
1401 case (EXTCODE_LITTLE_ADD):
1402 new = cpu_to_le64(le64_to_cpu(data) + le64_to_cpu(old));
1404 case (EXTCODE_BOUNDED_ADD):
1406 new = cpu_to_be64(be64_to_cpu(data) +
1412 case (EXTCODE_WRAP_ADD):
1414 new = cpu_to_be64(be64_to_cpu(data) +
1421 printk(KERN_ERR "raw1394: arm_lock64 FAILED "
1422 "ext_tcode not allowed -> rcode_type_error\n");
1423 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1427 DBGMSG("arm_lock64 -> (rcode_complete)");
1428 rcode = RCODE_COMPLETE;
1429 memcpy (store, &old, sizeof(*store));
1430 memcpy ((arm_addr->addr_space_buffer)+
1431 (addr-(arm_addr->start)),
1432 &new, sizeof(*store));
1436 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1437 DBGMSG("arm_lock64 -> rcode_type_error (access denied)");
1440 if (arm_addr->notification_options & ARM_LOCK) {
1441 DBGMSG("arm_lock64 -> entering notification-section");
1442 req = __alloc_pending_request(SLAB_ATOMIC);
1444 spin_unlock(&host_info_lock);
1445 DBGMSG("arm_lock64 -> rcode_conflict_error");
1446 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1447 The request may be retried */
1449 size = sizeof(struct arm_request)+sizeof(struct arm_response) +
1450 3 * sizeof(*store) +
1451 sizeof (struct arm_request_response); /* maximum */
1452 req->data = kmalloc(size, SLAB_ATOMIC);
1454 free_pending_request(req);
1455 spin_unlock(&host_info_lock);
1456 DBGMSG("arm_lock64 -> rcode_conflict_error");
1457 return(RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1458 The request may be retried */
1461 arm_req_resp = (struct arm_request_response *) (req->data);
1462 arm_req = (struct arm_request *) ((byte_t *)(req->data) +
1463 (sizeof (struct arm_request_response)));
1464 arm_resp = (struct arm_response *) ((byte_t *)(arm_req) +
1465 (sizeof(struct arm_request)));
1466 arm_req->buffer = ((byte_t *)(arm_resp) +
1467 (sizeof(struct arm_response)));
1468 arm_resp->buffer = ((byte_t *)(arm_req->buffer) +
1469 (2* sizeof(*store)));
1470 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1471 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1472 arm_req->buffer_length = sizeof(*store);
1473 memcpy (arm_req->buffer, &data, sizeof(*store));
1476 arm_req->buffer_length = 2 * sizeof(*store);
1477 memcpy (arm_req->buffer, &arg, sizeof(*store));
1478 memcpy (((arm_req->buffer) + sizeof(*store)),
1479 &data, sizeof(*store));
1481 if (rcode == RCODE_COMPLETE) {
1482 arm_resp->buffer_length = sizeof(*store);
1483 memcpy (arm_resp->buffer, &old, sizeof(*store));
1485 arm_resp->buffer = NULL;
1486 arm_resp->buffer_length = 0;
1488 req->file_info = fi;
1489 req->req.type = RAW1394_REQ_ARM;
1490 req->req.generation = get_hpsb_generation(host);
1491 req->req.misc = ( (((sizeof(*store)) << 16) & (0xFFFF0000)) |
1493 req->req.tag = arm_addr->arm_tag;
1494 req->req.recvb = arm_addr->recvb;
1495 req->req.length = size;
1496 arm_req->generation = req->req.generation;
1497 arm_req->extended_transaction_code = ext_tcode;
1498 arm_req->destination_offset = addr;
1499 arm_req->source_nodeid = nodeid;
1500 arm_req->destination_nodeid = host->node_id;
1501 arm_req->tlabel = (flags >> 10) & 0x3f;
1502 arm_req->tcode = (flags >> 4) & 0x0f;
1503 arm_resp->response_code = rcode;
1504 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1505 sizeof (struct arm_request_response));
1506 arm_req_resp->response = int2ptr((arm_addr->recvb) +
1507 sizeof (struct arm_request_response) +
1508 sizeof (struct arm_request));
1509 arm_req->buffer = int2ptr((arm_addr->recvb) +
1510 sizeof (struct arm_request_response) +
1511 sizeof (struct arm_request) +
1512 sizeof (struct arm_response));
1513 arm_resp->buffer = int2ptr((arm_addr->recvb) +
1514 sizeof (struct arm_request_response) +
1515 sizeof (struct arm_request) +
1516 sizeof (struct arm_response) +
1517 2* sizeof (*store));
1518 queue_complete_req(req);
1520 spin_unlock(&host_info_lock);
1524 static int arm_register(struct file_info *fi, struct pending_request *req)
1527 struct arm_addr *addr;
1528 struct host_info *hi;
1529 struct file_info *fi_hlp = NULL;
1530 struct list_head *entry;
1531 struct arm_addr *arm_addr = NULL;
1532 int same_host, another_host;
1533 unsigned long flags;
1535 DBGMSG("arm_register called "
1536 "addr(Offset): %8.8x %8.8x length: %u "
1537 "rights: %2.2X notify: %2.2X "
1538 "max_blk_len: %4.4X",
1539 (u32) ((req->req.address >>32) & 0xFFFF),
1540 (u32) (req->req.address & 0xFFFFFFFF),
1541 req->req.length, ((req->req.misc >> 8) & 0xFF),
1542 (req->req.misc & 0xFF),((req->req.misc >> 16) & 0xFFFF));
1543 /* check addressrange */
1544 if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) ||
1545 (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) != 0)) {
1546 req->req.length = 0;
1549 /* addr-list-entry for fileinfo */
1550 addr = (struct arm_addr *)kmalloc(sizeof(struct arm_addr), SLAB_KERNEL);
1552 req->req.length = 0;
1555 /* allocation of addr_space_buffer */
1556 addr->addr_space_buffer = (u8 *)vmalloc(req->req.length);
1557 if (!(addr->addr_space_buffer)) {
1559 req->req.length = 0;
1562 /* initialization of addr_space_buffer */
1563 if ((req->req.sendb)== (unsigned long)NULL) {
1565 memset(addr->addr_space_buffer, 0,req->req.length);
1567 /* init: user -> kernel */
1568 if (copy_from_user(addr->addr_space_buffer,int2ptr(req->req.sendb),
1570 vfree(addr->addr_space_buffer);
1575 INIT_LIST_HEAD(&addr->addr_list);
1576 addr->arm_tag = req->req.tag;
1577 addr->start = req->req.address;
1578 addr->end = req->req.address + req->req.length;
1579 addr->access_rights = (u8) (req->req.misc & 0x0F);
1580 addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F);
1581 addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F);
1582 addr->access_rights |= addr->client_transactions;
1583 addr->notification_options |= addr->client_transactions;
1584 addr->recvb = req->req.recvb;
1585 addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF);
1586 spin_lock_irqsave(&host_info_lock, flags);
1587 hi = find_host_info(fi->host);
1590 /* same host with address-entry containing same addressrange ? */
1591 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1592 entry = fi_hlp->addr_list.next;
1593 while (entry != &(fi_hlp->addr_list)) {
1594 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1595 if ( (arm_addr->start == addr->start) &&
1596 (arm_addr->end == addr->end)) {
1597 DBGMSG("same host ownes same "
1598 "addressrange -> EALREADY");
1602 entry = entry->next;
1609 /* addressrange occupied by same host */
1610 vfree(addr->addr_space_buffer);
1612 spin_unlock_irqrestore(&host_info_lock, flags);
1615 /* another host with valid address-entry containing same addressrange */
1616 list_for_each_entry(hi, &host_info_list, list) {
1617 if (hi->host != fi->host) {
1618 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1619 entry = fi_hlp->addr_list.next;
1620 while (entry != &(fi_hlp->addr_list)) {
1621 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1622 if ( (arm_addr->start == addr->start) &&
1623 (arm_addr->end == addr->end)) {
1624 DBGMSG("another host ownes same "
1629 entry = entry->next;
1638 DBGMSG("another hosts entry is valid -> SUCCESS");
1639 if (copy_to_user(int2ptr(req->req.recvb),
1640 int2ptr(&addr->start),sizeof(u64))) {
1641 printk(KERN_ERR "raw1394: arm_register failed "
1642 " address-range-entry is invalid -> EFAULT !!!\n");
1643 vfree(addr->addr_space_buffer);
1645 spin_unlock_irqrestore(&host_info_lock, flags);
1648 free_pending_request(req); /* immediate success or fail */
1650 list_add_tail(&addr->addr_list, &fi->addr_list);
1651 spin_unlock_irqrestore(&host_info_lock, flags);
1652 return sizeof(struct raw1394_request);
1654 retval = hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops, req->req.address,
1655 req->req.address + req->req.length);
1658 list_add_tail(&addr->addr_list, &fi->addr_list);
1660 DBGMSG("arm_register failed errno: %d \n",retval);
1661 vfree(addr->addr_space_buffer);
1663 spin_unlock_irqrestore(&host_info_lock, flags);
1666 spin_unlock_irqrestore(&host_info_lock, flags);
1667 free_pending_request(req); /* immediate success or fail */
1668 return sizeof(struct raw1394_request);
1671 static int arm_unregister(struct file_info *fi, struct pending_request *req)
1675 struct list_head *entry;
1676 struct arm_addr *addr = NULL;
1677 struct host_info *hi;
1678 struct file_info *fi_hlp = NULL;
1679 struct arm_addr *arm_addr = NULL;
1681 unsigned long flags;
1683 DBGMSG("arm_Unregister called addr(Offset): "
1685 (u32) ((req->req.address >>32) & 0xFFFF),
1686 (u32) (req->req.address & 0xFFFFFFFF));
1687 spin_lock_irqsave(&host_info_lock, flags);
1689 entry = fi->addr_list.next;
1690 while (entry != &(fi->addr_list)) {
1691 addr = list_entry(entry, struct arm_addr, addr_list);
1692 if (addr->start == req->req.address) {
1696 entry = entry->next;
1699 DBGMSG("arm_Unregister addr not found");
1700 spin_unlock_irqrestore(&host_info_lock, flags);
1703 DBGMSG("arm_Unregister addr found");
1705 /* another host with valid address-entry containing
1706 same addressrange */
1707 list_for_each_entry(hi, &host_info_list, list) {
1708 if (hi->host != fi->host) {
1709 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1710 entry = fi_hlp->addr_list.next;
1711 while (entry != &(fi_hlp->addr_list)) {
1712 arm_addr = list_entry(entry,
1713 struct arm_addr, addr_list);
1714 if (arm_addr->start ==
1716 DBGMSG("another host ownes "
1717 "same addressrange");
1721 entry = entry->next;
1730 DBGMSG("delete entry from list -> success");
1731 list_del(&addr->addr_list);
1732 vfree(addr->addr_space_buffer);
1734 free_pending_request(req); /* immediate success or fail */
1735 spin_unlock_irqrestore(&host_info_lock, flags);
1736 return sizeof(struct raw1394_request);
1738 retval = hpsb_unregister_addrspace(&raw1394_highlevel, fi->host, addr->start);
1740 printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n");
1741 spin_unlock_irqrestore(&host_info_lock, flags);
1744 DBGMSG("delete entry from list -> success");
1745 list_del(&addr->addr_list);
1746 spin_unlock_irqrestore(&host_info_lock, flags);
1747 vfree(addr->addr_space_buffer);
1749 free_pending_request(req); /* immediate success or fail */
1750 return sizeof(struct raw1394_request);
1753 /* Copy data from ARM buffer(s) to user buffer. */
1754 static int arm_get_buf(struct file_info *fi, struct pending_request *req)
1756 struct arm_addr *arm_addr = NULL;
1757 unsigned long flags;
1758 unsigned long offset;
1760 struct list_head *entry;
1762 DBGMSG("arm_get_buf "
1763 "addr(Offset): %04X %08X length: %u",
1764 (u32) ((req->req.address >> 32) & 0xFFFF),
1765 (u32) (req->req.address & 0xFFFFFFFF),
1766 (u32) req->req.length);
1768 spin_lock_irqsave(&host_info_lock, flags);
1769 entry = fi->addr_list.next;
1770 while (entry != &(fi->addr_list)) {
1771 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1772 if ((arm_addr->start <= req->req.address) &&
1773 (arm_addr->end > req->req.address)) {
1774 if (req->req.address + req->req.length <= arm_addr->end) {
1775 offset = req->req.address - arm_addr->start;
1777 DBGMSG("arm_get_buf copy_to_user( %08X, %p, %u )",
1778 (u32) req->req.recvb,
1779 arm_addr->addr_space_buffer+offset,
1780 (u32) req->req.length);
1782 if (copy_to_user(int2ptr(req->req.recvb), arm_addr->addr_space_buffer+offset, req->req.length)) {
1783 spin_unlock_irqrestore(&host_info_lock, flags);
1787 spin_unlock_irqrestore(&host_info_lock, flags);
1788 /* We have to free the request, because we
1789 * queue no response, and therefore nobody
1791 free_pending_request(req);
1792 return sizeof(struct raw1394_request);
1794 DBGMSG("arm_get_buf request exceeded mapping");
1795 spin_unlock_irqrestore(&host_info_lock, flags);
1799 entry = entry->next;
1801 spin_unlock_irqrestore(&host_info_lock, flags);
1806 /* Copy data from user buffer to ARM buffer(s). */
1807 static int arm_set_buf(struct file_info *fi, struct pending_request *req)
1809 struct arm_addr *arm_addr = NULL;
1810 unsigned long flags;
1811 unsigned long offset;
1813 struct list_head *entry;
1815 DBGMSG("arm_set_buf "
1816 "addr(Offset): %04X %08X length: %u",
1817 (u32) ((req->req.address >> 32) & 0xFFFF),
1818 (u32) (req->req.address & 0xFFFFFFFF),
1819 (u32) req->req.length);
1822 spin_lock_irqsave(&host_info_lock, flags);
1823 entry = fi->addr_list.next;
1824 while (entry != &(fi->addr_list)) {
1825 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1826 if ((arm_addr->start <= req->req.address) &&
1827 (arm_addr->end > req->req.address)) {
1828 if (req->req.address + req->req.length <= arm_addr->end) {
1829 offset = req->req.address - arm_addr->start;
1831 DBGMSG("arm_set_buf copy_from_user( %p, %08X, %u )",
1832 arm_addr->addr_space_buffer+offset,
1833 (u32) req->req.sendb,
1834 (u32) req->req.length);
1836 if (copy_from_user(arm_addr->addr_space_buffer+offset, int2ptr(req->req.sendb), req->req.length)) {
1837 spin_unlock_irqrestore(&host_info_lock, flags);
1841 spin_unlock_irqrestore(&host_info_lock, flags);
1842 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1843 return sizeof(struct raw1394_request);
1845 DBGMSG("arm_set_buf request exceeded mapping");
1846 spin_unlock_irqrestore(&host_info_lock, flags);
1850 entry = entry->next;
1852 spin_unlock_irqrestore(&host_info_lock, flags);
1856 static int reset_notification(struct file_info *fi, struct pending_request *req)
1858 DBGMSG("reset_notification called - switch %s ",
1859 (req->req.misc == RAW1394_NOTIFY_OFF)?"OFF":"ON");
1860 if ((req->req.misc == RAW1394_NOTIFY_OFF) ||
1861 (req->req.misc == RAW1394_NOTIFY_ON)) {
1862 fi->notification=(u8)req->req.misc;
1863 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1864 return sizeof(struct raw1394_request);
1866 /* error EINVAL (22) invalid argument */
1870 static int write_phypacket(struct file_info *fi, struct pending_request *req)
1872 struct hpsb_packet *packet = NULL;
1876 data = be32_to_cpu((u32)req->req.sendb);
1877 DBGMSG("write_phypacket called - quadlet 0x%8.8x ",data);
1878 packet = hpsb_make_phypacket (fi->host, data);
1879 if (!packet) return -ENOMEM;
1882 hpsb_set_packet_complete_task(packet, (void(*)(void*))queue_complete_cb, req);
1883 spin_lock_irq(&fi->reqlists_lock);
1884 list_add_tail(&req->list, &fi->req_pending);
1885 spin_unlock_irq(&fi->reqlists_lock);
1886 packet->generation = req->req.generation;
1887 retval = hpsb_send_packet(packet);
1888 DBGMSG("write_phypacket send_packet called => retval: %d ", retval);
1890 req->req.error = RAW1394_ERROR_SEND_ERROR;
1891 req->req.length = 0;
1892 queue_complete_req(req);
1894 return sizeof(struct raw1394_request);
1897 static int get_config_rom(struct file_info *fi, struct pending_request *req)
1899 int ret=sizeof(struct raw1394_request);
1900 quadlet_t *data = kmalloc(req->req.length, SLAB_KERNEL);
1903 if (!data) return -ENOMEM;
1905 status = csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET,
1906 data, req->req.length);
1907 if (copy_to_user(int2ptr(req->req.recvb), data,
1910 if (copy_to_user(int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len,
1911 sizeof(fi->host->csr.rom->cache_head->len)))
1913 if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation,
1914 sizeof(fi->host->csr.generation)))
1916 if (copy_to_user(int2ptr(req->req.sendb), &status,
1921 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1926 static int update_config_rom(struct file_info *fi, struct pending_request *req)
1928 int ret=sizeof(struct raw1394_request);
1929 quadlet_t *data = kmalloc(req->req.length, SLAB_KERNEL);
1930 if (!data) return -ENOMEM;
1931 if (copy_from_user(data,int2ptr(req->req.sendb),
1935 int status = hpsb_update_config_rom(fi->host,
1936 data, req->req.length,
1937 (unsigned char) req->req.misc);
1938 if (copy_to_user(int2ptr(req->req.recvb),
1939 &status, sizeof(status)))
1944 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1950 static int modify_config_rom(struct file_info *fi, struct pending_request *req)
1952 struct csr1212_keyval *kv;
1953 struct csr1212_csr_rom_cache *cache;
1954 struct csr1212_dentry *dentry;
1958 if (req->req.misc == ~0) {
1959 if (req->req.length == 0) return -EINVAL;
1961 /* Find an unused slot */
1962 for (dr = 0; dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr]; dr++);
1964 if (dr == RAW1394_MAX_USER_CSR_DIRS) return -ENOMEM;
1966 fi->csr1212_dirs[dr] = csr1212_new_directory(CSR1212_KV_ID_VENDOR);
1967 if (!fi->csr1212_dirs[dr]) return -ENOMEM;
1970 if (!fi->csr1212_dirs[dr]) return -EINVAL;
1972 /* Delete old stuff */
1973 for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head;
1974 dentry; dentry = dentry->next) {
1975 csr1212_detach_keyval_from_directory(fi->host->csr.rom->root_kv,
1979 if (req->req.length == 0) {
1980 csr1212_release_keyval(fi->csr1212_dirs[dr]);
1981 fi->csr1212_dirs[dr] = NULL;
1983 hpsb_update_config_rom_image(fi->host);
1984 free_pending_request(req);
1985 return sizeof(struct raw1394_request);
1989 cache = csr1212_rom_cache_malloc(0, req->req.length);
1991 csr1212_release_keyval(fi->csr1212_dirs[dr]);
1992 fi->csr1212_dirs[dr] = NULL;
1996 cache->filled_head = kmalloc(sizeof(struct csr1212_cache_region), GFP_KERNEL);
1997 if (!cache->filled_head) {
1998 csr1212_release_keyval(fi->csr1212_dirs[dr]);
1999 fi->csr1212_dirs[dr] = NULL;
2000 CSR1212_FREE(cache);
2003 cache->filled_tail = cache->filled_head;
2005 if (copy_from_user(cache->data, int2ptr(req->req.sendb),
2007 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2008 fi->csr1212_dirs[dr] = NULL;
2009 CSR1212_FREE(cache);
2012 cache->len = req->req.length;
2013 cache->filled_head->offset_start = 0;
2014 cache->filled_head->offset_end = cache->size -1;
2016 cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr];
2018 ret = CSR1212_SUCCESS;
2019 /* parse all the items */
2020 for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv;
2022 ret = csr1212_parse_keyval(kv, cache);
2025 /* attach top level items to the root directory */
2026 for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head;
2027 ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) {
2028 ret = csr1212_attach_keyval_to_directory(fi->host->csr.rom->root_kv,
2032 if (ret == CSR1212_SUCCESS) {
2033 ret = hpsb_update_config_rom_image(fi->host);
2035 if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb),
2041 kfree(cache->filled_head);
2045 /* we have to free the request, because we queue no response,
2046 * and therefore nobody will free it */
2047 free_pending_request(req);
2048 return sizeof(struct raw1394_request);
2050 for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head;
2051 dentry; dentry = dentry->next) {
2052 csr1212_detach_keyval_from_directory(fi->host->csr.rom->root_kv,
2055 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2056 fi->csr1212_dirs[dr] = NULL;
2061 static int state_connected(struct file_info *fi, struct pending_request *req)
2063 int node = req->req.address >> 48;
2065 req->req.error = RAW1394_ERROR_NONE;
2067 switch (req->req.type) {
2069 case RAW1394_REQ_ECHO:
2070 queue_complete_req(req);
2071 return sizeof(struct raw1394_request);
2073 case RAW1394_REQ_ISO_SEND:
2074 return handle_iso_send(fi, req, node);
2076 case RAW1394_REQ_ARM_REGISTER:
2077 return arm_register(fi, req);
2079 case RAW1394_REQ_ARM_UNREGISTER:
2080 return arm_unregister(fi, req);
2082 case RAW1394_REQ_ARM_SET_BUF:
2083 return arm_set_buf(fi, req);
2085 case RAW1394_REQ_ARM_GET_BUF:
2086 return arm_get_buf(fi, req);
2088 case RAW1394_REQ_RESET_NOTIFY:
2089 return reset_notification(fi, req);
2091 case RAW1394_REQ_ISO_LISTEN:
2092 handle_iso_listen(fi, req);
2093 return sizeof(struct raw1394_request);
2095 case RAW1394_REQ_FCP_LISTEN:
2096 handle_fcp_listen(fi, req);
2097 return sizeof(struct raw1394_request);
2099 case RAW1394_REQ_RESET_BUS:
2100 if (req->req.misc == RAW1394_LONG_RESET) {
2101 DBGMSG("busreset called (type: LONG)");
2102 hpsb_reset_bus(fi->host, LONG_RESET);
2103 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2104 return sizeof(struct raw1394_request);
2106 if (req->req.misc == RAW1394_SHORT_RESET) {
2107 DBGMSG("busreset called (type: SHORT)");
2108 hpsb_reset_bus(fi->host, SHORT_RESET);
2109 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2110 return sizeof(struct raw1394_request);
2112 /* error EINVAL (22) invalid argument */
2114 case RAW1394_REQ_GET_ROM:
2115 return get_config_rom(fi, req);
2117 case RAW1394_REQ_UPDATE_ROM:
2118 return update_config_rom(fi, req);
2120 case RAW1394_REQ_MODIFY_ROM:
2121 return modify_config_rom(fi, req);
2124 if (req->req.generation != get_hpsb_generation(fi->host)) {
2125 req->req.error = RAW1394_ERROR_GENERATION;
2126 req->req.generation = get_hpsb_generation(fi->host);
2127 req->req.length = 0;
2128 queue_complete_req(req);
2129 return sizeof(struct raw1394_request);
2132 switch (req->req.type) {
2133 case RAW1394_REQ_PHYPACKET:
2134 return write_phypacket(fi, req);
2135 case RAW1394_REQ_ASYNC_SEND:
2136 return handle_async_send(fi, req);
2139 if (req->req.length == 0) {
2140 req->req.error = RAW1394_ERROR_INVALID_ARG;
2141 queue_complete_req(req);
2142 return sizeof(struct raw1394_request);
2145 return handle_async_request(fi, req, node);
2149 static ssize_t raw1394_write(struct file *file, const char *buffer, size_t count,
2150 loff_t *offset_is_ignored)
2152 struct file_info *fi = (struct file_info *)file->private_data;
2153 struct pending_request *req;
2156 if (count != sizeof(struct raw1394_request)) {
2160 req = alloc_pending_request();
2164 req->file_info = fi;
2166 if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
2167 free_pending_request(req);
2171 switch (fi->state) {
2173 retval = state_opened(fi, req);
2177 retval = state_initialized(fi, req);
2181 retval = state_connected(fi, req);
2186 free_pending_request(req);
2192 /* rawiso operations */
2194 /* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
2195 * completion queue (reqlists_lock must be taken) */
2196 static inline int __rawiso_event_in_queue(struct file_info *fi)
2198 struct pending_request *req;
2200 list_for_each_entry(req, &fi->req_complete, list)
2201 if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY)
2207 /* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
2208 static void queue_rawiso_event(struct file_info *fi)
2210 unsigned long flags;
2212 spin_lock_irqsave(&fi->reqlists_lock, flags);
2214 /* only one ISO activity event may be in the queue */
2215 if (!__rawiso_event_in_queue(fi)) {
2216 struct pending_request *req = __alloc_pending_request(SLAB_ATOMIC);
2219 req->file_info = fi;
2220 req->req.type = RAW1394_REQ_RAWISO_ACTIVITY;
2221 req->req.generation = get_hpsb_generation(fi->host);
2222 __queue_complete_req(req);
2224 /* on allocation failure, signal an overflow */
2225 if (fi->iso_handle) {
2226 atomic_inc(&fi->iso_handle->overflows);
2230 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2233 static void rawiso_activity_cb(struct hpsb_iso *iso)
2235 unsigned long flags;
2236 struct host_info *hi;
2237 struct file_info *fi;
2239 spin_lock_irqsave(&host_info_lock, flags);
2240 hi = find_host_info(iso->host);
2243 list_for_each_entry(fi, &hi->file_info_list, list) {
2244 if (fi->iso_handle == iso)
2245 queue_rawiso_event(fi);
2249 spin_unlock_irqrestore(&host_info_lock, flags);
2252 /* helper function - gather all the kernel iso status bits for returning to user-space */
2253 static void raw1394_iso_fill_status(struct hpsb_iso *iso, struct raw1394_iso_status *stat)
2255 stat->config.data_buf_size = iso->buf_size;
2256 stat->config.buf_packets = iso->buf_packets;
2257 stat->config.channel = iso->channel;
2258 stat->config.speed = iso->speed;
2259 stat->config.irq_interval = iso->irq_interval;
2260 stat->n_packets = hpsb_iso_n_ready(iso);
2261 stat->overflows = atomic_read(&iso->overflows);
2262 stat->xmit_cycle = iso->xmit_cycle;
2265 static int raw1394_iso_xmit_init(struct file_info *fi, void *uaddr)
2267 struct raw1394_iso_status stat;
2272 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2275 fi->iso_handle = hpsb_iso_xmit_init(fi->host,
2276 stat.config.data_buf_size,
2277 stat.config.buf_packets,
2278 stat.config.channel,
2280 stat.config.irq_interval,
2281 rawiso_activity_cb);
2282 if (!fi->iso_handle)
2285 fi->iso_state = RAW1394_ISO_XMIT;
2287 raw1394_iso_fill_status(fi->iso_handle, &stat);
2288 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2291 /* queue an event to get things started */
2292 rawiso_activity_cb(fi->iso_handle);
2297 static int raw1394_iso_recv_init(struct file_info *fi, void *uaddr)
2299 struct raw1394_iso_status stat;
2304 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2307 fi->iso_handle = hpsb_iso_recv_init(fi->host,
2308 stat.config.data_buf_size,
2309 stat.config.buf_packets,
2310 stat.config.channel,
2311 stat.config.dma_mode,
2312 stat.config.irq_interval,
2313 rawiso_activity_cb);
2314 if (!fi->iso_handle)
2317 fi->iso_state = RAW1394_ISO_RECV;
2319 raw1394_iso_fill_status(fi->iso_handle, &stat);
2320 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2325 static int raw1394_iso_get_status(struct file_info *fi, void *uaddr)
2327 struct raw1394_iso_status stat;
2328 struct hpsb_iso *iso = fi->iso_handle;
2330 raw1394_iso_fill_status(fi->iso_handle, &stat);
2331 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2334 /* reset overflow counter */
2335 atomic_set(&iso->overflows, 0);
2340 /* copy N packet_infos out of the ringbuffer into user-supplied array */
2341 static int raw1394_iso_recv_packets(struct file_info *fi, void *uaddr)
2343 struct raw1394_iso_packets upackets;
2344 unsigned int packet = fi->iso_handle->first_packet;
2347 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2350 if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
2353 /* ensure user-supplied buffer is accessible and big enough */
2354 if (verify_area(VERIFY_WRITE, upackets.infos,
2355 upackets.n_packets * sizeof(struct raw1394_iso_packet_info)))
2358 /* copy the packet_infos out */
2359 for (i = 0; i < upackets.n_packets; i++) {
2360 if (__copy_to_user(&upackets.infos[i],
2361 &fi->iso_handle->infos[packet],
2362 sizeof(struct raw1394_iso_packet_info)))
2365 packet = (packet + 1) % fi->iso_handle->buf_packets;
2371 /* copy N packet_infos from user to ringbuffer, and queue them for transmission */
2372 static int raw1394_iso_send_packets(struct file_info *fi, void *uaddr)
2374 struct raw1394_iso_packets upackets;
2377 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2380 if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
2383 /* ensure user-supplied buffer is accessible and big enough */
2384 if (verify_area(VERIFY_READ, upackets.infos,
2385 upackets.n_packets * sizeof(struct raw1394_iso_packet_info)))
2388 /* copy the infos structs in and queue the packets */
2389 for (i = 0; i < upackets.n_packets; i++) {
2390 struct raw1394_iso_packet_info info;
2392 if (__copy_from_user(&info, &upackets.infos[i],
2393 sizeof(struct raw1394_iso_packet_info)))
2396 rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset,
2397 info.len, info.tag, info.sy);
2405 static void raw1394_iso_shutdown(struct file_info *fi)
2408 hpsb_iso_shutdown(fi->iso_handle);
2410 fi->iso_handle = NULL;
2411 fi->iso_state = RAW1394_ISO_INACTIVE;
2414 /* mmap the rawiso xmit/recv buffer */
2415 static int raw1394_mmap(struct file *file, struct vm_area_struct *vma)
2417 struct file_info *fi = file->private_data;
2419 if (fi->iso_state == RAW1394_ISO_INACTIVE)
2422 return dma_region_mmap(&fi->iso_handle->data_buf, file, vma);
2425 /* ioctl is only used for rawiso operations */
2426 static int raw1394_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2428 struct file_info *fi = file->private_data;
2430 switch(fi->iso_state) {
2431 case RAW1394_ISO_INACTIVE:
2433 case RAW1394_IOC_ISO_XMIT_INIT:
2434 return raw1394_iso_xmit_init(fi, (void*) arg);
2435 case RAW1394_IOC_ISO_RECV_INIT:
2436 return raw1394_iso_recv_init(fi, (void*) arg);
2441 case RAW1394_ISO_RECV:
2443 case RAW1394_IOC_ISO_RECV_START: {
2444 /* copy args from user-space */
2446 if (copy_from_user(&args[0], (void*) arg, sizeof(args)))
2448 return hpsb_iso_recv_start(fi->iso_handle, args[0], args[1], args[2]);
2450 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2451 hpsb_iso_stop(fi->iso_handle);
2453 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2454 return hpsb_iso_recv_listen_channel(fi->iso_handle, arg);
2455 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2456 return hpsb_iso_recv_unlisten_channel(fi->iso_handle, arg);
2457 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK: {
2458 /* copy the u64 from user-space */
2460 if (copy_from_user(&mask, (void*) arg, sizeof(mask)))
2462 return hpsb_iso_recv_set_channel_mask(fi->iso_handle, mask);
2464 case RAW1394_IOC_ISO_GET_STATUS:
2465 return raw1394_iso_get_status(fi, (void*) arg);
2466 case RAW1394_IOC_ISO_RECV_PACKETS:
2467 return raw1394_iso_recv_packets(fi, (void*) arg);
2468 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2469 return hpsb_iso_recv_release_packets(fi->iso_handle, arg);
2470 case RAW1394_IOC_ISO_RECV_FLUSH:
2471 return hpsb_iso_recv_flush(fi->iso_handle);
2472 case RAW1394_IOC_ISO_SHUTDOWN:
2473 raw1394_iso_shutdown(fi);
2475 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2476 queue_rawiso_event(fi);
2480 case RAW1394_ISO_XMIT:
2482 case RAW1394_IOC_ISO_XMIT_START: {
2483 /* copy two ints from user-space */
2485 if (copy_from_user(&args[0], (void*) arg, sizeof(args)))
2487 return hpsb_iso_xmit_start(fi->iso_handle, args[0], args[1]);
2489 case RAW1394_IOC_ISO_XMIT_SYNC:
2490 return hpsb_iso_xmit_sync(fi->iso_handle);
2491 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2492 hpsb_iso_stop(fi->iso_handle);
2494 case RAW1394_IOC_ISO_GET_STATUS:
2495 return raw1394_iso_get_status(fi, (void*) arg);
2496 case RAW1394_IOC_ISO_XMIT_PACKETS:
2497 return raw1394_iso_send_packets(fi, (void*) arg);
2498 case RAW1394_IOC_ISO_SHUTDOWN:
2499 raw1394_iso_shutdown(fi);
2501 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2502 queue_rawiso_event(fi);
2513 static unsigned int raw1394_poll(struct file *file, poll_table *pt)
2515 struct file_info *fi = file->private_data;
2516 unsigned int mask = POLLOUT | POLLWRNORM;
2518 poll_wait(file, &fi->poll_wait_complete, pt);
2520 spin_lock_irq(&fi->reqlists_lock);
2521 if (!list_empty(&fi->req_complete)) {
2522 mask |= POLLIN | POLLRDNORM;
2524 spin_unlock_irq(&fi->reqlists_lock);
2529 static int raw1394_open(struct inode *inode, struct file *file)
2531 struct file_info *fi;
2533 fi = kmalloc(sizeof(struct file_info), SLAB_KERNEL);
2537 memset(fi, 0, sizeof(struct file_info));
2538 fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */
2540 INIT_LIST_HEAD(&fi->list);
2542 INIT_LIST_HEAD(&fi->req_pending);
2543 INIT_LIST_HEAD(&fi->req_complete);
2544 sema_init(&fi->complete_sem, 0);
2545 spin_lock_init(&fi->reqlists_lock);
2546 init_waitqueue_head(&fi->poll_wait_complete);
2547 INIT_LIST_HEAD(&fi->addr_list);
2549 file->private_data = fi;
2554 static int raw1394_release(struct inode *inode, struct file *file)
2556 struct file_info *fi = file->private_data;
2557 struct list_head *lh;
2558 struct pending_request *req;
2559 int done = 0, i, fail = 0;
2561 struct list_head *entry;
2562 struct arm_addr *addr = NULL;
2563 struct host_info *hi;
2564 struct file_info *fi_hlp = NULL;
2565 struct arm_addr *arm_addr = NULL;
2569 if (fi->iso_state != RAW1394_ISO_INACTIVE)
2570 raw1394_iso_shutdown(fi);
2572 for (i = 0; i < 64; i++) {
2573 if (fi->listen_channels & (1ULL << i)) {
2574 hpsb_unlisten_channel(&raw1394_highlevel, fi->host, i);
2578 spin_lock_irq(&host_info_lock);
2579 fi->listen_channels = 0;
2580 spin_unlock_irq(&host_info_lock);
2583 /* set address-entries invalid */
2584 spin_lock_irq(&host_info_lock);
2586 while (!list_empty(&fi->addr_list)) {
2588 lh = fi->addr_list.next;
2589 addr = list_entry(lh, struct arm_addr, addr_list);
2590 /* another host with valid address-entry containing
2591 same addressrange? */
2592 list_for_each_entry(hi, &host_info_list, list) {
2593 if (hi->host != fi->host) {
2594 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
2595 entry = fi_hlp->addr_list.next;
2596 while (entry != &(fi_hlp->addr_list)) {
2597 arm_addr = list_entry(entry,
2598 struct arm_addr, addr_list);
2599 if (arm_addr->start ==
2601 DBGMSG("raw1394_release: "
2602 "another host ownes "
2603 "same addressrange");
2607 entry = entry->next;
2615 if (!another_host) {
2616 DBGMSG("raw1394_release: call hpsb_arm_unregister");
2617 retval = hpsb_unregister_addrspace(&raw1394_highlevel, fi->host, addr->start);
2620 printk(KERN_ERR "raw1394_release arm_Unregister failed\n");
2623 DBGMSG("raw1394_release: delete addr_entry from list");
2624 list_del(&addr->addr_list);
2625 vfree(addr->addr_space_buffer);
2628 spin_unlock_irq(&host_info_lock);
2630 printk(KERN_ERR "raw1394: during addr_list-release "
2631 "error(s) occurred \n");
2635 spin_lock_irq(&fi->reqlists_lock);
2637 while (!list_empty(&fi->req_complete)) {
2638 lh = fi->req_complete.next;
2641 req = list_entry(lh, struct pending_request, list);
2643 free_pending_request(req);
2646 if (list_empty(&fi->req_pending)) done = 1;
2648 spin_unlock_irq(&fi->reqlists_lock);
2650 if (!done) down_interruptible(&fi->complete_sem);
2653 /* Remove any sub-trees left by user space programs */
2654 for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) {
2655 struct csr1212_dentry *dentry;
2656 if (!fi->csr1212_dirs[i]) continue;
2657 for (dentry = fi->csr1212_dirs[i]->value.directory.dentries_head;
2658 dentry; dentry = dentry->next) {
2659 csr1212_detach_keyval_from_directory(fi->host->csr.rom->root_kv, dentry->kv);
2661 csr1212_release_keyval(fi->csr1212_dirs[i]);
2662 fi->csr1212_dirs[i] = NULL;
2666 if ((csr_mod || fi->cfgrom_upd) && hpsb_update_config_rom_image(fi->host) < 0)
2667 HPSB_ERR("Failed to generate Configuration ROM image for host %d", fi->host->id);
2669 if (fi->state == connected) {
2670 spin_lock_irq(&host_info_lock);
2671 list_del(&fi->list);
2672 spin_unlock_irq(&host_info_lock);
2674 put_device(&fi->host->device);
2683 /*** HOTPLUG STUFF **********************************************************/
2685 * Export information about protocols/devices supported by this driver.
2687 static struct ieee1394_device_id raw1394_id_table[] = {
2689 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2690 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
2691 .version = AVC_SW_VERSION_ENTRY & 0xffffff
2694 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2695 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2696 .version = CAMERA_SW_VERSION_ENTRY & 0xffffff
2701 MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table);
2703 static struct hpsb_protocol_driver raw1394_driver = {
2704 .name = "raw1394 Driver",
2705 .id_table = raw1394_id_table,
2708 .bus = &ieee1394_bus_type,
2713 /******************************************************************************/
2716 static struct hpsb_highlevel raw1394_highlevel = {
2717 .name = RAW1394_DEVICE_NAME,
2718 .add_host = add_host,
2719 .remove_host = remove_host,
2720 .host_reset = host_reset,
2721 .iso_receive = iso_receive,
2722 .fcp_request = fcp_request,
2725 static struct cdev raw1394_cdev;
2726 static struct file_operations raw1394_fops = {
2727 .owner = THIS_MODULE,
2728 .read = raw1394_read,
2729 .write = raw1394_write,
2730 .mmap = raw1394_mmap,
2731 .ioctl = raw1394_ioctl,
2732 .poll = raw1394_poll,
2733 .open = raw1394_open,
2734 .release = raw1394_release,
2737 static int __init init_raw1394(void)
2741 hpsb_register_highlevel(&raw1394_highlevel);
2743 devfs_mk_cdev(MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16),
2744 S_IFCHR | S_IRUSR | S_IWUSR, RAW1394_DEVICE_NAME);
2746 cdev_init(&raw1394_cdev, &raw1394_fops);
2747 raw1394_cdev.owner = THIS_MODULE;
2748 kobject_set_name(&raw1394_cdev.kobj, RAW1394_DEVICE_NAME);
2749 ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1);
2751 HPSB_ERR("raw1394 failed to register minor device block");
2752 devfs_remove(RAW1394_DEVICE_NAME);
2753 hpsb_unregister_highlevel(&raw1394_highlevel);
2757 HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME);
2759 ret = hpsb_register_protocol(&raw1394_driver);
2761 HPSB_ERR("raw1394: failed to register protocol");
2762 cdev_del(&raw1394_cdev);
2763 devfs_remove(RAW1394_DEVICE_NAME);
2764 hpsb_unregister_highlevel(&raw1394_highlevel);
2771 static void __exit cleanup_raw1394(void)
2773 hpsb_unregister_protocol(&raw1394_driver);
2774 cdev_del(&raw1394_cdev);
2775 devfs_remove(RAW1394_DEVICE_NAME);
2776 hpsb_unregister_highlevel(&raw1394_highlevel);
2779 module_init(init_raw1394);
2780 module_exit(cleanup_raw1394);
2781 MODULE_LICENSE("GPL");
2782 MODULE_ALIAS_CHARDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16);