blob: cadf0479cce54d7b0150aaa833114d2b9b8f2b7e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/interrupt.h>
39#include <linux/vmalloc.h>
40#include <linux/cdev.h>
41#include <asm/uaccess.h>
42#include <asm/atomic.h>
Andi Kleen4bc32c42006-03-25 16:30:07 +010043#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#include "csr1212.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "highlevel.h"
Stefan Richterde4394f2006-07-03 12:02:29 -040047#include "hosts.h"
48#include "ieee1394.h"
49#include "ieee1394_core.h"
50#include "ieee1394_hotplug.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include "ieee1394_transactions.h"
Stefan Richterde4394f2006-07-03 12:02:29 -040052#include "ieee1394_types.h"
53#include "iso.h"
54#include "nodemgr.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include "raw1394.h"
56#include "raw1394-private.h"
57
58#define int2ptr(x) ((void __user *)(unsigned long)x)
59#define ptr2int(x) ((u64)(unsigned long)(void __user *)x)
60
61#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
62#define RAW1394_DEBUG
63#endif
64
65#ifdef RAW1394_DEBUG
66#define DBGMSG(fmt, args...) \
67printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
68#else
Stefan Richter611aa192006-08-02 18:44:00 +020069#define DBGMSG(fmt, args...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#endif
71
72static LIST_HEAD(host_info_list);
73static int host_count;
74static DEFINE_SPINLOCK(host_info_lock);
75static atomic_t internal_generation = ATOMIC_INIT(0);
76
77static atomic_t iso_buffer_size;
78static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
79
80static struct hpsb_highlevel raw1394_highlevel;
81
82static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
83 u64 addr, size_t length, u16 flags);
84static int arm_write(struct hpsb_host *host, int nodeid, int destid,
85 quadlet_t * data, u64 addr, size_t length, u16 flags);
86static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
87 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
88 u16 flags);
89static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
90 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
91 u16 flags);
92static struct hpsb_address_ops arm_ops = {
93 .read = arm_read,
94 .write = arm_write,
95 .lock = arm_lock,
96 .lock64 = arm_lock64,
97};
98
99static void queue_complete_cb(struct pending_request *req);
100
Al Virodd0fc662005-10-07 07:46:04 +0100101static struct pending_request *__alloc_pending_request(gfp_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
103 struct pending_request *req;
104
Stefan Richter85511582005-11-07 06:31:45 -0500105 req = kzalloc(sizeof(*req), flags);
106 if (req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 INIT_LIST_HEAD(&req->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109 return req;
110}
111
112static inline struct pending_request *alloc_pending_request(void)
113{
Christoph Lametere94b1762006-12-06 20:33:17 -0800114 return __alloc_pending_request(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
116
117static void free_pending_request(struct pending_request *req)
118{
119 if (req->ibs) {
120 if (atomic_dec_and_test(&req->ibs->refcount)) {
121 atomic_sub(req->ibs->data_size, &iso_buffer_size);
122 kfree(req->ibs);
123 }
124 } else if (req->free_data) {
125 kfree(req->data);
126 }
127 hpsb_free_packet(req->packet);
128 kfree(req);
129}
130
131/* fi->reqlists_lock must be taken */
132static void __queue_complete_req(struct pending_request *req)
133{
134 struct file_info *fi = req->file_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Stefan Richter45289bf2006-07-03 12:02:33 -0400136 list_move_tail(&req->list, &fi->req_complete);
137 wake_up(&fi->wait_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138}
139
140static void queue_complete_req(struct pending_request *req)
141{
142 unsigned long flags;
143 struct file_info *fi = req->file_info;
144
145 spin_lock_irqsave(&fi->reqlists_lock, flags);
146 __queue_complete_req(req);
147 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
148}
149
150static void queue_complete_cb(struct pending_request *req)
151{
152 struct hpsb_packet *packet = req->packet;
153 int rcode = (packet->header[1] >> 12) & 0xf;
154
155 switch (packet->ack_code) {
156 case ACKX_NONE:
157 case ACKX_SEND_ERROR:
158 req->req.error = RAW1394_ERROR_SEND_ERROR;
159 break;
160 case ACKX_ABORTED:
161 req->req.error = RAW1394_ERROR_ABORTED;
162 break;
163 case ACKX_TIMEOUT:
164 req->req.error = RAW1394_ERROR_TIMEOUT;
165 break;
166 default:
167 req->req.error = (packet->ack_code << 16) | rcode;
168 break;
169 }
170
171 if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
172 req->req.length = 0;
173 }
174
175 if ((req->req.type == RAW1394_REQ_ASYNC_READ) ||
176 (req->req.type == RAW1394_REQ_ASYNC_WRITE) ||
177 (req->req.type == RAW1394_REQ_ASYNC_STREAM) ||
178 (req->req.type == RAW1394_REQ_LOCK) ||
179 (req->req.type == RAW1394_REQ_LOCK64))
180 hpsb_free_tlabel(packet);
181
182 queue_complete_req(req);
183}
184
185static void add_host(struct hpsb_host *host)
186{
187 struct host_info *hi;
188 unsigned long flags;
189
Stefan Richter85511582005-11-07 06:31:45 -0500190 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Stefan Richter85511582005-11-07 06:31:45 -0500192 if (hi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 INIT_LIST_HEAD(&hi->list);
194 hi->host = host;
195 INIT_LIST_HEAD(&hi->file_info_list);
196
197 spin_lock_irqsave(&host_info_lock, flags);
198 list_add_tail(&hi->list, &host_info_list);
199 host_count++;
200 spin_unlock_irqrestore(&host_info_lock, flags);
201 }
202
203 atomic_inc(&internal_generation);
204}
205
206static struct host_info *find_host_info(struct hpsb_host *host)
207{
208 struct host_info *hi;
209
210 list_for_each_entry(hi, &host_info_list, list)
211 if (hi->host == host)
212 return hi;
213
214 return NULL;
215}
216
217static void remove_host(struct hpsb_host *host)
218{
219 struct host_info *hi;
220 unsigned long flags;
221
222 spin_lock_irqsave(&host_info_lock, flags);
223 hi = find_host_info(host);
224
225 if (hi != NULL) {
226 list_del(&hi->list);
227 host_count--;
228 /*
229 FIXME: address ranges should be removed
230 and fileinfo states should be initialized
231 (including setting generation to
232 internal-generation ...)
233 */
234 }
235 spin_unlock_irqrestore(&host_info_lock, flags);
236
237 if (hi == NULL) {
238 printk(KERN_ERR "raw1394: attempt to remove unknown host "
239 "0x%p\n", host);
240 return;
241 }
242
243 kfree(hi);
244
245 atomic_inc(&internal_generation);
246}
247
248static void host_reset(struct hpsb_host *host)
249{
250 unsigned long flags;
251 struct host_info *hi;
252 struct file_info *fi;
253 struct pending_request *req;
254
255 spin_lock_irqsave(&host_info_lock, flags);
256 hi = find_host_info(host);
257
258 if (hi != NULL) {
259 list_for_each_entry(fi, &hi->file_info_list, list) {
260 if (fi->notification == RAW1394_NOTIFY_ON) {
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800261 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 if (req != NULL) {
264 req->file_info = fi;
265 req->req.type = RAW1394_REQ_BUS_RESET;
266 req->req.generation =
267 get_hpsb_generation(host);
268 req->req.misc = (host->node_id << 16)
269 | host->node_count;
270 if (fi->protocol_version > 3) {
271 req->req.misc |=
272 (NODEID_TO_NODE
273 (host->irm_id)
274 << 8);
275 }
276
277 queue_complete_req(req);
278 }
279 }
280 }
281 }
282 spin_unlock_irqrestore(&host_info_lock, flags);
283}
284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
286 int cts, u8 * data, size_t length)
287{
288 unsigned long flags;
289 struct host_info *hi;
290 struct file_info *fi;
291 struct pending_request *req, *req_next;
292 struct iso_block_store *ibs = NULL;
293 LIST_HEAD(reqs);
294
295 if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
296 HPSB_INFO("dropped fcp request");
297 return;
298 }
299
300 spin_lock_irqsave(&host_info_lock, flags);
301 hi = find_host_info(host);
302
303 if (hi != NULL) {
304 list_for_each_entry(fi, &hi->file_info_list, list) {
305 if (!fi->fcp_buffer)
306 continue;
307
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800308 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 if (!req)
310 break;
311
312 if (!ibs) {
Stefan Richter85511582005-11-07 06:31:45 -0500313 ibs = kmalloc(sizeof(*ibs) + length,
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800314 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 if (!ibs) {
316 kfree(req);
317 break;
318 }
319
320 atomic_add(length, &iso_buffer_size);
321 atomic_set(&ibs->refcount, 0);
322 ibs->data_size = length;
323 memcpy(ibs->data, data, length);
324 }
325
326 atomic_inc(&ibs->refcount);
327
328 req->file_info = fi;
329 req->ibs = ibs;
330 req->data = ibs->data;
331 req->req.type = RAW1394_REQ_FCP_REQUEST;
332 req->req.generation = get_hpsb_generation(host);
333 req->req.misc = nodeid | (direction << 16);
334 req->req.recvb = ptr2int(fi->fcp_buffer);
335 req->req.length = length;
336
337 list_add_tail(&req->list, &reqs);
338 }
339 }
340 spin_unlock_irqrestore(&host_info_lock, flags);
341
342 list_for_each_entry_safe(req, req_next, &reqs, list)
343 queue_complete_req(req);
344}
345
Andi Kleen4bc32c42006-03-25 16:30:07 +0100346#ifdef CONFIG_COMPAT
347struct compat_raw1394_req {
Ben Collins75970282006-06-12 18:12:10 -0400348 __u32 type;
349 __s32 error;
350 __u32 misc;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100351
Ben Collins75970282006-06-12 18:12:10 -0400352 __u32 generation;
353 __u32 length;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100354
Ben Collins75970282006-06-12 18:12:10 -0400355 __u64 address;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100356
Ben Collins75970282006-06-12 18:12:10 -0400357 __u64 tag;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100358
Ben Collins75970282006-06-12 18:12:10 -0400359 __u64 sendb;
360 __u64 recvb;
Stefan Richter59337082007-07-04 23:13:53 +0200361}
362#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
363__attribute__((packed))
364#endif
365;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100366
367static const char __user *raw1394_compat_write(const char __user *buf)
368{
Ben Collins75970282006-06-12 18:12:10 -0400369 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100370 struct raw1394_request __user *r;
371 r = compat_alloc_user_space(sizeof(struct raw1394_request));
372
373#define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x))
374
375 if (copy_in_user(r, cr, sizeof(struct compat_raw1394_req)) ||
Ben Collins75970282006-06-12 18:12:10 -0400376 C(address) ||
377 C(tag) ||
378 C(sendb) ||
379 C(recvb))
Andi Kleen4bc32c42006-03-25 16:30:07 +0100380 return ERR_PTR(-EFAULT);
381 return (const char __user *)r;
382}
383#undef C
384
385#define P(x) __put_user(r->x, &cr->x)
386
Ben Collins75970282006-06-12 18:12:10 -0400387static int
Andi Kleen4bc32c42006-03-25 16:30:07 +0100388raw1394_compat_read(const char __user *buf, struct raw1394_request *r)
389{
Petr Vandrovecee9be422007-05-07 04:14:47 +0200390 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
Ben Collins75970282006-06-12 18:12:10 -0400391 if (!access_ok(VERIFY_WRITE, cr, sizeof(struct compat_raw1394_req)) ||
Andi Kleen4bc32c42006-03-25 16:30:07 +0100392 P(type) ||
393 P(error) ||
394 P(misc) ||
395 P(generation) ||
396 P(length) ||
397 P(address) ||
398 P(tag) ||
399 P(sendb) ||
400 P(recvb))
401 return -EFAULT;
402 return sizeof(struct compat_raw1394_req);
403}
404#undef P
405
406#endif
407
Stefan Richter45289bf2006-07-03 12:02:33 -0400408/* get next completed request (caller must hold fi->reqlists_lock) */
409static 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 */
423static 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}
Andi Kleen4bc32c42006-03-25 16:30:07 +0100433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434static 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 = (struct file_info *)file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 struct pending_request *req;
439 ssize_t ret;
440
Andi Kleen4bc32c42006-03-25 16:30:07 +0100441#ifdef CONFIG_COMPAT
442 if (count == sizeof(struct compat_raw1394_req)) {
443 /* ok */
444 } else
445#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 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) {
Stefan Richter45289bf2006-07-03 12:02:33 -0400455 if (!(req = next_complete_req(fi)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 } else {
Stefan Richter45289bf2006-07-03 12:02:33 -0400458 /*
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))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Andi Kleen4bc32c42006-03-25 16:30:07 +0100477#ifdef CONFIG_COMPAT
Ben Collins75970282006-06-12 18:12:10 -0400478 if (count == sizeof(struct compat_raw1394_req) &&
479 sizeof(struct compat_raw1394_req) !=
480 sizeof(struct raw1394_request)) {
Andi Kleen4bc32c42006-03-25 16:30:07 +0100481 ret = raw1394_compat_read(buffer, &req->req);
Ben Collins75970282006-06-12 18:12:10 -0400482 } else
Andi Kleen4bc32c42006-03-25 16:30:07 +0100483#endif
484 {
485 if (copy_to_user(buffer, &req->req, sizeof(req->req))) {
486 ret = -EFAULT;
487 goto out;
Ben Collins75970282006-06-12 18:12:10 -0400488 }
Andi Kleen4bc32c42006-03-25 16:30:07 +0100489 ret = (ssize_t) sizeof(struct raw1394_request);
490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 out:
492 free_pending_request(req);
493 return ret;
494}
495
496static 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);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200518 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
520
521static int state_initialized(struct file_info *fi, struct pending_request *req)
522{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700523 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 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);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200532 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534
535 switch (req->req.type) {
536 case RAW1394_REQ_LIST_CARDS:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700537 spin_lock_irqsave(&host_info_lock, flags);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800538 khl = kmalloc(sizeof(*khl) * host_count, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Stefan Richter85511582005-11-07 06:31:45 -0500540 if (khl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 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 }
Andy Wingo4a9949d2005-10-19 21:23:46 -0700550 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Stefan Richter85511582005-11-07 06:31:45 -0500552 if (khl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 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:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700565 spin_lock_irqsave(&host_info_lock, flags);
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100566 if (req->req.misc >= host_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 req->req.error = RAW1394_ERROR_INVALID_ARG;
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100568 goto out_set_card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 }
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100570 list_for_each_entry(hi, &host_info_list, list)
571 if (!req->req.misc--)
572 break;
573 get_device(&hi->host->device); /* FIXME handle failure case */
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;
591out_set_card:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700592 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
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);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200604 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605}
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607static 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
627static int handle_async_request(struct file_info *fi,
628 struct pending_request *req, int node)
629{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700630 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 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);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200759 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
761
762 hpsb_set_packet_complete_task(packet,
763 (void (*)(void *))queue_complete_cb, req);
764
Andy Wingo4a9949d2005-10-19 21:23:46 -0700765 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700767 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
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 }
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200777 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780static int handle_async_send(struct file_info *fi, struct pending_request *req)
781{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700782 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 struct hpsb_packet *packet;
784 int header_length = req->req.misc & 0xffff;
785 int expect_response = req->req.misc >> 16;
Petr Vandrovec976da962007-05-13 22:14:44 -0700786 size_t data_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Stefan Richter7542e0e2007-03-25 22:22:40 +0200788 if (header_length > req->req.length || header_length < 12 ||
789 header_length > FIELD_SIZEOF(struct hpsb_packet, header)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 req->req.error = RAW1394_ERROR_INVALID_ARG;
791 req->req.length = 0;
792 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200793 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
795
Petr Vandrovec976da962007-05-13 22:14:44 -0700796 data_size = req->req.length - header_length;
797 packet = hpsb_alloc_packet(data_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 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);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200807 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 }
809
810 if (copy_from_user
811 (packet->data, int2ptr(req->req.sendb) + header_length,
Petr Vandrovec976da962007-05-13 22:14:44 -0700812 data_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 req->req.error = RAW1394_ERROR_MEMFAULT;
814 req->req.length = 0;
815 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200816 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 }
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;
Petr Vandrovec976da962007-05-13 22:14:44 -0700826 packet->data_size = data_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 req->req.length = 0;
829 hpsb_set_packet_complete_task(packet,
830 (void (*)(void *))queue_complete_cb, req);
831
Andy Wingo4a9949d2005-10-19 21:23:46 -0700832 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700834 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
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
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200844 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845}
846
847static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
848 u64 addr, size_t length, u16 flags)
849{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700850 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 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);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700865 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 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");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700890 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 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");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800917 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if (!req) {
919 DBGMSG("arm_read -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700920 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 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 }
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800936 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (!(req->data)) {
938 free_pending_request(req);
939 DBGMSG("arm_read -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700940 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 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 }
Andy Wingo4a9949d2005-10-19 21:23:46 -0700997 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 return (rcode);
999}
1000
1001static int arm_write(struct hpsb_host *host, int nodeid, int destid,
1002 quadlet_t * data, u64 addr, size_t length, u16 flags)
1003{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001004 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 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, length_conflict = 0;
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);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001019 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 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");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001044 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 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 length_conflict = 1;
1052 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
1053 }
1054 if (rcode == -1) {
1055 if (arm_addr->access_rights & ARM_WRITE) {
1056 if (!(arm_addr->client_transactions & ARM_WRITE)) {
1057 memcpy((arm_addr->addr_space_buffer) +
1058 (addr - (arm_addr->start)), data,
1059 length);
1060 DBGMSG("arm_write -> (rcode_complete)");
1061 rcode = RCODE_COMPLETE;
1062 }
1063 } else {
1064 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1065 DBGMSG("arm_write -> rcode_type_error (access denied)");
1066 }
1067 }
1068 if (arm_addr->notification_options & ARM_WRITE) {
1069 DBGMSG("arm_write -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001070 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 if (!req) {
1072 DBGMSG("arm_write -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001073 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1075 The request my be retried */
1076 }
1077 size =
1078 sizeof(struct arm_request) + sizeof(struct arm_response) +
1079 (length) * sizeof(byte_t) +
1080 sizeof(struct arm_request_response);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001081 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 if (!(req->data)) {
1083 free_pending_request(req);
1084 DBGMSG("arm_write -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001085 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1087 The request may be retried */
1088 }
1089 req->free_data = 1;
1090 req->file_info = fi;
1091 req->req.type = RAW1394_REQ_ARM;
1092 req->req.generation = get_hpsb_generation(host);
1093 req->req.misc =
1094 (((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF));
1095 req->req.tag = arm_addr->arm_tag;
1096 req->req.recvb = arm_addr->recvb;
1097 req->req.length = size;
1098 arm_req_resp = (struct arm_request_response *)(req->data);
1099 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1100 (sizeof
1101 (struct
1102 arm_request_response)));
1103 arm_resp =
1104 (struct arm_response *)((byte_t *) (arm_req) +
1105 (sizeof(struct arm_request)));
1106 arm_resp->buffer = NULL;
1107 memcpy((byte_t *) arm_resp + sizeof(struct arm_response),
1108 data, length);
1109 arm_req->buffer = int2ptr((arm_addr->recvb) +
1110 sizeof(struct arm_request_response) +
1111 sizeof(struct arm_request) +
1112 sizeof(struct arm_response));
1113 arm_req->buffer_length = length;
1114 arm_req->generation = req->req.generation;
1115 arm_req->extended_transaction_code = 0;
1116 arm_req->destination_offset = addr;
1117 arm_req->source_nodeid = nodeid;
1118 arm_req->destination_nodeid = destid;
1119 arm_req->tlabel = (flags >> 10) & 0x3f;
1120 arm_req->tcode = (flags >> 4) & 0x0f;
1121 arm_resp->buffer_length = 0;
1122 arm_resp->response_code = rcode;
1123 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1124 sizeof(struct
1125 arm_request_response));
1126 arm_req_resp->response =
1127 int2ptr((arm_addr->recvb) +
1128 sizeof(struct arm_request_response) +
1129 sizeof(struct arm_request));
1130 queue_complete_req(req);
1131 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001132 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 return (rcode);
1134}
1135
1136static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
1137 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
1138 u16 flags)
1139{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001140 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 struct pending_request *req;
1142 struct host_info *hi;
1143 struct file_info *fi = NULL;
1144 struct list_head *entry;
1145 struct arm_addr *arm_addr = NULL;
1146 struct arm_request *arm_req = NULL;
1147 struct arm_response *arm_resp = NULL;
1148 int found = 0, size = 0, rcode = -1;
1149 quadlet_t old, new;
1150 struct arm_request_response *arm_req_resp = NULL;
1151
1152 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1153 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1154 DBGMSG("arm_lock called by node: %X "
1155 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
1156 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1157 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1158 be32_to_cpu(data));
1159 } else {
1160 DBGMSG("arm_lock called by node: %X "
1161 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
1162 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1163 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1164 be32_to_cpu(data), be32_to_cpu(arg));
1165 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001166 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 hi = find_host_info(host); /* search address-entry */
1168 if (hi != NULL) {
1169 list_for_each_entry(fi, &hi->file_info_list, list) {
1170 entry = fi->addr_list.next;
1171 while (entry != &(fi->addr_list)) {
1172 arm_addr =
1173 list_entry(entry, struct arm_addr,
1174 addr_list);
1175 if (((arm_addr->start) <= (addr))
1176 && ((arm_addr->end) >=
1177 (addr + sizeof(*store)))) {
1178 found = 1;
1179 break;
1180 }
1181 entry = entry->next;
1182 }
1183 if (found) {
1184 break;
1185 }
1186 }
1187 }
1188 rcode = -1;
1189 if (!found) {
1190 printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found"
1191 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001192 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 return (RCODE_ADDRESS_ERROR);
1194 } else {
1195 DBGMSG("arm_lock addr_entry FOUND");
1196 }
1197 if (rcode == -1) {
1198 if (arm_addr->access_rights & ARM_LOCK) {
1199 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1200 memcpy(&old,
1201 (arm_addr->addr_space_buffer) + (addr -
1202 (arm_addr->
1203 start)),
1204 sizeof(old));
1205 switch (ext_tcode) {
1206 case (EXTCODE_MASK_SWAP):
1207 new = data | (old & ~arg);
1208 break;
1209 case (EXTCODE_COMPARE_SWAP):
1210 if (old == arg) {
1211 new = data;
1212 } else {
1213 new = old;
1214 }
1215 break;
1216 case (EXTCODE_FETCH_ADD):
1217 new =
1218 cpu_to_be32(be32_to_cpu(data) +
1219 be32_to_cpu(old));
1220 break;
1221 case (EXTCODE_LITTLE_ADD):
1222 new =
1223 cpu_to_le32(le32_to_cpu(data) +
1224 le32_to_cpu(old));
1225 break;
1226 case (EXTCODE_BOUNDED_ADD):
1227 if (old != arg) {
1228 new =
1229 cpu_to_be32(be32_to_cpu
1230 (data) +
1231 be32_to_cpu
1232 (old));
1233 } else {
1234 new = old;
1235 }
1236 break;
1237 case (EXTCODE_WRAP_ADD):
1238 if (old != arg) {
1239 new =
1240 cpu_to_be32(be32_to_cpu
1241 (data) +
1242 be32_to_cpu
1243 (old));
1244 } else {
1245 new = data;
1246 }
1247 break;
1248 default:
1249 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1250 printk(KERN_ERR
1251 "raw1394: arm_lock FAILED "
1252 "ext_tcode not allowed -> rcode_type_error\n");
1253 break;
1254 } /*switch */
1255 if (rcode == -1) {
1256 DBGMSG("arm_lock -> (rcode_complete)");
1257 rcode = RCODE_COMPLETE;
1258 memcpy(store, &old, sizeof(*store));
1259 memcpy((arm_addr->addr_space_buffer) +
1260 (addr - (arm_addr->start)),
1261 &new, sizeof(*store));
1262 }
1263 }
1264 } else {
1265 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1266 DBGMSG("arm_lock -> rcode_type_error (access denied)");
1267 }
1268 }
1269 if (arm_addr->notification_options & ARM_LOCK) {
1270 byte_t *buf1, *buf2;
1271 DBGMSG("arm_lock -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001272 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if (!req) {
1274 DBGMSG("arm_lock -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001275 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1277 The request may be retried */
1278 }
1279 size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001280 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (!(req->data)) {
1282 free_pending_request(req);
1283 DBGMSG("arm_lock -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001284 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1286 The request may be retried */
1287 }
1288 req->free_data = 1;
1289 arm_req_resp = (struct arm_request_response *)(req->data);
1290 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1291 (sizeof
1292 (struct
1293 arm_request_response)));
1294 arm_resp =
1295 (struct arm_response *)((byte_t *) (arm_req) +
1296 (sizeof(struct arm_request)));
1297 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1298 buf2 = buf1 + 2 * sizeof(*store);
1299 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1300 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1301 arm_req->buffer_length = sizeof(*store);
1302 memcpy(buf1, &data, sizeof(*store));
1303
1304 } else {
1305 arm_req->buffer_length = 2 * sizeof(*store);
1306 memcpy(buf1, &arg, sizeof(*store));
1307 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1308 }
1309 if (rcode == RCODE_COMPLETE) {
1310 arm_resp->buffer_length = sizeof(*store);
1311 memcpy(buf2, &old, sizeof(*store));
1312 } else {
1313 arm_resp->buffer_length = 0;
1314 }
1315 req->file_info = fi;
1316 req->req.type = RAW1394_REQ_ARM;
1317 req->req.generation = get_hpsb_generation(host);
1318 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1319 (ARM_LOCK & 0xFF));
1320 req->req.tag = arm_addr->arm_tag;
1321 req->req.recvb = arm_addr->recvb;
1322 req->req.length = size;
1323 arm_req->generation = req->req.generation;
1324 arm_req->extended_transaction_code = ext_tcode;
1325 arm_req->destination_offset = addr;
1326 arm_req->source_nodeid = nodeid;
1327 arm_req->destination_nodeid = host->node_id;
1328 arm_req->tlabel = (flags >> 10) & 0x3f;
1329 arm_req->tcode = (flags >> 4) & 0x0f;
1330 arm_resp->response_code = rcode;
1331 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1332 sizeof(struct
1333 arm_request_response));
1334 arm_req_resp->response =
1335 int2ptr((arm_addr->recvb) +
1336 sizeof(struct arm_request_response) +
1337 sizeof(struct arm_request));
1338 arm_req->buffer =
1339 int2ptr((arm_addr->recvb) +
1340 sizeof(struct arm_request_response) +
1341 sizeof(struct arm_request) +
1342 sizeof(struct arm_response));
1343 arm_resp->buffer =
1344 int2ptr((arm_addr->recvb) +
1345 sizeof(struct arm_request_response) +
1346 sizeof(struct arm_request) +
1347 sizeof(struct arm_response) + 2 * sizeof(*store));
1348 queue_complete_req(req);
1349 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001350 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return (rcode);
1352}
1353
1354static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
1355 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
1356 u16 flags)
1357{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001358 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 struct pending_request *req;
1360 struct host_info *hi;
1361 struct file_info *fi = NULL;
1362 struct list_head *entry;
1363 struct arm_addr *arm_addr = NULL;
1364 struct arm_request *arm_req = NULL;
1365 struct arm_response *arm_resp = NULL;
1366 int found = 0, size = 0, rcode = -1;
1367 octlet_t old, new;
1368 struct arm_request_response *arm_req_resp = NULL;
1369
1370 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1371 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1372 DBGMSG("arm_lock64 called by node: %X "
1373 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
1374 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1375 (u32) (addr & 0xFFFFFFFF),
1376 ext_tcode & 0xFF,
1377 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1378 (u32) (be64_to_cpu(data) & 0xFFFFFFFF));
1379 } else {
1380 DBGMSG("arm_lock64 called by node: %X "
1381 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
1382 "%8.8X %8.8X ",
1383 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1384 (u32) (addr & 0xFFFFFFFF),
1385 ext_tcode & 0xFF,
1386 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1387 (u32) (be64_to_cpu(data) & 0xFFFFFFFF),
1388 (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF),
1389 (u32) (be64_to_cpu(arg) & 0xFFFFFFFF));
1390 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001391 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 hi = find_host_info(host); /* search addressentry in file_info's for host */
1393 if (hi != NULL) {
1394 list_for_each_entry(fi, &hi->file_info_list, list) {
1395 entry = fi->addr_list.next;
1396 while (entry != &(fi->addr_list)) {
1397 arm_addr =
1398 list_entry(entry, struct arm_addr,
1399 addr_list);
1400 if (((arm_addr->start) <= (addr))
1401 && ((arm_addr->end) >=
1402 (addr + sizeof(*store)))) {
1403 found = 1;
1404 break;
1405 }
1406 entry = entry->next;
1407 }
1408 if (found) {
1409 break;
1410 }
1411 }
1412 }
1413 rcode = -1;
1414 if (!found) {
1415 printk(KERN_ERR
1416 "raw1394: arm_lock64 FAILED addr_entry not found"
1417 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001418 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 return (RCODE_ADDRESS_ERROR);
1420 } else {
1421 DBGMSG("arm_lock64 addr_entry FOUND");
1422 }
1423 if (rcode == -1) {
1424 if (arm_addr->access_rights & ARM_LOCK) {
1425 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1426 memcpy(&old,
1427 (arm_addr->addr_space_buffer) + (addr -
1428 (arm_addr->
1429 start)),
1430 sizeof(old));
1431 switch (ext_tcode) {
1432 case (EXTCODE_MASK_SWAP):
1433 new = data | (old & ~arg);
1434 break;
1435 case (EXTCODE_COMPARE_SWAP):
1436 if (old == arg) {
1437 new = data;
1438 } else {
1439 new = old;
1440 }
1441 break;
1442 case (EXTCODE_FETCH_ADD):
1443 new =
1444 cpu_to_be64(be64_to_cpu(data) +
1445 be64_to_cpu(old));
1446 break;
1447 case (EXTCODE_LITTLE_ADD):
1448 new =
1449 cpu_to_le64(le64_to_cpu(data) +
1450 le64_to_cpu(old));
1451 break;
1452 case (EXTCODE_BOUNDED_ADD):
1453 if (old != arg) {
1454 new =
1455 cpu_to_be64(be64_to_cpu
1456 (data) +
1457 be64_to_cpu
1458 (old));
1459 } else {
1460 new = old;
1461 }
1462 break;
1463 case (EXTCODE_WRAP_ADD):
1464 if (old != arg) {
1465 new =
1466 cpu_to_be64(be64_to_cpu
1467 (data) +
1468 be64_to_cpu
1469 (old));
1470 } else {
1471 new = data;
1472 }
1473 break;
1474 default:
1475 printk(KERN_ERR
1476 "raw1394: arm_lock64 FAILED "
1477 "ext_tcode not allowed -> rcode_type_error\n");
1478 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1479 break;
1480 } /*switch */
1481 if (rcode == -1) {
1482 DBGMSG
1483 ("arm_lock64 -> (rcode_complete)");
1484 rcode = RCODE_COMPLETE;
1485 memcpy(store, &old, sizeof(*store));
1486 memcpy((arm_addr->addr_space_buffer) +
1487 (addr - (arm_addr->start)),
1488 &new, sizeof(*store));
1489 }
1490 }
1491 } else {
1492 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1493 DBGMSG
1494 ("arm_lock64 -> rcode_type_error (access denied)");
1495 }
1496 }
1497 if (arm_addr->notification_options & ARM_LOCK) {
1498 byte_t *buf1, *buf2;
1499 DBGMSG("arm_lock64 -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001500 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 if (!req) {
Andy Wingo4a9949d2005-10-19 21:23:46 -07001502 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 DBGMSG("arm_lock64 -> rcode_conflict_error");
1504 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1505 The request may be retried */
1506 }
1507 size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001508 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 if (!(req->data)) {
1510 free_pending_request(req);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001511 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 DBGMSG("arm_lock64 -> rcode_conflict_error");
1513 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1514 The request may be retried */
1515 }
1516 req->free_data = 1;
1517 arm_req_resp = (struct arm_request_response *)(req->data);
1518 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1519 (sizeof
1520 (struct
1521 arm_request_response)));
1522 arm_resp =
1523 (struct arm_response *)((byte_t *) (arm_req) +
1524 (sizeof(struct arm_request)));
1525 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1526 buf2 = buf1 + 2 * sizeof(*store);
1527 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1528 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1529 arm_req->buffer_length = sizeof(*store);
1530 memcpy(buf1, &data, sizeof(*store));
1531
1532 } else {
1533 arm_req->buffer_length = 2 * sizeof(*store);
1534 memcpy(buf1, &arg, sizeof(*store));
1535 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1536 }
1537 if (rcode == RCODE_COMPLETE) {
1538 arm_resp->buffer_length = sizeof(*store);
1539 memcpy(buf2, &old, sizeof(*store));
1540 } else {
1541 arm_resp->buffer_length = 0;
1542 }
1543 req->file_info = fi;
1544 req->req.type = RAW1394_REQ_ARM;
1545 req->req.generation = get_hpsb_generation(host);
1546 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1547 (ARM_LOCK & 0xFF));
1548 req->req.tag = arm_addr->arm_tag;
1549 req->req.recvb = arm_addr->recvb;
1550 req->req.length = size;
1551 arm_req->generation = req->req.generation;
1552 arm_req->extended_transaction_code = ext_tcode;
1553 arm_req->destination_offset = addr;
1554 arm_req->source_nodeid = nodeid;
1555 arm_req->destination_nodeid = host->node_id;
1556 arm_req->tlabel = (flags >> 10) & 0x3f;
1557 arm_req->tcode = (flags >> 4) & 0x0f;
1558 arm_resp->response_code = rcode;
1559 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1560 sizeof(struct
1561 arm_request_response));
1562 arm_req_resp->response =
1563 int2ptr((arm_addr->recvb) +
1564 sizeof(struct arm_request_response) +
1565 sizeof(struct arm_request));
1566 arm_req->buffer =
1567 int2ptr((arm_addr->recvb) +
1568 sizeof(struct arm_request_response) +
1569 sizeof(struct arm_request) +
1570 sizeof(struct arm_response));
1571 arm_resp->buffer =
1572 int2ptr((arm_addr->recvb) +
1573 sizeof(struct arm_request_response) +
1574 sizeof(struct arm_request) +
1575 sizeof(struct arm_response) + 2 * sizeof(*store));
1576 queue_complete_req(req);
1577 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001578 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 return (rcode);
1580}
1581
1582static int arm_register(struct file_info *fi, struct pending_request *req)
1583{
1584 int retval;
1585 struct arm_addr *addr;
1586 struct host_info *hi;
1587 struct file_info *fi_hlp = NULL;
1588 struct list_head *entry;
1589 struct arm_addr *arm_addr = NULL;
1590 int same_host, another_host;
1591 unsigned long flags;
1592
1593 DBGMSG("arm_register called "
1594 "addr(Offset): %8.8x %8.8x length: %u "
1595 "rights: %2.2X notify: %2.2X "
1596 "max_blk_len: %4.4X",
1597 (u32) ((req->req.address >> 32) & 0xFFFF),
1598 (u32) (req->req.address & 0xFFFFFFFF),
1599 req->req.length, ((req->req.misc >> 8) & 0xFF),
1600 (req->req.misc & 0xFF), ((req->req.misc >> 16) & 0xFFFF));
1601 /* check addressrange */
1602 if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) ||
1603 (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) !=
1604 0)) {
1605 req->req.length = 0;
1606 return (-EINVAL);
1607 }
1608 /* addr-list-entry for fileinfo */
Christoph Lametere94b1762006-12-06 20:33:17 -08001609 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 if (!addr) {
1611 req->req.length = 0;
1612 return (-ENOMEM);
1613 }
1614 /* allocation of addr_space_buffer */
Stefan Richter85511582005-11-07 06:31:45 -05001615 addr->addr_space_buffer = vmalloc(req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 if (!(addr->addr_space_buffer)) {
1617 kfree(addr);
1618 req->req.length = 0;
1619 return (-ENOMEM);
1620 }
1621 /* initialization of addr_space_buffer */
1622 if ((req->req.sendb) == (unsigned long)NULL) {
1623 /* init: set 0 */
1624 memset(addr->addr_space_buffer, 0, req->req.length);
1625 } else {
1626 /* init: user -> kernel */
1627 if (copy_from_user
1628 (addr->addr_space_buffer, int2ptr(req->req.sendb),
1629 req->req.length)) {
1630 vfree(addr->addr_space_buffer);
1631 kfree(addr);
1632 return (-EFAULT);
1633 }
1634 }
1635 INIT_LIST_HEAD(&addr->addr_list);
1636 addr->arm_tag = req->req.tag;
1637 addr->start = req->req.address;
1638 addr->end = req->req.address + req->req.length;
1639 addr->access_rights = (u8) (req->req.misc & 0x0F);
1640 addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F);
1641 addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F);
1642 addr->access_rights |= addr->client_transactions;
1643 addr->notification_options |= addr->client_transactions;
1644 addr->recvb = req->req.recvb;
1645 addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF);
Stefan Richter3253b662006-09-14 22:05:16 +02001646
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 spin_lock_irqsave(&host_info_lock, flags);
1648 hi = find_host_info(fi->host);
1649 same_host = 0;
1650 another_host = 0;
1651 /* same host with address-entry containing same addressrange ? */
1652 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1653 entry = fi_hlp->addr_list.next;
1654 while (entry != &(fi_hlp->addr_list)) {
1655 arm_addr =
1656 list_entry(entry, struct arm_addr, addr_list);
1657 if ((arm_addr->start == addr->start)
1658 && (arm_addr->end == addr->end)) {
1659 DBGMSG("same host ownes same "
1660 "addressrange -> EALREADY");
1661 same_host = 1;
1662 break;
1663 }
1664 entry = entry->next;
1665 }
1666 if (same_host) {
1667 break;
1668 }
1669 }
1670 if (same_host) {
1671 /* addressrange occupied by same host */
Stefan Richter3253b662006-09-14 22:05:16 +02001672 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 vfree(addr->addr_space_buffer);
1674 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 return (-EALREADY);
1676 }
1677 /* another host with valid address-entry containing same addressrange */
1678 list_for_each_entry(hi, &host_info_list, list) {
1679 if (hi->host != fi->host) {
1680 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1681 entry = fi_hlp->addr_list.next;
1682 while (entry != &(fi_hlp->addr_list)) {
1683 arm_addr =
1684 list_entry(entry, struct arm_addr,
1685 addr_list);
1686 if ((arm_addr->start == addr->start)
1687 && (arm_addr->end == addr->end)) {
1688 DBGMSG
1689 ("another host ownes same "
1690 "addressrange");
1691 another_host = 1;
1692 break;
1693 }
1694 entry = entry->next;
1695 }
1696 if (another_host) {
1697 break;
1698 }
1699 }
1700 }
1701 }
Stefan Richter3253b662006-09-14 22:05:16 +02001702 spin_unlock_irqrestore(&host_info_lock, flags);
1703
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 if (another_host) {
1705 DBGMSG("another hosts entry is valid -> SUCCESS");
1706 if (copy_to_user(int2ptr(req->req.recvb),
1707 &addr->start, sizeof(u64))) {
1708 printk(KERN_ERR "raw1394: arm_register failed "
1709 " address-range-entry is invalid -> EFAULT !!!\n");
1710 vfree(addr->addr_space_buffer);
1711 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 return (-EFAULT);
1713 }
1714 free_pending_request(req); /* immediate success or fail */
1715 /* INSERT ENTRY */
Stefan Richter3253b662006-09-14 22:05:16 +02001716 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 list_add_tail(&addr->addr_list, &fi->addr_list);
1718 spin_unlock_irqrestore(&host_info_lock, flags);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001719 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 }
1721 retval =
1722 hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops,
1723 req->req.address,
1724 req->req.address + req->req.length);
1725 if (retval) {
1726 /* INSERT ENTRY */
Stefan Richter3253b662006-09-14 22:05:16 +02001727 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 list_add_tail(&addr->addr_list, &fi->addr_list);
Stefan Richter3253b662006-09-14 22:05:16 +02001729 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 } else {
1731 DBGMSG("arm_register failed errno: %d \n", retval);
1732 vfree(addr->addr_space_buffer);
1733 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 return (-EALREADY);
1735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001737 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738}
1739
1740static int arm_unregister(struct file_info *fi, struct pending_request *req)
1741{
1742 int found = 0;
1743 int retval = 0;
1744 struct list_head *entry;
1745 struct arm_addr *addr = NULL;
1746 struct host_info *hi;
1747 struct file_info *fi_hlp = NULL;
1748 struct arm_addr *arm_addr = NULL;
1749 int another_host;
1750 unsigned long flags;
1751
1752 DBGMSG("arm_Unregister called addr(Offset): "
1753 "%8.8x %8.8x",
1754 (u32) ((req->req.address >> 32) & 0xFFFF),
1755 (u32) (req->req.address & 0xFFFFFFFF));
1756 spin_lock_irqsave(&host_info_lock, flags);
1757 /* get addr */
1758 entry = fi->addr_list.next;
1759 while (entry != &(fi->addr_list)) {
1760 addr = list_entry(entry, struct arm_addr, addr_list);
1761 if (addr->start == req->req.address) {
1762 found = 1;
1763 break;
1764 }
1765 entry = entry->next;
1766 }
1767 if (!found) {
1768 DBGMSG("arm_Unregister addr not found");
1769 spin_unlock_irqrestore(&host_info_lock, flags);
1770 return (-EINVAL);
1771 }
1772 DBGMSG("arm_Unregister addr found");
1773 another_host = 0;
1774 /* another host with valid address-entry containing
1775 same addressrange */
1776 list_for_each_entry(hi, &host_info_list, list) {
1777 if (hi->host != fi->host) {
1778 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1779 entry = fi_hlp->addr_list.next;
1780 while (entry != &(fi_hlp->addr_list)) {
1781 arm_addr = list_entry(entry,
1782 struct arm_addr,
1783 addr_list);
1784 if (arm_addr->start == addr->start) {
1785 DBGMSG("another host ownes "
1786 "same addressrange");
1787 another_host = 1;
1788 break;
1789 }
1790 entry = entry->next;
1791 }
1792 if (another_host) {
1793 break;
1794 }
1795 }
1796 }
1797 }
1798 if (another_host) {
1799 DBGMSG("delete entry from list -> success");
1800 list_del(&addr->addr_list);
Stefan Richter3253b662006-09-14 22:05:16 +02001801 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 vfree(addr->addr_space_buffer);
1803 kfree(addr);
1804 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001805 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 }
1807 retval =
1808 hpsb_unregister_addrspace(&raw1394_highlevel, fi->host,
1809 addr->start);
1810 if (!retval) {
1811 printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n");
1812 spin_unlock_irqrestore(&host_info_lock, flags);
1813 return (-EINVAL);
1814 }
1815 DBGMSG("delete entry from list -> success");
1816 list_del(&addr->addr_list);
1817 spin_unlock_irqrestore(&host_info_lock, flags);
1818 vfree(addr->addr_space_buffer);
1819 kfree(addr);
1820 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001821 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822}
1823
1824/* Copy data from ARM buffer(s) to user buffer. */
1825static int arm_get_buf(struct file_info *fi, struct pending_request *req)
1826{
1827 struct arm_addr *arm_addr = NULL;
1828 unsigned long flags;
1829 unsigned long offset;
1830
1831 struct list_head *entry;
1832
1833 DBGMSG("arm_get_buf "
1834 "addr(Offset): %04X %08X length: %u",
1835 (u32) ((req->req.address >> 32) & 0xFFFF),
1836 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1837
1838 spin_lock_irqsave(&host_info_lock, flags);
1839 entry = fi->addr_list.next;
1840 while (entry != &(fi->addr_list)) {
1841 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1842 if ((arm_addr->start <= req->req.address) &&
1843 (arm_addr->end > req->req.address)) {
1844 if (req->req.address + req->req.length <= arm_addr->end) {
1845 offset = req->req.address - arm_addr->start;
Stefan Richter3253b662006-09-14 22:05:16 +02001846 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
1848 DBGMSG
1849 ("arm_get_buf copy_to_user( %08X, %p, %u )",
1850 (u32) req->req.recvb,
1851 arm_addr->addr_space_buffer + offset,
1852 (u32) req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 if (copy_to_user
1854 (int2ptr(req->req.recvb),
1855 arm_addr->addr_space_buffer + offset,
Stefan Richter3253b662006-09-14 22:05:16 +02001856 req->req.length))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 return (-EFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 /* We have to free the request, because we
1860 * queue no response, and therefore nobody
1861 * will free it. */
1862 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001863 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 } else {
1865 DBGMSG("arm_get_buf request exceeded mapping");
1866 spin_unlock_irqrestore(&host_info_lock, flags);
1867 return (-EINVAL);
1868 }
1869 }
1870 entry = entry->next;
1871 }
1872 spin_unlock_irqrestore(&host_info_lock, flags);
1873 return (-EINVAL);
1874}
1875
1876/* Copy data from user buffer to ARM buffer(s). */
1877static int arm_set_buf(struct file_info *fi, struct pending_request *req)
1878{
1879 struct arm_addr *arm_addr = NULL;
1880 unsigned long flags;
1881 unsigned long offset;
1882
1883 struct list_head *entry;
1884
1885 DBGMSG("arm_set_buf "
1886 "addr(Offset): %04X %08X length: %u",
1887 (u32) ((req->req.address >> 32) & 0xFFFF),
1888 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1889
1890 spin_lock_irqsave(&host_info_lock, flags);
1891 entry = fi->addr_list.next;
1892 while (entry != &(fi->addr_list)) {
1893 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1894 if ((arm_addr->start <= req->req.address) &&
1895 (arm_addr->end > req->req.address)) {
1896 if (req->req.address + req->req.length <= arm_addr->end) {
1897 offset = req->req.address - arm_addr->start;
Stefan Richter3253b662006-09-14 22:05:16 +02001898 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
1900 DBGMSG
1901 ("arm_set_buf copy_from_user( %p, %08X, %u )",
1902 arm_addr->addr_space_buffer + offset,
1903 (u32) req->req.sendb,
1904 (u32) req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 if (copy_from_user
1906 (arm_addr->addr_space_buffer + offset,
1907 int2ptr(req->req.sendb),
Stefan Richter3253b662006-09-14 22:05:16 +02001908 req->req.length))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 return (-EFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
Stefan Richter3253b662006-09-14 22:05:16 +02001911 /* We have to free the request, because we
1912 * queue no response, and therefore nobody
1913 * will free it. */
1914 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001915 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 } else {
1917 DBGMSG("arm_set_buf request exceeded mapping");
1918 spin_unlock_irqrestore(&host_info_lock, flags);
1919 return (-EINVAL);
1920 }
1921 }
1922 entry = entry->next;
1923 }
1924 spin_unlock_irqrestore(&host_info_lock, flags);
1925 return (-EINVAL);
1926}
1927
1928static int reset_notification(struct file_info *fi, struct pending_request *req)
1929{
1930 DBGMSG("reset_notification called - switch %s ",
1931 (req->req.misc == RAW1394_NOTIFY_OFF) ? "OFF" : "ON");
1932 if ((req->req.misc == RAW1394_NOTIFY_OFF) ||
1933 (req->req.misc == RAW1394_NOTIFY_ON)) {
1934 fi->notification = (u8) req->req.misc;
1935 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001936 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 }
1938 /* error EINVAL (22) invalid argument */
1939 return (-EINVAL);
1940}
1941
1942static int write_phypacket(struct file_info *fi, struct pending_request *req)
1943{
1944 struct hpsb_packet *packet = NULL;
1945 int retval = 0;
1946 quadlet_t data;
Andy Wingo4a9949d2005-10-19 21:23:46 -07001947 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 data = be32_to_cpu((u32) req->req.sendb);
1950 DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data);
1951 packet = hpsb_make_phypacket(fi->host, data);
1952 if (!packet)
1953 return -ENOMEM;
1954 req->req.length = 0;
1955 req->packet = packet;
1956 hpsb_set_packet_complete_task(packet,
1957 (void (*)(void *))queue_complete_cb, req);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001958 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001960 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 packet->generation = req->req.generation;
1962 retval = hpsb_send_packet(packet);
1963 DBGMSG("write_phypacket send_packet called => retval: %d ", retval);
1964 if (retval < 0) {
1965 req->req.error = RAW1394_ERROR_SEND_ERROR;
1966 req->req.length = 0;
1967 queue_complete_req(req);
1968 }
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001969 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970}
1971
1972static int get_config_rom(struct file_info *fi, struct pending_request *req)
1973{
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001974 int ret = 0;
Christoph Lametere94b1762006-12-06 20:33:17 -08001975 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 int status;
1977
1978 if (!data)
1979 return -ENOMEM;
1980
1981 status =
1982 csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET,
1983 data, req->req.length);
1984 if (copy_to_user(int2ptr(req->req.recvb), data, req->req.length))
1985 ret = -EFAULT;
1986 if (copy_to_user
1987 (int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len,
1988 sizeof(fi->host->csr.rom->cache_head->len)))
1989 ret = -EFAULT;
1990 if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation,
1991 sizeof(fi->host->csr.generation)))
1992 ret = -EFAULT;
1993 if (copy_to_user(int2ptr(req->req.sendb), &status, sizeof(status)))
1994 ret = -EFAULT;
1995 kfree(data);
1996 if (ret >= 0) {
1997 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
1998 }
1999 return ret;
2000}
2001
2002static int update_config_rom(struct file_info *fi, struct pending_request *req)
2003{
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002004 int ret = 0;
Christoph Lametere94b1762006-12-06 20:33:17 -08002005 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 if (!data)
2007 return -ENOMEM;
2008 if (copy_from_user(data, int2ptr(req->req.sendb), req->req.length)) {
2009 ret = -EFAULT;
2010 } else {
2011 int status = hpsb_update_config_rom(fi->host,
2012 data, req->req.length,
2013 (unsigned char)req->req.
2014 misc);
2015 if (copy_to_user
2016 (int2ptr(req->req.recvb), &status, sizeof(status)))
2017 ret = -ENOMEM;
2018 }
2019 kfree(data);
2020 if (ret >= 0) {
2021 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2022 fi->cfgrom_upd = 1;
2023 }
2024 return ret;
2025}
2026
2027static int modify_config_rom(struct file_info *fi, struct pending_request *req)
2028{
2029 struct csr1212_keyval *kv;
2030 struct csr1212_csr_rom_cache *cache;
2031 struct csr1212_dentry *dentry;
2032 u32 dr;
2033 int ret = 0;
2034
2035 if (req->req.misc == ~0) {
2036 if (req->req.length == 0)
2037 return -EINVAL;
2038
2039 /* Find an unused slot */
2040 for (dr = 0;
2041 dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr];
2042 dr++) ;
2043
2044 if (dr == RAW1394_MAX_USER_CSR_DIRS)
2045 return -ENOMEM;
2046
2047 fi->csr1212_dirs[dr] =
2048 csr1212_new_directory(CSR1212_KV_ID_VENDOR);
2049 if (!fi->csr1212_dirs[dr])
2050 return -ENOMEM;
2051 } else {
2052 dr = req->req.misc;
2053 if (!fi->csr1212_dirs[dr])
2054 return -EINVAL;
2055
2056 /* Delete old stuff */
2057 for (dentry =
2058 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2059 dentry; dentry = dentry->next) {
2060 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2061 root_kv,
2062 dentry->kv);
2063 }
2064
2065 if (req->req.length == 0) {
2066 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2067 fi->csr1212_dirs[dr] = NULL;
2068
2069 hpsb_update_config_rom_image(fi->host);
2070 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002071 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 }
2073 }
2074
2075 cache = csr1212_rom_cache_malloc(0, req->req.length);
2076 if (!cache) {
2077 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2078 fi->csr1212_dirs[dr] = NULL;
2079 return -ENOMEM;
2080 }
2081
Stefan Richter85511582005-11-07 06:31:45 -05002082 cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 if (!cache->filled_head) {
2084 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2085 fi->csr1212_dirs[dr] = NULL;
2086 CSR1212_FREE(cache);
2087 return -ENOMEM;
2088 }
2089 cache->filled_tail = cache->filled_head;
2090
2091 if (copy_from_user(cache->data, int2ptr(req->req.sendb),
2092 req->req.length)) {
2093 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2094 fi->csr1212_dirs[dr] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 ret = -EFAULT;
2096 } else {
2097 cache->len = req->req.length;
2098 cache->filled_head->offset_start = 0;
2099 cache->filled_head->offset_end = cache->size - 1;
2100
2101 cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr];
2102
2103 ret = CSR1212_SUCCESS;
2104 /* parse all the items */
2105 for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv;
2106 kv = kv->next) {
2107 ret = csr1212_parse_keyval(kv, cache);
2108 }
2109
2110 /* attach top level items to the root directory */
2111 for (dentry =
2112 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2113 ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) {
2114 ret =
2115 csr1212_attach_keyval_to_directory(fi->host->csr.
2116 rom->root_kv,
2117 dentry->kv);
2118 }
2119
2120 if (ret == CSR1212_SUCCESS) {
2121 ret = hpsb_update_config_rom_image(fi->host);
2122
2123 if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb),
2124 &dr, sizeof(dr))) {
2125 ret = -ENOMEM;
2126 }
2127 }
2128 }
2129 kfree(cache->filled_head);
Stefan Richterb12479d2005-11-21 17:32:18 -05002130 CSR1212_FREE(cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131
2132 if (ret >= 0) {
2133 /* we have to free the request, because we queue no response,
2134 * and therefore nobody will free it */
2135 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002136 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 } else {
2138 for (dentry =
2139 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2140 dentry; dentry = dentry->next) {
2141 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2142 root_kv,
2143 dentry->kv);
2144 }
2145 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2146 fi->csr1212_dirs[dr] = NULL;
2147 return ret;
2148 }
2149}
2150
2151static int state_connected(struct file_info *fi, struct pending_request *req)
2152{
2153 int node = req->req.address >> 48;
2154
2155 req->req.error = RAW1394_ERROR_NONE;
2156
2157 switch (req->req.type) {
2158
2159 case RAW1394_REQ_ECHO:
2160 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002161 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 case RAW1394_REQ_ARM_REGISTER:
2164 return arm_register(fi, req);
2165
2166 case RAW1394_REQ_ARM_UNREGISTER:
2167 return arm_unregister(fi, req);
2168
2169 case RAW1394_REQ_ARM_SET_BUF:
2170 return arm_set_buf(fi, req);
2171
2172 case RAW1394_REQ_ARM_GET_BUF:
2173 return arm_get_buf(fi, req);
2174
2175 case RAW1394_REQ_RESET_NOTIFY:
2176 return reset_notification(fi, req);
2177
Stefan Richter53c96b42007-06-24 15:31:54 +02002178 case RAW1394_REQ_ISO_SEND:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 case RAW1394_REQ_ISO_LISTEN:
Stefan Richter53c96b42007-06-24 15:31:54 +02002180 printk(KERN_DEBUG "raw1394: old iso ABI has been removed\n");
2181 req->req.error = RAW1394_ERROR_COMPAT;
2182 req->req.misc = RAW1394_KERNELAPI_VERSION;
2183 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002184 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
2186 case RAW1394_REQ_FCP_LISTEN:
2187 handle_fcp_listen(fi, req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002188 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
2190 case RAW1394_REQ_RESET_BUS:
2191 if (req->req.misc == RAW1394_LONG_RESET) {
2192 DBGMSG("busreset called (type: LONG)");
2193 hpsb_reset_bus(fi->host, LONG_RESET);
2194 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002195 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 }
2197 if (req->req.misc == RAW1394_SHORT_RESET) {
2198 DBGMSG("busreset called (type: SHORT)");
2199 hpsb_reset_bus(fi->host, SHORT_RESET);
2200 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002201 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 }
2203 /* error EINVAL (22) invalid argument */
2204 return (-EINVAL);
2205 case RAW1394_REQ_GET_ROM:
2206 return get_config_rom(fi, req);
2207
2208 case RAW1394_REQ_UPDATE_ROM:
2209 return update_config_rom(fi, req);
2210
2211 case RAW1394_REQ_MODIFY_ROM:
2212 return modify_config_rom(fi, req);
2213 }
2214
2215 if (req->req.generation != get_hpsb_generation(fi->host)) {
2216 req->req.error = RAW1394_ERROR_GENERATION;
2217 req->req.generation = get_hpsb_generation(fi->host);
2218 req->req.length = 0;
2219 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002220 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 }
2222
2223 switch (req->req.type) {
2224 case RAW1394_REQ_PHYPACKET:
2225 return write_phypacket(fi, req);
2226 case RAW1394_REQ_ASYNC_SEND:
2227 return handle_async_send(fi, req);
2228 }
2229
2230 if (req->req.length == 0) {
2231 req->req.error = RAW1394_ERROR_INVALID_ARG;
2232 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002233 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 }
2235
2236 return handle_async_request(fi, req, node);
2237}
2238
2239static ssize_t raw1394_write(struct file *file, const char __user * buffer,
2240 size_t count, loff_t * offset_is_ignored)
2241{
2242 struct file_info *fi = (struct file_info *)file->private_data;
2243 struct pending_request *req;
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002244 ssize_t retval = -EBADFD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245
Andi Kleen4bc32c42006-03-25 16:30:07 +01002246#ifdef CONFIG_COMPAT
Ben Collins75970282006-06-12 18:12:10 -04002247 if (count == sizeof(struct compat_raw1394_req) &&
2248 sizeof(struct compat_raw1394_req) !=
2249 sizeof(struct raw1394_request)) {
Andi Kleen4bc32c42006-03-25 16:30:07 +01002250 buffer = raw1394_compat_write(buffer);
2251 if (IS_ERR(buffer))
2252 return PTR_ERR(buffer);
2253 } else
2254#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 if (count != sizeof(struct raw1394_request)) {
2256 return -EINVAL;
2257 }
2258
2259 req = alloc_pending_request();
2260 if (req == NULL) {
2261 return -ENOMEM;
2262 }
2263 req->file_info = fi;
2264
2265 if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
2266 free_pending_request(req);
2267 return -EFAULT;
2268 }
2269
2270 switch (fi->state) {
2271 case opened:
2272 retval = state_opened(fi, req);
2273 break;
2274
2275 case initialized:
2276 retval = state_initialized(fi, req);
2277 break;
2278
2279 case connected:
2280 retval = state_connected(fi, req);
2281 break;
2282 }
2283
2284 if (retval < 0) {
2285 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002286 } else {
2287 BUG_ON(retval);
2288 retval = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 }
2290
2291 return retval;
2292}
2293
2294/* rawiso operations */
2295
2296/* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
2297 * completion queue (reqlists_lock must be taken) */
2298static inline int __rawiso_event_in_queue(struct file_info *fi)
2299{
2300 struct pending_request *req;
2301
2302 list_for_each_entry(req, &fi->req_complete, list)
2303 if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY)
2304 return 1;
2305
2306 return 0;
2307}
2308
2309/* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
2310static void queue_rawiso_event(struct file_info *fi)
2311{
2312 unsigned long flags;
2313
2314 spin_lock_irqsave(&fi->reqlists_lock, flags);
2315
2316 /* only one ISO activity event may be in the queue */
2317 if (!__rawiso_event_in_queue(fi)) {
2318 struct pending_request *req =
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08002319 __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320
2321 if (req) {
2322 req->file_info = fi;
2323 req->req.type = RAW1394_REQ_RAWISO_ACTIVITY;
2324 req->req.generation = get_hpsb_generation(fi->host);
2325 __queue_complete_req(req);
2326 } else {
2327 /* on allocation failure, signal an overflow */
2328 if (fi->iso_handle) {
2329 atomic_inc(&fi->iso_handle->overflows);
2330 }
2331 }
2332 }
2333 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2334}
2335
2336static void rawiso_activity_cb(struct hpsb_iso *iso)
2337{
2338 unsigned long flags;
2339 struct host_info *hi;
2340 struct file_info *fi;
2341
2342 spin_lock_irqsave(&host_info_lock, flags);
2343 hi = find_host_info(iso->host);
2344
2345 if (hi != NULL) {
2346 list_for_each_entry(fi, &hi->file_info_list, list) {
2347 if (fi->iso_handle == iso)
2348 queue_rawiso_event(fi);
2349 }
2350 }
2351
2352 spin_unlock_irqrestore(&host_info_lock, flags);
2353}
2354
2355/* helper function - gather all the kernel iso status bits for returning to user-space */
2356static void raw1394_iso_fill_status(struct hpsb_iso *iso,
2357 struct raw1394_iso_status *stat)
2358{
2359 stat->config.data_buf_size = iso->buf_size;
2360 stat->config.buf_packets = iso->buf_packets;
2361 stat->config.channel = iso->channel;
2362 stat->config.speed = iso->speed;
2363 stat->config.irq_interval = iso->irq_interval;
2364 stat->n_packets = hpsb_iso_n_ready(iso);
2365 stat->overflows = atomic_read(&iso->overflows);
2366 stat->xmit_cycle = iso->xmit_cycle;
2367}
2368
2369static int raw1394_iso_xmit_init(struct file_info *fi, void __user * uaddr)
2370{
2371 struct raw1394_iso_status stat;
2372
2373 if (!fi->host)
2374 return -EINVAL;
2375
2376 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2377 return -EFAULT;
2378
2379 fi->iso_handle = hpsb_iso_xmit_init(fi->host,
2380 stat.config.data_buf_size,
2381 stat.config.buf_packets,
2382 stat.config.channel,
2383 stat.config.speed,
2384 stat.config.irq_interval,
2385 rawiso_activity_cb);
2386 if (!fi->iso_handle)
2387 return -ENOMEM;
2388
2389 fi->iso_state = RAW1394_ISO_XMIT;
2390
2391 raw1394_iso_fill_status(fi->iso_handle, &stat);
2392 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2393 return -EFAULT;
2394
2395 /* queue an event to get things started */
2396 rawiso_activity_cb(fi->iso_handle);
2397
2398 return 0;
2399}
2400
2401static int raw1394_iso_recv_init(struct file_info *fi, void __user * uaddr)
2402{
2403 struct raw1394_iso_status stat;
2404
2405 if (!fi->host)
2406 return -EINVAL;
2407
2408 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2409 return -EFAULT;
2410
2411 fi->iso_handle = hpsb_iso_recv_init(fi->host,
2412 stat.config.data_buf_size,
2413 stat.config.buf_packets,
2414 stat.config.channel,
2415 stat.config.dma_mode,
2416 stat.config.irq_interval,
2417 rawiso_activity_cb);
2418 if (!fi->iso_handle)
2419 return -ENOMEM;
2420
2421 fi->iso_state = RAW1394_ISO_RECV;
2422
2423 raw1394_iso_fill_status(fi->iso_handle, &stat);
2424 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2425 return -EFAULT;
2426 return 0;
2427}
2428
2429static int raw1394_iso_get_status(struct file_info *fi, void __user * uaddr)
2430{
2431 struct raw1394_iso_status stat;
2432 struct hpsb_iso *iso = fi->iso_handle;
2433
2434 raw1394_iso_fill_status(fi->iso_handle, &stat);
2435 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2436 return -EFAULT;
2437
2438 /* reset overflow counter */
2439 atomic_set(&iso->overflows, 0);
2440
2441 return 0;
2442}
2443
2444/* copy N packet_infos out of the ringbuffer into user-supplied array */
2445static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr)
2446{
2447 struct raw1394_iso_packets upackets;
2448 unsigned int packet = fi->iso_handle->first_packet;
2449 int i;
2450
2451 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2452 return -EFAULT;
2453
2454 if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
2455 return -EINVAL;
2456
2457 /* ensure user-supplied buffer is accessible and big enough */
2458 if (!access_ok(VERIFY_WRITE, upackets.infos,
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002459 upackets.n_packets *
2460 sizeof(struct raw1394_iso_packet_info)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 return -EFAULT;
2462
2463 /* copy the packet_infos out */
2464 for (i = 0; i < upackets.n_packets; i++) {
2465 if (__copy_to_user(&upackets.infos[i],
2466 &fi->iso_handle->infos[packet],
2467 sizeof(struct raw1394_iso_packet_info)))
2468 return -EFAULT;
2469
2470 packet = (packet + 1) % fi->iso_handle->buf_packets;
2471 }
2472
2473 return 0;
2474}
2475
2476/* copy N packet_infos from user to ringbuffer, and queue them for transmission */
2477static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr)
2478{
2479 struct raw1394_iso_packets upackets;
2480 int i, rv;
2481
2482 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2483 return -EFAULT;
2484
Ben Collins1934b8b2005-07-09 20:01:23 -04002485 if (upackets.n_packets >= fi->iso_handle->buf_packets)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 return -EINVAL;
2487
Ben Collins1934b8b2005-07-09 20:01:23 -04002488 if (upackets.n_packets >= hpsb_iso_n_ready(fi->iso_handle))
2489 return -EAGAIN;
2490
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 /* ensure user-supplied buffer is accessible and big enough */
2492 if (!access_ok(VERIFY_READ, upackets.infos,
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002493 upackets.n_packets *
2494 sizeof(struct raw1394_iso_packet_info)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 return -EFAULT;
2496
2497 /* copy the infos structs in and queue the packets */
2498 for (i = 0; i < upackets.n_packets; i++) {
2499 struct raw1394_iso_packet_info info;
2500
2501 if (__copy_from_user(&info, &upackets.infos[i],
2502 sizeof(struct raw1394_iso_packet_info)))
2503 return -EFAULT;
2504
2505 rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset,
2506 info.len, info.tag, info.sy);
2507 if (rv)
2508 return rv;
2509 }
2510
2511 return 0;
2512}
2513
2514static void raw1394_iso_shutdown(struct file_info *fi)
2515{
2516 if (fi->iso_handle)
2517 hpsb_iso_shutdown(fi->iso_handle);
2518
2519 fi->iso_handle = NULL;
2520 fi->iso_state = RAW1394_ISO_INACTIVE;
2521}
2522
Pieter Palmers3dc5ea92007-02-03 17:44:39 +01002523static int raw1394_read_cycle_timer(struct file_info *fi, void __user * uaddr)
2524{
2525 struct raw1394_cycle_timer ct;
2526 int err;
2527
2528 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2529 if (!err)
2530 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2531 err = -EFAULT;
2532 return err;
2533}
2534
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535/* mmap the rawiso xmit/recv buffer */
2536static int raw1394_mmap(struct file *file, struct vm_area_struct *vma)
2537{
2538 struct file_info *fi = file->private_data;
2539
2540 if (fi->iso_state == RAW1394_ISO_INACTIVE)
2541 return -EINVAL;
2542
2543 return dma_region_mmap(&fi->iso_handle->data_buf, file, vma);
2544}
2545
2546/* ioctl is only used for rawiso operations */
2547static int raw1394_ioctl(struct inode *inode, struct file *file,
2548 unsigned int cmd, unsigned long arg)
2549{
2550 struct file_info *fi = file->private_data;
2551 void __user *argp = (void __user *)arg;
2552
2553 switch (fi->iso_state) {
2554 case RAW1394_ISO_INACTIVE:
2555 switch (cmd) {
2556 case RAW1394_IOC_ISO_XMIT_INIT:
2557 return raw1394_iso_xmit_init(fi, argp);
2558 case RAW1394_IOC_ISO_RECV_INIT:
2559 return raw1394_iso_recv_init(fi, argp);
2560 default:
2561 break;
2562 }
2563 break;
2564 case RAW1394_ISO_RECV:
2565 switch (cmd) {
2566 case RAW1394_IOC_ISO_RECV_START:{
2567 /* copy args from user-space */
2568 int args[3];
2569 if (copy_from_user
2570 (&args[0], argp, sizeof(args)))
2571 return -EFAULT;
2572 return hpsb_iso_recv_start(fi->iso_handle,
2573 args[0], args[1],
2574 args[2]);
2575 }
2576 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2577 hpsb_iso_stop(fi->iso_handle);
2578 return 0;
2579 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2580 return hpsb_iso_recv_listen_channel(fi->iso_handle,
2581 arg);
2582 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2583 return hpsb_iso_recv_unlisten_channel(fi->iso_handle,
2584 arg);
2585 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:{
2586 /* copy the u64 from user-space */
2587 u64 mask;
2588 if (copy_from_user(&mask, argp, sizeof(mask)))
2589 return -EFAULT;
2590 return hpsb_iso_recv_set_channel_mask(fi->
2591 iso_handle,
2592 mask);
2593 }
2594 case RAW1394_IOC_ISO_GET_STATUS:
2595 return raw1394_iso_get_status(fi, argp);
2596 case RAW1394_IOC_ISO_RECV_PACKETS:
2597 return raw1394_iso_recv_packets(fi, argp);
2598 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2599 return hpsb_iso_recv_release_packets(fi->iso_handle,
2600 arg);
2601 case RAW1394_IOC_ISO_RECV_FLUSH:
2602 return hpsb_iso_recv_flush(fi->iso_handle);
2603 case RAW1394_IOC_ISO_SHUTDOWN:
2604 raw1394_iso_shutdown(fi);
2605 return 0;
2606 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2607 queue_rawiso_event(fi);
2608 return 0;
2609 }
2610 break;
2611 case RAW1394_ISO_XMIT:
2612 switch (cmd) {
2613 case RAW1394_IOC_ISO_XMIT_START:{
2614 /* copy two ints from user-space */
2615 int args[2];
2616 if (copy_from_user
2617 (&args[0], argp, sizeof(args)))
2618 return -EFAULT;
2619 return hpsb_iso_xmit_start(fi->iso_handle,
2620 args[0], args[1]);
2621 }
2622 case RAW1394_IOC_ISO_XMIT_SYNC:
2623 return hpsb_iso_xmit_sync(fi->iso_handle);
2624 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2625 hpsb_iso_stop(fi->iso_handle);
2626 return 0;
2627 case RAW1394_IOC_ISO_GET_STATUS:
2628 return raw1394_iso_get_status(fi, argp);
2629 case RAW1394_IOC_ISO_XMIT_PACKETS:
2630 return raw1394_iso_send_packets(fi, argp);
2631 case RAW1394_IOC_ISO_SHUTDOWN:
2632 raw1394_iso_shutdown(fi);
2633 return 0;
2634 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2635 queue_rawiso_event(fi);
2636 return 0;
2637 }
2638 break;
2639 default:
2640 break;
2641 }
2642
Pieter Palmers3dc5ea92007-02-03 17:44:39 +01002643 /* state-independent commands */
2644 switch(cmd) {
2645 case RAW1394_IOC_GET_CYCLE_TIMER:
2646 return raw1394_read_cycle_timer(fi, argp);
2647 default:
2648 break;
2649 }
2650
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 return -EINVAL;
2652}
2653
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002654#ifdef CONFIG_COMPAT
2655struct raw1394_iso_packets32 {
2656 __u32 n_packets;
2657 compat_uptr_t infos;
2658} __attribute__((packed));
2659
2660struct raw1394_cycle_timer32 {
2661 __u32 cycle_timer;
2662 __u64 local_time;
Stefan Richter19f00e62007-05-21 18:52:06 +02002663}
2664#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
2665__attribute__((packed))
2666#endif
2667;
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002668
2669#define RAW1394_IOC_ISO_RECV_PACKETS32 \
2670 _IOW ('#', 0x25, struct raw1394_iso_packets32)
2671#define RAW1394_IOC_ISO_XMIT_PACKETS32 \
2672 _IOW ('#', 0x27, struct raw1394_iso_packets32)
2673#define RAW1394_IOC_GET_CYCLE_TIMER32 \
2674 _IOR ('#', 0x30, struct raw1394_cycle_timer32)
2675
2676static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd,
2677 struct raw1394_iso_packets32 __user *arg)
2678{
2679 compat_uptr_t infos32;
Al Viro5b26e642007-07-26 17:36:19 +01002680 void __user *infos;
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002681 long err = -EFAULT;
2682 struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets));
2683
2684 if (!copy_in_user(&dst->n_packets, &arg->n_packets, sizeof arg->n_packets) &&
2685 !copy_from_user(&infos32, &arg->infos, sizeof infos32)) {
2686 infos = compat_ptr(infos32);
2687 if (!copy_to_user(&dst->infos, &infos, sizeof infos))
2688 err = raw1394_ioctl(NULL, file, cmd, (unsigned long)dst);
2689 }
2690 return err;
2691}
2692
2693static long raw1394_read_cycle_timer32(struct file_info *fi, void __user * uaddr)
2694{
2695 struct raw1394_cycle_timer32 ct;
2696 int err;
2697
2698 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2699 if (!err)
2700 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2701 err = -EFAULT;
2702 return err;
2703}
2704
2705static long raw1394_compat_ioctl(struct file *file,
2706 unsigned int cmd, unsigned long arg)
2707{
2708 struct file_info *fi = file->private_data;
2709 void __user *argp = (void __user *)arg;
2710 long err;
2711
2712 lock_kernel();
2713 switch (cmd) {
2714 /* These requests have same format as long as 'int' has same size. */
2715 case RAW1394_IOC_ISO_RECV_INIT:
2716 case RAW1394_IOC_ISO_RECV_START:
2717 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2718 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2719 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:
2720 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2721 case RAW1394_IOC_ISO_RECV_FLUSH:
2722 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2723 case RAW1394_IOC_ISO_XMIT_INIT:
2724 case RAW1394_IOC_ISO_XMIT_START:
2725 case RAW1394_IOC_ISO_XMIT_SYNC:
2726 case RAW1394_IOC_ISO_GET_STATUS:
2727 case RAW1394_IOC_ISO_SHUTDOWN:
2728 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2729 err = raw1394_ioctl(NULL, file, cmd, arg);
2730 break;
2731 /* These request have different format. */
2732 case RAW1394_IOC_ISO_RECV_PACKETS32:
2733 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_RECV_PACKETS, argp);
2734 break;
2735 case RAW1394_IOC_ISO_XMIT_PACKETS32:
2736 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_XMIT_PACKETS, argp);
2737 break;
2738 case RAW1394_IOC_GET_CYCLE_TIMER32:
2739 err = raw1394_read_cycle_timer32(fi, argp);
2740 break;
2741 default:
2742 err = -EINVAL;
2743 break;
2744 }
2745 unlock_kernel();
2746
2747 return err;
2748}
2749#endif
2750
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751static unsigned int raw1394_poll(struct file *file, poll_table * pt)
2752{
2753 struct file_info *fi = file->private_data;
2754 unsigned int mask = POLLOUT | POLLWRNORM;
Andy Wingo4a9949d2005-10-19 21:23:46 -07002755 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756
Stefan Richter45289bf2006-07-03 12:02:33 -04002757 poll_wait(file, &fi->wait_complete, pt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758
Andy Wingo4a9949d2005-10-19 21:23:46 -07002759 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 if (!list_empty(&fi->req_complete)) {
2761 mask |= POLLIN | POLLRDNORM;
2762 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07002763 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764
2765 return mask;
2766}
2767
2768static int raw1394_open(struct inode *inode, struct file *file)
2769{
2770 struct file_info *fi;
2771
Christoph Lametere94b1762006-12-06 20:33:17 -08002772 fi = kzalloc(sizeof(*fi), GFP_KERNEL);
Stefan Richter85511582005-11-07 06:31:45 -05002773 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 return -ENOMEM;
2775
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */
2777
2778 INIT_LIST_HEAD(&fi->list);
2779 fi->state = opened;
2780 INIT_LIST_HEAD(&fi->req_pending);
2781 INIT_LIST_HEAD(&fi->req_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 spin_lock_init(&fi->reqlists_lock);
Stefan Richter45289bf2006-07-03 12:02:33 -04002783 init_waitqueue_head(&fi->wait_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002784 INIT_LIST_HEAD(&fi->addr_list);
2785
2786 file->private_data = fi;
2787
2788 return 0;
2789}
2790
2791static int raw1394_release(struct inode *inode, struct file *file)
2792{
2793 struct file_info *fi = file->private_data;
2794 struct list_head *lh;
2795 struct pending_request *req;
Stefan Richter45289bf2006-07-03 12:02:33 -04002796 int i, fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 int retval = 0;
2798 struct list_head *entry;
2799 struct arm_addr *addr = NULL;
2800 struct host_info *hi;
2801 struct file_info *fi_hlp = NULL;
2802 struct arm_addr *arm_addr = NULL;
2803 int another_host;
2804 int csr_mod = 0;
Andy Wingo4a9949d2005-10-19 21:23:46 -07002805 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806
2807 if (fi->iso_state != RAW1394_ISO_INACTIVE)
2808 raw1394_iso_shutdown(fi);
2809
Andy Wingo4a9949d2005-10-19 21:23:46 -07002810 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811
2812 fail = 0;
2813 /* set address-entries invalid */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814
2815 while (!list_empty(&fi->addr_list)) {
2816 another_host = 0;
2817 lh = fi->addr_list.next;
2818 addr = list_entry(lh, struct arm_addr, addr_list);
2819 /* another host with valid address-entry containing
2820 same addressrange? */
2821 list_for_each_entry(hi, &host_info_list, list) {
2822 if (hi->host != fi->host) {
2823 list_for_each_entry(fi_hlp, &hi->file_info_list,
2824 list) {
2825 entry = fi_hlp->addr_list.next;
2826 while (entry != &(fi_hlp->addr_list)) {
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002827 arm_addr = list_entry(entry, struct
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 arm_addr,
2829 addr_list);
2830 if (arm_addr->start ==
2831 addr->start) {
2832 DBGMSG
2833 ("raw1394_release: "
2834 "another host ownes "
2835 "same addressrange");
2836 another_host = 1;
2837 break;
2838 }
2839 entry = entry->next;
2840 }
2841 if (another_host) {
2842 break;
2843 }
2844 }
2845 }
2846 }
2847 if (!another_host) {
2848 DBGMSG("raw1394_release: call hpsb_arm_unregister");
2849 retval =
2850 hpsb_unregister_addrspace(&raw1394_highlevel,
2851 fi->host, addr->start);
2852 if (!retval) {
2853 ++fail;
2854 printk(KERN_ERR
2855 "raw1394_release arm_Unregister failed\n");
2856 }
2857 }
2858 DBGMSG("raw1394_release: delete addr_entry from list");
2859 list_del(&addr->addr_list);
2860 vfree(addr->addr_space_buffer);
2861 kfree(addr);
2862 } /* while */
Andy Wingo4a9949d2005-10-19 21:23:46 -07002863 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 if (fail > 0) {
2865 printk(KERN_ERR "raw1394: during addr_list-release "
2866 "error(s) occurred \n");
2867 }
2868
Stefan Richter45289bf2006-07-03 12:02:33 -04002869 for (;;) {
2870 /* This locked section guarantees that neither
2871 * complete nor pending requests exist once i!=0 */
Andy Wingo4a9949d2005-10-19 21:23:46 -07002872 spin_lock_irqsave(&fi->reqlists_lock, flags);
Stefan Richter45289bf2006-07-03 12:02:33 -04002873 while ((req = __next_complete_req(fi)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 free_pending_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875
Stefan Richter45289bf2006-07-03 12:02:33 -04002876 i = list_empty(&fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -07002877 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878
Stefan Richter45289bf2006-07-03 12:02:33 -04002879 if (i)
2880 break;
2881 /*
2882 * Sleep until more requests can be freed.
2883 *
2884 * NB: We call the macro wait_event() with a condition argument
2885 * with side effect. This is only possible because the side
2886 * effect does not occur until the condition became true, and
2887 * wait_event() won't evaluate the condition again after that.
2888 */
2889 wait_event(fi->wait_complete, (req = next_complete_req(fi)));
2890 free_pending_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891 }
2892
2893 /* Remove any sub-trees left by user space programs */
2894 for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) {
2895 struct csr1212_dentry *dentry;
2896 if (!fi->csr1212_dirs[i])
2897 continue;
2898 for (dentry =
2899 fi->csr1212_dirs[i]->value.directory.dentries_head; dentry;
2900 dentry = dentry->next) {
2901 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2902 root_kv,
2903 dentry->kv);
2904 }
2905 csr1212_release_keyval(fi->csr1212_dirs[i]);
2906 fi->csr1212_dirs[i] = NULL;
2907 csr_mod = 1;
2908 }
2909
2910 if ((csr_mod || fi->cfgrom_upd)
2911 && hpsb_update_config_rom_image(fi->host) < 0)
2912 HPSB_ERR
2913 ("Failed to generate Configuration ROM image for host %d",
2914 fi->host->id);
2915
2916 if (fi->state == connected) {
Andy Wingo4a9949d2005-10-19 21:23:46 -07002917 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 list_del(&fi->list);
Andy Wingo4a9949d2005-10-19 21:23:46 -07002919 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920
2921 put_device(&fi->host->device);
2922 }
2923
Stefan Richter0fe4c6f2007-02-03 16:48:51 +01002924 spin_lock_irqsave(&host_info_lock, flags);
2925 if (fi->host)
2926 module_put(fi->host->driver->owner);
2927 spin_unlock_irqrestore(&host_info_lock, flags);
2928
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 kfree(fi);
2930
2931 return 0;
2932}
2933
2934/*** HOTPLUG STUFF **********************************************************/
2935/*
2936 * Export information about protocols/devices supported by this driver.
2937 */
2938static struct ieee1394_device_id raw1394_id_table[] = {
2939 {
2940 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2941 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
2942 .version = AVC_SW_VERSION_ENTRY & 0xffffff},
2943 {
2944 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2945 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2946 .version = CAMERA_SW_VERSION_ENTRY & 0xffffff},
2947 {
2948 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2949 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2950 .version = (CAMERA_SW_VERSION_ENTRY + 1) & 0xffffff},
2951 {
2952 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2953 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2954 .version = (CAMERA_SW_VERSION_ENTRY + 2) & 0xffffff},
2955 {}
2956};
2957
2958MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table);
2959
2960static struct hpsb_protocol_driver raw1394_driver = {
Ben Collinsed30c262006-11-23 13:59:48 -05002961 .name = "raw1394",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962 .id_table = raw1394_id_table,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963};
2964
2965/******************************************************************************/
2966
2967static struct hpsb_highlevel raw1394_highlevel = {
2968 .name = RAW1394_DEVICE_NAME,
2969 .add_host = add_host,
2970 .remove_host = remove_host,
2971 .host_reset = host_reset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 .fcp_request = fcp_request,
2973};
2974
2975static struct cdev raw1394_cdev;
Arjan van de Ven2b8693c2007-02-12 00:55:32 -08002976static const struct file_operations raw1394_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 .owner = THIS_MODULE,
2978 .read = raw1394_read,
2979 .write = raw1394_write,
2980 .mmap = raw1394_mmap,
2981 .ioctl = raw1394_ioctl,
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002982#ifdef CONFIG_COMPAT
2983 .compat_ioctl = raw1394_compat_ioctl,
2984#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 .poll = raw1394_poll,
2986 .open = raw1394_open,
2987 .release = raw1394_release,
2988};
2989
2990static int __init init_raw1394(void)
2991{
2992 int ret = 0;
2993
2994 hpsb_register_highlevel(&raw1394_highlevel);
2995
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002996 if (IS_ERR
Kay Sieversdd7f2922007-05-25 11:50:53 +02002997 (device_create(
2998 hpsb_protocol_class, NULL,
2999 MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16),
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003000 RAW1394_DEVICE_NAME))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 ret = -EFAULT;
3002 goto out_unreg;
3003 }
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003004
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 cdev_init(&raw1394_cdev, &raw1394_fops);
3006 raw1394_cdev.owner = THIS_MODULE;
3007 kobject_set_name(&raw1394_cdev.kobj, RAW1394_DEVICE_NAME);
3008 ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1);
3009 if (ret) {
3010 HPSB_ERR("raw1394 failed to register minor device block");
3011 goto out_dev;
3012 }
3013
3014 HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME);
3015
3016 ret = hpsb_register_protocol(&raw1394_driver);
3017 if (ret) {
3018 HPSB_ERR("raw1394: failed to register protocol");
3019 cdev_del(&raw1394_cdev);
3020 goto out_dev;
3021 }
3022
3023 goto out;
3024
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003025 out_dev:
Kay Sieversdd7f2922007-05-25 11:50:53 +02003026 device_destroy(hpsb_protocol_class,
3027 MKDEV(IEEE1394_MAJOR,
3028 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003029 out_unreg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 hpsb_unregister_highlevel(&raw1394_highlevel);
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003031 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 return ret;
3033}
3034
3035static void __exit cleanup_raw1394(void)
3036{
Kay Sieversdd7f2922007-05-25 11:50:53 +02003037 device_destroy(hpsb_protocol_class,
3038 MKDEV(IEEE1394_MAJOR,
3039 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 cdev_del(&raw1394_cdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041 hpsb_unregister_highlevel(&raw1394_highlevel);
3042 hpsb_unregister_protocol(&raw1394_driver);
3043}
3044
3045module_init(init_raw1394);
3046module_exit(cleanup_raw1394);
3047MODULE_LICENSE("GPL");