?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / ieee1394 / raw1394.c
blobdd1a56fa05e661819935abf4fa9ab9c0ae49c18b
1 /*
2 * IEEE 1394 for Linux
3 *
4 * Raw interface to the bus
5 *
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>
9 *
10 * This code is licensed under the GPL. See the file COPYING in the root
11 * directory of the kernel sources for details.
12 *
13 *
14 * Contributions:
15 *
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
23 * lock64 request
24 * transmit physical packet
25 * busreset notification control (switch on/off)
26 * busreset with selection of type (short/long)
27 * request_reply
28 */
29
30 #include <linux/kernel.h>
31 #include <linux/list.h>
32 #include <linux/sched.h>
33 #include <linux/string.h>
34 #include <linux/slab.h>
35 #include <linux/fs.h>
36 #include <linux/poll.h>
37 #include <linux/module.h>
38 #include <linux/mutex.h>
39 #include <linux/init.h>
40 #include <linux/interrupt.h>
41 #include <linux/vmalloc.h>
42 #include <linux/cdev.h>
43 #include <asm/uaccess.h>
44 #include <asm/atomic.h>
45 #include <linux/compat.h>
46
47 #include "csr1212.h"
48 #include "highlevel.h"
49 #include "hosts.h"
50 #include "ieee1394.h"
51 #include "ieee1394_core.h"
52 #include "ieee1394_hotplug.h"
53 #include "ieee1394_transactions.h"
54 #include "ieee1394_types.h"
55 #include "iso.h"
56 #include "nodemgr.h"
57 #include "raw1394.h"
58 #include "raw1394-private.h"
59
60 #define int2ptr(x) ((void __user *)(unsigned long)x)
61 #define ptr2int(x) ((u64)(unsigned long)(void __user *)x)
62
63 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
64 #define RAW1394_DEBUG
65 #endif
66
67 #ifdef RAW1394_DEBUG
68 #define DBGMSG(fmt, args...) \
69 printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
70 #else
71 #define DBGMSG(fmt, args...) do {} while (0)
72 #endif
73
74 static LIST_HEAD(host_info_list);
75 static int host_count;
76 static DEFINE_SPINLOCK(host_info_lock);
77 static atomic_t internal_generation = ATOMIC_INIT(0);
78
79 static atomic_t iso_buffer_size;
80 static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
81
82 static struct hpsb_highlevel raw1394_highlevel;
83
84 static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
85 u64 addr, size_t length, u16 flags);
86 static int arm_write(struct hpsb_host *host, int nodeid, int destid,
87 quadlet_t * data, u64 addr, size_t length, u16 flags);
88 static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
89 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
90 u16 flags);
91 static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
92 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
93 u16 flags);
94 static const struct hpsb_address_ops arm_ops = {
95 .read = arm_read,
96 .write = arm_write,
97 .lock = arm_lock,
98 .lock64 = arm_lock64,
99 };
100
101 static void queue_complete_cb(struct pending_request *req);
102
103 static struct pending_request *__alloc_pending_request(gfp_t flags)
104 {
105 struct pending_request *req;
106
107 req = kzalloc(sizeof(*req), flags);
108 if (req)
109 INIT_LIST_HEAD(&req->list);
110
111 return req;
112 }
113
114 static inline struct pending_request *alloc_pending_request(void)
115 {
116 return __alloc_pending_request(GFP_KERNEL);
117 }
118
119 static void free_pending_request(struct pending_request *req)
120 {
121 if (req->ibs) {
122 if (atomic_dec_and_test(&req->ibs->refcount)) {
123 atomic_sub(req->ibs->data_size, &iso_buffer_size);
124 kfree(req->ibs);
125 }
126 } else if (req->free_data) {
127 kfree(req->data);
128 }
129 hpsb_free_packet(req->packet);
130 kfree(req);
131 }
132
133 /* fi->reqlists_lock must be taken */
134 static void __queue_complete_req(struct pending_request *req)
135 {
136 struct file_info *fi = req->file_info;
137
138 list_move_tail(&req->list, &fi->req_complete);
139 wake_up(&fi->wait_complete);
140 }
141
142 static void queue_complete_req(struct pending_request *req)
143 {
144 unsigned long flags;
145 struct file_info *fi = req->file_info;
146
147 spin_lock_irqsave(&fi->reqlists_lock, flags);
148 __queue_complete_req(req);
149 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
150 }
151
152 static void queue_complete_cb(struct pending_request *req)
153 {
154 struct hpsb_packet *packet = req->packet;
155 int rcode = (packet->header[1] >> 12) & 0xf;
156
157 switch (packet->ack_code) {
158 case ACKX_NONE:
159 case ACKX_SEND_ERROR:
160 req->req.error = RAW1394_ERROR_SEND_ERROR;
161 break;
162 case ACKX_ABORTED:
163 req->req.error = RAW1394_ERROR_ABORTED;
164 break;
165 case ACKX_TIMEOUT:
166 req->req.error = RAW1394_ERROR_TIMEOUT;
167 break;
168 default:
169 req->req.error = (packet->ack_code << 16) | rcode;
170 break;
171 }
172
173 if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
174 req->req.length = 0;
175 }
176
177 if ((req->req.type == RAW1394_REQ_ASYNC_READ) ||
178 (req->req.type == RAW1394_REQ_ASYNC_WRITE) ||
179 (req->req.type == RAW1394_REQ_ASYNC_STREAM) ||
180 (req->req.type == RAW1394_REQ_LOCK) ||
181 (req->req.type == RAW1394_REQ_LOCK64))
182 hpsb_free_tlabel(packet);
183
184 queue_complete_req(req);
185 }
186
187 static void add_host(struct hpsb_host *host)
188 {
189 struct host_info *hi;
190 unsigned long flags;
191
192 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
193
194 if (hi) {
195 INIT_LIST_HEAD(&hi->list);
196 hi->host = host;
197 INIT_LIST_HEAD(&hi->file_info_list);
198
199 spin_lock_irqsave(&host_info_lock, flags);
200 list_add_tail(&hi->list, &host_info_list);
201 host_count++;
202 spin_unlock_irqrestore(&host_info_lock, flags);
203 }
204
205 atomic_inc(&internal_generation);
206 }
207
208 static struct host_info *find_host_info(struct hpsb_host *host)
209 {
210 struct host_info *hi;
211
212 list_for_each_entry(hi, &host_info_list, list)
213 if (hi->host == host)
214 return hi;
215
216 return NULL;
217 }
218
219 static void remove_host(struct hpsb_host *host)
220 {
221 struct host_info *hi;
222 unsigned long flags;
223
224 spin_lock_irqsave(&host_info_lock, flags);
225 hi = find_host_info(host);
226
227 if (hi != NULL) {
228 list_del(&hi->list);
229 host_count--;
230 }
231 spin_unlock_irqrestore(&host_info_lock, flags);
232
233 if (hi == NULL) {
234 printk(KERN_ERR "raw1394: attempt to remove unknown host "
235 "0x%p\n", host);
236 return;
237 }
238
239 kfree(hi);
240
241 atomic_inc(&internal_generation);
242 }
243
244 static void host_reset(struct hpsb_host *host)
245 {
246 unsigned long flags;
247 struct host_info *hi;
248 struct file_info *fi;
249 struct pending_request *req;
250
251 spin_lock_irqsave(&host_info_lock, flags);
252 hi = find_host_info(host);
253
254 if (hi != NULL) {
255 list_for_each_entry(fi, &hi->file_info_list, list) {
256 if (fi->notification == RAW1394_NOTIFY_ON) {
257 req = __alloc_pending_request(GFP_ATOMIC);
258
259 if (req != NULL) {
260 req->file_info = fi;
261 req->req.type = RAW1394_REQ_BUS_RESET;
262 req->req.generation =
263 get_hpsb_generation(host);
264 req->req.misc = (host->node_id << 16)
265 | host->node_count;
266 if (fi->protocol_version > 3) {
267 req->req.misc |=
268 (NODEID_TO_NODE
269 (host->irm_id)
270 << 8);
271 }
272
273 queue_complete_req(req);
274 }
275 }
276 }
277 }
278 spin_unlock_irqrestore(&host_info_lock, flags);
279 }
280
281 static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
282 int cts, u8 * data, size_t length)
283 {
284 unsigned long flags;
285 struct host_info *hi;
286 struct file_info *fi;
287 struct pending_request *req, *req_next;
288 struct iso_block_store *ibs = NULL;
289 LIST_HEAD(reqs);
290
291 if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
292 HPSB_INFO("dropped fcp request");
293 return;
294 }
295
296 spin_lock_irqsave(&host_info_lock, flags);
297 hi = find_host_info(host);
298
299 if (hi != NULL) {
300 list_for_each_entry(fi, &hi->file_info_list, list) {
301 if (!fi->fcp_buffer)
302 continue;
303
304 req = __alloc_pending_request(GFP_ATOMIC);
305 if (!req)
306 break;
307
308 if (!ibs) {
309 ibs = kmalloc(sizeof(*ibs) + length,
310 GFP_ATOMIC);
311 if (!ibs) {
312 kfree(req);
313 break;
314 }
315
316 atomic_add(length, &iso_buffer_size);
317 atomic_set(&ibs->refcount, 0);
318 ibs->data_size = length;
319 memcpy(ibs->data, data, length);
320 }
321
322 atomic_inc(&ibs->refcount);
323
324 req->file_info = fi;
325 req->ibs = ibs;
326 req->data = ibs->data;
327 req->req.type = RAW1394_REQ_FCP_REQUEST;
328 req->req.generation = get_hpsb_generation(host);
329 req->req.misc = nodeid | (direction << 16);
330 req->req.recvb = ptr2int(fi->fcp_buffer);
331 req->req.length = length;
332
333 list_add_tail(&req->list, &reqs);
334 }
335 }
336 spin_unlock_irqrestore(&host_info_lock, flags);
337
338 list_for_each_entry_safe(req, req_next, &reqs, list)
339 queue_complete_req(req);
340 }
341
342 #ifdef CONFIG_COMPAT
343 struct compat_raw1394_req {
344 __u32 type;
345 __s32 error;
346 __u32 misc;
347
348 __u32 generation;
349 __u32 length;
350
351 __u64 address;
352
353 __u64 tag;
354
355 __u64 sendb;
356 __u64 recvb;
357 }
358 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
359 __attribute__((packed))
360 #endif
361 ;
362
363 static const char __user *raw1394_compat_write(const char __user *buf)
364 {
365 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
366 struct raw1394_request __user *r;
367
368 r = compat_alloc_user_space(sizeof(struct raw1394_request));
369
370 #define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x))
371
372 if (copy_in_user(r, cr, sizeof(struct compat_raw1394_req)) ||
373 C(address) ||
374 C(tag) ||
375 C(sendb) ||
376 C(recvb))
377 return (__force const char __user *)ERR_PTR(-EFAULT);
378
379 return (const char __user *)r;
380 }
381 #undef C
382
383 #define P(x) __put_user(r->x, &cr->x)
384
385 static int
386 raw1394_compat_read(const char __user *buf, struct raw1394_request *r)
387 {
388 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
389
390 if (!access_ok(VERIFY_WRITE, cr, sizeof(struct compat_raw1394_req)) ||
391 P(type) ||
392 P(error) ||
393 P(misc) ||
394 P(generation) ||
395 P(length) ||
396 P(address) ||
397 P(tag) ||
398 P(sendb) ||
399 P(recvb))
400 return -EFAULT;
401
402 return sizeof(struct compat_raw1394_req);
403 }
404 #undef P
405
406 #endif
407
408 /* get next completed request (caller must hold fi->reqlists_lock) */
409 static inline struct pending_request *__next_complete_req(struct file_info *fi)
410 {
411 struct list_head *lh;
412 struct pending_request *req = NULL;
413
414 if (!list_empty(&fi->req_complete)) {
415 lh = fi->req_complete.next;
416 list_del(lh);
417 req = list_entry(lh, struct pending_request, list);
418 }
419 return req;
420 }
421
422 /* atomically get next completed request */
423 static struct pending_request *next_complete_req(struct file_info *fi)
424 {
425 unsigned long flags;
426 struct pending_request *req;
427
428 spin_lock_irqsave(&fi->reqlists_lock, flags);
429 req = __next_complete_req(fi);
430 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
431 return req;
432 }
433
434 static ssize_t raw1394_read(struct file *file, char __user * buffer,
435 size_t count, loff_t * offset_is_ignored)
436 {
437 struct file_info *fi = file->private_data;
438 struct pending_request *req;
439 ssize_t ret;
440
441 #ifdef CONFIG_COMPAT
442 if (count == sizeof(struct compat_raw1394_req)) {
443 /* ok */
444 } else
445 #endif
446 if (count != sizeof(struct raw1394_request)) {
447 return -EINVAL;
448 }
449
450 if (!access_ok(VERIFY_WRITE, buffer, count)) {
451 return -EFAULT;
452 }
453
454 if (file->f_flags & O_NONBLOCK) {
455 if (!(req = next_complete_req(fi)))
456 return -EAGAIN;
457 } else {
458 /*
459 * NB: We call the macro wait_event_interruptible() with a
460 * condition argument with side effect. This is only possible
461 * because the side effect does not occur until the condition
462 * became true, and wait_event_interruptible() won't evaluate
463 * the condition again after that.
464 */
465 if (wait_event_interruptible(fi->wait_complete,
466 (req = next_complete_req(fi))))
467 return -ERESTARTSYS;
468 }
469
470 if (req->req.length) {
471 if (copy_to_user(int2ptr(req->req.recvb), req->data,
472 req->req.length)) {
473 req->req.error = RAW1394_ERROR_MEMFAULT;
474 }
475 }
476
477 #ifdef CONFIG_COMPAT
478 if (count == sizeof(struct compat_raw1394_req) &&
479 sizeof(struct compat_raw1394_req) !=
480 sizeof(struct raw1394_request)) {
481 ret = raw1394_compat_read(buffer, &req->req);
482 } else
483 #endif
484 {
485 if (copy_to_user(buffer, &req->req, sizeof(req->req))) {
486 ret = -EFAULT;
487 goto out;
488 }
489 ret = (ssize_t) sizeof(struct raw1394_request);
490 }
491 out:
492 free_pending_request(req);
493 return ret;
494 }
495
496 static int state_opened(struct file_info *fi, struct pending_request *req)
497 {
498 if (req->req.type == RAW1394_REQ_INITIALIZE) {
499 switch (req->req.misc) {
500 case RAW1394_KERNELAPI_VERSION:
501 case 3:
502 fi->state = initialized;
503 fi->protocol_version = req->req.misc;
504 req->req.error = RAW1394_ERROR_NONE;
505 req->req.generation = atomic_read(&internal_generation);
506 break;
507
508 default:
509 req->req.error = RAW1394_ERROR_COMPAT;
510 req->req.misc = RAW1394_KERNELAPI_VERSION;
511 }
512 } else {
513 req->req.error = RAW1394_ERROR_STATE_ORDER;
514 }
515
516 req->req.length = 0;
517 queue_complete_req(req);
518 return 0;
519 }
520
521 static int state_initialized(struct file_info *fi, struct pending_request *req)
522 {
523 unsigned long flags;
524 struct host_info *hi;
525 struct raw1394_khost_list *khl;
526
527 if (req->req.generation != atomic_read(&internal_generation)) {
528 req->req.error = RAW1394_ERROR_GENERATION;
529 req->req.generation = atomic_read(&internal_generation);
530 req->req.length = 0;
531 queue_complete_req(req);
532 return 0;
533 }
534
535 switch (req->req.type) {
536 case RAW1394_REQ_LIST_CARDS:
537 spin_lock_irqsave(&host_info_lock, flags);
538 khl = kmalloc(sizeof(*khl) * host_count, GFP_ATOMIC);
539
540 if (khl) {
541 req->req.misc = host_count;
542 req->data = (quadlet_t *) khl;
543
544 list_for_each_entry(hi, &host_info_list, list) {
545 khl->nodes = hi->host->node_count;
546 strcpy(khl->name, hi->host->driver->name);
547 khl++;
548 }
549 }
550 spin_unlock_irqrestore(&host_info_lock, flags);
551
552 if (khl) {
553 req->req.error = RAW1394_ERROR_NONE;
554 req->req.length = min(req->req.length,
555 (u32) (sizeof
556 (struct raw1394_khost_list)
557 * req->req.misc));
558 req->free_data = 1;
559 } else {
560 return -ENOMEM;
561 }
562 break;
563
564 case RAW1394_REQ_SET_CARD:
565 spin_lock_irqsave(&host_info_lock, flags);
566 if (req->req.misc >= host_count) {
567 req->req.error = RAW1394_ERROR_INVALID_ARG;
568 goto out_set_card;
569 }
570 list_for_each_entry(hi, &host_info_list, list)
571 if (!req->req.misc--)
572 break;
573 get_device(&hi->host->device);
574 list_add_tail(&fi->list, &hi->file_info_list);
575
576 /* prevent unloading of the host's low-level driver */
577 if (!try_module_get(hi->host->driver->owner)) {
578 req->req.error = RAW1394_ERROR_ABORTED;
579 goto out_set_card;
580 }
581 WARN_ON(fi->host);
582 fi->host = hi->host;
583 fi->state = connected;
584
585 req->req.error = RAW1394_ERROR_NONE;
586 req->req.generation = get_hpsb_generation(fi->host);
587 req->req.misc = (fi->host->node_id << 16)
588 | fi->host->node_count;
589 if (fi->protocol_version > 3)
590 req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8;
591 out_set_card:
592 spin_unlock_irqrestore(&host_info_lock, flags);
593
594 req->req.length = 0;
595 break;
596
597 default:
598 req->req.error = RAW1394_ERROR_STATE_ORDER;
599 req->req.length = 0;
600 break;
601 }
602
603 queue_complete_req(req);
604 return 0;
605 }
606
607 static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
608 {
609 if (req->req.misc) {
610 if (fi->fcp_buffer) {
611 req->req.error = RAW1394_ERROR_ALREADY;
612 } else {
613 fi->fcp_buffer = int2ptr(req->req.recvb);
614 }
615 } else {
616 if (!fi->fcp_buffer) {
617 req->req.error = RAW1394_ERROR_ALREADY;
618 } else {
619 fi->fcp_buffer = NULL;
620 }
621 }
622
623 req->req.length = 0;
624 queue_complete_req(req);
625 }
626
627 static int handle_async_request(struct file_info *fi,
628 struct pending_request *req, int node)
629 {
630 unsigned long flags;
631 struct hpsb_packet *packet = NULL;
632 u64 addr = req->req.address & 0xffffffffffffULL;
633
634 switch (req->req.type) {
635 case RAW1394_REQ_ASYNC_READ:
636 DBGMSG("read_request called");
637 packet =
638 hpsb_make_readpacket(fi->host, node, addr, req->req.length);
639
640 if (!packet)
641 return -ENOMEM;
642
643 if (req->req.length == 4)
644 req->data = &packet->header[3];
645 else
646 req->data = packet->data;
647
648 break;
649
650 case RAW1394_REQ_ASYNC_WRITE:
651 DBGMSG("write_request called");
652
653 packet = hpsb_make_writepacket(fi->host, node, addr, NULL,
654 req->req.length);
655 if (!packet)
656 return -ENOMEM;
657
658 if (req->req.length == 4) {
659 if (copy_from_user
660 (&packet->header[3], int2ptr(req->req.sendb),
661 req->req.length))
662 req->req.error = RAW1394_ERROR_MEMFAULT;
663 } else {
664 if (copy_from_user
665 (packet->data, int2ptr(req->req.sendb),
666 req->req.length))
667 req->req.error = RAW1394_ERROR_MEMFAULT;
668 }
669
670 req->req.length = 0;
671 break;
672
673 case RAW1394_REQ_ASYNC_STREAM:
674 DBGMSG("stream_request called");
675
676 packet =
677 hpsb_make_streampacket(fi->host, NULL, req->req.length,
678 node & 0x3f /*channel */ ,
679 (req->req.misc >> 16) & 0x3,
680 req->req.misc & 0xf);
681 if (!packet)
682 return -ENOMEM;
683
684 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
685 req->req.length))
686 req->req.error = RAW1394_ERROR_MEMFAULT;
687
688 req->req.length = 0;
689 break;
690
691 case RAW1394_REQ_LOCK:
692 DBGMSG("lock_request called");
693 if ((req->req.misc == EXTCODE_FETCH_ADD)
694 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
695 if (req->req.length != 4) {
696 req->req.error = RAW1394_ERROR_INVALID_ARG;
697 break;
698 }
699 } else {
700 if (req->req.length != 8) {
701 req->req.error = RAW1394_ERROR_INVALID_ARG;
702 break;
703 }
704 }
705
706 packet = hpsb_make_lockpacket(fi->host, node, addr,
707 req->req.misc, NULL, 0);
708 if (!packet)
709 return -ENOMEM;
710
711 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
712 req->req.length)) {
713 req->req.error = RAW1394_ERROR_MEMFAULT;
714 break;
715 }
716
717 req->data = packet->data;
718 req->req.length = 4;
719 break;
720
721 case RAW1394_REQ_LOCK64:
722 DBGMSG("lock64_request called");
723 if ((req->req.misc == EXTCODE_FETCH_ADD)
724 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
725 if (req->req.length != 8) {
726 req->req.error = RAW1394_ERROR_INVALID_ARG;
727 break;
728 }
729 } else {
730 if (req->req.length != 16) {
731 req->req.error = RAW1394_ERROR_INVALID_ARG;
732 break;
733 }
734 }
735 packet = hpsb_make_lock64packet(fi->host, node, addr,
736 req->req.misc, NULL, 0);
737 if (!packet)
738 return -ENOMEM;
739
740 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
741 req->req.length)) {
742 req->req.error = RAW1394_ERROR_MEMFAULT;
743 break;
744 }
745
746 req->data = packet->data;
747 req->req.length = 8;
748 break;
749
750 default:
751 req->req.error = RAW1394_ERROR_STATE_ORDER;
752 }
753
754 req->packet = packet;
755
756 if (req->req.error) {
757 req->req.length = 0;
758 queue_complete_req(req);
759 return 0;
760 }
761
762 hpsb_set_packet_complete_task(packet,
763 (void (*)(void *))queue_complete_cb, req);
764
765 spin_lock_irqsave(&fi->reqlists_lock, flags);
766 list_add_tail(&req->list, &fi->req_pending);
767 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
768
769 packet->generation = req->req.generation;
770
771 if (hpsb_send_packet(packet) < 0) {
772 req->req.error = RAW1394_ERROR_SEND_ERROR;
773 req->req.length = 0;
774 hpsb_free_tlabel(packet);
775 queue_complete_req(req);
776 }
777 return 0;
778 }
779
780 static int handle_async_send(struct file_info *fi, struct pending_request *req)
781 {
782 unsigned long flags;
783 struct hpsb_packet *packet;
784 int header_length = req->req.misc & 0xffff;
785 int expect_response = req->req.misc >> 16;
786 size_t data_size;
787
788 if (header_length > req->req.length || header_length < 12 ||
789 header_length > FIELD_SIZEOF(struct hpsb_packet, header)) {
790 req->req.error = RAW1394_ERROR_INVALID_ARG;
791 req->req.length = 0;
792 queue_complete_req(req);
793 return 0;
794 }
795
796 data_size = req->req.length - header_length;
797 packet = hpsb_alloc_packet(data_size);
798 req->packet = packet;
799 if (!packet)
800 return -ENOMEM;
801
802 if (copy_from_user(packet->header, int2ptr(req->req.sendb),
803 header_length)) {
804 req->req.error = RAW1394_ERROR_MEMFAULT;
805 req->req.length = 0;
806 queue_complete_req(req);
807 return 0;
808 }
809
810 if (copy_from_user
811 (packet->data, int2ptr(req->req.sendb) + header_length,
812 data_size)) {
813 req->req.error = RAW1394_ERROR_MEMFAULT;
814 req->req.length = 0;
815 queue_complete_req(req);
816 return 0;
817 }
818
819 packet->type = hpsb_async;
820 packet->node_id = packet->header[0] >> 16;
821 packet->tcode = (packet->header[0] >> 4) & 0xf;
822 packet->tlabel = (packet->header[0] >> 10) & 0x3f;
823 packet->host = fi->host;
824 packet->expect_response = expect_response;
825 packet->header_size = header_length;
826 packet->data_size = data_size;
827
828 req->req.length = 0;
829 hpsb_set_packet_complete_task(packet,
830 (void (*)(void *))queue_complete_cb, req);
831
832 spin_lock_irqsave(&fi->reqlists_lock, flags);
833 list_add_tail(&req->list, &fi->req_pending);
834 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
835
836 /* Update the generation of the packet just before sending. */
837 packet->generation = req->req.generation;
838
839 if (hpsb_send_packet(packet) < 0) {
840 req->req.error = RAW1394_ERROR_SEND_ERROR;
841 queue_complete_req(req);
842 }
843
844 return 0;
845 }
846
847 static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
848 u64 addr, size_t length, u16 flags)
849 {
850 unsigned long irqflags;
851 struct pending_request *req;
852 struct host_info *hi;
853 struct file_info *fi = NULL;
854 struct list_head *entry;
855 struct arm_addr *arm_addr = NULL;
856 struct arm_request *arm_req = NULL;
857 struct arm_response *arm_resp = NULL;
858 int found = 0, size = 0, rcode = -1;
859 struct arm_request_response *arm_req_resp = NULL;
860
861 DBGMSG("arm_read called by node: %X "
862 "addr: %4.4x %8.8x length: %Zu", nodeid,
863 (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
864 length);
865 spin_lock_irqsave(&host_info_lock, irqflags);
866 hi = find_host_info(host); /* search address-entry */
867 if (hi != NULL) {
868 list_for_each_entry(fi, &hi->file_info_list, list) {
869 entry = fi->addr_list.next;
870 while (entry != &(fi->addr_list)) {
871 arm_addr =
872 list_entry(entry, struct arm_addr,
873 addr_list);
874 if (((arm_addr->start) <= (addr))
875 && ((arm_addr->end) >= (addr + length))) {
876 found = 1;
877 break;
878 }
879 entry = entry->next;
880 }
881 if (found) {
882 break;
883 }
884 }
885 }
886 rcode = -1;
887 if (!found) {
888 printk(KERN_ERR "raw1394: arm_read FAILED addr_entry not found"
889 " -> rcode_address_error\n");
890 spin_unlock_irqrestore(&host_info_lock, irqflags);
891 return (RCODE_ADDRESS_ERROR);
892 } else {
893 DBGMSG("arm_read addr_entry FOUND");
894 }
895 if (arm_addr->rec_length < length) {
896 DBGMSG("arm_read blocklength too big -> rcode_data_error");
897 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
898 }
899 if (rcode == -1) {
900 if (arm_addr->access_rights & ARM_READ) {
901 if (!(arm_addr->client_transactions & ARM_READ)) {
902 memcpy(buffer,
903 (arm_addr->addr_space_buffer) + (addr -
904 (arm_addr->
905 start)),
906 length);
907 DBGMSG("arm_read -> (rcode_complete)");
908 rcode = RCODE_COMPLETE;
909 }
910 } else {
911 rcode = RCODE_TYPE_ERROR; /* function not allowed */
912 DBGMSG("arm_read -> rcode_type_error (access denied)");
913 }
914 }
915 if (arm_addr->notification_options & ARM_READ) {
916 DBGMSG("arm_read -> entering notification-section");
917 req = __alloc_pending_request(GFP_ATOMIC);
918 if (!req) {
919 DBGMSG("arm_read -> rcode_conflict_error");
920 spin_unlock_irqrestore(&host_info_lock, irqflags);
921 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
922 The request may be retried */
923 }
924 if (rcode == RCODE_COMPLETE) {
925 size =
926 sizeof(struct arm_request) +
927 sizeof(struct arm_response) +
928 length * sizeof(byte_t) +
929 sizeof(struct arm_request_response);
930 } else {
931 size =
932 sizeof(struct arm_request) +
933 sizeof(struct arm_response) +
934 sizeof(struct arm_request_response);
935 }
936 req->data = kmalloc(size, GFP_ATOMIC);
937 if (!(req->data)) {
938 free_pending_request(req);
939 DBGMSG("arm_read -> rcode_conflict_error");
940 spin_unlock_irqrestore(&host_info_lock, irqflags);
941 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
942 The request may be retried */
943 }
944 req->free_data = 1;
945 req->file_info = fi;
946 req->req.type = RAW1394_REQ_ARM;
947 req->req.generation = get_hpsb_generation(host);
948 req->req.misc =
949 (((length << 16) & (0xFFFF0000)) | (ARM_READ & 0xFF));
950 req->req.tag = arm_addr->arm_tag;
951 req->req.recvb = arm_addr->recvb;
952 req->req.length = size;
953 arm_req_resp = (struct arm_request_response *)(req->data);
954 arm_req = (struct arm_request *)((byte_t *) (req->data) +
955 (sizeof
956 (struct
957 arm_request_response)));
958 arm_resp =
959 (struct arm_response *)((byte_t *) (arm_req) +
960 (sizeof(struct arm_request)));
961 arm_req->buffer = NULL;
962 arm_resp->buffer = NULL;
963 if (rcode == RCODE_COMPLETE) {
964 byte_t *buf =
965 (byte_t *) arm_resp + sizeof(struct arm_response);
966 memcpy(buf,
967 (arm_addr->addr_space_buffer) + (addr -
968 (arm_addr->
969 start)),
970 length);
971 arm_resp->buffer =
972 int2ptr((arm_addr->recvb) +
973 sizeof(struct arm_request_response) +
974 sizeof(struct arm_request) +
975 sizeof(struct arm_response));
976 }
977 arm_resp->buffer_length =
978 (rcode == RCODE_COMPLETE) ? length : 0;
979 arm_resp->response_code = rcode;
980 arm_req->buffer_length = 0;
981 arm_req->generation = req->req.generation;
982 arm_req->extended_transaction_code = 0;
983 arm_req->destination_offset = addr;
984 arm_req->source_nodeid = nodeid;
985 arm_req->destination_nodeid = host->node_id;
986 arm_req->tlabel = (flags >> 10) & 0x3f;
987 arm_req->tcode = (flags >> 4) & 0x0f;
988 arm_req_resp->request = int2ptr((arm_addr->recvb) +
989 sizeof(struct
990 arm_request_response));
991 arm_req_resp->response =
992 int2ptr((arm_addr->recvb) +
993 sizeof(struct arm_request_response) +
994 sizeof(struct arm_request));
995 queue_complete_req(req);
996 }
997 spin_unlock_irqrestore(&host_info_lock, irqflags);
998 return (rcode);
999 }
1000
1001 static int arm_write(struct hpsb_host *host, int nodeid, int destid,
1002 quadlet_t * data, u64 addr, size_t length, u16 flags)
1003 {
1004 unsigned long irqflags;
1005 struct pending_request *req;
1006 struct host_info *hi;
1007 struct file_info *fi = NULL;
1008 struct list_head *entry;
1009 struct arm_addr *arm_addr = NULL;
1010 struct arm_request *arm_req = NULL;
1011 struct arm_response *arm_resp = NULL;
1012 int found = 0, size = 0, rcode = -1;
1013 struct arm_request_response *arm_req_resp = NULL;
1014
1015 DBGMSG("arm_write called by node: %X "
1016 "addr: %4.4x %8.8x length: %Zu", nodeid,
1017 (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
1018 length);
1019 spin_lock_irqsave(&host_info_lock, irqflags);
1020 hi = find_host_info(host); /* search address-entry */
1021 if (hi != NULL) {
1022 list_for_each_entry(fi, &hi->file_info_list, list) {
1023 entry = fi->addr_list.next;
1024 while (entry != &(fi->addr_list)) {
1025 arm_addr =
1026 list_entry(entry, struct arm_addr,
1027 addr_list);
1028 if (((arm_addr->start) <= (addr))
1029 && ((arm_addr->end) >= (addr + length))) {
1030 found = 1;
1031 break;
1032 }
1033 entry = entry->next;
1034 }
1035 if (found) {
1036 break;
1037 }
1038 }
1039 }
1040 rcode = -1;
1041 if (!found) {
1042 printk(KERN_ERR "raw1394: arm_write FAILED addr_entry not found"
1043 " -> rcode_address_error\n");
1044 spin_unlock_irqrestore(&host_info_lock, irqflags);
1045 return (RCODE_ADDRESS_ERROR);
1046 } else {
1047 DBGMSG("arm_write addr_entry FOUND");
1048 }
1049 if (arm_addr->rec_length < length) {
1050 DBGMSG("arm_write blocklength too big -> rcode_data_error");
1051 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
1052 }
1053 if (rcode == -1) {
1054 if (arm_addr->access_rights & ARM_WRITE) {
1055 if (!(arm_addr->client_transactions & ARM_WRITE)) {
1056 memcpy((arm_addr->addr_space_buffer) +
1057 (addr - (arm_addr->start)), data,
1058 length);
1059 DBGMSG("arm_write -> (rcode_complete)");
1060 rcode = RCODE_COMPLETE;
1061 }
1062 } else {
1063 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1064 DBGMSG("arm_write -> rcode_type_error (access denied)");
1065 }
1066 }
1067 if (arm_addr->notification_options & ARM_WRITE) {
1068 DBGMSG("arm_write -> entering notification-section");
1069 req = __alloc_pending_request(GFP_ATOMIC);
1070 if (!req) {
1071 DBGMSG("arm_write -> rcode_conflict_error");
1072 spin_unlock_irqrestore(&host_info_lock, irqflags);
1073 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1074 The request my be retried */
1075 }
1076 size =
1077 sizeof(struct arm_request) + sizeof(struct arm_response) +
1078 (length) * sizeof(byte_t) +
1079 sizeof(struct arm_request_response);
1080 req->data = kmalloc(size, GFP_ATOMIC);
1081 if (!(req->data)) {
1082 free_pending_request(req);
1083 DBGMSG("arm_write -> rcode_conflict_error");
1084 spin_unlock_irqrestore(&host_info_lock, irqflags);
1085 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1086 The request may be retried */
1087 }
1088 req->free_data = 1;
1089 req->file_info = fi;
1090 req->req.type = RAW1394_REQ_ARM;
1091 req->req.generation = get_hpsb_generation(host);
1092 req->req.misc =
1093 (((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF));
1094 req->req.tag = arm_addr->arm_tag;
1095 req->req.recvb = arm_addr->recvb;
1096 req->req.length = size;
1097 arm_req_resp = (struct arm_request_response *)(req->data);
1098 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1099 (sizeof
1100 (struct
1101 arm_request_response)));
1102 arm_resp =
1103 (struct arm_response *)((byte_t *) (arm_req) +
1104 (sizeof(struct arm_request)));
1105 arm_resp->buffer = NULL;
1106 memcpy((byte_t *) arm_resp + sizeof(struct arm_response),
1107 data, length);
1108 arm_req->buffer = int2ptr((arm_addr->recvb) +
1109 sizeof(struct arm_request_response) +
1110 sizeof(struct arm_request) +
1111 sizeof(struct arm_response));
1112 arm_req->buffer_length = length;
1113 arm_req->generation = req->req.generation;
1114 arm_req->extended_transaction_code = 0;
1115 arm_req->destination_offset = addr;
1116 arm_req->source_nodeid = nodeid;
1117 arm_req->destination_nodeid = destid;
1118 arm_req->tlabel = (flags >> 10) & 0x3f;
1119 arm_req->tcode = (flags >> 4) & 0x0f;
1120 arm_resp->buffer_length = 0;
1121 arm_resp->response_code = rcode;
1122 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1123 sizeof(struct
1124 arm_request_response));
1125 arm_req_resp->response =
1126 int2ptr((arm_addr->recvb) +
1127 sizeof(struct arm_request_response) +
1128 sizeof(struct arm_request));
1129 queue_complete_req(req);
1130 }
1131 spin_unlock_irqrestore(&host_info_lock, irqflags);
1132 return (rcode);
1133 }
1134
1135 static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
1136 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
1137 u16 flags)
1138 {
1139 unsigned long irqflags;
1140 struct pending_request *req;
1141 struct host_info *hi;
1142 struct file_info *fi = NULL;
1143 struct list_head *entry;
1144 struct arm_addr *arm_addr = NULL;
1145 struct arm_request *arm_req = NULL;
1146 struct arm_response *arm_resp = NULL;
1147 int found = 0, size = 0, rcode = -1;
1148 quadlet_t old, new;
1149 struct arm_request_response *arm_req_resp = NULL;
1150
1151 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1152 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1153 DBGMSG("arm_lock called by node: %X "
1154 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
1155 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1156 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1157 be32_to_cpu(data));
1158 } else {
1159 DBGMSG("arm_lock called by node: %X "
1160 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
1161 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1162 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1163 be32_to_cpu(data), be32_to_cpu(arg));
1164 }
1165 spin_lock_irqsave(&host_info_lock, irqflags);
1166 hi = find_host_info(host); /* search address-entry */
1167 if (hi != NULL) {
1168 list_for_each_entry(fi, &hi->file_info_list, list) {
1169 entry = fi->addr_list.next;
1170 while (entry != &(fi->addr_list)) {
1171 arm_addr =
1172 list_entry(entry, struct arm_addr,
1173 addr_list);
1174 if (((arm_addr->start) <= (addr))
1175 && ((arm_addr->end) >=
1176 (addr + sizeof(*store)))) {
1177 found = 1;
1178 break;
1179 }
1180 entry = entry->next;
1181 }
1182 if (found) {
1183 break;
1184 }
1185 }
1186 }
1187 rcode = -1;
1188 if (!found) {
1189 printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found"
1190 " -> rcode_address_error\n");
1191 spin_unlock_irqrestore(&host_info_lock, irqflags);
1192 return (RCODE_ADDRESS_ERROR);
1193 } else {
1194 DBGMSG("arm_lock addr_entry FOUND");
1195 }
1196 if (rcode == -1) {
1197 if (arm_addr->access_rights & ARM_LOCK) {
1198 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1199 memcpy(&old,
1200 (arm_addr->addr_space_buffer) + (addr -
1201 (arm_addr->
1202 start)),
1203 sizeof(old));
1204 switch (ext_tcode) {
1205 case (EXTCODE_MASK_SWAP):
1206 new = data | (old & ~arg);
1207 break;
1208 case (EXTCODE_COMPARE_SWAP):
1209 if (old == arg) {
1210 new = data;
1211 } else {
1212 new = old;
1213 }
1214 break;
1215 case (EXTCODE_FETCH_ADD):
1216 new =
1217 cpu_to_be32(be32_to_cpu(data) +
1218 be32_to_cpu(old));
1219 break;
1220 case (EXTCODE_LITTLE_ADD):
1221 new =
1222 cpu_to_le32(le32_to_cpu(data) +
1223 le32_to_cpu(old));
1224 break;
1225 case (EXTCODE_BOUNDED_ADD):
1226 if (old != arg) {
1227 new =
1228 cpu_to_be32(be32_to_cpu
1229 (data) +
1230 be32_to_cpu
1231 (old));
1232 } else {
1233 new = old;
1234 }
1235 break;
1236 case (EXTCODE_WRAP_ADD):
1237 if (old != arg) {
1238 new =
1239 cpu_to_be32(be32_to_cpu
1240 (data) +
1241 be32_to_cpu
1242 (old));
1243 } else {
1244 new = data;
1245 }
1246 break;
1247 default:
1248 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1249 printk(KERN_ERR
1250 "raw1394: arm_lock FAILED "
1251 "ext_tcode not allowed -> rcode_type_error\n");
1252 break;
1253 } /*switch */
1254 if (rcode == -1) {
1255 DBGMSG("arm_lock -> (rcode_complete)");
1256 rcode = RCODE_COMPLETE;
1257 memcpy(store, &old, sizeof(*store));
1258 memcpy((arm_addr->addr_space_buffer) +
1259 (addr - (arm_addr->start)),
1260 &new, sizeof(*store));
1261 }
1262 }
1263 } else {
1264 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1265 DBGMSG("arm_lock -> rcode_type_error (access denied)");
1266 }
1267 }
1268 if (arm_addr->notification_options & ARM_LOCK) {
1269 byte_t *buf1, *buf2;
1270 DBGMSG("arm_lock -> entering notification-section");
1271 req = __alloc_pending_request(GFP_ATOMIC);
1272 if (!req) {
1273 DBGMSG("arm_lock -> rcode_conflict_error");
1274 spin_unlock_irqrestore(&host_info_lock, irqflags);
1275 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1276 The request may be retried */
1277 }
1278 size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */
1279 req->data = kmalloc(size, GFP_ATOMIC);
1280 if (!(req->data)) {
1281 free_pending_request(req);
1282 DBGMSG("arm_lock -> rcode_conflict_error");
1283 spin_unlock_irqrestore(&host_info_lock, irqflags);
1284 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1285 The request may be retried */
1286 }
1287 req->free_data = 1;
1288 arm_req_resp = (struct arm_request_response *)(req->data);
1289 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1290 (sizeof
1291 (struct
1292 arm_request_response)));
1293 arm_resp =
1294 (struct arm_response *)((byte_t *) (arm_req) +
1295 (sizeof(struct arm_request)));
1296 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1297 buf2 = buf1 + 2 * sizeof(*store);
1298 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1299 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1300 arm_req->buffer_length = sizeof(*store);
1301 memcpy(buf1, &data, sizeof(*store));
1302
1303 } else {
1304 arm_req->buffer_length = 2 * sizeof(*store);
1305 memcpy(buf1, &arg, sizeof(*store));
1306 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1307 }
1308 if (rcode == RCODE_COMPLETE) {
1309 arm_resp->buffer_length = sizeof(*store);
1310 memcpy(buf2, &old, sizeof(*store));
1311 } else {
1312 arm_resp->buffer_length = 0;
1313 }
1314 req->file_info = fi;
1315 req->req.type = RAW1394_REQ_ARM;
1316 req->req.generation = get_hpsb_generation(host);
1317 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1318 (ARM_LOCK & 0xFF));
1319 req->req.tag = arm_addr->arm_tag;
1320 req->req.recvb = arm_addr->recvb;
1321 req->req.length = size;
1322 arm_req->generation = req->req.generation;
1323 arm_req->extended_transaction_code = ext_tcode;
1324 arm_req->destination_offset = addr;
1325 arm_req->source_nodeid = nodeid;
1326 arm_req->destination_nodeid = host->node_id;
1327 arm_req->tlabel = (flags >> 10) & 0x3f;
1328 arm_req->tcode = (flags >> 4) & 0x0f;
1329 arm_resp->response_code = rcode;
1330 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1331 sizeof(struct
1332 arm_request_response));
1333 arm_req_resp->response =
1334 int2ptr((arm_addr->recvb) +
1335 sizeof(struct arm_request_response) +
1336 sizeof(struct arm_request));
1337 arm_req->buffer =
1338 int2ptr((arm_addr->recvb) +
1339 sizeof(struct arm_request_response) +
1340 sizeof(struct arm_request) +
1341 sizeof(struct arm_response));
1342 arm_resp->buffer =
1343 int2ptr((arm_addr->recvb) +
1344 sizeof(struct arm_request_response) +
1345 sizeof(struct arm_request) +
1346 sizeof(struct arm_response) + 2 * sizeof(*store));
1347 queue_complete_req(req);
1348 }
1349 spin_unlock_irqrestore(&host_info_lock, irqflags);
1350 return (rcode);
1351 }
1352
1353 static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
1354 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
1355 u16 flags)
1356 {
1357 unsigned long irqflags;
1358 struct pending_request *req;
1359 struct host_info *hi;
1360 struct file_info *fi = NULL;
1361 struct list_head *entry;
1362 struct arm_addr *arm_addr = NULL;
1363 struct arm_request *arm_req = NULL;
1364 struct arm_response *arm_resp = NULL;
1365 int found = 0, size = 0, rcode = -1;
1366 octlet_t old, new;
1367 struct arm_request_response *arm_req_resp = NULL;
1368
1369 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1370 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1371 DBGMSG("arm_lock64 called by node: %X "
1372 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
1373 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1374 (u32) (addr & 0xFFFFFFFF),
1375 ext_tcode & 0xFF,
1376 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1377 (u32) (be64_to_cpu(data) & 0xFFFFFFFF));
1378 } else {
1379 DBGMSG("arm_lock64 called by node: %X "
1380 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
1381 "%8.8X %8.8X ",
1382 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1383 (u32) (addr & 0xFFFFFFFF),
1384 ext_tcode & 0xFF,
1385 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1386 (u32) (be64_to_cpu(data) & 0xFFFFFFFF),
1387 (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF),
1388 (u32) (be64_to_cpu(arg) & 0xFFFFFFFF));
1389 }
1390 spin_lock_irqsave(&host_info_lock, irqflags);
1391 hi = find_host_info(host); /* search addressentry in file_info's for host */
1392 if (hi != NULL) {
1393 list_for_each_entry(fi, &hi->file_info_list, list) {
1394 entry = fi->addr_list.next;
1395 while (entry != &(fi->addr_list)) {
1396 arm_addr =
1397 list_entry(entry, struct arm_addr,
1398 addr_list);
1399 if (((arm_addr->start) <= (addr))
1400 && ((arm_addr->end) >=
1401 (addr + sizeof(*store)))) {
1402 found = 1;
1403 break;
1404 }
1405 entry = entry->next;
1406 }
1407 if (found) {
1408 break;
1409 }
1410 }
1411 }
1412 rcode = -1;
1413 if (!found) {
1414 printk(KERN_ERR
1415 "raw1394: arm_lock64 FAILED addr_entry not found"
1416 " -> rcode_address_error\n");
1417 spin_unlock_irqrestore(&host_info_lock, irqflags);
1418 return (RCODE_ADDRESS_ERROR);
1419 } else {
1420 DBGMSG("arm_lock64 addr_entry FOUND");
1421 }
1422 if (rcode == -1) {
1423 if (arm_addr->access_rights & ARM_LOCK) {
1424 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1425 memcpy(&old,
1426 (arm_addr->addr_space_buffer) + (addr -
1427 (arm_addr->
1428 start)),
1429 sizeof(old));
1430 switch (ext_tcode) {
1431 case (EXTCODE_MASK_SWAP):
1432 new = data | (old & ~arg);
1433 break;
1434 case (EXTCODE_COMPARE_SWAP):
1435 if (old == arg) {
1436 new = data;
1437 } else {
1438 new = old;
1439 }
1440 break;
1441 case (EXTCODE_FETCH_ADD):
1442 new =
1443 cpu_to_be64(be64_to_cpu(data) +
1444 be64_to_cpu(old));
1445 break;
1446 case (EXTCODE_LITTLE_ADD):
1447 new =
1448 cpu_to_le64(le64_to_cpu(data) +
1449 le64_to_cpu(old));
1450 break;
1451 case (EXTCODE_BOUNDED_ADD):
1452 if (old != arg) {
1453 new =
1454 cpu_to_be64(be64_to_cpu
1455 (data) +
1456 be64_to_cpu
1457 (old));
1458 } else {
1459 new = old;
1460 }
1461 break;
1462 case (EXTCODE_WRAP_ADD):
1463 if (old != arg) {
1464 new =
1465 cpu_to_be64(be64_to_cpu
1466 (data) +
1467 be64_to_cpu
1468 (old));
1469 } else {
1470 new = data;
1471 }
1472 break;
1473 default:
1474 printk(KERN_ERR
1475 "raw1394: arm_lock64 FAILED "
1476 "ext_tcode not allowed -> rcode_type_error\n");
1477 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1478 break;
1479 } /*switch */
1480 if (rcode == -1) {
1481 DBGMSG
1482 ("arm_lock64 -> (rcode_complete)");
1483 rcode = RCODE_COMPLETE;
1484 memcpy(store, &old, sizeof(*store));
1485 memcpy((arm_addr->addr_space_buffer) +
1486 (addr - (arm_addr->start)),
1487 &new, sizeof(*store));
1488 }
1489 }
1490 } else {
1491 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1492 DBGMSG
1493 ("arm_lock64 -> rcode_type_error (access denied)");
1494 }
1495 }
1496 if (arm_addr->notification_options & ARM_LOCK) {
1497 byte_t *buf1, *buf2;
1498 DBGMSG("arm_lock64 -> entering notification-section");
1499 req = __alloc_pending_request(GFP_ATOMIC);
1500 if (!req) {
1501 spin_unlock_irqrestore(&host_info_lock, irqflags);
1502 DBGMSG("arm_lock64 -> rcode_conflict_error");
1503 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1504 The request may be retried */
1505 }
1506 size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */
1507 req->data = kmalloc(size, GFP_ATOMIC);
1508 if (!(req->data)) {
1509 free_pending_request(req);
1510 spin_unlock_irqrestore(&host_info_lock, irqflags);
1511 DBGMSG("arm_lock64 -> rcode_conflict_error");
1512 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1513 The request may be retried */
1514 }
1515 req->free_data = 1;
1516 arm_req_resp = (struct arm_request_response *)(req->data);
1517 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1518 (sizeof
1519 (struct
1520 arm_request_response)));
1521 arm_resp =
1522 (struct arm_response *)((byte_t *) (arm_req) +
1523 (sizeof(struct arm_request)));
1524 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1525 buf2 = buf1 + 2 * sizeof(*store);
1526 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1527 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1528 arm_req->buffer_length = sizeof(*store);
1529 memcpy(buf1, &data, sizeof(*store));
1530
1531 } else {
1532 arm_req->buffer_length = 2 * sizeof(*store);
1533 memcpy(buf1, &arg, sizeof(*store));
1534 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1535 }
1536 if (rcode == RCODE_COMPLETE) {
1537 arm_resp->buffer_length = sizeof(*store);
1538 memcpy(buf2, &old, sizeof(*store));
1539 } else {
1540 arm_resp->buffer_length = 0;
1541 }
1542 req->file_info = fi;
1543 req->req.type = RAW1394_REQ_ARM;
1544 req->req.generation = get_hpsb_generation(host);
1545 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1546 (ARM_LOCK & 0xFF));
1547 req->req.tag = arm_addr->arm_tag;
1548 req->req.recvb = arm_addr->recvb;
1549 req->req.length = size;
1550 arm_req->generation = req->req.generation;
1551 arm_req->extended_transaction_code = ext_tcode;
1552 arm_req->destination_offset = addr;
1553 arm_req->source_nodeid = nodeid;
1554 arm_req->destination_nodeid = host->node_id;
1555 arm_req->tlabel = (flags >> 10) & 0x3f;
1556 arm_req->tcode = (flags >> 4) & 0x0f;
1557 arm_resp->response_code = rcode;
1558 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1559 sizeof(struct
1560 arm_request_response));
1561 arm_req_resp->response =
1562 int2ptr((arm_addr->recvb) +
1563 sizeof(struct arm_request_response) +
1564 sizeof(struct arm_request));
1565 arm_req->buffer =
1566 int2ptr((arm_addr->recvb) +
1567 sizeof(struct arm_request_response) +
1568 sizeof(struct arm_request) +
1569 sizeof(struct arm_response));
1570 arm_resp->buffer =
1571 int2ptr((arm_addr->recvb) +
1572 sizeof(struct arm_request_response) +
1573 sizeof(struct arm_request) +
1574 sizeof(struct arm_response) + 2 * sizeof(*store));
1575 queue_complete_req(req);
1576 }
1577 spin_unlock_irqrestore(&host_info_lock, irqflags);
1578 return (rcode);
1579 }
1580
1581 static int arm_register(struct file_info *fi, struct pending_request *req)
1582 {
1583 int retval;
1584 struct arm_addr *addr;
1585 struct host_info *hi;
1586 struct file_info *fi_hlp = NULL;
1587 struct list_head *entry;
1588 struct arm_addr *arm_addr = NULL;
1589 int same_host, another_host;
1590 unsigned long flags;
1591
1592 DBGMSG("arm_register called "
1593 "addr(Offset): %8.8x %8.8x length: %u "
1594 "rights: %2.2X notify: %2.2X "
1595 "max_blk_len: %4.4X",
1596 (u32) ((req->req.address >> 32) & 0xFFFF),
1597 (u32) (req->req.address & 0xFFFFFFFF),
1598 req->req.length, ((req->req.misc >> 8) & 0xFF),
1599 (req->req.misc & 0xFF), ((req->req.misc >> 16) & 0xFFFF));
1600 /* check addressrange */
1601 if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) ||
1602 (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) !=
1603 0)) {
1604 req->req.length = 0;
1605 return (-EINVAL);
1606 }
1607 /* addr-list-entry for fileinfo */
1608 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
1609 if (!addr) {
1610 req->req.length = 0;
1611 return (-ENOMEM);
1612 }
1613 /* allocation of addr_space_buffer */
1614 addr->addr_space_buffer = vmalloc(req->req.length);
1615 if (!(addr->addr_space_buffer)) {
1616 kfree(addr);
1617 req->req.length = 0;
1618 return (-ENOMEM);
1619 }
1620 /* initialization of addr_space_buffer */
1621 if ((req->req.sendb) == (unsigned long)NULL) {
1622 /* init: set 0 */
1623 memset(addr->addr_space_buffer, 0, req->req.length);
1624 } else {
1625 /* init: user -> kernel */
1626 if (copy_from_user
1627 (addr->addr_space_buffer, int2ptr(req->req.sendb),
1628 req->req.length)) {
1629 vfree(addr->addr_space_buffer);
1630 kfree(addr);
1631 return (-EFAULT);
1632 }
1633 }
1634 INIT_LIST_HEAD(&addr->addr_list);
1635 addr->arm_tag = req->req.tag;
1636 addr->start = req->req.address;
1637 addr->end = req->req.address + req->req.length;
1638 addr->access_rights = (u8) (req->req.misc & 0x0F);
1639 addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F);
1640 addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F);
1641 addr->access_rights |= addr->client_transactions;
1642 addr->notification_options |= addr->client_transactions;
1643 addr->recvb = req->req.recvb;
1644 addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF);
1645
1646 spin_lock_irqsave(&host_info_lock, flags);
1647 hi = find_host_info(fi->host);
1648 same_host = 0;
1649 another_host = 0;
1650 /* same host with address-entry containing same addressrange ? */
1651 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1652 entry = fi_hlp->addr_list.next;
1653 while (entry != &(fi_hlp->addr_list)) {
1654 arm_addr =
1655 list_entry(entry, struct arm_addr, addr_list);
1656 if ((arm_addr->start == addr->start)
1657 && (arm_addr->end == addr->end)) {
1658 DBGMSG("same host ownes same "
1659 "addressrange -> EALREADY");
1660 same_host = 1;
1661 break;
1662 }
1663 entry = entry->next;
1664 }
1665 if (same_host) {
1666 break;
1667 }
1668 }
1669 if (same_host) {
1670 /* addressrange occupied by same host */
1671 spin_unlock_irqrestore(&host_info_lock, flags);
1672 vfree(addr->addr_space_buffer);
1673 kfree(addr);
1674 return (-EALREADY);
1675 }
1676 /* another host with valid address-entry containing same addressrange */
1677 list_for_each_entry(hi, &host_info_list, list) {
1678 if (hi->host != fi->host) {
1679 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1680 entry = fi_hlp->addr_list.next;
1681 while (entry != &(fi_hlp->addr_list)) {
1682 arm_addr =
1683 list_entry(entry, struct arm_addr,
1684 addr_list);
1685 if ((arm_addr->start == addr->start)
1686 && (arm_addr->end == addr->end)) {
1687 DBGMSG
1688 ("another host ownes same "
1689 "addressrange");
1690 another_host = 1;
1691 break;
1692 }
1693 entry = entry->next;
1694 }
1695 if (another_host) {
1696 break;
1697 }
1698 }
1699 }
1700 }
1701 spin_unlock_irqrestore(&host_info_lock, flags);
1702
1703 if (another_host) {
1704 DBGMSG("another hosts entry is valid -> SUCCESS");
1705 if (copy_to_user(int2ptr(req->req.recvb),
1706 &addr->start, sizeof(u64))) {
1707 printk(KERN_ERR "raw1394: arm_register failed "
1708 " address-range-entry is invalid -> EFAULT !!!\n");
1709 vfree(addr->addr_space_buffer);
1710 kfree(addr);
1711 return (-EFAULT);
1712 }
1713 free_pending_request(req); /* immediate success or fail */
1714 /* INSERT ENTRY */
1715 spin_lock_irqsave(&host_info_lock, flags);
1716 list_add_tail(&addr->addr_list, &fi->addr_list);
1717 spin_unlock_irqrestore(&host_info_lock, flags);
1718 return 0;
1719 }
1720 retval =
1721 hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops,
1722 req->req.address,
1723 req->req.address + req->req.length);
1724 if (retval) {
1725 /* INSERT ENTRY */
1726 spin_lock_irqsave(&host_info_lock, flags);
1727 list_add_tail(&addr->addr_list, &fi->addr_list);
1728 spin_unlock_irqrestore(&host_info_lock, flags);
1729 } else {
1730 DBGMSG("arm_register failed errno: %d \n", retval);
1731 vfree(addr->addr_space_buffer);
1732 kfree(addr);
1733 return (-EALREADY);
1734 }
1735 free_pending_request(req); /* immediate success or fail */
1736 return 0;
1737 }
1738
1739 static int arm_unregister(struct file_info *fi, struct pending_request *req)
1740 {
1741 int found = 0;
1742 int retval = 0;
1743 struct list_head *entry;
1744 struct arm_addr *addr = NULL;
1745 struct host_info *hi;
1746 struct file_info *fi_hlp = NULL;
1747 struct arm_addr *arm_addr = NULL;
1748 int another_host;
1749 unsigned long flags;
1750
1751 DBGMSG("arm_Unregister called addr(Offset): "
1752 "%8.8x %8.8x",
1753 (u32) ((req->req.address >> 32) & 0xFFFF),
1754 (u32) (req->req.address & 0xFFFFFFFF));
1755 spin_lock_irqsave(&host_info_lock, flags);
1756 /* get addr */
1757 entry = fi->addr_list.next;
1758 while (entry != &(fi->addr_list)) {
1759 addr = list_entry(entry, struct arm_addr, addr_list);
1760 if (addr->start == req->req.address) {
1761 found = 1;
1762 break;
1763 }
1764 entry = entry->next;
1765 }
1766 if (!found) {
1767 DBGMSG("arm_Unregister addr not found");
1768 spin_unlock_irqrestore(&host_info_lock, flags);
1769 return (-EINVAL);
1770 }
1771 DBGMSG("arm_Unregister addr found");
1772 another_host = 0;
1773 /* another host with valid address-entry containing
1774 same addressrange */
1775 list_for_each_entry(hi, &host_info_list, list) {
1776 if (hi->host != fi->host) {
1777 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1778 entry = fi_hlp->addr_list.next;
1779 while (entry != &(fi_hlp->addr_list)) {
1780 arm_addr = list_entry(entry,
1781 struct arm_addr,
1782 addr_list);
1783 if (arm_addr->start == addr->start) {
1784 DBGMSG("another host ownes "
1785 "same addressrange");
1786 another_host = 1;
1787 break;
1788 }
1789 entry = entry->next;
1790 }
1791 if (another_host) {
1792 break;
1793 }
1794 }
1795 }
1796 }
1797 if (another_host) {
1798 DBGMSG("delete entry from list -> success");
1799 list_del(&addr->addr_list);
1800 spin_unlock_irqrestore(&host_info_lock, flags);
1801 vfree(addr->addr_space_buffer);
1802 kfree(addr);
1803 free_pending_request(req); /* immediate success or fail */
1804 return 0;
1805 }
1806 retval =
1807 hpsb_unregister_addrspace(&raw1394_highlevel, fi->host,
1808 addr->start);
1809 if (!retval) {
1810 printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n");
1811 spin_unlock_irqrestore(&host_info_lock, flags);
1812 return (-EINVAL);
1813 }
1814 DBGMSG("delete entry from list -> success");
1815 list_del(&addr->addr_list);
1816 spin_unlock_irqrestore(&host_info_lock, flags);
1817 vfree(addr->addr_space_buffer);
1818 kfree(addr);
1819 free_pending_request(req); /* immediate success or fail */
1820 return 0;
1821 }
1822
1823 /* Copy data from ARM buffer(s) to user buffer. */
1824 static int arm_get_buf(struct file_info *fi, struct pending_request *req)
1825 {
1826 struct arm_addr *arm_addr = NULL;
1827 unsigned long flags;
1828 unsigned long offset;
1829
1830 struct list_head *entry;
1831
1832 DBGMSG("arm_get_buf "
1833 "addr(Offset): %04X %08X length: %u",
1834 (u32) ((req->req.address >> 32) & 0xFFFF),
1835 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1836
1837 spin_lock_irqsave(&host_info_lock, flags);
1838 entry = fi->addr_list.next;
1839 while (entry != &(fi->addr_list)) {
1840 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1841 if ((arm_addr->start <= req->req.address) &&
1842 (arm_addr->end > req->req.address)) {
1843 if (req->req.address + req->req.length <= arm_addr->end) {
1844 offset = req->req.address - arm_addr->start;
1845 spin_unlock_irqrestore(&host_info_lock, flags);
1846
1847 DBGMSG
1848 ("arm_get_buf copy_to_user( %08X, %p, %u )",
1849 (u32) req->req.recvb,
1850 arm_addr->addr_space_buffer + offset,
1851 (u32) req->req.length);
1852 if (copy_to_user
1853 (int2ptr(req->req.recvb),
1854 arm_addr->addr_space_buffer + offset,
1855 req->req.length))
1856 return (-EFAULT);
1857
1858 /* We have to free the request, because we
1859 * queue no response, and therefore nobody
1860 * will free it. */
1861 free_pending_request(req);
1862 return 0;
1863 } else {
1864 DBGMSG("arm_get_buf request exceeded mapping");
1865 spin_unlock_irqrestore(&host_info_lock, flags);
1866 return (-EINVAL);
1867 }
1868 }
1869 entry = entry->next;
1870 }
1871 spin_unlock_irqrestore(&host_info_lock, flags);
1872 return (-EINVAL);
1873 }
1874
1875 /* Copy data from user buffer to ARM buffer(s). */
1876 static int arm_set_buf(struct file_info *fi, struct pending_request *req)
1877 {
1878 struct arm_addr *arm_addr = NULL;
1879 unsigned long flags;
1880 unsigned long offset;
1881
1882 struct list_head *entry;
1883
1884 DBGMSG("arm_set_buf "
1885 "addr(Offset): %04X %08X length: %u",
1886 (u32) ((req->req.address >> 32) & 0xFFFF),
1887 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1888
1889 spin_lock_irqsave(&host_info_lock, flags);
1890 entry = fi->addr_list.next;
1891 while (entry != &(fi->addr_list)) {
1892 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1893 if ((arm_addr->start <= req->req.address) &&
1894 (arm_addr->end > req->req.address)) {
1895 if (req->req.address + req->req.length <= arm_addr->end) {
1896 offset = req->req.address - arm_addr->start;
1897 spin_unlock_irqrestore(&host_info_lock, flags);
1898
1899 DBGMSG
1900 ("arm_set_buf copy_from_user( %p, %08X, %u )",
1901 arm_addr->addr_space_buffer + offset,
1902 (u32) req->req.sendb,
1903 (u32) req->req.length);
1904 if (copy_from_user
1905 (arm_addr->addr_space_buffer + offset,
1906 int2ptr(req->req.sendb),
1907 req->req.length))
1908 return (-EFAULT);
1909
1910 /* We have to free the request, because we
1911 * queue no response, and therefore nobody
1912 * will free it. */
1913 free_pending_request(req);
1914 return 0;
1915 } else {
1916 DBGMSG("arm_set_buf request exceeded mapping");
1917 spin_unlock_irqrestore(&host_info_lock, flags);
1918 return (-EINVAL);
1919 }
1920 }
1921 entry = entry->next;
1922 }
1923 spin_unlock_irqrestore(&host_info_lock, flags);
1924 return (-EINVAL);
1925 }
1926
1927 static int reset_notification(struct file_info *fi, struct pending_request *req)
1928 {
1929 DBGMSG("reset_notification called - switch %s ",
1930 (req->req.misc == RAW1394_NOTIFY_OFF) ? "OFF" : "ON");
1931 if ((req->req.misc == RAW1394_NOTIFY_OFF) ||
1932 (req->req.misc == RAW1394_NOTIFY_ON)) {
1933 fi->notification = (u8) req->req.misc;
1934 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1935 return 0;
1936 }
1937 /* error EINVAL (22) invalid argument */
1938 return (-EINVAL);
1939 }
1940
1941 static int write_phypacket(struct file_info *fi, struct pending_request *req)
1942 {
1943 struct hpsb_packet *packet = NULL;
1944 int retval = 0;
1945 quadlet_t data;
1946 unsigned long flags;
1947
1948 data = be32_to_cpu((u32) req->req.sendb);
1949 DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data);
1950 packet = hpsb_make_phypacket(fi->host, data);
1951 if (!packet)
1952 return -ENOMEM;
1953 req->req.length = 0;
1954 req->packet = packet;
1955 hpsb_set_packet_complete_task(packet,
1956 (void (*)(void *))queue_complete_cb, req);
1957 spin_lock_irqsave(&fi->reqlists_lock, flags);
1958 list_add_tail(&req->list, &fi->req_pending);
1959 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
1960 packet->generation = req->req.generation;
1961 retval = hpsb_send_packet(packet);
1962 DBGMSG("write_phypacket send_packet called => retval: %d ", retval);
1963 if (retval < 0) {
1964 req->req.error = RAW1394_ERROR_SEND_ERROR;
1965 req->req.length = 0;
1966 queue_complete_req(req);
1967 }
1968 return 0;
1969 }
1970
1971 static int get_config_rom(struct file_info *fi, struct pending_request *req)
1972 {
1973 int ret = 0;
1974 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
1975 int status;
1976
1977 if (!data)
1978 return -ENOMEM;
1979
1980 status =
1981 csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET,
1982 data, req->req.length);
1983 if (copy_to_user(int2ptr(req->req.recvb), data, req->req.length))
1984 ret = -EFAULT;
1985 if (copy_to_user
1986 (int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len,
1987 sizeof(fi->host->csr.rom->cache_head->len)))
1988 ret = -EFAULT;
1989 if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation,
1990 sizeof(fi->host->csr.generation)))
1991 ret = -EFAULT;
1992 if (copy_to_user(int2ptr(req->req.sendb), &status, sizeof(status)))
1993 ret = -EFAULT;
1994 kfree(data);
1995 if (ret >= 0) {
1996 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1997 }
1998 return ret;
1999 }
2000
2001 static int update_config_rom(struct file_info *fi, struct pending_request *req)
2002 {
2003 int ret = 0;
2004 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
2005 if (!data)
2006 return -ENOMEM;
2007 if (copy_from_user(data, int2ptr(req->req.sendb), req->req.length)) {
2008 ret = -EFAULT;
2009 } else {
2010 int status = hpsb_update_config_rom(fi->host,
2011 data, req->req.length,
2012 (unsigned char)req->req.
2013 misc);
2014 if (copy_to_user
2015 (int2ptr(req->req.recvb), &status, sizeof(status)))
2016 ret = -ENOMEM;
2017 }
2018 kfree(data);
2019 if (ret >= 0) {
2020 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2021 fi->cfgrom_upd = 1;
2022 }
2023 return ret;
2024 }
2025
2026 static int modify_config_rom(struct file_info *fi, struct pending_request *req)
2027 {
2028 struct csr1212_keyval *kv;
2029 struct csr1212_csr_rom_cache *cache;
2030 struct csr1212_dentry *dentry;
2031 u32 dr;
2032 int ret = 0;
2033
2034 if (req->req.misc == ~0) {
2035 if (req->req.length == 0)
2036 return -EINVAL;
2037
2038 /* Find an unused slot */
2039 for (dr = 0;
2040 dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr];
2041 dr++) ;
2042
2043 if (dr == RAW1394_MAX_USER_CSR_DIRS)
2044 return -ENOMEM;
2045
2046 fi->csr1212_dirs[dr] =
2047 csr1212_new_directory(CSR1212_KV_ID_VENDOR);
2048 if (!fi->csr1212_dirs[dr])
2049 return -ENOMEM;
2050 } else {
2051 dr = req->req.misc;
2052 if (!fi->csr1212_dirs[dr])
2053 return -EINVAL;
2054
2055 /* Delete old stuff */
2056 for (dentry =
2057 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2058 dentry; dentry = dentry->next) {
2059 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2060 root_kv,
2061 dentry->kv);
2062 }
2063
2064 if (req->req.length == 0) {
2065 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2066 fi->csr1212_dirs[dr] = NULL;
2067
2068 hpsb_update_config_rom_image(fi->host);
2069 free_pending_request(req);
2070 return 0;
2071 }
2072 }
2073
2074 cache = csr1212_rom_cache_malloc(0, req->req.length);
2075 if (!cache) {
2076 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2077 fi->csr1212_dirs[dr] = NULL;
2078 return -ENOMEM;
2079 }
2080
2081 cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL);
2082 if (!cache->filled_head) {
2083 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2084 fi->csr1212_dirs[dr] = NULL;
2085 CSR1212_FREE(cache);
2086 return -ENOMEM;
2087 }
2088 cache->filled_tail = cache->filled_head;
2089
2090 if (copy_from_user(cache->data, int2ptr(req->req.sendb),
2091 req->req.length)) {
2092 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2093 fi->csr1212_dirs[dr] = NULL;
2094 ret = -EFAULT;
2095 } else {
2096 cache->len = req->req.length;
2097 cache->filled_head->offset_start = 0;
2098 cache->filled_head->offset_end = cache->size - 1;
2099
2100 cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr];
2101
2102 ret = CSR1212_SUCCESS;
2103 /* parse all the items */
2104 for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv;
2105 kv = kv->next) {
2106 ret = csr1212_parse_keyval(kv, cache);
2107 }
2108
2109 /* attach top level items to the root directory */
2110 for (dentry =
2111 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2112 ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) {
2113 ret =
2114 csr1212_attach_keyval_to_directory(fi->host->csr.
2115 rom->root_kv,
2116 dentry->kv);
2117 }
2118
2119 if (ret == CSR1212_SUCCESS) {
2120 ret = hpsb_update_config_rom_image(fi->host);
2121
2122 if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb),
2123 &dr, sizeof(dr))) {
2124 ret = -ENOMEM;
2125 }
2126 }
2127 }
2128 kfree(cache->filled_head);
2129 CSR1212_FREE(cache);
2130
2131 if (ret >= 0) {
2132 /* we have to free the request, because we queue no response,
2133 * and therefore nobody will free it */
2134 free_pending_request(req);
2135 return 0;
2136 } else {
2137 for (dentry =
2138 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2139 dentry; dentry = dentry->next) {
2140 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2141 root_kv,
2142 dentry->kv);
2143 }
2144 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2145 fi->csr1212_dirs[dr] = NULL;
2146 return ret;
2147 }
2148 }
2149
2150 static int state_connected(struct file_info *fi, struct pending_request *req)
2151 {
2152 int node = req->req.address >> 48;
2153
2154 req->req.error = RAW1394_ERROR_NONE;
2155
2156 switch (req->req.type) {
2157
2158 case RAW1394_REQ_ECHO:
2159 queue_complete_req(req);
2160 return 0;
2161
2162 case RAW1394_REQ_ARM_REGISTER:
2163 return arm_register(fi, req);
2164
2165 case RAW1394_REQ_ARM_UNREGISTER:
2166 return arm_unregister(fi, req);
2167
2168 case RAW1394_REQ_ARM_SET_BUF:
2169 return arm_set_buf(fi, req);
2170
2171 case RAW1394_REQ_ARM_GET_BUF:
2172 return arm_get_buf(fi, req);
2173
2174 case RAW1394_REQ_RESET_NOTIFY:
2175 return reset_notification(fi, req);
2176
2177 case RAW1394_REQ_ISO_SEND:
2178 case RAW1394_REQ_ISO_LISTEN:
2179 printk(KERN_DEBUG "raw1394: old iso ABI has been removed\n");
2180 req->req.error = RAW1394_ERROR_COMPAT;
2181 req->req.misc = RAW1394_KERNELAPI_VERSION;
2182 queue_complete_req(req);
2183 return 0;
2184
2185 case RAW1394_REQ_FCP_LISTEN:
2186 handle_fcp_listen(fi, req);
2187 return 0;
2188
2189 case RAW1394_REQ_RESET_BUS:
2190 if (req->req.misc == RAW1394_LONG_RESET) {
2191 DBGMSG("busreset called (type: LONG)");
2192 hpsb_reset_bus(fi->host, LONG_RESET);
2193 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2194 return 0;
2195 }
2196 if (req->req.misc == RAW1394_SHORT_RESET) {
2197 DBGMSG("busreset called (type: SHORT)");
2198 hpsb_reset_bus(fi->host, SHORT_RESET);
2199 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2200 return 0;
2201 }
2202 /* error EINVAL (22) invalid argument */
2203 return (-EINVAL);
2204 case RAW1394_REQ_GET_ROM:
2205 return get_config_rom(fi, req);
2206
2207 case RAW1394_REQ_UPDATE_ROM:
2208 return update_config_rom(fi, req);
2209
2210 case RAW1394_REQ_MODIFY_ROM:
2211 return modify_config_rom(fi, req);
2212 }
2213
2214 if (req->req.generation != get_hpsb_generation(fi->host)) {
2215 req->req.error = RAW1394_ERROR_GENERATION;
2216 req->req.generation = get_hpsb_generation(fi->host);
2217 req->req.length = 0;
2218 queue_complete_req(req);
2219 return 0;
2220 }
2221
2222 switch (req->req.type) {
2223 case RAW1394_REQ_PHYPACKET:
2224 return write_phypacket(fi, req);
2225 case RAW1394_REQ_ASYNC_SEND:
2226 return handle_async_send(fi, req);
2227 }
2228
2229 if (req->req.length == 0) {
2230 req->req.error = RAW1394_ERROR_INVALID_ARG;
2231 queue_complete_req(req);
2232 return 0;
2233 }
2234
2235 return handle_async_request(fi, req, node);
2236 }
2237
2238 static ssize_t raw1394_write(struct file *file, const char __user * buffer,
2239 size_t count, loff_t * offset_is_ignored)
2240 {
2241 struct file_info *fi = file->private_data;
2242 struct pending_request *req;
2243 ssize_t retval = -EBADFD;
2244
2245 #ifdef CONFIG_COMPAT
2246 if (count == sizeof(struct compat_raw1394_req) &&
2247 sizeof(struct compat_raw1394_req) !=
2248 sizeof(struct raw1394_request)) {
2249 buffer = raw1394_compat_write(buffer);
2250 if (IS_ERR((__force void *)buffer))
2251 return PTR_ERR((__force void *)buffer);
2252 } else
2253 #endif
2254 if (count != sizeof(struct raw1394_request)) {
2255 return -EINVAL;
2256 }
2257
2258 req = alloc_pending_request();
2259 if (req == NULL) {
2260 return -ENOMEM;
2261 }
2262 req->file_info = fi;
2263
2264 if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
2265 free_pending_request(req);
2266 return -EFAULT;
2267 }
2268
2269 if (!mutex_trylock(&fi->state_mutex)) {
2270 free_pending_request(req);
2271 return -EAGAIN;
2272 }
2273
2274 switch (fi->state) {
2275 case opened:
2276 retval = state_opened(fi, req);
2277 break;
2278
2279 case initialized:
2280 retval = state_initialized(fi, req);
2281 break;
2282
2283 case connected:
2284 retval = state_connected(fi, req);
2285 break;
2286 }
2287
2288 mutex_unlock(&fi->state_mutex);
2289
2290 if (retval < 0) {
2291 free_pending_request(req);
2292 } else {
2293 BUG_ON(retval);
2294 retval = count;
2295 }
2296
2297 return retval;
2298 }
2299
2300 /* rawiso operations */
2301
2302 /* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
2303 * completion queue (reqlists_lock must be taken) */
2304 static inline int __rawiso_event_in_queue(struct file_info *fi)
2305 {
2306 struct pending_request *req;
2307
2308 list_for_each_entry(req, &fi->req_complete, list)
2309 if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY)
2310 return 1;
2311
2312 return 0;
2313 }
2314
2315 /* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
2316 static void queue_rawiso_event(struct file_info *fi)
2317 {
2318 unsigned long flags;
2319
2320 spin_lock_irqsave(&fi->reqlists_lock, flags);
2321
2322 /* only one ISO activity event may be in the queue */
2323 if (!__rawiso_event_in_queue(fi)) {
2324 struct pending_request *req =
2325 __alloc_pending_request(GFP_ATOMIC);
2326
2327 if (req) {
2328 req->file_info = fi;
2329 req->req.type = RAW1394_REQ_RAWISO_ACTIVITY;
2330 req->req.generation = get_hpsb_generation(fi->host);
2331 __queue_complete_req(req);
2332 } else {
2333 /* on allocation failure, signal an overflow */
2334 if (fi->iso_handle) {
2335 atomic_inc(&fi->iso_handle->overflows);
2336 }
2337 }
2338 }
2339 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2340 }
2341
2342 static void rawiso_activity_cb(struct hpsb_iso *iso)
2343 {
2344 unsigned long flags;
2345 struct host_info *hi;
2346 struct file_info *fi;
2347
2348 spin_lock_irqsave(&host_info_lock, flags);
2349 hi = find_host_info(iso->host);
2350
2351 if (hi != NULL) {
2352 list_for_each_entry(fi, &hi->file_info_list, list) {
2353 if (fi->iso_handle == iso)
2354 queue_rawiso_event(fi);
2355 }
2356 }
2357
2358 spin_unlock_irqrestore(&host_info_lock, flags);
2359 }
2360
2361 /* helper function - gather all the kernel iso status bits for returning to user-space */
2362 static void raw1394_iso_fill_status(struct hpsb_iso *iso,
2363 struct raw1394_iso_status *stat)
2364 {
2365 int overflows = atomic_read(&iso->overflows);
2366 int skips = atomic_read(&iso->skips);
2367
2368 stat->config.data_buf_size = iso->buf_size;
2369 stat->config.buf_packets = iso->buf_packets;
2370 stat->config.channel = iso->channel;
2371 stat->config.speed = iso->speed;
2372 stat->config.irq_interval = iso->irq_interval;
2373 stat->n_packets = hpsb_iso_n_ready(iso);
2374 stat->overflows = ((skips & 0xFFFF) << 16) | ((overflows & 0xFFFF));
2375 stat->xmit_cycle = iso->xmit_cycle;
2376 }
2377
2378 static int raw1394_iso_xmit_init(struct file_info *fi, void __user * uaddr)
2379 {
2380 struct raw1394_iso_status stat;
2381
2382 if (!fi->host)
2383 return -EINVAL;
2384
2385 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2386 return -EFAULT;
2387
2388 fi->iso_handle = hpsb_iso_xmit_init(fi->host,
2389 stat.config.data_buf_size,
2390 stat.config.buf_packets,
2391 stat.config.channel,
2392 stat.config.speed,
2393 stat.config.irq_interval,
2394 rawiso_activity_cb);
2395 if (!fi->iso_handle)
2396 return -ENOMEM;
2397
2398 fi->iso_state = RAW1394_ISO_XMIT;
2399
2400 raw1394_iso_fill_status(fi->iso_handle, &stat);
2401 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2402 return -EFAULT;
2403
2404 /* queue an event to get things started */
2405 rawiso_activity_cb(fi->iso_handle);
2406
2407 return 0;
2408 }
2409
2410 static int raw1394_iso_recv_init(struct file_info *fi, void __user * uaddr)
2411 {
2412 struct raw1394_iso_status stat;
2413
2414 if (!fi->host)
2415 return -EINVAL;
2416
2417 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2418 return -EFAULT;
2419
2420 fi->iso_handle = hpsb_iso_recv_init(fi->host,
2421 stat.config.data_buf_size,
2422 stat.config.buf_packets,
2423 stat.config.channel,
2424 stat.config.dma_mode,
2425 stat.config.irq_interval,
2426 rawiso_activity_cb);
2427 if (!fi->iso_handle)
2428 return -ENOMEM;
2429
2430 fi->iso_state = RAW1394_ISO_RECV;
2431
2432 raw1394_iso_fill_status(fi->iso_handle, &stat);
2433 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2434 return -EFAULT;
2435 return 0;
2436 }
2437
2438 static int raw1394_iso_get_status(struct file_info *fi, void __user * uaddr)
2439 {
2440 struct raw1394_iso_status stat;
2441 struct hpsb_iso *iso = fi->iso_handle;
2442
2443 raw1394_iso_fill_status(fi->iso_handle, &stat);
2444 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2445 return -EFAULT;
2446
2447 /* reset overflow counter */
2448 atomic_set(&iso->overflows, 0);
2449 /* reset skip counter */
2450 atomic_set(&iso->skips, 0);
2451
2452 return 0;
2453 }
2454
2455 /* copy N packet_infos out of the ringbuffer into user-supplied array */
2456 static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr)
2457 {
2458 struct raw1394_iso_packets upackets;
2459 unsigned int packet = fi->iso_handle->first_packet;
2460 int i;
2461
2462 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2463 return -EFAULT;
2464
2465 if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
2466 return -EINVAL;
2467
2468 /* ensure user-supplied buffer is accessible and big enough */
2469 if (!access_ok(VERIFY_WRITE, upackets.infos,
2470 upackets.n_packets *
2471 sizeof(struct raw1394_iso_packet_info)))
2472 return -EFAULT;
2473
2474 /* copy the packet_infos out */
2475 for (i = 0; i < upackets.n_packets; i++) {
2476 if (__copy_to_user(&upackets.infos[i],
2477 &fi->iso_handle->infos[packet],
2478 sizeof(struct raw1394_iso_packet_info)))
2479 return -EFAULT;
2480
2481 packet = (packet + 1) % fi->iso_handle->buf_packets;
2482 }
2483
2484 return 0;
2485 }
2486
2487 /* copy N packet_infos from user to ringbuffer, and queue them for transmission */
2488 static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr)
2489 {
2490 struct raw1394_iso_packets upackets;
2491 int i, rv;
2492
2493 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2494 return -EFAULT;
2495
2496 if (upackets.n_packets >= fi->iso_handle->buf_packets)
2497 return -EINVAL;
2498
2499 if (upackets.n_packets >= hpsb_iso_n_ready(fi->iso_handle))
2500 return -EAGAIN;
2501
2502 /* ensure user-supplied buffer is accessible and big enough */
2503 if (!access_ok(VERIFY_READ, upackets.infos,
2504 upackets.n_packets *
2505 sizeof(struct raw1394_iso_packet_info)))
2506 return -EFAULT;
2507
2508 /* copy the infos structs in and queue the packets */
2509 for (i = 0; i < upackets.n_packets; i++) {
2510 struct raw1394_iso_packet_info info;
2511
2512 if (__copy_from_user(&info, &upackets.infos[i],
2513 sizeof(struct raw1394_iso_packet_info)))
2514 return -EFAULT;
2515
2516 rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset,
2517 info.len, info.tag, info.sy);
2518 if (rv)
2519 return rv;
2520 }
2521
2522 return 0;
2523 }
2524
2525 static void raw1394_iso_shutdown(struct file_info *fi)
2526 {
2527 if (fi->iso_handle)
2528 hpsb_iso_shutdown(fi->iso_handle);
2529
2530 fi->iso_handle = NULL;
2531 fi->iso_state = RAW1394_ISO_INACTIVE;
2532 }
2533
2534 static int raw1394_read_cycle_timer(struct file_info *fi, void __user * uaddr)
2535 {
2536 struct raw1394_cycle_timer ct;
2537 int err;
2538
2539 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2540 if (!err)
2541 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2542 err = -EFAULT;
2543 return err;
2544 }
2545
2546 /* mmap the rawiso xmit/recv buffer */
2547 static int raw1394_mmap(struct file *file, struct vm_area_struct *vma)
2548 {
2549 struct file_info *fi = file->private_data;
2550 int ret;
2551
2552 if (!mutex_trylock(&fi->state_mutex))
2553 return -EAGAIN;
2554
2555 if (fi->iso_state == RAW1394_ISO_INACTIVE)
2556 ret = -EINVAL;
2557 else
2558 ret = dma_region_mmap(&fi->iso_handle->data_buf, file, vma);
2559
2560 mutex_unlock(&fi->state_mutex);
2561
2562 return ret;
2563 }
2564
2565 static long raw1394_ioctl_inactive(struct file_info *fi, unsigned int cmd,
2566 void __user *argp)
2567 {
2568 switch (cmd) {
2569 case RAW1394_IOC_ISO_XMIT_INIT:
2570 return raw1394_iso_xmit_init(fi, argp);
2571 case RAW1394_IOC_ISO_RECV_INIT:
2572 return raw1394_iso_recv_init(fi, argp);
2573 default:
2574 return -EINVAL;
2575 }
2576 }
2577
2578 static long raw1394_ioctl_recv(struct file_info *fi, unsigned int cmd,
2579 unsigned long arg)
2580 {
2581 void __user *argp = (void __user *)arg;
2582
2583 switch (cmd) {
2584 case RAW1394_IOC_ISO_RECV_START:{
2585 int args[3];
2586
2587 if (copy_from_user(&args[0], argp, sizeof(args)))
2588 return -EFAULT;
2589 return hpsb_iso_recv_start(fi->iso_handle,
2590 args[0], args[1], args[2]);
2591 }
2592 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2593 hpsb_iso_stop(fi->iso_handle);
2594 return 0;
2595 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2596 return hpsb_iso_recv_listen_channel(fi->iso_handle, arg);
2597 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2598 return hpsb_iso_recv_unlisten_channel(fi->iso_handle, arg);
2599 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:{
2600 u64 mask;
2601
2602 if (copy_from_user(&mask, argp, sizeof(mask)))
2603 return -EFAULT;
2604 return hpsb_iso_recv_set_channel_mask(fi->iso_handle,
2605 mask);
2606 }
2607 case RAW1394_IOC_ISO_GET_STATUS:
2608 return raw1394_iso_get_status(fi, argp);
2609 case RAW1394_IOC_ISO_RECV_PACKETS:
2610 return raw1394_iso_recv_packets(fi, argp);
2611 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2612 return hpsb_iso_recv_release_packets(fi->iso_handle, arg);
2613 case RAW1394_IOC_ISO_RECV_FLUSH:
2614 return hpsb_iso_recv_flush(fi->iso_handle);
2615 case RAW1394_IOC_ISO_SHUTDOWN:
2616 raw1394_iso_shutdown(fi);
2617 return 0;
2618 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2619 queue_rawiso_event(fi);
2620 return 0;
2621 default:
2622 return -EINVAL;
2623 }
2624 }
2625
2626 static long raw1394_ioctl_xmit(struct file_info *fi, unsigned int cmd,
2627 void __user *argp)
2628 {
2629 switch (cmd) {
2630 case RAW1394_IOC_ISO_XMIT_START:{
2631 int args[2];
2632
2633 if (copy_from_user(&args[0], argp, sizeof(args)))
2634 return -EFAULT;
2635 return hpsb_iso_xmit_start(fi->iso_handle,
2636 args[0], args[1]);
2637 }
2638 case RAW1394_IOC_ISO_XMIT_SYNC:
2639 return hpsb_iso_xmit_sync(fi->iso_handle);
2640 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2641 hpsb_iso_stop(fi->iso_handle);
2642 return 0;
2643 case RAW1394_IOC_ISO_GET_STATUS:
2644 return raw1394_iso_get_status(fi, argp);
2645 case RAW1394_IOC_ISO_XMIT_PACKETS:
2646 return raw1394_iso_send_packets(fi, argp);
2647 case RAW1394_IOC_ISO_SHUTDOWN:
2648 raw1394_iso_shutdown(fi);
2649 return 0;
2650 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2651 queue_rawiso_event(fi);
2652 return 0;
2653 default:
2654 return -EINVAL;
2655 }
2656 }
2657
2658 /* ioctl is only used for rawiso operations */
2659 static long raw1394_ioctl(struct file *file, unsigned int cmd,
2660 unsigned long arg)
2661 {
2662 struct file_info *fi = file->private_data;
2663 void __user *argp = (void __user *)arg;
2664 long ret;
2665
2666 /* state-independent commands */
2667 switch(cmd) {
2668 case RAW1394_IOC_GET_CYCLE_TIMER:
2669 return raw1394_read_cycle_timer(fi, argp);
2670 default:
2671 break;
2672 }
2673
2674 if (!mutex_trylock(&fi->state_mutex))
2675 return -EAGAIN;
2676
2677 switch (fi->iso_state) {
2678 case RAW1394_ISO_INACTIVE:
2679 ret = raw1394_ioctl_inactive(fi, cmd, argp);
2680 break;
2681 case RAW1394_ISO_RECV:
2682 ret = raw1394_ioctl_recv(fi, cmd, arg);
2683 break;
2684 case RAW1394_ISO_XMIT:
2685 ret = raw1394_ioctl_xmit(fi, cmd, argp);
2686 break;
2687 default:
2688 ret = -EINVAL;
2689 break;
2690 }
2691
2692 mutex_unlock(&fi->state_mutex);
2693
2694 return ret;
2695 }
2696
2697 #ifdef CONFIG_COMPAT
2698 struct raw1394_iso_packets32 {
2699 __u32 n_packets;
2700 compat_uptr_t infos;
2701 } __attribute__((packed));
2702
2703 struct raw1394_cycle_timer32 {
2704 __u32 cycle_timer;
2705 __u64 local_time;
2706 }
2707 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
2708 __attribute__((packed))
2709 #endif
2710 ;
2711
2712 #define RAW1394_IOC_ISO_RECV_PACKETS32 \
2713 _IOW ('#', 0x25, struct raw1394_iso_packets32)
2714 #define RAW1394_IOC_ISO_XMIT_PACKETS32 \
2715 _IOW ('#', 0x27, struct raw1394_iso_packets32)
2716 #define RAW1394_IOC_GET_CYCLE_TIMER32 \
2717 _IOR ('#', 0x30, struct raw1394_cycle_timer32)
2718
2719 static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd,
2720 struct raw1394_iso_packets32 __user *arg)
2721 {
2722 compat_uptr_t infos32;
2723 void __user *infos;
2724 long err = -EFAULT;
2725 struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets));
2726
2727 if (!copy_in_user(&dst->n_packets, &arg->n_packets, sizeof arg->n_packets) &&
2728 !copy_from_user(&infos32, &arg->infos, sizeof infos32)) {
2729 infos = compat_ptr(infos32);
2730 if (!copy_to_user(&dst->infos, &infos, sizeof infos))
2731 err = raw1394_ioctl(file, cmd, (unsigned long)dst);
2732 }
2733 return err;
2734 }
2735
2736 static long raw1394_read_cycle_timer32(struct file_info *fi, void __user * uaddr)
2737 {
2738 struct raw1394_cycle_timer32 ct;
2739 int err;
2740
2741 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2742 if (!err)
2743 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2744 err = -EFAULT;
2745 return err;
2746 }
2747
2748 static long raw1394_compat_ioctl(struct file *file,
2749 unsigned int cmd, unsigned long arg)
2750 {
2751 struct file_info *fi = file->private_data;
2752 void __user *argp = (void __user *)arg;
2753 long err;
2754
2755 switch (cmd) {
2756 /* These requests have same format as long as 'int' has same size. */
2757 case RAW1394_IOC_ISO_RECV_INIT:
2758 case RAW1394_IOC_ISO_RECV_START:
2759 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2760 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2761 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:
2762 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2763 case RAW1394_IOC_ISO_RECV_FLUSH:
2764 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2765 case RAW1394_IOC_ISO_XMIT_INIT:
2766 case RAW1394_IOC_ISO_XMIT_START:
2767 case RAW1394_IOC_ISO_XMIT_SYNC:
2768 case RAW1394_IOC_ISO_GET_STATUS:
2769 case RAW1394_IOC_ISO_SHUTDOWN:
2770 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2771 err = raw1394_ioctl(file, cmd, arg);
2772 break;
2773 /* These request have different format. */
2774 case RAW1394_IOC_ISO_RECV_PACKETS32:
2775 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_RECV_PACKETS, argp);
2776 break;
2777 case RAW1394_IOC_ISO_XMIT_PACKETS32:
2778 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_XMIT_PACKETS, argp);
2779 break;
2780 case RAW1394_IOC_GET_CYCLE_TIMER32:
2781 err = raw1394_read_cycle_timer32(fi, argp);
2782 break;
2783 default:
2784 err = -EINVAL;
2785 break;
2786 }
2787
2788 return err;
2789 }
2790 #endif
2791
2792 static unsigned int raw1394_poll(struct file *file, poll_table * pt)
2793 {
2794 struct file_info *fi = file->private_data;
2795 unsigned int mask = POLLOUT | POLLWRNORM;
2796 unsigned long flags;
2797
2798 poll_wait(file, &fi->wait_complete, pt);
2799
2800 spin_lock_irqsave(&fi->reqlists_lock, flags);
2801 if (!list_empty(&fi->req_complete)) {
2802 mask |= POLLIN | POLLRDNORM;
2803 }
2804 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2805
2806 return mask;
2807 }
2808
2809 static int raw1394_open(struct inode *inode, struct file *file)
2810 {
2811 struct file_info *fi;
2812
2813 fi = kzalloc(sizeof(*fi), GFP_KERNEL);
2814 if (!fi)
2815 return -ENOMEM;
2816
2817 fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */
2818
2819 INIT_LIST_HEAD(&fi->list);
2820 mutex_init(&fi->state_mutex);
2821 fi->state = opened;
2822 INIT_LIST_HEAD(&fi->req_pending);
2823 INIT_LIST_HEAD(&fi->req_complete);
2824 spin_lock_init(&fi->reqlists_lock);
2825 init_waitqueue_head(&fi->wait_complete);
2826 INIT_LIST_HEAD(&fi->addr_list);
2827
2828 file->private_data = fi;
2829
2830 return nonseekable_open(inode, file);
2831 }
2832
2833 static int raw1394_release(struct inode *inode, struct file *file)
2834 {
2835 struct file_info *fi = file->private_data;
2836 struct list_head *lh;
2837 struct pending_request *req;
2838 int i, fail;
2839 int retval = 0;
2840 struct list_head *entry;
2841 struct arm_addr *addr = NULL;
2842 struct host_info *hi;
2843 struct file_info *fi_hlp = NULL;
2844 struct arm_addr *arm_addr = NULL;
2845 int another_host;
2846 int csr_mod = 0;
2847 unsigned long flags;
2848
2849 if (fi->iso_state != RAW1394_ISO_INACTIVE)
2850 raw1394_iso_shutdown(fi);
2851
2852 spin_lock_irqsave(&host_info_lock, flags);
2853
2854 fail = 0;
2855 /* set address-entries invalid */
2856
2857 while (!list_empty(&fi->addr_list)) {
2858 another_host = 0;
2859 lh = fi->addr_list.next;
2860 addr = list_entry(lh, struct arm_addr, addr_list);
2861 /* another host with valid address-entry containing
2862 same addressrange? */
2863 list_for_each_entry(hi, &host_info_list, list) {
2864 if (hi->host != fi->host) {
2865 list_for_each_entry(fi_hlp, &hi->file_info_list,
2866 list) {
2867 entry = fi_hlp->addr_list.next;
2868 while (entry != &(fi_hlp->addr_list)) {
2869 arm_addr = list_entry(entry, struct
2870 arm_addr,
2871 addr_list);
2872 if (arm_addr->start ==
2873 addr->start) {
2874 DBGMSG
2875 ("raw1394_release: "
2876 "another host ownes "
2877 "same addressrange");
2878 another_host = 1;
2879 break;
2880 }
2881 entry = entry->next;
2882 }
2883 if (another_host) {
2884 break;
2885 }
2886 }
2887 }
2888 }
2889 if (!another_host) {
2890 DBGMSG("raw1394_release: call hpsb_arm_unregister");
2891 retval =
2892 hpsb_unregister_addrspace(&raw1394_highlevel,
2893 fi->host, addr->start);
2894 if (!retval) {
2895 ++fail;
2896 printk(KERN_ERR
2897 "raw1394_release arm_Unregister failed\n");
2898 }
2899 }
2900 DBGMSG("raw1394_release: delete addr_entry from list");
2901 list_del(&addr->addr_list);
2902 vfree(addr->addr_space_buffer);
2903 kfree(addr);
2904 } /* while */
2905 spin_unlock_irqrestore(&host_info_lock, flags);
2906 if (fail > 0) {
2907 printk(KERN_ERR "raw1394: during addr_list-release "
2908 "error(s) occurred \n");
2909 }
2910
2911 for (;;) {
2912 /* This locked section guarantees that neither
2913 * complete nor pending requests exist once i!=0 */
2914 spin_lock_irqsave(&fi->reqlists_lock, flags);
2915 while ((req = __next_complete_req(fi)))
2916 free_pending_request(req);
2917
2918 i = list_empty(&fi->req_pending);
2919 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2920
2921 if (i)
2922 break;
2923 /*
2924 * Sleep until more requests can be freed.
2925 *
2926 * NB: We call the macro wait_event() with a condition argument
2927 * with side effect. This is only possible because the side
2928 * effect does not occur until the condition became true, and
2929 * wait_event() won't evaluate the condition again after that.
2930 */
2931 wait_event(fi->wait_complete, (req = next_complete_req(fi)));
2932 free_pending_request(req);
2933 }
2934
2935 /* Remove any sub-trees left by user space programs */
2936 for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) {
2937 struct csr1212_dentry *dentry;
2938 if (!fi->csr1212_dirs[i])
2939 continue;
2940 for (dentry =
2941 fi->csr1212_dirs[i]->value.directory.dentries_head; dentry;
2942 dentry = dentry->next) {
2943 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2944 root_kv,
2945 dentry->kv);
2946 }
2947 csr1212_release_keyval(fi->csr1212_dirs[i]);
2948 fi->csr1212_dirs[i] = NULL;
2949 csr_mod = 1;
2950 }
2951
2952 if ((csr_mod || fi->cfgrom_upd)
2953 && hpsb_update_config_rom_image(fi->host) < 0)
2954 HPSB_ERR
2955 ("Failed to generate Configuration ROM image for host %d",
2956 fi->host->id);
2957
2958 if (fi->state == connected) {
2959 spin_lock_irqsave(&host_info_lock, flags);
2960 list_del(&fi->list);
2961 spin_unlock_irqrestore(&host_info_lock, flags);
2962
2963 put_device(&fi->host->device);
2964 }
2965
2966 spin_lock_irqsave(&host_info_lock, flags);
2967 if (fi->host)
2968 module_put(fi->host->driver->owner);
2969 spin_unlock_irqrestore(&host_info_lock, flags);
2970
2971 kfree(fi);
2972
2973 return 0;
2974 }
2975
2976 /*** HOTPLUG STUFF **********************************************************/
2977 /*
2978 * Export information about protocols/devices supported by this driver.
2979 */
2980 #ifdef MODULE
2981 static const struct ieee1394_device_id raw1394_id_table[] = {
2982 {
2983 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2984 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
2985 .version = AVC_SW_VERSION_ENTRY & 0xffffff},
2986 {
2987 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2988 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2989 .version = CAMERA_SW_VERSION_ENTRY & 0xffffff},
2990 {
2991 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2992 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2993 .version = (CAMERA_SW_VERSION_ENTRY + 1) & 0xffffff},
2994 {
2995 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2996 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2997 .version = (CAMERA_SW_VERSION_ENTRY + 2) & 0xffffff},
2998 {}
2999 };
3000
3001 MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table);
3002 #endif /* MODULE */
3003
3004 static struct hpsb_protocol_driver raw1394_driver = {
3005 .name = "raw1394",
3006 };
3007
3008 /******************************************************************************/
3009
3010 static struct hpsb_highlevel raw1394_highlevel = {
3011 .name = RAW1394_DEVICE_NAME,
3012 .add_host = add_host,
3013 .remove_host = remove_host,
3014 .host_reset = host_reset,
3015 .fcp_request = fcp_request,
3016 };
3017
3018 static struct cdev raw1394_cdev;
3019 static const struct file_operations raw1394_fops = {
3020 .owner = THIS_MODULE,
3021 .read = raw1394_read,
3022 .write = raw1394_write,
3023 .mmap = raw1394_mmap,
3024 .unlocked_ioctl = raw1394_ioctl,
3025 #ifdef CONFIG_COMPAT
3026 .compat_ioctl = raw1394_compat_ioctl,
3027 #endif
3028 .poll = raw1394_poll,
3029 .open = raw1394_open,
3030 .release = raw1394_release,
3031 .llseek = no_llseek,
3032 };
3033
3034 static int __init init_raw1394(void)
3035 {
3036 int ret = 0;
3037
3038 hpsb_register_highlevel(&raw1394_highlevel);
3039
3040 if (IS_ERR
3041 (device_create(hpsb_protocol_class, NULL,
3042 MKDEV(IEEE1394_MAJOR,
3043 IEEE1394_MINOR_BLOCK_RAW1394 * 16),
3044 NULL, RAW1394_DEVICE_NAME))) {
3045 ret = -EFAULT;
3046 goto out_unreg;
3047 }
3048
3049 cdev_init(&raw1394_cdev, &raw1394_fops);
3050 raw1394_cdev.owner = THIS_MODULE;
3051 ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1);
3052 if (ret) {
3053 HPSB_ERR("raw1394 failed to register minor device block");
3054 goto out_dev;
3055 }
3056
3057 HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME);
3058
3059 ret = hpsb_register_protocol(&raw1394_driver);
3060 if (ret) {
3061 HPSB_ERR("raw1394: failed to register protocol");
3062 cdev_del(&raw1394_cdev);
3063 goto out_dev;
3064 }
3065
3066 goto out;
3067
3068 out_dev:
3069 device_destroy(hpsb_protocol_class,
3070 MKDEV(IEEE1394_MAJOR,
3071 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
3072 out_unreg:
3073 hpsb_unregister_highlevel(&raw1394_highlevel);
3074 out:
3075 return ret;
3076 }
3077
3078 static void __exit cleanup_raw1394(void)
3079 {
3080 device_destroy(hpsb_protocol_class,
3081 MKDEV(IEEE1394_MAJOR,
3082 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
3083 cdev_del(&raw1394_cdev);
3084 hpsb_unregister_highlevel(&raw1394_highlevel);
3085 hpsb_unregister_protocol(&raw1394_driver);
3086 }
3087
3088 module_init(init_raw1394);
3089 module_exit(cleanup_raw1394);
3090 MODULE_LICENSE("GPL");
Tomato firmware and modifications.