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