blob: da5f8829b503d1047c7cb36126033c036ad630ca [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>
Stefan Richter10963ea2008-08-16 00:11:48 +020037#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/interrupt.h>
40#include <linux/vmalloc.h>
41#include <linux/cdev.h>
42#include <asm/uaccess.h>
43#include <asm/atomic.h>
Andi Kleen4bc32c42006-03-25 16:30:07 +010044#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include "csr1212.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "highlevel.h"
Stefan Richterde4394f2006-07-03 12:02:29 -040048#include "hosts.h"
49#include "ieee1394.h"
50#include "ieee1394_core.h"
51#include "ieee1394_hotplug.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include "ieee1394_transactions.h"
Stefan Richterde4394f2006-07-03 12:02:29 -040053#include "ieee1394_types.h"
54#include "iso.h"
55#include "nodemgr.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include "raw1394.h"
57#include "raw1394-private.h"
58
59#define int2ptr(x) ((void __user *)(unsigned long)x)
60#define ptr2int(x) ((u64)(unsigned long)(void __user *)x)
61
62#ifdef CONFIG_IEEE1394_VERBOSEDEBUG
63#define RAW1394_DEBUG
64#endif
65
66#ifdef RAW1394_DEBUG
67#define DBGMSG(fmt, args...) \
68printk(KERN_INFO "raw1394:" fmt "\n" , ## args)
69#else
Stefan Richter611aa192006-08-02 18:44:00 +020070#define DBGMSG(fmt, args...) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#endif
72
73static LIST_HEAD(host_info_list);
74static int host_count;
75static DEFINE_SPINLOCK(host_info_lock);
76static atomic_t internal_generation = ATOMIC_INIT(0);
77
78static atomic_t iso_buffer_size;
79static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
80
81static struct hpsb_highlevel raw1394_highlevel;
82
83static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
84 u64 addr, size_t length, u16 flags);
85static int arm_write(struct hpsb_host *host, int nodeid, int destid,
86 quadlet_t * data, u64 addr, size_t length, u16 flags);
87static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
88 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
89 u16 flags);
90static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
91 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
92 u16 flags);
Tobias Klauser1c4fb572009-02-09 22:05:06 +010093static const struct hpsb_address_ops arm_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 .read = arm_read,
95 .write = arm_write,
96 .lock = arm_lock,
97 .lock64 = arm_lock64,
98};
99
100static void queue_complete_cb(struct pending_request *req);
101
Al Virodd0fc662005-10-07 07:46:04 +0100102static struct pending_request *__alloc_pending_request(gfp_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103{
104 struct pending_request *req;
105
Stefan Richter85511582005-11-07 06:31:45 -0500106 req = kzalloc(sizeof(*req), flags);
107 if (req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 INIT_LIST_HEAD(&req->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110 return req;
111}
112
113static inline struct pending_request *alloc_pending_request(void)
114{
Christoph Lametere94b1762006-12-06 20:33:17 -0800115 return __alloc_pending_request(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
118static void free_pending_request(struct pending_request *req)
119{
120 if (req->ibs) {
121 if (atomic_dec_and_test(&req->ibs->refcount)) {
122 atomic_sub(req->ibs->data_size, &iso_buffer_size);
123 kfree(req->ibs);
124 }
125 } else if (req->free_data) {
126 kfree(req->data);
127 }
128 hpsb_free_packet(req->packet);
129 kfree(req);
130}
131
132/* fi->reqlists_lock must be taken */
133static void __queue_complete_req(struct pending_request *req)
134{
135 struct file_info *fi = req->file_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Stefan Richter45289bf2006-07-03 12:02:33 -0400137 list_move_tail(&req->list, &fi->req_complete);
138 wake_up(&fi->wait_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
141static void queue_complete_req(struct pending_request *req)
142{
143 unsigned long flags;
144 struct file_info *fi = req->file_info;
145
146 spin_lock_irqsave(&fi->reqlists_lock, flags);
147 __queue_complete_req(req);
148 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
149}
150
151static void queue_complete_cb(struct pending_request *req)
152{
153 struct hpsb_packet *packet = req->packet;
154 int rcode = (packet->header[1] >> 12) & 0xf;
155
156 switch (packet->ack_code) {
157 case ACKX_NONE:
158 case ACKX_SEND_ERROR:
159 req->req.error = RAW1394_ERROR_SEND_ERROR;
160 break;
161 case ACKX_ABORTED:
162 req->req.error = RAW1394_ERROR_ABORTED;
163 break;
164 case ACKX_TIMEOUT:
165 req->req.error = RAW1394_ERROR_TIMEOUT;
166 break;
167 default:
168 req->req.error = (packet->ack_code << 16) | rcode;
169 break;
170 }
171
172 if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
173 req->req.length = 0;
174 }
175
176 if ((req->req.type == RAW1394_REQ_ASYNC_READ) ||
177 (req->req.type == RAW1394_REQ_ASYNC_WRITE) ||
178 (req->req.type == RAW1394_REQ_ASYNC_STREAM) ||
179 (req->req.type == RAW1394_REQ_LOCK) ||
180 (req->req.type == RAW1394_REQ_LOCK64))
181 hpsb_free_tlabel(packet);
182
183 queue_complete_req(req);
184}
185
186static void add_host(struct hpsb_host *host)
187{
188 struct host_info *hi;
189 unsigned long flags;
190
Stefan Richter85511582005-11-07 06:31:45 -0500191 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Stefan Richter85511582005-11-07 06:31:45 -0500193 if (hi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 INIT_LIST_HEAD(&hi->list);
195 hi->host = host;
196 INIT_LIST_HEAD(&hi->file_info_list);
197
198 spin_lock_irqsave(&host_info_lock, flags);
199 list_add_tail(&hi->list, &host_info_list);
200 host_count++;
201 spin_unlock_irqrestore(&host_info_lock, flags);
202 }
203
204 atomic_inc(&internal_generation);
205}
206
207static struct host_info *find_host_info(struct hpsb_host *host)
208{
209 struct host_info *hi;
210
211 list_for_each_entry(hi, &host_info_list, list)
212 if (hi->host == host)
213 return hi;
214
215 return NULL;
216}
217
218static void remove_host(struct hpsb_host *host)
219{
220 struct host_info *hi;
221 unsigned long flags;
222
223 spin_lock_irqsave(&host_info_lock, flags);
224 hi = find_host_info(host);
225
226 if (hi != NULL) {
227 list_del(&hi->list);
228 host_count--;
229 /*
230 FIXME: address ranges should be removed
231 and fileinfo states should be initialized
232 (including setting generation to
233 internal-generation ...)
234 */
235 }
236 spin_unlock_irqrestore(&host_info_lock, flags);
237
238 if (hi == NULL) {
239 printk(KERN_ERR "raw1394: attempt to remove unknown host "
240 "0x%p\n", host);
241 return;
242 }
243
244 kfree(hi);
245
246 atomic_inc(&internal_generation);
247}
248
249static void host_reset(struct hpsb_host *host)
250{
251 unsigned long flags;
252 struct host_info *hi;
253 struct file_info *fi;
254 struct pending_request *req;
255
256 spin_lock_irqsave(&host_info_lock, flags);
257 hi = find_host_info(host);
258
259 if (hi != NULL) {
260 list_for_each_entry(fi, &hi->file_info_list, list) {
261 if (fi->notification == RAW1394_NOTIFY_ON) {
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800262 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 if (req != NULL) {
265 req->file_info = fi;
266 req->req.type = RAW1394_REQ_BUS_RESET;
267 req->req.generation =
268 get_hpsb_generation(host);
269 req->req.misc = (host->node_id << 16)
270 | host->node_count;
271 if (fi->protocol_version > 3) {
272 req->req.misc |=
273 (NODEID_TO_NODE
274 (host->irm_id)
275 << 8);
276 }
277
278 queue_complete_req(req);
279 }
280 }
281 }
282 }
283 spin_unlock_irqrestore(&host_info_lock, flags);
284}
285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
287 int cts, u8 * data, size_t length)
288{
289 unsigned long flags;
290 struct host_info *hi;
291 struct file_info *fi;
292 struct pending_request *req, *req_next;
293 struct iso_block_store *ibs = NULL;
294 LIST_HEAD(reqs);
295
296 if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
297 HPSB_INFO("dropped fcp request");
298 return;
299 }
300
301 spin_lock_irqsave(&host_info_lock, flags);
302 hi = find_host_info(host);
303
304 if (hi != NULL) {
305 list_for_each_entry(fi, &hi->file_info_list, list) {
306 if (!fi->fcp_buffer)
307 continue;
308
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800309 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 if (!req)
311 break;
312
313 if (!ibs) {
Stefan Richter85511582005-11-07 06:31:45 -0500314 ibs = kmalloc(sizeof(*ibs) + length,
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800315 GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 if (!ibs) {
317 kfree(req);
318 break;
319 }
320
321 atomic_add(length, &iso_buffer_size);
322 atomic_set(&ibs->refcount, 0);
323 ibs->data_size = length;
324 memcpy(ibs->data, data, length);
325 }
326
327 atomic_inc(&ibs->refcount);
328
329 req->file_info = fi;
330 req->ibs = ibs;
331 req->data = ibs->data;
332 req->req.type = RAW1394_REQ_FCP_REQUEST;
333 req->req.generation = get_hpsb_generation(host);
334 req->req.misc = nodeid | (direction << 16);
335 req->req.recvb = ptr2int(fi->fcp_buffer);
336 req->req.length = length;
337
338 list_add_tail(&req->list, &reqs);
339 }
340 }
341 spin_unlock_irqrestore(&host_info_lock, flags);
342
343 list_for_each_entry_safe(req, req_next, &reqs, list)
344 queue_complete_req(req);
345}
346
Andi Kleen4bc32c42006-03-25 16:30:07 +0100347#ifdef CONFIG_COMPAT
348struct compat_raw1394_req {
Ben Collins75970282006-06-12 18:12:10 -0400349 __u32 type;
350 __s32 error;
351 __u32 misc;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100352
Ben Collins75970282006-06-12 18:12:10 -0400353 __u32 generation;
354 __u32 length;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100355
Ben Collins75970282006-06-12 18:12:10 -0400356 __u64 address;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100357
Ben Collins75970282006-06-12 18:12:10 -0400358 __u64 tag;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100359
Ben Collins75970282006-06-12 18:12:10 -0400360 __u64 sendb;
361 __u64 recvb;
Stefan Richter59337082007-07-04 23:13:53 +0200362}
363#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
364__attribute__((packed))
365#endif
366;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100367
368static const char __user *raw1394_compat_write(const char __user *buf)
369{
Ben Collins75970282006-06-12 18:12:10 -0400370 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
Andi Kleen4bc32c42006-03-25 16:30:07 +0100371 struct raw1394_request __user *r;
Stefan Richter42169682009-02-15 22:49:24 +0100372
Andi Kleen4bc32c42006-03-25 16:30:07 +0100373 r = compat_alloc_user_space(sizeof(struct raw1394_request));
374
375#define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x))
376
377 if (copy_in_user(r, cr, sizeof(struct compat_raw1394_req)) ||
Ben Collins75970282006-06-12 18:12:10 -0400378 C(address) ||
379 C(tag) ||
380 C(sendb) ||
381 C(recvb))
Stefan Richter42169682009-02-15 22:49:24 +0100382 return (__force const char __user *)ERR_PTR(-EFAULT);
383
Andi Kleen4bc32c42006-03-25 16:30:07 +0100384 return (const char __user *)r;
385}
386#undef C
387
388#define P(x) __put_user(r->x, &cr->x)
389
Ben Collins75970282006-06-12 18:12:10 -0400390static int
Andi Kleen4bc32c42006-03-25 16:30:07 +0100391raw1394_compat_read(const char __user *buf, struct raw1394_request *r)
392{
Petr Vandrovecee9be422007-05-07 04:14:47 +0200393 struct compat_raw1394_req __user *cr = (typeof(cr)) buf;
Stefan Richter42169682009-02-15 22:49:24 +0100394
Ben Collins75970282006-06-12 18:12:10 -0400395 if (!access_ok(VERIFY_WRITE, cr, sizeof(struct compat_raw1394_req)) ||
Andi Kleen4bc32c42006-03-25 16:30:07 +0100396 P(type) ||
397 P(error) ||
398 P(misc) ||
399 P(generation) ||
400 P(length) ||
401 P(address) ||
402 P(tag) ||
403 P(sendb) ||
404 P(recvb))
405 return -EFAULT;
Stefan Richter42169682009-02-15 22:49:24 +0100406
Andi Kleen4bc32c42006-03-25 16:30:07 +0100407 return sizeof(struct compat_raw1394_req);
408}
409#undef P
410
411#endif
412
Stefan Richter45289bf2006-07-03 12:02:33 -0400413/* get next completed request (caller must hold fi->reqlists_lock) */
414static inline struct pending_request *__next_complete_req(struct file_info *fi)
415{
416 struct list_head *lh;
417 struct pending_request *req = NULL;
418
419 if (!list_empty(&fi->req_complete)) {
420 lh = fi->req_complete.next;
421 list_del(lh);
422 req = list_entry(lh, struct pending_request, list);
423 }
424 return req;
425}
426
427/* atomically get next completed request */
428static struct pending_request *next_complete_req(struct file_info *fi)
429{
430 unsigned long flags;
431 struct pending_request *req;
432
433 spin_lock_irqsave(&fi->reqlists_lock, flags);
434 req = __next_complete_req(fi);
435 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
436 return req;
437}
Andi Kleen4bc32c42006-03-25 16:30:07 +0100438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439static ssize_t raw1394_read(struct file *file, char __user * buffer,
440 size_t count, loff_t * offset_is_ignored)
441{
442 struct file_info *fi = (struct file_info *)file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 struct pending_request *req;
444 ssize_t ret;
445
Andi Kleen4bc32c42006-03-25 16:30:07 +0100446#ifdef CONFIG_COMPAT
447 if (count == sizeof(struct compat_raw1394_req)) {
448 /* ok */
449 } else
450#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (count != sizeof(struct raw1394_request)) {
452 return -EINVAL;
453 }
454
455 if (!access_ok(VERIFY_WRITE, buffer, count)) {
456 return -EFAULT;
457 }
458
459 if (file->f_flags & O_NONBLOCK) {
Stefan Richter45289bf2006-07-03 12:02:33 -0400460 if (!(req = next_complete_req(fi)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 } else {
Stefan Richter45289bf2006-07-03 12:02:33 -0400463 /*
464 * NB: We call the macro wait_event_interruptible() with a
465 * condition argument with side effect. This is only possible
466 * because the side effect does not occur until the condition
467 * became true, and wait_event_interruptible() won't evaluate
468 * the condition again after that.
469 */
470 if (wait_event_interruptible(fi->wait_complete,
471 (req = next_complete_req(fi))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 }
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 if (req->req.length) {
476 if (copy_to_user(int2ptr(req->req.recvb), req->data,
477 req->req.length)) {
478 req->req.error = RAW1394_ERROR_MEMFAULT;
479 }
480 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Andi Kleen4bc32c42006-03-25 16:30:07 +0100482#ifdef CONFIG_COMPAT
Ben Collins75970282006-06-12 18:12:10 -0400483 if (count == sizeof(struct compat_raw1394_req) &&
484 sizeof(struct compat_raw1394_req) !=
485 sizeof(struct raw1394_request)) {
Andi Kleen4bc32c42006-03-25 16:30:07 +0100486 ret = raw1394_compat_read(buffer, &req->req);
Ben Collins75970282006-06-12 18:12:10 -0400487 } else
Andi Kleen4bc32c42006-03-25 16:30:07 +0100488#endif
489 {
490 if (copy_to_user(buffer, &req->req, sizeof(req->req))) {
491 ret = -EFAULT;
492 goto out;
Ben Collins75970282006-06-12 18:12:10 -0400493 }
Andi Kleen4bc32c42006-03-25 16:30:07 +0100494 ret = (ssize_t) sizeof(struct raw1394_request);
495 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 out:
497 free_pending_request(req);
498 return ret;
499}
500
501static int state_opened(struct file_info *fi, struct pending_request *req)
502{
503 if (req->req.type == RAW1394_REQ_INITIALIZE) {
504 switch (req->req.misc) {
505 case RAW1394_KERNELAPI_VERSION:
506 case 3:
507 fi->state = initialized;
508 fi->protocol_version = req->req.misc;
509 req->req.error = RAW1394_ERROR_NONE;
510 req->req.generation = atomic_read(&internal_generation);
511 break;
512
513 default:
514 req->req.error = RAW1394_ERROR_COMPAT;
515 req->req.misc = RAW1394_KERNELAPI_VERSION;
516 }
517 } else {
518 req->req.error = RAW1394_ERROR_STATE_ORDER;
519 }
520
521 req->req.length = 0;
522 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200523 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
526static int state_initialized(struct file_info *fi, struct pending_request *req)
527{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700528 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 struct host_info *hi;
530 struct raw1394_khost_list *khl;
531
532 if (req->req.generation != atomic_read(&internal_generation)) {
533 req->req.error = RAW1394_ERROR_GENERATION;
534 req->req.generation = atomic_read(&internal_generation);
535 req->req.length = 0;
536 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200537 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 }
539
540 switch (req->req.type) {
541 case RAW1394_REQ_LIST_CARDS:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700542 spin_lock_irqsave(&host_info_lock, flags);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800543 khl = kmalloc(sizeof(*khl) * host_count, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Stefan Richter85511582005-11-07 06:31:45 -0500545 if (khl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 req->req.misc = host_count;
547 req->data = (quadlet_t *) khl;
548
549 list_for_each_entry(hi, &host_info_list, list) {
550 khl->nodes = hi->host->node_count;
551 strcpy(khl->name, hi->host->driver->name);
552 khl++;
553 }
554 }
Andy Wingo4a9949d2005-10-19 21:23:46 -0700555 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Stefan Richter85511582005-11-07 06:31:45 -0500557 if (khl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 req->req.error = RAW1394_ERROR_NONE;
559 req->req.length = min(req->req.length,
560 (u32) (sizeof
561 (struct raw1394_khost_list)
562 * req->req.misc));
563 req->free_data = 1;
564 } else {
565 return -ENOMEM;
566 }
567 break;
568
569 case RAW1394_REQ_SET_CARD:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700570 spin_lock_irqsave(&host_info_lock, flags);
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100571 if (req->req.misc >= host_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 req->req.error = RAW1394_ERROR_INVALID_ARG;
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100573 goto out_set_card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 }
Stefan Richter0fe4c6f2007-02-03 16:48:51 +0100575 list_for_each_entry(hi, &host_info_list, list)
576 if (!req->req.misc--)
577 break;
578 get_device(&hi->host->device); /* FIXME handle failure case */
579 list_add_tail(&fi->list, &hi->file_info_list);
580
581 /* prevent unloading of the host's low-level driver */
582 if (!try_module_get(hi->host->driver->owner)) {
583 req->req.error = RAW1394_ERROR_ABORTED;
584 goto out_set_card;
585 }
586 WARN_ON(fi->host);
587 fi->host = hi->host;
588 fi->state = connected;
589
590 req->req.error = RAW1394_ERROR_NONE;
591 req->req.generation = get_hpsb_generation(fi->host);
592 req->req.misc = (fi->host->node_id << 16)
593 | fi->host->node_count;
594 if (fi->protocol_version > 3)
595 req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8;
596out_set_card:
Andy Wingo4a9949d2005-10-19 21:23:46 -0700597 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 req->req.length = 0;
600 break;
601
602 default:
603 req->req.error = RAW1394_ERROR_STATE_ORDER;
604 req->req.length = 0;
605 break;
606 }
607
608 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200609 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610}
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
613{
614 if (req->req.misc) {
615 if (fi->fcp_buffer) {
616 req->req.error = RAW1394_ERROR_ALREADY;
617 } else {
618 fi->fcp_buffer = int2ptr(req->req.recvb);
619 }
620 } else {
621 if (!fi->fcp_buffer) {
622 req->req.error = RAW1394_ERROR_ALREADY;
623 } else {
624 fi->fcp_buffer = NULL;
625 }
626 }
627
628 req->req.length = 0;
629 queue_complete_req(req);
630}
631
632static int handle_async_request(struct file_info *fi,
633 struct pending_request *req, int node)
634{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700635 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 struct hpsb_packet *packet = NULL;
637 u64 addr = req->req.address & 0xffffffffffffULL;
638
639 switch (req->req.type) {
640 case RAW1394_REQ_ASYNC_READ:
641 DBGMSG("read_request called");
642 packet =
643 hpsb_make_readpacket(fi->host, node, addr, req->req.length);
644
645 if (!packet)
646 return -ENOMEM;
647
648 if (req->req.length == 4)
649 req->data = &packet->header[3];
650 else
651 req->data = packet->data;
652
653 break;
654
655 case RAW1394_REQ_ASYNC_WRITE:
656 DBGMSG("write_request called");
657
658 packet = hpsb_make_writepacket(fi->host, node, addr, NULL,
659 req->req.length);
660 if (!packet)
661 return -ENOMEM;
662
663 if (req->req.length == 4) {
664 if (copy_from_user
665 (&packet->header[3], int2ptr(req->req.sendb),
666 req->req.length))
667 req->req.error = RAW1394_ERROR_MEMFAULT;
668 } else {
669 if (copy_from_user
670 (packet->data, int2ptr(req->req.sendb),
671 req->req.length))
672 req->req.error = RAW1394_ERROR_MEMFAULT;
673 }
674
675 req->req.length = 0;
676 break;
677
678 case RAW1394_REQ_ASYNC_STREAM:
679 DBGMSG("stream_request called");
680
681 packet =
682 hpsb_make_streampacket(fi->host, NULL, req->req.length,
683 node & 0x3f /*channel */ ,
684 (req->req.misc >> 16) & 0x3,
685 req->req.misc & 0xf);
686 if (!packet)
687 return -ENOMEM;
688
689 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
690 req->req.length))
691 req->req.error = RAW1394_ERROR_MEMFAULT;
692
693 req->req.length = 0;
694 break;
695
696 case RAW1394_REQ_LOCK:
697 DBGMSG("lock_request called");
698 if ((req->req.misc == EXTCODE_FETCH_ADD)
699 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
700 if (req->req.length != 4) {
701 req->req.error = RAW1394_ERROR_INVALID_ARG;
702 break;
703 }
704 } else {
705 if (req->req.length != 8) {
706 req->req.error = RAW1394_ERROR_INVALID_ARG;
707 break;
708 }
709 }
710
711 packet = hpsb_make_lockpacket(fi->host, node, addr,
712 req->req.misc, NULL, 0);
713 if (!packet)
714 return -ENOMEM;
715
716 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
717 req->req.length)) {
718 req->req.error = RAW1394_ERROR_MEMFAULT;
719 break;
720 }
721
722 req->data = packet->data;
723 req->req.length = 4;
724 break;
725
726 case RAW1394_REQ_LOCK64:
727 DBGMSG("lock64_request called");
728 if ((req->req.misc == EXTCODE_FETCH_ADD)
729 || (req->req.misc == EXTCODE_LITTLE_ADD)) {
730 if (req->req.length != 8) {
731 req->req.error = RAW1394_ERROR_INVALID_ARG;
732 break;
733 }
734 } else {
735 if (req->req.length != 16) {
736 req->req.error = RAW1394_ERROR_INVALID_ARG;
737 break;
738 }
739 }
740 packet = hpsb_make_lock64packet(fi->host, node, addr,
741 req->req.misc, NULL, 0);
742 if (!packet)
743 return -ENOMEM;
744
745 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
746 req->req.length)) {
747 req->req.error = RAW1394_ERROR_MEMFAULT;
748 break;
749 }
750
751 req->data = packet->data;
752 req->req.length = 8;
753 break;
754
755 default:
756 req->req.error = RAW1394_ERROR_STATE_ORDER;
757 }
758
759 req->packet = packet;
760
761 if (req->req.error) {
762 req->req.length = 0;
763 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200764 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
766
767 hpsb_set_packet_complete_task(packet,
768 (void (*)(void *))queue_complete_cb, req);
769
Andy Wingo4a9949d2005-10-19 21:23:46 -0700770 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700772 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 packet->generation = req->req.generation;
775
776 if (hpsb_send_packet(packet) < 0) {
777 req->req.error = RAW1394_ERROR_SEND_ERROR;
778 req->req.length = 0;
779 hpsb_free_tlabel(packet);
780 queue_complete_req(req);
781 }
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200782 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783}
784
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785static int handle_async_send(struct file_info *fi, struct pending_request *req)
786{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700787 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 struct hpsb_packet *packet;
789 int header_length = req->req.misc & 0xffff;
790 int expect_response = req->req.misc >> 16;
Petr Vandrovec976da962007-05-13 22:14:44 -0700791 size_t data_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Stefan Richter7542e0e2007-03-25 22:22:40 +0200793 if (header_length > req->req.length || header_length < 12 ||
794 header_length > FIELD_SIZEOF(struct hpsb_packet, header)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 req->req.error = RAW1394_ERROR_INVALID_ARG;
796 req->req.length = 0;
797 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200798 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800
Petr Vandrovec976da962007-05-13 22:14:44 -0700801 data_size = req->req.length - header_length;
802 packet = hpsb_alloc_packet(data_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 req->packet = packet;
804 if (!packet)
805 return -ENOMEM;
806
807 if (copy_from_user(packet->header, int2ptr(req->req.sendb),
808 header_length)) {
809 req->req.error = RAW1394_ERROR_MEMFAULT;
810 req->req.length = 0;
811 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200812 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
814
815 if (copy_from_user
816 (packet->data, int2ptr(req->req.sendb) + header_length,
Petr Vandrovec976da962007-05-13 22:14:44 -0700817 data_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 req->req.error = RAW1394_ERROR_MEMFAULT;
819 req->req.length = 0;
820 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200821 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823
824 packet->type = hpsb_async;
825 packet->node_id = packet->header[0] >> 16;
826 packet->tcode = (packet->header[0] >> 4) & 0xf;
827 packet->tlabel = (packet->header[0] >> 10) & 0x3f;
828 packet->host = fi->host;
829 packet->expect_response = expect_response;
830 packet->header_size = header_length;
Petr Vandrovec976da962007-05-13 22:14:44 -0700831 packet->data_size = data_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 req->req.length = 0;
834 hpsb_set_packet_complete_task(packet,
835 (void (*)(void *))queue_complete_cb, req);
836
Andy Wingo4a9949d2005-10-19 21:23:46 -0700837 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700839 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 /* Update the generation of the packet just before sending. */
842 packet->generation = req->req.generation;
843
844 if (hpsb_send_packet(packet) < 0) {
845 req->req.error = RAW1394_ERROR_SEND_ERROR;
846 queue_complete_req(req);
847 }
848
Petr Vandrovec883b97e2007-05-07 04:14:47 +0200849 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
852static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer,
853 u64 addr, size_t length, u16 flags)
854{
Andy Wingo4a9949d2005-10-19 21:23:46 -0700855 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 struct pending_request *req;
857 struct host_info *hi;
858 struct file_info *fi = NULL;
859 struct list_head *entry;
860 struct arm_addr *arm_addr = NULL;
861 struct arm_request *arm_req = NULL;
862 struct arm_response *arm_resp = NULL;
863 int found = 0, size = 0, rcode = -1;
864 struct arm_request_response *arm_req_resp = NULL;
865
Joe Perchesa5c52df2007-11-19 17:48:10 -0800866 DBGMSG("arm_read called by node: %X "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 "addr: %4.4x %8.8x length: %Zu", nodeid,
868 (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
869 length);
Andy Wingo4a9949d2005-10-19 21:23:46 -0700870 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 hi = find_host_info(host); /* search address-entry */
872 if (hi != NULL) {
873 list_for_each_entry(fi, &hi->file_info_list, list) {
874 entry = fi->addr_list.next;
875 while (entry != &(fi->addr_list)) {
876 arm_addr =
877 list_entry(entry, struct arm_addr,
878 addr_list);
879 if (((arm_addr->start) <= (addr))
880 && ((arm_addr->end) >= (addr + length))) {
881 found = 1;
882 break;
883 }
884 entry = entry->next;
885 }
886 if (found) {
887 break;
888 }
889 }
890 }
891 rcode = -1;
892 if (!found) {
893 printk(KERN_ERR "raw1394: arm_read FAILED addr_entry not found"
894 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700895 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 return (RCODE_ADDRESS_ERROR);
897 } else {
898 DBGMSG("arm_read addr_entry FOUND");
899 }
900 if (arm_addr->rec_length < length) {
901 DBGMSG("arm_read blocklength too big -> rcode_data_error");
902 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
903 }
904 if (rcode == -1) {
905 if (arm_addr->access_rights & ARM_READ) {
906 if (!(arm_addr->client_transactions & ARM_READ)) {
907 memcpy(buffer,
908 (arm_addr->addr_space_buffer) + (addr -
909 (arm_addr->
910 start)),
911 length);
912 DBGMSG("arm_read -> (rcode_complete)");
913 rcode = RCODE_COMPLETE;
914 }
915 } else {
916 rcode = RCODE_TYPE_ERROR; /* function not allowed */
917 DBGMSG("arm_read -> rcode_type_error (access denied)");
918 }
919 }
920 if (arm_addr->notification_options & ARM_READ) {
921 DBGMSG("arm_read -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800922 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 if (!req) {
924 DBGMSG("arm_read -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700925 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
927 The request may be retried */
928 }
929 if (rcode == RCODE_COMPLETE) {
930 size =
931 sizeof(struct arm_request) +
932 sizeof(struct arm_response) +
933 length * sizeof(byte_t) +
934 sizeof(struct arm_request_response);
935 } else {
936 size =
937 sizeof(struct arm_request) +
938 sizeof(struct arm_response) +
939 sizeof(struct arm_request_response);
940 }
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800941 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (!(req->data)) {
943 free_pending_request(req);
944 DBGMSG("arm_read -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -0700945 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
947 The request may be retried */
948 }
949 req->free_data = 1;
950 req->file_info = fi;
951 req->req.type = RAW1394_REQ_ARM;
952 req->req.generation = get_hpsb_generation(host);
953 req->req.misc =
954 (((length << 16) & (0xFFFF0000)) | (ARM_READ & 0xFF));
955 req->req.tag = arm_addr->arm_tag;
956 req->req.recvb = arm_addr->recvb;
957 req->req.length = size;
958 arm_req_resp = (struct arm_request_response *)(req->data);
959 arm_req = (struct arm_request *)((byte_t *) (req->data) +
960 (sizeof
961 (struct
962 arm_request_response)));
963 arm_resp =
964 (struct arm_response *)((byte_t *) (arm_req) +
965 (sizeof(struct arm_request)));
966 arm_req->buffer = NULL;
967 arm_resp->buffer = NULL;
968 if (rcode == RCODE_COMPLETE) {
969 byte_t *buf =
970 (byte_t *) arm_resp + sizeof(struct arm_response);
971 memcpy(buf,
972 (arm_addr->addr_space_buffer) + (addr -
973 (arm_addr->
974 start)),
975 length);
976 arm_resp->buffer =
977 int2ptr((arm_addr->recvb) +
978 sizeof(struct arm_request_response) +
979 sizeof(struct arm_request) +
980 sizeof(struct arm_response));
981 }
982 arm_resp->buffer_length =
983 (rcode == RCODE_COMPLETE) ? length : 0;
984 arm_resp->response_code = rcode;
985 arm_req->buffer_length = 0;
986 arm_req->generation = req->req.generation;
987 arm_req->extended_transaction_code = 0;
988 arm_req->destination_offset = addr;
989 arm_req->source_nodeid = nodeid;
990 arm_req->destination_nodeid = host->node_id;
991 arm_req->tlabel = (flags >> 10) & 0x3f;
992 arm_req->tcode = (flags >> 4) & 0x0f;
993 arm_req_resp->request = int2ptr((arm_addr->recvb) +
994 sizeof(struct
995 arm_request_response));
996 arm_req_resp->response =
997 int2ptr((arm_addr->recvb) +
998 sizeof(struct arm_request_response) +
999 sizeof(struct arm_request));
1000 queue_complete_req(req);
1001 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001002 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 return (rcode);
1004}
1005
1006static int arm_write(struct hpsb_host *host, int nodeid, int destid,
1007 quadlet_t * data, u64 addr, size_t length, u16 flags)
1008{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001009 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 struct pending_request *req;
1011 struct host_info *hi;
1012 struct file_info *fi = NULL;
1013 struct list_head *entry;
1014 struct arm_addr *arm_addr = NULL;
1015 struct arm_request *arm_req = NULL;
1016 struct arm_response *arm_resp = NULL;
1017 int found = 0, size = 0, rcode = -1, length_conflict = 0;
1018 struct arm_request_response *arm_req_resp = NULL;
1019
Joe Perchesa5c52df2007-11-19 17:48:10 -08001020 DBGMSG("arm_write called by node: %X "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 "addr: %4.4x %8.8x length: %Zu", nodeid,
1022 (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF),
1023 length);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001024 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 hi = find_host_info(host); /* search address-entry */
1026 if (hi != NULL) {
1027 list_for_each_entry(fi, &hi->file_info_list, list) {
1028 entry = fi->addr_list.next;
1029 while (entry != &(fi->addr_list)) {
1030 arm_addr =
1031 list_entry(entry, struct arm_addr,
1032 addr_list);
1033 if (((arm_addr->start) <= (addr))
1034 && ((arm_addr->end) >= (addr + length))) {
1035 found = 1;
1036 break;
1037 }
1038 entry = entry->next;
1039 }
1040 if (found) {
1041 break;
1042 }
1043 }
1044 }
1045 rcode = -1;
1046 if (!found) {
1047 printk(KERN_ERR "raw1394: arm_write FAILED addr_entry not found"
1048 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001049 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 return (RCODE_ADDRESS_ERROR);
1051 } else {
1052 DBGMSG("arm_write addr_entry FOUND");
1053 }
1054 if (arm_addr->rec_length < length) {
1055 DBGMSG("arm_write blocklength too big -> rcode_data_error");
1056 length_conflict = 1;
1057 rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */
1058 }
1059 if (rcode == -1) {
1060 if (arm_addr->access_rights & ARM_WRITE) {
1061 if (!(arm_addr->client_transactions & ARM_WRITE)) {
1062 memcpy((arm_addr->addr_space_buffer) +
1063 (addr - (arm_addr->start)), data,
1064 length);
1065 DBGMSG("arm_write -> (rcode_complete)");
1066 rcode = RCODE_COMPLETE;
1067 }
1068 } else {
1069 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1070 DBGMSG("arm_write -> rcode_type_error (access denied)");
1071 }
1072 }
1073 if (arm_addr->notification_options & ARM_WRITE) {
1074 DBGMSG("arm_write -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001075 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 if (!req) {
1077 DBGMSG("arm_write -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001078 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1080 The request my be retried */
1081 }
1082 size =
1083 sizeof(struct arm_request) + sizeof(struct arm_response) +
1084 (length) * sizeof(byte_t) +
1085 sizeof(struct arm_request_response);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001086 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 if (!(req->data)) {
1088 free_pending_request(req);
1089 DBGMSG("arm_write -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001090 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1092 The request may be retried */
1093 }
1094 req->free_data = 1;
1095 req->file_info = fi;
1096 req->req.type = RAW1394_REQ_ARM;
1097 req->req.generation = get_hpsb_generation(host);
1098 req->req.misc =
1099 (((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF));
1100 req->req.tag = arm_addr->arm_tag;
1101 req->req.recvb = arm_addr->recvb;
1102 req->req.length = size;
1103 arm_req_resp = (struct arm_request_response *)(req->data);
1104 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1105 (sizeof
1106 (struct
1107 arm_request_response)));
1108 arm_resp =
1109 (struct arm_response *)((byte_t *) (arm_req) +
1110 (sizeof(struct arm_request)));
1111 arm_resp->buffer = NULL;
1112 memcpy((byte_t *) arm_resp + sizeof(struct arm_response),
1113 data, length);
1114 arm_req->buffer = int2ptr((arm_addr->recvb) +
1115 sizeof(struct arm_request_response) +
1116 sizeof(struct arm_request) +
1117 sizeof(struct arm_response));
1118 arm_req->buffer_length = length;
1119 arm_req->generation = req->req.generation;
1120 arm_req->extended_transaction_code = 0;
1121 arm_req->destination_offset = addr;
1122 arm_req->source_nodeid = nodeid;
1123 arm_req->destination_nodeid = destid;
1124 arm_req->tlabel = (flags >> 10) & 0x3f;
1125 arm_req->tcode = (flags >> 4) & 0x0f;
1126 arm_resp->buffer_length = 0;
1127 arm_resp->response_code = rcode;
1128 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1129 sizeof(struct
1130 arm_request_response));
1131 arm_req_resp->response =
1132 int2ptr((arm_addr->recvb) +
1133 sizeof(struct arm_request_response) +
1134 sizeof(struct arm_request));
1135 queue_complete_req(req);
1136 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001137 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 return (rcode);
1139}
1140
1141static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store,
1142 u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
1143 u16 flags)
1144{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001145 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 struct pending_request *req;
1147 struct host_info *hi;
1148 struct file_info *fi = NULL;
1149 struct list_head *entry;
1150 struct arm_addr *arm_addr = NULL;
1151 struct arm_request *arm_req = NULL;
1152 struct arm_response *arm_resp = NULL;
1153 int found = 0, size = 0, rcode = -1;
1154 quadlet_t old, new;
1155 struct arm_request_response *arm_req_resp = NULL;
1156
1157 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1158 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1159 DBGMSG("arm_lock called by node: %X "
1160 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X",
1161 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1162 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1163 be32_to_cpu(data));
1164 } else {
1165 DBGMSG("arm_lock called by node: %X "
1166 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X",
1167 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1168 (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF,
1169 be32_to_cpu(data), be32_to_cpu(arg));
1170 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001171 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 hi = find_host_info(host); /* search address-entry */
1173 if (hi != NULL) {
1174 list_for_each_entry(fi, &hi->file_info_list, list) {
1175 entry = fi->addr_list.next;
1176 while (entry != &(fi->addr_list)) {
1177 arm_addr =
1178 list_entry(entry, struct arm_addr,
1179 addr_list);
1180 if (((arm_addr->start) <= (addr))
1181 && ((arm_addr->end) >=
1182 (addr + sizeof(*store)))) {
1183 found = 1;
1184 break;
1185 }
1186 entry = entry->next;
1187 }
1188 if (found) {
1189 break;
1190 }
1191 }
1192 }
1193 rcode = -1;
1194 if (!found) {
1195 printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found"
1196 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001197 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 return (RCODE_ADDRESS_ERROR);
1199 } else {
1200 DBGMSG("arm_lock addr_entry FOUND");
1201 }
1202 if (rcode == -1) {
1203 if (arm_addr->access_rights & ARM_LOCK) {
1204 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1205 memcpy(&old,
1206 (arm_addr->addr_space_buffer) + (addr -
1207 (arm_addr->
1208 start)),
1209 sizeof(old));
1210 switch (ext_tcode) {
1211 case (EXTCODE_MASK_SWAP):
1212 new = data | (old & ~arg);
1213 break;
1214 case (EXTCODE_COMPARE_SWAP):
1215 if (old == arg) {
1216 new = data;
1217 } else {
1218 new = old;
1219 }
1220 break;
1221 case (EXTCODE_FETCH_ADD):
1222 new =
1223 cpu_to_be32(be32_to_cpu(data) +
1224 be32_to_cpu(old));
1225 break;
1226 case (EXTCODE_LITTLE_ADD):
1227 new =
1228 cpu_to_le32(le32_to_cpu(data) +
1229 le32_to_cpu(old));
1230 break;
1231 case (EXTCODE_BOUNDED_ADD):
1232 if (old != arg) {
1233 new =
1234 cpu_to_be32(be32_to_cpu
1235 (data) +
1236 be32_to_cpu
1237 (old));
1238 } else {
1239 new = old;
1240 }
1241 break;
1242 case (EXTCODE_WRAP_ADD):
1243 if (old != arg) {
1244 new =
1245 cpu_to_be32(be32_to_cpu
1246 (data) +
1247 be32_to_cpu
1248 (old));
1249 } else {
1250 new = data;
1251 }
1252 break;
1253 default:
1254 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1255 printk(KERN_ERR
1256 "raw1394: arm_lock FAILED "
1257 "ext_tcode not allowed -> rcode_type_error\n");
1258 break;
1259 } /*switch */
1260 if (rcode == -1) {
1261 DBGMSG("arm_lock -> (rcode_complete)");
1262 rcode = RCODE_COMPLETE;
1263 memcpy(store, &old, sizeof(*store));
1264 memcpy((arm_addr->addr_space_buffer) +
1265 (addr - (arm_addr->start)),
1266 &new, sizeof(*store));
1267 }
1268 }
1269 } else {
1270 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1271 DBGMSG("arm_lock -> rcode_type_error (access denied)");
1272 }
1273 }
1274 if (arm_addr->notification_options & ARM_LOCK) {
1275 byte_t *buf1, *buf2;
1276 DBGMSG("arm_lock -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001277 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 if (!req) {
1279 DBGMSG("arm_lock -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001280 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1282 The request may be retried */
1283 }
1284 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 -08001285 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 if (!(req->data)) {
1287 free_pending_request(req);
1288 DBGMSG("arm_lock -> rcode_conflict_error");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001289 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1291 The request may be retried */
1292 }
1293 req->free_data = 1;
1294 arm_req_resp = (struct arm_request_response *)(req->data);
1295 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1296 (sizeof
1297 (struct
1298 arm_request_response)));
1299 arm_resp =
1300 (struct arm_response *)((byte_t *) (arm_req) +
1301 (sizeof(struct arm_request)));
1302 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1303 buf2 = buf1 + 2 * sizeof(*store);
1304 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1305 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1306 arm_req->buffer_length = sizeof(*store);
1307 memcpy(buf1, &data, sizeof(*store));
1308
1309 } else {
1310 arm_req->buffer_length = 2 * sizeof(*store);
1311 memcpy(buf1, &arg, sizeof(*store));
1312 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1313 }
1314 if (rcode == RCODE_COMPLETE) {
1315 arm_resp->buffer_length = sizeof(*store);
1316 memcpy(buf2, &old, sizeof(*store));
1317 } else {
1318 arm_resp->buffer_length = 0;
1319 }
1320 req->file_info = fi;
1321 req->req.type = RAW1394_REQ_ARM;
1322 req->req.generation = get_hpsb_generation(host);
1323 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1324 (ARM_LOCK & 0xFF));
1325 req->req.tag = arm_addr->arm_tag;
1326 req->req.recvb = arm_addr->recvb;
1327 req->req.length = size;
1328 arm_req->generation = req->req.generation;
1329 arm_req->extended_transaction_code = ext_tcode;
1330 arm_req->destination_offset = addr;
1331 arm_req->source_nodeid = nodeid;
1332 arm_req->destination_nodeid = host->node_id;
1333 arm_req->tlabel = (flags >> 10) & 0x3f;
1334 arm_req->tcode = (flags >> 4) & 0x0f;
1335 arm_resp->response_code = rcode;
1336 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1337 sizeof(struct
1338 arm_request_response));
1339 arm_req_resp->response =
1340 int2ptr((arm_addr->recvb) +
1341 sizeof(struct arm_request_response) +
1342 sizeof(struct arm_request));
1343 arm_req->buffer =
1344 int2ptr((arm_addr->recvb) +
1345 sizeof(struct arm_request_response) +
1346 sizeof(struct arm_request) +
1347 sizeof(struct arm_response));
1348 arm_resp->buffer =
1349 int2ptr((arm_addr->recvb) +
1350 sizeof(struct arm_request_response) +
1351 sizeof(struct arm_request) +
1352 sizeof(struct arm_response) + 2 * sizeof(*store));
1353 queue_complete_req(req);
1354 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001355 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 return (rcode);
1357}
1358
1359static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store,
1360 u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
1361 u16 flags)
1362{
Andy Wingo4a9949d2005-10-19 21:23:46 -07001363 unsigned long irqflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 struct pending_request *req;
1365 struct host_info *hi;
1366 struct file_info *fi = NULL;
1367 struct list_head *entry;
1368 struct arm_addr *arm_addr = NULL;
1369 struct arm_request *arm_req = NULL;
1370 struct arm_response *arm_resp = NULL;
1371 int found = 0, size = 0, rcode = -1;
1372 octlet_t old, new;
1373 struct arm_request_response *arm_req_resp = NULL;
1374
1375 if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) ||
1376 ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) {
1377 DBGMSG("arm_lock64 called by node: %X "
1378 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ",
1379 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1380 (u32) (addr & 0xFFFFFFFF),
1381 ext_tcode & 0xFF,
1382 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1383 (u32) (be64_to_cpu(data) & 0xFFFFFFFF));
1384 } else {
1385 DBGMSG("arm_lock64 called by node: %X "
1386 "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: "
1387 "%8.8X %8.8X ",
1388 nodeid, (u16) ((addr >> 32) & 0xFFFF),
1389 (u32) (addr & 0xFFFFFFFF),
1390 ext_tcode & 0xFF,
1391 (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF),
1392 (u32) (be64_to_cpu(data) & 0xFFFFFFFF),
1393 (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF),
1394 (u32) (be64_to_cpu(arg) & 0xFFFFFFFF));
1395 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001396 spin_lock_irqsave(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 hi = find_host_info(host); /* search addressentry in file_info's for host */
1398 if (hi != NULL) {
1399 list_for_each_entry(fi, &hi->file_info_list, list) {
1400 entry = fi->addr_list.next;
1401 while (entry != &(fi->addr_list)) {
1402 arm_addr =
1403 list_entry(entry, struct arm_addr,
1404 addr_list);
1405 if (((arm_addr->start) <= (addr))
1406 && ((arm_addr->end) >=
1407 (addr + sizeof(*store)))) {
1408 found = 1;
1409 break;
1410 }
1411 entry = entry->next;
1412 }
1413 if (found) {
1414 break;
1415 }
1416 }
1417 }
1418 rcode = -1;
1419 if (!found) {
1420 printk(KERN_ERR
1421 "raw1394: arm_lock64 FAILED addr_entry not found"
1422 " -> rcode_address_error\n");
Andy Wingo4a9949d2005-10-19 21:23:46 -07001423 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 return (RCODE_ADDRESS_ERROR);
1425 } else {
1426 DBGMSG("arm_lock64 addr_entry FOUND");
1427 }
1428 if (rcode == -1) {
1429 if (arm_addr->access_rights & ARM_LOCK) {
1430 if (!(arm_addr->client_transactions & ARM_LOCK)) {
1431 memcpy(&old,
1432 (arm_addr->addr_space_buffer) + (addr -
1433 (arm_addr->
1434 start)),
1435 sizeof(old));
1436 switch (ext_tcode) {
1437 case (EXTCODE_MASK_SWAP):
1438 new = data | (old & ~arg);
1439 break;
1440 case (EXTCODE_COMPARE_SWAP):
1441 if (old == arg) {
1442 new = data;
1443 } else {
1444 new = old;
1445 }
1446 break;
1447 case (EXTCODE_FETCH_ADD):
1448 new =
1449 cpu_to_be64(be64_to_cpu(data) +
1450 be64_to_cpu(old));
1451 break;
1452 case (EXTCODE_LITTLE_ADD):
1453 new =
1454 cpu_to_le64(le64_to_cpu(data) +
1455 le64_to_cpu(old));
1456 break;
1457 case (EXTCODE_BOUNDED_ADD):
1458 if (old != arg) {
1459 new =
1460 cpu_to_be64(be64_to_cpu
1461 (data) +
1462 be64_to_cpu
1463 (old));
1464 } else {
1465 new = old;
1466 }
1467 break;
1468 case (EXTCODE_WRAP_ADD):
1469 if (old != arg) {
1470 new =
1471 cpu_to_be64(be64_to_cpu
1472 (data) +
1473 be64_to_cpu
1474 (old));
1475 } else {
1476 new = data;
1477 }
1478 break;
1479 default:
1480 printk(KERN_ERR
1481 "raw1394: arm_lock64 FAILED "
1482 "ext_tcode not allowed -> rcode_type_error\n");
1483 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1484 break;
1485 } /*switch */
1486 if (rcode == -1) {
1487 DBGMSG
1488 ("arm_lock64 -> (rcode_complete)");
1489 rcode = RCODE_COMPLETE;
1490 memcpy(store, &old, sizeof(*store));
1491 memcpy((arm_addr->addr_space_buffer) +
1492 (addr - (arm_addr->start)),
1493 &new, sizeof(*store));
1494 }
1495 }
1496 } else {
1497 rcode = RCODE_TYPE_ERROR; /* function not allowed */
1498 DBGMSG
1499 ("arm_lock64 -> rcode_type_error (access denied)");
1500 }
1501 }
1502 if (arm_addr->notification_options & ARM_LOCK) {
1503 byte_t *buf1, *buf2;
1504 DBGMSG("arm_lock64 -> entering notification-section");
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001505 req = __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 if (!req) {
Andy Wingo4a9949d2005-10-19 21:23:46 -07001507 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 DBGMSG("arm_lock64 -> rcode_conflict_error");
1509 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1510 The request may be retried */
1511 }
1512 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 -08001513 req->data = kmalloc(size, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 if (!(req->data)) {
1515 free_pending_request(req);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001516 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 DBGMSG("arm_lock64 -> rcode_conflict_error");
1518 return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected.
1519 The request may be retried */
1520 }
1521 req->free_data = 1;
1522 arm_req_resp = (struct arm_request_response *)(req->data);
1523 arm_req = (struct arm_request *)((byte_t *) (req->data) +
1524 (sizeof
1525 (struct
1526 arm_request_response)));
1527 arm_resp =
1528 (struct arm_response *)((byte_t *) (arm_req) +
1529 (sizeof(struct arm_request)));
1530 buf1 = (byte_t *) arm_resp + sizeof(struct arm_response);
1531 buf2 = buf1 + 2 * sizeof(*store);
1532 if ((ext_tcode == EXTCODE_FETCH_ADD) ||
1533 (ext_tcode == EXTCODE_LITTLE_ADD)) {
1534 arm_req->buffer_length = sizeof(*store);
1535 memcpy(buf1, &data, sizeof(*store));
1536
1537 } else {
1538 arm_req->buffer_length = 2 * sizeof(*store);
1539 memcpy(buf1, &arg, sizeof(*store));
1540 memcpy(buf1 + sizeof(*store), &data, sizeof(*store));
1541 }
1542 if (rcode == RCODE_COMPLETE) {
1543 arm_resp->buffer_length = sizeof(*store);
1544 memcpy(buf2, &old, sizeof(*store));
1545 } else {
1546 arm_resp->buffer_length = 0;
1547 }
1548 req->file_info = fi;
1549 req->req.type = RAW1394_REQ_ARM;
1550 req->req.generation = get_hpsb_generation(host);
1551 req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) |
1552 (ARM_LOCK & 0xFF));
1553 req->req.tag = arm_addr->arm_tag;
1554 req->req.recvb = arm_addr->recvb;
1555 req->req.length = size;
1556 arm_req->generation = req->req.generation;
1557 arm_req->extended_transaction_code = ext_tcode;
1558 arm_req->destination_offset = addr;
1559 arm_req->source_nodeid = nodeid;
1560 arm_req->destination_nodeid = host->node_id;
1561 arm_req->tlabel = (flags >> 10) & 0x3f;
1562 arm_req->tcode = (flags >> 4) & 0x0f;
1563 arm_resp->response_code = rcode;
1564 arm_req_resp->request = int2ptr((arm_addr->recvb) +
1565 sizeof(struct
1566 arm_request_response));
1567 arm_req_resp->response =
1568 int2ptr((arm_addr->recvb) +
1569 sizeof(struct arm_request_response) +
1570 sizeof(struct arm_request));
1571 arm_req->buffer =
1572 int2ptr((arm_addr->recvb) +
1573 sizeof(struct arm_request_response) +
1574 sizeof(struct arm_request) +
1575 sizeof(struct arm_response));
1576 arm_resp->buffer =
1577 int2ptr((arm_addr->recvb) +
1578 sizeof(struct arm_request_response) +
1579 sizeof(struct arm_request) +
1580 sizeof(struct arm_response) + 2 * sizeof(*store));
1581 queue_complete_req(req);
1582 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07001583 spin_unlock_irqrestore(&host_info_lock, irqflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 return (rcode);
1585}
1586
1587static int arm_register(struct file_info *fi, struct pending_request *req)
1588{
1589 int retval;
1590 struct arm_addr *addr;
1591 struct host_info *hi;
1592 struct file_info *fi_hlp = NULL;
1593 struct list_head *entry;
1594 struct arm_addr *arm_addr = NULL;
1595 int same_host, another_host;
1596 unsigned long flags;
1597
1598 DBGMSG("arm_register called "
1599 "addr(Offset): %8.8x %8.8x length: %u "
1600 "rights: %2.2X notify: %2.2X "
1601 "max_blk_len: %4.4X",
1602 (u32) ((req->req.address >> 32) & 0xFFFF),
1603 (u32) (req->req.address & 0xFFFFFFFF),
1604 req->req.length, ((req->req.misc >> 8) & 0xFF),
1605 (req->req.misc & 0xFF), ((req->req.misc >> 16) & 0xFFFF));
1606 /* check addressrange */
1607 if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) ||
1608 (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) !=
1609 0)) {
1610 req->req.length = 0;
1611 return (-EINVAL);
1612 }
1613 /* addr-list-entry for fileinfo */
Christoph Lametere94b1762006-12-06 20:33:17 -08001614 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 if (!addr) {
1616 req->req.length = 0;
1617 return (-ENOMEM);
1618 }
1619 /* allocation of addr_space_buffer */
Stefan Richter85511582005-11-07 06:31:45 -05001620 addr->addr_space_buffer = vmalloc(req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 if (!(addr->addr_space_buffer)) {
1622 kfree(addr);
1623 req->req.length = 0;
1624 return (-ENOMEM);
1625 }
1626 /* initialization of addr_space_buffer */
1627 if ((req->req.sendb) == (unsigned long)NULL) {
1628 /* init: set 0 */
1629 memset(addr->addr_space_buffer, 0, req->req.length);
1630 } else {
1631 /* init: user -> kernel */
1632 if (copy_from_user
1633 (addr->addr_space_buffer, int2ptr(req->req.sendb),
1634 req->req.length)) {
1635 vfree(addr->addr_space_buffer);
1636 kfree(addr);
1637 return (-EFAULT);
1638 }
1639 }
1640 INIT_LIST_HEAD(&addr->addr_list);
1641 addr->arm_tag = req->req.tag;
1642 addr->start = req->req.address;
1643 addr->end = req->req.address + req->req.length;
1644 addr->access_rights = (u8) (req->req.misc & 0x0F);
1645 addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F);
1646 addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F);
1647 addr->access_rights |= addr->client_transactions;
1648 addr->notification_options |= addr->client_transactions;
1649 addr->recvb = req->req.recvb;
1650 addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF);
Stefan Richter3253b662006-09-14 22:05:16 +02001651
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 spin_lock_irqsave(&host_info_lock, flags);
1653 hi = find_host_info(fi->host);
1654 same_host = 0;
1655 another_host = 0;
1656 /* same host with address-entry containing same addressrange ? */
1657 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1658 entry = fi_hlp->addr_list.next;
1659 while (entry != &(fi_hlp->addr_list)) {
1660 arm_addr =
1661 list_entry(entry, struct arm_addr, addr_list);
1662 if ((arm_addr->start == addr->start)
1663 && (arm_addr->end == addr->end)) {
1664 DBGMSG("same host ownes same "
1665 "addressrange -> EALREADY");
1666 same_host = 1;
1667 break;
1668 }
1669 entry = entry->next;
1670 }
1671 if (same_host) {
1672 break;
1673 }
1674 }
1675 if (same_host) {
1676 /* addressrange occupied by same host */
Stefan Richter3253b662006-09-14 22:05:16 +02001677 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 vfree(addr->addr_space_buffer);
1679 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 return (-EALREADY);
1681 }
1682 /* another host with valid address-entry containing same addressrange */
1683 list_for_each_entry(hi, &host_info_list, list) {
1684 if (hi->host != fi->host) {
1685 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1686 entry = fi_hlp->addr_list.next;
1687 while (entry != &(fi_hlp->addr_list)) {
1688 arm_addr =
1689 list_entry(entry, struct arm_addr,
1690 addr_list);
1691 if ((arm_addr->start == addr->start)
1692 && (arm_addr->end == addr->end)) {
1693 DBGMSG
1694 ("another host ownes same "
1695 "addressrange");
1696 another_host = 1;
1697 break;
1698 }
1699 entry = entry->next;
1700 }
1701 if (another_host) {
1702 break;
1703 }
1704 }
1705 }
1706 }
Stefan Richter3253b662006-09-14 22:05:16 +02001707 spin_unlock_irqrestore(&host_info_lock, flags);
1708
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 if (another_host) {
1710 DBGMSG("another hosts entry is valid -> SUCCESS");
1711 if (copy_to_user(int2ptr(req->req.recvb),
1712 &addr->start, sizeof(u64))) {
1713 printk(KERN_ERR "raw1394: arm_register failed "
1714 " address-range-entry is invalid -> EFAULT !!!\n");
1715 vfree(addr->addr_space_buffer);
1716 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 return (-EFAULT);
1718 }
1719 free_pending_request(req); /* immediate success or fail */
1720 /* INSERT ENTRY */
Stefan Richter3253b662006-09-14 22:05:16 +02001721 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 list_add_tail(&addr->addr_list, &fi->addr_list);
1723 spin_unlock_irqrestore(&host_info_lock, flags);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001724 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 }
1726 retval =
1727 hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops,
1728 req->req.address,
1729 req->req.address + req->req.length);
1730 if (retval) {
1731 /* INSERT ENTRY */
Stefan Richter3253b662006-09-14 22:05:16 +02001732 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 list_add_tail(&addr->addr_list, &fi->addr_list);
Stefan Richter3253b662006-09-14 22:05:16 +02001734 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 } else {
1736 DBGMSG("arm_register failed errno: %d \n", retval);
1737 vfree(addr->addr_space_buffer);
1738 kfree(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 return (-EALREADY);
1740 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001742 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743}
1744
1745static int arm_unregister(struct file_info *fi, struct pending_request *req)
1746{
1747 int found = 0;
1748 int retval = 0;
1749 struct list_head *entry;
1750 struct arm_addr *addr = NULL;
1751 struct host_info *hi;
1752 struct file_info *fi_hlp = NULL;
1753 struct arm_addr *arm_addr = NULL;
1754 int another_host;
1755 unsigned long flags;
1756
1757 DBGMSG("arm_Unregister called addr(Offset): "
1758 "%8.8x %8.8x",
1759 (u32) ((req->req.address >> 32) & 0xFFFF),
1760 (u32) (req->req.address & 0xFFFFFFFF));
1761 spin_lock_irqsave(&host_info_lock, flags);
1762 /* get addr */
1763 entry = fi->addr_list.next;
1764 while (entry != &(fi->addr_list)) {
1765 addr = list_entry(entry, struct arm_addr, addr_list);
1766 if (addr->start == req->req.address) {
1767 found = 1;
1768 break;
1769 }
1770 entry = entry->next;
1771 }
1772 if (!found) {
1773 DBGMSG("arm_Unregister addr not found");
1774 spin_unlock_irqrestore(&host_info_lock, flags);
1775 return (-EINVAL);
1776 }
1777 DBGMSG("arm_Unregister addr found");
1778 another_host = 0;
1779 /* another host with valid address-entry containing
1780 same addressrange */
1781 list_for_each_entry(hi, &host_info_list, list) {
1782 if (hi->host != fi->host) {
1783 list_for_each_entry(fi_hlp, &hi->file_info_list, list) {
1784 entry = fi_hlp->addr_list.next;
1785 while (entry != &(fi_hlp->addr_list)) {
1786 arm_addr = list_entry(entry,
1787 struct arm_addr,
1788 addr_list);
1789 if (arm_addr->start == addr->start) {
1790 DBGMSG("another host ownes "
1791 "same addressrange");
1792 another_host = 1;
1793 break;
1794 }
1795 entry = entry->next;
1796 }
1797 if (another_host) {
1798 break;
1799 }
1800 }
1801 }
1802 }
1803 if (another_host) {
1804 DBGMSG("delete entry from list -> success");
1805 list_del(&addr->addr_list);
Stefan Richter3253b662006-09-14 22:05:16 +02001806 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 vfree(addr->addr_space_buffer);
1808 kfree(addr);
1809 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001810 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 }
1812 retval =
1813 hpsb_unregister_addrspace(&raw1394_highlevel, fi->host,
1814 addr->start);
1815 if (!retval) {
1816 printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n");
1817 spin_unlock_irqrestore(&host_info_lock, flags);
1818 return (-EINVAL);
1819 }
1820 DBGMSG("delete entry from list -> success");
1821 list_del(&addr->addr_list);
1822 spin_unlock_irqrestore(&host_info_lock, flags);
1823 vfree(addr->addr_space_buffer);
1824 kfree(addr);
1825 free_pending_request(req); /* immediate success or fail */
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001826 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827}
1828
1829/* Copy data from ARM buffer(s) to user buffer. */
1830static int arm_get_buf(struct file_info *fi, struct pending_request *req)
1831{
1832 struct arm_addr *arm_addr = NULL;
1833 unsigned long flags;
1834 unsigned long offset;
1835
1836 struct list_head *entry;
1837
1838 DBGMSG("arm_get_buf "
1839 "addr(Offset): %04X %08X length: %u",
1840 (u32) ((req->req.address >> 32) & 0xFFFF),
1841 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1842
1843 spin_lock_irqsave(&host_info_lock, flags);
1844 entry = fi->addr_list.next;
1845 while (entry != &(fi->addr_list)) {
1846 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1847 if ((arm_addr->start <= req->req.address) &&
1848 (arm_addr->end > req->req.address)) {
1849 if (req->req.address + req->req.length <= arm_addr->end) {
1850 offset = req->req.address - arm_addr->start;
Stefan Richter3253b662006-09-14 22:05:16 +02001851 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852
1853 DBGMSG
1854 ("arm_get_buf copy_to_user( %08X, %p, %u )",
1855 (u32) req->req.recvb,
1856 arm_addr->addr_space_buffer + offset,
1857 (u32) req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 if (copy_to_user
1859 (int2ptr(req->req.recvb),
1860 arm_addr->addr_space_buffer + offset,
Stefan Richter3253b662006-09-14 22:05:16 +02001861 req->req.length))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 return (-EFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 /* We have to free the request, because we
1865 * queue no response, and therefore nobody
1866 * will free it. */
1867 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001868 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 } else {
1870 DBGMSG("arm_get_buf request exceeded mapping");
1871 spin_unlock_irqrestore(&host_info_lock, flags);
1872 return (-EINVAL);
1873 }
1874 }
1875 entry = entry->next;
1876 }
1877 spin_unlock_irqrestore(&host_info_lock, flags);
1878 return (-EINVAL);
1879}
1880
1881/* Copy data from user buffer to ARM buffer(s). */
1882static int arm_set_buf(struct file_info *fi, struct pending_request *req)
1883{
1884 struct arm_addr *arm_addr = NULL;
1885 unsigned long flags;
1886 unsigned long offset;
1887
1888 struct list_head *entry;
1889
1890 DBGMSG("arm_set_buf "
1891 "addr(Offset): %04X %08X length: %u",
1892 (u32) ((req->req.address >> 32) & 0xFFFF),
1893 (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length);
1894
1895 spin_lock_irqsave(&host_info_lock, flags);
1896 entry = fi->addr_list.next;
1897 while (entry != &(fi->addr_list)) {
1898 arm_addr = list_entry(entry, struct arm_addr, addr_list);
1899 if ((arm_addr->start <= req->req.address) &&
1900 (arm_addr->end > req->req.address)) {
1901 if (req->req.address + req->req.length <= arm_addr->end) {
1902 offset = req->req.address - arm_addr->start;
Stefan Richter3253b662006-09-14 22:05:16 +02001903 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
1905 DBGMSG
1906 ("arm_set_buf copy_from_user( %p, %08X, %u )",
1907 arm_addr->addr_space_buffer + offset,
1908 (u32) req->req.sendb,
1909 (u32) req->req.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 if (copy_from_user
1911 (arm_addr->addr_space_buffer + offset,
1912 int2ptr(req->req.sendb),
Stefan Richter3253b662006-09-14 22:05:16 +02001913 req->req.length))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 return (-EFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
Stefan Richter3253b662006-09-14 22:05:16 +02001916 /* We have to free the request, because we
1917 * queue no response, and therefore nobody
1918 * will free it. */
1919 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001920 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 } else {
1922 DBGMSG("arm_set_buf request exceeded mapping");
1923 spin_unlock_irqrestore(&host_info_lock, flags);
1924 return (-EINVAL);
1925 }
1926 }
1927 entry = entry->next;
1928 }
1929 spin_unlock_irqrestore(&host_info_lock, flags);
1930 return (-EINVAL);
1931}
1932
1933static int reset_notification(struct file_info *fi, struct pending_request *req)
1934{
1935 DBGMSG("reset_notification called - switch %s ",
1936 (req->req.misc == RAW1394_NOTIFY_OFF) ? "OFF" : "ON");
1937 if ((req->req.misc == RAW1394_NOTIFY_OFF) ||
1938 (req->req.misc == RAW1394_NOTIFY_ON)) {
1939 fi->notification = (u8) req->req.misc;
1940 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 +02001941 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 }
1943 /* error EINVAL (22) invalid argument */
1944 return (-EINVAL);
1945}
1946
1947static int write_phypacket(struct file_info *fi, struct pending_request *req)
1948{
1949 struct hpsb_packet *packet = NULL;
1950 int retval = 0;
1951 quadlet_t data;
Andy Wingo4a9949d2005-10-19 21:23:46 -07001952 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
1954 data = be32_to_cpu((u32) req->req.sendb);
1955 DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data);
1956 packet = hpsb_make_phypacket(fi->host, data);
1957 if (!packet)
1958 return -ENOMEM;
1959 req->req.length = 0;
1960 req->packet = packet;
1961 hpsb_set_packet_complete_task(packet,
1962 (void (*)(void *))queue_complete_cb, req);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001963 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 list_add_tail(&req->list, &fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -07001965 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 packet->generation = req->req.generation;
1967 retval = hpsb_send_packet(packet);
1968 DBGMSG("write_phypacket send_packet called => retval: %d ", retval);
1969 if (retval < 0) {
1970 req->req.error = RAW1394_ERROR_SEND_ERROR;
1971 req->req.length = 0;
1972 queue_complete_req(req);
1973 }
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001974 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975}
1976
1977static int get_config_rom(struct file_info *fi, struct pending_request *req)
1978{
Petr Vandrovec883b97e2007-05-07 04:14:47 +02001979 int ret = 0;
Christoph Lametere94b1762006-12-06 20:33:17 -08001980 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 int status;
1982
1983 if (!data)
1984 return -ENOMEM;
1985
1986 status =
1987 csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET,
1988 data, req->req.length);
1989 if (copy_to_user(int2ptr(req->req.recvb), data, req->req.length))
1990 ret = -EFAULT;
1991 if (copy_to_user
1992 (int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len,
1993 sizeof(fi->host->csr.rom->cache_head->len)))
1994 ret = -EFAULT;
1995 if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation,
1996 sizeof(fi->host->csr.generation)))
1997 ret = -EFAULT;
1998 if (copy_to_user(int2ptr(req->req.sendb), &status, sizeof(status)))
1999 ret = -EFAULT;
2000 kfree(data);
2001 if (ret >= 0) {
2002 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2003 }
2004 return ret;
2005}
2006
2007static int update_config_rom(struct file_info *fi, struct pending_request *req)
2008{
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002009 int ret = 0;
Christoph Lametere94b1762006-12-06 20:33:17 -08002010 quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 if (!data)
2012 return -ENOMEM;
2013 if (copy_from_user(data, int2ptr(req->req.sendb), req->req.length)) {
2014 ret = -EFAULT;
2015 } else {
2016 int status = hpsb_update_config_rom(fi->host,
2017 data, req->req.length,
2018 (unsigned char)req->req.
2019 misc);
2020 if (copy_to_user
2021 (int2ptr(req->req.recvb), &status, sizeof(status)))
2022 ret = -ENOMEM;
2023 }
2024 kfree(data);
2025 if (ret >= 0) {
2026 free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */
2027 fi->cfgrom_upd = 1;
2028 }
2029 return ret;
2030}
2031
2032static int modify_config_rom(struct file_info *fi, struct pending_request *req)
2033{
2034 struct csr1212_keyval *kv;
2035 struct csr1212_csr_rom_cache *cache;
2036 struct csr1212_dentry *dentry;
2037 u32 dr;
2038 int ret = 0;
2039
2040 if (req->req.misc == ~0) {
2041 if (req->req.length == 0)
2042 return -EINVAL;
2043
2044 /* Find an unused slot */
2045 for (dr = 0;
2046 dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr];
2047 dr++) ;
2048
2049 if (dr == RAW1394_MAX_USER_CSR_DIRS)
2050 return -ENOMEM;
2051
2052 fi->csr1212_dirs[dr] =
2053 csr1212_new_directory(CSR1212_KV_ID_VENDOR);
2054 if (!fi->csr1212_dirs[dr])
2055 return -ENOMEM;
2056 } else {
2057 dr = req->req.misc;
2058 if (!fi->csr1212_dirs[dr])
2059 return -EINVAL;
2060
2061 /* Delete old stuff */
2062 for (dentry =
2063 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2064 dentry; dentry = dentry->next) {
2065 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2066 root_kv,
2067 dentry->kv);
2068 }
2069
2070 if (req->req.length == 0) {
2071 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2072 fi->csr1212_dirs[dr] = NULL;
2073
2074 hpsb_update_config_rom_image(fi->host);
2075 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002076 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 }
2078 }
2079
2080 cache = csr1212_rom_cache_malloc(0, req->req.length);
2081 if (!cache) {
2082 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2083 fi->csr1212_dirs[dr] = NULL;
2084 return -ENOMEM;
2085 }
2086
Stefan Richter85511582005-11-07 06:31:45 -05002087 cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 if (!cache->filled_head) {
2089 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2090 fi->csr1212_dirs[dr] = NULL;
2091 CSR1212_FREE(cache);
2092 return -ENOMEM;
2093 }
2094 cache->filled_tail = cache->filled_head;
2095
2096 if (copy_from_user(cache->data, int2ptr(req->req.sendb),
2097 req->req.length)) {
2098 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2099 fi->csr1212_dirs[dr] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 ret = -EFAULT;
2101 } else {
2102 cache->len = req->req.length;
2103 cache->filled_head->offset_start = 0;
2104 cache->filled_head->offset_end = cache->size - 1;
2105
2106 cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr];
2107
2108 ret = CSR1212_SUCCESS;
2109 /* parse all the items */
2110 for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv;
2111 kv = kv->next) {
2112 ret = csr1212_parse_keyval(kv, cache);
2113 }
2114
2115 /* attach top level items to the root directory */
2116 for (dentry =
2117 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2118 ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) {
2119 ret =
2120 csr1212_attach_keyval_to_directory(fi->host->csr.
2121 rom->root_kv,
2122 dentry->kv);
2123 }
2124
2125 if (ret == CSR1212_SUCCESS) {
2126 ret = hpsb_update_config_rom_image(fi->host);
2127
2128 if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb),
2129 &dr, sizeof(dr))) {
2130 ret = -ENOMEM;
2131 }
2132 }
2133 }
2134 kfree(cache->filled_head);
Stefan Richterb12479d2005-11-21 17:32:18 -05002135 CSR1212_FREE(cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
2137 if (ret >= 0) {
2138 /* we have to free the request, because we queue no response,
2139 * and therefore nobody will free it */
2140 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002141 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 } else {
2143 for (dentry =
2144 fi->csr1212_dirs[dr]->value.directory.dentries_head;
2145 dentry; dentry = dentry->next) {
2146 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2147 root_kv,
2148 dentry->kv);
2149 }
2150 csr1212_release_keyval(fi->csr1212_dirs[dr]);
2151 fi->csr1212_dirs[dr] = NULL;
2152 return ret;
2153 }
2154}
2155
2156static int state_connected(struct file_info *fi, struct pending_request *req)
2157{
2158 int node = req->req.address >> 48;
2159
2160 req->req.error = RAW1394_ERROR_NONE;
2161
2162 switch (req->req.type) {
2163
2164 case RAW1394_REQ_ECHO:
2165 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 case RAW1394_REQ_ARM_REGISTER:
2169 return arm_register(fi, req);
2170
2171 case RAW1394_REQ_ARM_UNREGISTER:
2172 return arm_unregister(fi, req);
2173
2174 case RAW1394_REQ_ARM_SET_BUF:
2175 return arm_set_buf(fi, req);
2176
2177 case RAW1394_REQ_ARM_GET_BUF:
2178 return arm_get_buf(fi, req);
2179
2180 case RAW1394_REQ_RESET_NOTIFY:
2181 return reset_notification(fi, req);
2182
Stefan Richter53c96b42007-06-24 15:31:54 +02002183 case RAW1394_REQ_ISO_SEND:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 case RAW1394_REQ_ISO_LISTEN:
Stefan Richter53c96b42007-06-24 15:31:54 +02002185 printk(KERN_DEBUG "raw1394: old iso ABI has been removed\n");
2186 req->req.error = RAW1394_ERROR_COMPAT;
2187 req->req.misc = RAW1394_KERNELAPI_VERSION;
2188 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002189 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190
2191 case RAW1394_REQ_FCP_LISTEN:
2192 handle_fcp_listen(fi, req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002193 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194
2195 case RAW1394_REQ_RESET_BUS:
2196 if (req->req.misc == RAW1394_LONG_RESET) {
2197 DBGMSG("busreset called (type: LONG)");
2198 hpsb_reset_bus(fi->host, LONG_RESET);
2199 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 +02002200 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 }
2202 if (req->req.misc == RAW1394_SHORT_RESET) {
2203 DBGMSG("busreset called (type: SHORT)");
2204 hpsb_reset_bus(fi->host, SHORT_RESET);
2205 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 +02002206 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 }
2208 /* error EINVAL (22) invalid argument */
2209 return (-EINVAL);
2210 case RAW1394_REQ_GET_ROM:
2211 return get_config_rom(fi, req);
2212
2213 case RAW1394_REQ_UPDATE_ROM:
2214 return update_config_rom(fi, req);
2215
2216 case RAW1394_REQ_MODIFY_ROM:
2217 return modify_config_rom(fi, req);
2218 }
2219
2220 if (req->req.generation != get_hpsb_generation(fi->host)) {
2221 req->req.error = RAW1394_ERROR_GENERATION;
2222 req->req.generation = get_hpsb_generation(fi->host);
2223 req->req.length = 0;
2224 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002225 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
2227
2228 switch (req->req.type) {
2229 case RAW1394_REQ_PHYPACKET:
2230 return write_phypacket(fi, req);
2231 case RAW1394_REQ_ASYNC_SEND:
2232 return handle_async_send(fi, req);
2233 }
2234
2235 if (req->req.length == 0) {
2236 req->req.error = RAW1394_ERROR_INVALID_ARG;
2237 queue_complete_req(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002238 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 }
2240
2241 return handle_async_request(fi, req, node);
2242}
2243
2244static ssize_t raw1394_write(struct file *file, const char __user * buffer,
2245 size_t count, loff_t * offset_is_ignored)
2246{
2247 struct file_info *fi = (struct file_info *)file->private_data;
2248 struct pending_request *req;
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002249 ssize_t retval = -EBADFD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
Andi Kleen4bc32c42006-03-25 16:30:07 +01002251#ifdef CONFIG_COMPAT
Ben Collins75970282006-06-12 18:12:10 -04002252 if (count == sizeof(struct compat_raw1394_req) &&
2253 sizeof(struct compat_raw1394_req) !=
2254 sizeof(struct raw1394_request)) {
Andi Kleen4bc32c42006-03-25 16:30:07 +01002255 buffer = raw1394_compat_write(buffer);
Stefan Richter42169682009-02-15 22:49:24 +01002256 if (IS_ERR((__force void *)buffer))
2257 return PTR_ERR((__force void *)buffer);
Andi Kleen4bc32c42006-03-25 16:30:07 +01002258 } else
2259#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 if (count != sizeof(struct raw1394_request)) {
2261 return -EINVAL;
2262 }
2263
2264 req = alloc_pending_request();
2265 if (req == NULL) {
2266 return -ENOMEM;
2267 }
2268 req->file_info = fi;
2269
2270 if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
2271 free_pending_request(req);
2272 return -EFAULT;
2273 }
2274
Stefan Richter638570b2008-10-26 12:03:37 +01002275 if (!mutex_trylock(&fi->state_mutex))
2276 return -EAGAIN;
Stefan Richterf22e52b2008-08-16 00:15:16 +02002277
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 switch (fi->state) {
2279 case opened:
2280 retval = state_opened(fi, req);
2281 break;
2282
2283 case initialized:
2284 retval = state_initialized(fi, req);
2285 break;
2286
2287 case connected:
2288 retval = state_connected(fi, req);
2289 break;
2290 }
2291
Stefan Richterf22e52b2008-08-16 00:15:16 +02002292 mutex_unlock(&fi->state_mutex);
2293
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 if (retval < 0) {
2295 free_pending_request(req);
Petr Vandrovec883b97e2007-05-07 04:14:47 +02002296 } else {
2297 BUG_ON(retval);
2298 retval = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 }
2300
2301 return retval;
2302}
2303
2304/* rawiso operations */
2305
2306/* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the
2307 * completion queue (reqlists_lock must be taken) */
2308static inline int __rawiso_event_in_queue(struct file_info *fi)
2309{
2310 struct pending_request *req;
2311
2312 list_for_each_entry(req, &fi->req_complete, list)
2313 if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY)
2314 return 1;
2315
2316 return 0;
2317}
2318
2319/* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */
2320static void queue_rawiso_event(struct file_info *fi)
2321{
2322 unsigned long flags;
2323
2324 spin_lock_irqsave(&fi->reqlists_lock, flags);
2325
2326 /* only one ISO activity event may be in the queue */
2327 if (!__rawiso_event_in_queue(fi)) {
2328 struct pending_request *req =
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08002329 __alloc_pending_request(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
2331 if (req) {
2332 req->file_info = fi;
2333 req->req.type = RAW1394_REQ_RAWISO_ACTIVITY;
2334 req->req.generation = get_hpsb_generation(fi->host);
2335 __queue_complete_req(req);
2336 } else {
2337 /* on allocation failure, signal an overflow */
2338 if (fi->iso_handle) {
2339 atomic_inc(&fi->iso_handle->overflows);
2340 }
2341 }
2342 }
2343 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
2344}
2345
2346static void rawiso_activity_cb(struct hpsb_iso *iso)
2347{
2348 unsigned long flags;
2349 struct host_info *hi;
2350 struct file_info *fi;
2351
2352 spin_lock_irqsave(&host_info_lock, flags);
2353 hi = find_host_info(iso->host);
2354
2355 if (hi != NULL) {
2356 list_for_each_entry(fi, &hi->file_info_list, list) {
2357 if (fi->iso_handle == iso)
2358 queue_rawiso_event(fi);
2359 }
2360 }
2361
2362 spin_unlock_irqrestore(&host_info_lock, flags);
2363}
2364
2365/* helper function - gather all the kernel iso status bits for returning to user-space */
2366static void raw1394_iso_fill_status(struct hpsb_iso *iso,
2367 struct raw1394_iso_status *stat)
2368{
Pieter Palmerscc9429b2008-03-19 22:10:59 +01002369 int overflows = atomic_read(&iso->overflows);
2370 int skips = atomic_read(&iso->skips);
2371
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 stat->config.data_buf_size = iso->buf_size;
2373 stat->config.buf_packets = iso->buf_packets;
2374 stat->config.channel = iso->channel;
2375 stat->config.speed = iso->speed;
2376 stat->config.irq_interval = iso->irq_interval;
2377 stat->n_packets = hpsb_iso_n_ready(iso);
Pieter Palmerscc9429b2008-03-19 22:10:59 +01002378 stat->overflows = ((skips & 0xFFFF) << 16) | ((overflows & 0xFFFF));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 stat->xmit_cycle = iso->xmit_cycle;
2380}
2381
2382static int raw1394_iso_xmit_init(struct file_info *fi, void __user * uaddr)
2383{
2384 struct raw1394_iso_status stat;
2385
2386 if (!fi->host)
2387 return -EINVAL;
2388
2389 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2390 return -EFAULT;
2391
2392 fi->iso_handle = hpsb_iso_xmit_init(fi->host,
2393 stat.config.data_buf_size,
2394 stat.config.buf_packets,
2395 stat.config.channel,
2396 stat.config.speed,
2397 stat.config.irq_interval,
2398 rawiso_activity_cb);
2399 if (!fi->iso_handle)
2400 return -ENOMEM;
2401
2402 fi->iso_state = RAW1394_ISO_XMIT;
2403
2404 raw1394_iso_fill_status(fi->iso_handle, &stat);
2405 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2406 return -EFAULT;
2407
2408 /* queue an event to get things started */
2409 rawiso_activity_cb(fi->iso_handle);
2410
2411 return 0;
2412}
2413
2414static int raw1394_iso_recv_init(struct file_info *fi, void __user * uaddr)
2415{
2416 struct raw1394_iso_status stat;
2417
2418 if (!fi->host)
2419 return -EINVAL;
2420
2421 if (copy_from_user(&stat, uaddr, sizeof(stat)))
2422 return -EFAULT;
2423
2424 fi->iso_handle = hpsb_iso_recv_init(fi->host,
2425 stat.config.data_buf_size,
2426 stat.config.buf_packets,
2427 stat.config.channel,
2428 stat.config.dma_mode,
2429 stat.config.irq_interval,
2430 rawiso_activity_cb);
2431 if (!fi->iso_handle)
2432 return -ENOMEM;
2433
2434 fi->iso_state = RAW1394_ISO_RECV;
2435
2436 raw1394_iso_fill_status(fi->iso_handle, &stat);
2437 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2438 return -EFAULT;
2439 return 0;
2440}
2441
2442static int raw1394_iso_get_status(struct file_info *fi, void __user * uaddr)
2443{
2444 struct raw1394_iso_status stat;
2445 struct hpsb_iso *iso = fi->iso_handle;
2446
2447 raw1394_iso_fill_status(fi->iso_handle, &stat);
2448 if (copy_to_user(uaddr, &stat, sizeof(stat)))
2449 return -EFAULT;
2450
2451 /* reset overflow counter */
2452 atomic_set(&iso->overflows, 0);
Pieter Palmerscc9429b2008-03-19 22:10:59 +01002453 /* reset skip counter */
2454 atomic_set(&iso->skips, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455
2456 return 0;
2457}
2458
2459/* copy N packet_infos out of the ringbuffer into user-supplied array */
2460static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr)
2461{
2462 struct raw1394_iso_packets upackets;
2463 unsigned int packet = fi->iso_handle->first_packet;
2464 int i;
2465
2466 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2467 return -EFAULT;
2468
2469 if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle))
2470 return -EINVAL;
2471
2472 /* ensure user-supplied buffer is accessible and big enough */
2473 if (!access_ok(VERIFY_WRITE, upackets.infos,
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002474 upackets.n_packets *
2475 sizeof(struct raw1394_iso_packet_info)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 return -EFAULT;
2477
2478 /* copy the packet_infos out */
2479 for (i = 0; i < upackets.n_packets; i++) {
2480 if (__copy_to_user(&upackets.infos[i],
2481 &fi->iso_handle->infos[packet],
2482 sizeof(struct raw1394_iso_packet_info)))
2483 return -EFAULT;
2484
2485 packet = (packet + 1) % fi->iso_handle->buf_packets;
2486 }
2487
2488 return 0;
2489}
2490
2491/* copy N packet_infos from user to ringbuffer, and queue them for transmission */
2492static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr)
2493{
2494 struct raw1394_iso_packets upackets;
2495 int i, rv;
2496
2497 if (copy_from_user(&upackets, uaddr, sizeof(upackets)))
2498 return -EFAULT;
2499
Ben Collins1934b8b2005-07-09 20:01:23 -04002500 if (upackets.n_packets >= fi->iso_handle->buf_packets)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 return -EINVAL;
2502
Ben Collins1934b8b2005-07-09 20:01:23 -04002503 if (upackets.n_packets >= hpsb_iso_n_ready(fi->iso_handle))
2504 return -EAGAIN;
2505
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 /* ensure user-supplied buffer is accessible and big enough */
2507 if (!access_ok(VERIFY_READ, upackets.infos,
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002508 upackets.n_packets *
2509 sizeof(struct raw1394_iso_packet_info)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510 return -EFAULT;
2511
2512 /* copy the infos structs in and queue the packets */
2513 for (i = 0; i < upackets.n_packets; i++) {
2514 struct raw1394_iso_packet_info info;
2515
2516 if (__copy_from_user(&info, &upackets.infos[i],
2517 sizeof(struct raw1394_iso_packet_info)))
2518 return -EFAULT;
2519
2520 rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset,
2521 info.len, info.tag, info.sy);
2522 if (rv)
2523 return rv;
2524 }
2525
2526 return 0;
2527}
2528
2529static void raw1394_iso_shutdown(struct file_info *fi)
2530{
2531 if (fi->iso_handle)
2532 hpsb_iso_shutdown(fi->iso_handle);
2533
2534 fi->iso_handle = NULL;
2535 fi->iso_state = RAW1394_ISO_INACTIVE;
2536}
2537
Pieter Palmers3dc5ea92007-02-03 17:44:39 +01002538static int raw1394_read_cycle_timer(struct file_info *fi, void __user * uaddr)
2539{
2540 struct raw1394_cycle_timer ct;
2541 int err;
2542
2543 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2544 if (!err)
2545 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2546 err = -EFAULT;
2547 return err;
2548}
2549
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550/* mmap the rawiso xmit/recv buffer */
2551static int raw1394_mmap(struct file *file, struct vm_area_struct *vma)
2552{
2553 struct file_info *fi = file->private_data;
Stefan Richter10963ea2008-08-16 00:11:48 +02002554 int ret;
2555
Stefan Richter638570b2008-10-26 12:03:37 +01002556 if (!mutex_trylock(&fi->state_mutex))
2557 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
2559 if (fi->iso_state == RAW1394_ISO_INACTIVE)
Stefan Richter10963ea2008-08-16 00:11:48 +02002560 ret = -EINVAL;
2561 else
2562 ret = dma_region_mmap(&fi->iso_handle->data_buf, file, vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
Stefan Richter10963ea2008-08-16 00:11:48 +02002564 mutex_unlock(&fi->state_mutex);
2565
2566 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567}
2568
Stefan Richterddfb9082008-08-16 17:52:04 +02002569static long raw1394_ioctl_inactive(struct file_info *fi, unsigned int cmd,
2570 void __user *argp)
2571{
2572 switch (cmd) {
2573 case RAW1394_IOC_ISO_XMIT_INIT:
2574 return raw1394_iso_xmit_init(fi, argp);
2575 case RAW1394_IOC_ISO_RECV_INIT:
2576 return raw1394_iso_recv_init(fi, argp);
2577 default:
2578 return -EINVAL;
2579 }
2580}
2581
2582static long raw1394_ioctl_recv(struct file_info *fi, unsigned int cmd,
2583 unsigned long arg)
2584{
2585 void __user *argp = (void __user *)arg;
2586
2587 switch (cmd) {
2588 case RAW1394_IOC_ISO_RECV_START:{
2589 int args[3];
2590
2591 if (copy_from_user(&args[0], argp, sizeof(args)))
2592 return -EFAULT;
2593 return hpsb_iso_recv_start(fi->iso_handle,
2594 args[0], args[1], args[2]);
2595 }
2596 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2597 hpsb_iso_stop(fi->iso_handle);
2598 return 0;
2599 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2600 return hpsb_iso_recv_listen_channel(fi->iso_handle, arg);
2601 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2602 return hpsb_iso_recv_unlisten_channel(fi->iso_handle, arg);
2603 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:{
2604 u64 mask;
2605
2606 if (copy_from_user(&mask, argp, sizeof(mask)))
2607 return -EFAULT;
2608 return hpsb_iso_recv_set_channel_mask(fi->iso_handle,
2609 mask);
2610 }
2611 case RAW1394_IOC_ISO_GET_STATUS:
2612 return raw1394_iso_get_status(fi, argp);
2613 case RAW1394_IOC_ISO_RECV_PACKETS:
2614 return raw1394_iso_recv_packets(fi, argp);
2615 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2616 return hpsb_iso_recv_release_packets(fi->iso_handle, arg);
2617 case RAW1394_IOC_ISO_RECV_FLUSH:
2618 return hpsb_iso_recv_flush(fi->iso_handle);
2619 case RAW1394_IOC_ISO_SHUTDOWN:
2620 raw1394_iso_shutdown(fi);
2621 return 0;
2622 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2623 queue_rawiso_event(fi);
2624 return 0;
2625 default:
2626 return -EINVAL;
2627 }
2628}
2629
2630static long raw1394_ioctl_xmit(struct file_info *fi, unsigned int cmd,
2631 void __user *argp)
2632{
2633 switch (cmd) {
2634 case RAW1394_IOC_ISO_XMIT_START:{
2635 int args[2];
2636
2637 if (copy_from_user(&args[0], argp, sizeof(args)))
2638 return -EFAULT;
2639 return hpsb_iso_xmit_start(fi->iso_handle,
2640 args[0], args[1]);
2641 }
2642 case RAW1394_IOC_ISO_XMIT_SYNC:
2643 return hpsb_iso_xmit_sync(fi->iso_handle);
2644 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2645 hpsb_iso_stop(fi->iso_handle);
2646 return 0;
2647 case RAW1394_IOC_ISO_GET_STATUS:
2648 return raw1394_iso_get_status(fi, argp);
2649 case RAW1394_IOC_ISO_XMIT_PACKETS:
2650 return raw1394_iso_send_packets(fi, argp);
2651 case RAW1394_IOC_ISO_SHUTDOWN:
2652 raw1394_iso_shutdown(fi);
2653 return 0;
2654 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
2655 queue_rawiso_event(fi);
2656 return 0;
2657 default:
2658 return -EINVAL;
2659 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660}
2661
2662/* ioctl is only used for rawiso operations */
Stefan Richterddfb9082008-08-16 17:52:04 +02002663static long raw1394_ioctl(struct file *file, unsigned int cmd,
2664 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665{
2666 struct file_info *fi = file->private_data;
2667 void __user *argp = (void __user *)arg;
Stefan Richterddfb9082008-08-16 17:52:04 +02002668 long ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669
Pieter Palmers3dc5ea92007-02-03 17:44:39 +01002670 /* state-independent commands */
2671 switch(cmd) {
2672 case RAW1394_IOC_GET_CYCLE_TIMER:
2673 return raw1394_read_cycle_timer(fi, argp);
2674 default:
2675 break;
2676 }
2677
Stefan Richter638570b2008-10-26 12:03:37 +01002678 if (!mutex_trylock(&fi->state_mutex))
2679 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680
Stefan Richterddfb9082008-08-16 17:52:04 +02002681 switch (fi->iso_state) {
2682 case RAW1394_ISO_INACTIVE:
2683 ret = raw1394_ioctl_inactive(fi, cmd, argp);
2684 break;
2685 case RAW1394_ISO_RECV:
2686 ret = raw1394_ioctl_recv(fi, cmd, arg);
2687 break;
2688 case RAW1394_ISO_XMIT:
2689 ret = raw1394_ioctl_xmit(fi, cmd, argp);
2690 break;
2691 default:
2692 ret = -EINVAL;
2693 break;
2694 }
2695
Stefan Richter10963ea2008-08-16 00:11:48 +02002696 mutex_unlock(&fi->state_mutex);
Stefan Richterddfb9082008-08-16 17:52:04 +02002697
Alan Cox3aea50a2008-05-23 11:57:41 +01002698 return ret;
2699}
2700
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002701#ifdef CONFIG_COMPAT
2702struct raw1394_iso_packets32 {
2703 __u32 n_packets;
2704 compat_uptr_t infos;
2705} __attribute__((packed));
2706
2707struct raw1394_cycle_timer32 {
2708 __u32 cycle_timer;
2709 __u64 local_time;
Stefan Richter19f00e62007-05-21 18:52:06 +02002710}
2711#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
2712__attribute__((packed))
2713#endif
2714;
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002715
2716#define RAW1394_IOC_ISO_RECV_PACKETS32 \
2717 _IOW ('#', 0x25, struct raw1394_iso_packets32)
2718#define RAW1394_IOC_ISO_XMIT_PACKETS32 \
2719 _IOW ('#', 0x27, struct raw1394_iso_packets32)
2720#define RAW1394_IOC_GET_CYCLE_TIMER32 \
2721 _IOR ('#', 0x30, struct raw1394_cycle_timer32)
2722
2723static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd,
2724 struct raw1394_iso_packets32 __user *arg)
2725{
2726 compat_uptr_t infos32;
Al Viro5b26e642007-07-26 17:36:19 +01002727 void __user *infos;
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002728 long err = -EFAULT;
2729 struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets));
2730
2731 if (!copy_in_user(&dst->n_packets, &arg->n_packets, sizeof arg->n_packets) &&
2732 !copy_from_user(&infos32, &arg->infos, sizeof infos32)) {
2733 infos = compat_ptr(infos32);
2734 if (!copy_to_user(&dst->infos, &infos, sizeof infos))
Stefan Richterddfb9082008-08-16 17:52:04 +02002735 err = raw1394_ioctl(file, cmd, (unsigned long)dst);
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002736 }
2737 return err;
2738}
2739
2740static long raw1394_read_cycle_timer32(struct file_info *fi, void __user * uaddr)
2741{
2742 struct raw1394_cycle_timer32 ct;
2743 int err;
2744
2745 err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time);
2746 if (!err)
2747 if (copy_to_user(uaddr, &ct, sizeof(ct)))
2748 err = -EFAULT;
2749 return err;
2750}
2751
2752static long raw1394_compat_ioctl(struct file *file,
2753 unsigned int cmd, unsigned long arg)
2754{
2755 struct file_info *fi = file->private_data;
2756 void __user *argp = (void __user *)arg;
2757 long err;
2758
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002759 switch (cmd) {
2760 /* These requests have same format as long as 'int' has same size. */
2761 case RAW1394_IOC_ISO_RECV_INIT:
2762 case RAW1394_IOC_ISO_RECV_START:
2763 case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL:
2764 case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL:
2765 case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:
2766 case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS:
2767 case RAW1394_IOC_ISO_RECV_FLUSH:
2768 case RAW1394_IOC_ISO_XMIT_RECV_STOP:
2769 case RAW1394_IOC_ISO_XMIT_INIT:
2770 case RAW1394_IOC_ISO_XMIT_START:
2771 case RAW1394_IOC_ISO_XMIT_SYNC:
2772 case RAW1394_IOC_ISO_GET_STATUS:
2773 case RAW1394_IOC_ISO_SHUTDOWN:
2774 case RAW1394_IOC_ISO_QUEUE_ACTIVITY:
Stefan Richterddfb9082008-08-16 17:52:04 +02002775 err = raw1394_ioctl(file, cmd, arg);
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002776 break;
2777 /* These request have different format. */
2778 case RAW1394_IOC_ISO_RECV_PACKETS32:
2779 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_RECV_PACKETS, argp);
2780 break;
2781 case RAW1394_IOC_ISO_XMIT_PACKETS32:
2782 err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_XMIT_PACKETS, argp);
2783 break;
2784 case RAW1394_IOC_GET_CYCLE_TIMER32:
2785 err = raw1394_read_cycle_timer32(fi, argp);
2786 break;
2787 default:
2788 err = -EINVAL;
2789 break;
2790 }
Petr Vandrovec650c12c2007-05-07 04:14:47 +02002791
2792 return err;
2793}
2794#endif
2795
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796static unsigned int raw1394_poll(struct file *file, poll_table * pt)
2797{
2798 struct file_info *fi = file->private_data;
2799 unsigned int mask = POLLOUT | POLLWRNORM;
Andy Wingo4a9949d2005-10-19 21:23:46 -07002800 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
Stefan Richter45289bf2006-07-03 12:02:33 -04002802 poll_wait(file, &fi->wait_complete, pt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
Andy Wingo4a9949d2005-10-19 21:23:46 -07002804 spin_lock_irqsave(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805 if (!list_empty(&fi->req_complete)) {
2806 mask |= POLLIN | POLLRDNORM;
2807 }
Andy Wingo4a9949d2005-10-19 21:23:46 -07002808 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809
2810 return mask;
2811}
2812
2813static int raw1394_open(struct inode *inode, struct file *file)
2814{
2815 struct file_info *fi;
2816
Christoph Lametere94b1762006-12-06 20:33:17 -08002817 fi = kzalloc(sizeof(*fi), GFP_KERNEL);
Stefan Richter85511582005-11-07 06:31:45 -05002818 if (!fi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 return -ENOMEM;
2820
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */
2822
2823 INIT_LIST_HEAD(&fi->list);
Stefan Richter10963ea2008-08-16 00:11:48 +02002824 mutex_init(&fi->state_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 fi->state = opened;
2826 INIT_LIST_HEAD(&fi->req_pending);
2827 INIT_LIST_HEAD(&fi->req_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 spin_lock_init(&fi->reqlists_lock);
Stefan Richter45289bf2006-07-03 12:02:33 -04002829 init_waitqueue_head(&fi->wait_complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 INIT_LIST_HEAD(&fi->addr_list);
2831
2832 file->private_data = fi;
2833
2834 return 0;
2835}
2836
2837static int raw1394_release(struct inode *inode, struct file *file)
2838{
2839 struct file_info *fi = file->private_data;
2840 struct list_head *lh;
2841 struct pending_request *req;
Stefan Richter45289bf2006-07-03 12:02:33 -04002842 int i, fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 int retval = 0;
2844 struct list_head *entry;
2845 struct arm_addr *addr = NULL;
2846 struct host_info *hi;
2847 struct file_info *fi_hlp = NULL;
2848 struct arm_addr *arm_addr = NULL;
2849 int another_host;
2850 int csr_mod = 0;
Andy Wingo4a9949d2005-10-19 21:23:46 -07002851 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852
2853 if (fi->iso_state != RAW1394_ISO_INACTIVE)
2854 raw1394_iso_shutdown(fi);
2855
Andy Wingo4a9949d2005-10-19 21:23:46 -07002856 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857
2858 fail = 0;
2859 /* set address-entries invalid */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860
2861 while (!list_empty(&fi->addr_list)) {
2862 another_host = 0;
2863 lh = fi->addr_list.next;
2864 addr = list_entry(lh, struct arm_addr, addr_list);
2865 /* another host with valid address-entry containing
2866 same addressrange? */
2867 list_for_each_entry(hi, &host_info_list, list) {
2868 if (hi->host != fi->host) {
2869 list_for_each_entry(fi_hlp, &hi->file_info_list,
2870 list) {
2871 entry = fi_hlp->addr_list.next;
2872 while (entry != &(fi_hlp->addr_list)) {
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05002873 arm_addr = list_entry(entry, struct
Linus Torvalds1da177e2005-04-16 15:20:36 -07002874 arm_addr,
2875 addr_list);
2876 if (arm_addr->start ==
2877 addr->start) {
2878 DBGMSG
2879 ("raw1394_release: "
2880 "another host ownes "
2881 "same addressrange");
2882 another_host = 1;
2883 break;
2884 }
2885 entry = entry->next;
2886 }
2887 if (another_host) {
2888 break;
2889 }
2890 }
2891 }
2892 }
2893 if (!another_host) {
2894 DBGMSG("raw1394_release: call hpsb_arm_unregister");
2895 retval =
2896 hpsb_unregister_addrspace(&raw1394_highlevel,
2897 fi->host, addr->start);
2898 if (!retval) {
2899 ++fail;
2900 printk(KERN_ERR
2901 "raw1394_release arm_Unregister failed\n");
2902 }
2903 }
2904 DBGMSG("raw1394_release: delete addr_entry from list");
2905 list_del(&addr->addr_list);
2906 vfree(addr->addr_space_buffer);
2907 kfree(addr);
2908 } /* while */
Andy Wingo4a9949d2005-10-19 21:23:46 -07002909 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 if (fail > 0) {
2911 printk(KERN_ERR "raw1394: during addr_list-release "
2912 "error(s) occurred \n");
2913 }
2914
Stefan Richter45289bf2006-07-03 12:02:33 -04002915 for (;;) {
2916 /* This locked section guarantees that neither
2917 * complete nor pending requests exist once i!=0 */
Andy Wingo4a9949d2005-10-19 21:23:46 -07002918 spin_lock_irqsave(&fi->reqlists_lock, flags);
Stefan Richter45289bf2006-07-03 12:02:33 -04002919 while ((req = __next_complete_req(fi)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 free_pending_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921
Stefan Richter45289bf2006-07-03 12:02:33 -04002922 i = list_empty(&fi->req_pending);
Andy Wingo4a9949d2005-10-19 21:23:46 -07002923 spin_unlock_irqrestore(&fi->reqlists_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924
Stefan Richter45289bf2006-07-03 12:02:33 -04002925 if (i)
2926 break;
2927 /*
2928 * Sleep until more requests can be freed.
2929 *
2930 * NB: We call the macro wait_event() with a condition argument
2931 * with side effect. This is only possible because the side
2932 * effect does not occur until the condition became true, and
2933 * wait_event() won't evaluate the condition again after that.
2934 */
2935 wait_event(fi->wait_complete, (req = next_complete_req(fi)));
2936 free_pending_request(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 }
2938
2939 /* Remove any sub-trees left by user space programs */
2940 for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) {
2941 struct csr1212_dentry *dentry;
2942 if (!fi->csr1212_dirs[i])
2943 continue;
2944 for (dentry =
2945 fi->csr1212_dirs[i]->value.directory.dentries_head; dentry;
2946 dentry = dentry->next) {
2947 csr1212_detach_keyval_from_directory(fi->host->csr.rom->
2948 root_kv,
2949 dentry->kv);
2950 }
2951 csr1212_release_keyval(fi->csr1212_dirs[i]);
2952 fi->csr1212_dirs[i] = NULL;
2953 csr_mod = 1;
2954 }
2955
2956 if ((csr_mod || fi->cfgrom_upd)
2957 && hpsb_update_config_rom_image(fi->host) < 0)
2958 HPSB_ERR
2959 ("Failed to generate Configuration ROM image for host %d",
2960 fi->host->id);
2961
2962 if (fi->state == connected) {
Andy Wingo4a9949d2005-10-19 21:23:46 -07002963 spin_lock_irqsave(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 list_del(&fi->list);
Andy Wingo4a9949d2005-10-19 21:23:46 -07002965 spin_unlock_irqrestore(&host_info_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966
2967 put_device(&fi->host->device);
2968 }
2969
Stefan Richter0fe4c6f2007-02-03 16:48:51 +01002970 spin_lock_irqsave(&host_info_lock, flags);
2971 if (fi->host)
2972 module_put(fi->host->driver->owner);
2973 spin_unlock_irqrestore(&host_info_lock, flags);
2974
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 kfree(fi);
2976
2977 return 0;
2978}
2979
2980/*** HOTPLUG STUFF **********************************************************/
2981/*
2982 * Export information about protocols/devices supported by this driver.
2983 */
Tony Breedse3864972008-04-24 09:02:04 +02002984#ifdef MODULE
Stefan Richterc6409462009-02-15 23:11:38 +01002985static const struct ieee1394_device_id raw1394_id_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 {
2987 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2988 .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff,
2989 .version = AVC_SW_VERSION_ENTRY & 0xffffff},
2990 {
2991 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2992 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2993 .version = CAMERA_SW_VERSION_ENTRY & 0xffffff},
2994 {
2995 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
2996 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
2997 .version = (CAMERA_SW_VERSION_ENTRY + 1) & 0xffffff},
2998 {
2999 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
3000 .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff,
3001 .version = (CAMERA_SW_VERSION_ENTRY + 2) & 0xffffff},
3002 {}
3003};
3004
3005MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table);
Tony Breedse3864972008-04-24 09:02:04 +02003006#endif /* MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007
3008static struct hpsb_protocol_driver raw1394_driver = {
Ben Collinsed30c262006-11-23 13:59:48 -05003009 .name = "raw1394",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010};
3011
3012/******************************************************************************/
3013
3014static struct hpsb_highlevel raw1394_highlevel = {
3015 .name = RAW1394_DEVICE_NAME,
3016 .add_host = add_host,
3017 .remove_host = remove_host,
3018 .host_reset = host_reset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 .fcp_request = fcp_request,
3020};
3021
3022static struct cdev raw1394_cdev;
Arjan van de Ven2b8693c2007-02-12 00:55:32 -08003023static const struct file_operations raw1394_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024 .owner = THIS_MODULE,
3025 .read = raw1394_read,
3026 .write = raw1394_write,
3027 .mmap = raw1394_mmap,
Alan Cox3aea50a2008-05-23 11:57:41 +01003028 .unlocked_ioctl = raw1394_ioctl,
Petr Vandrovec650c12c2007-05-07 04:14:47 +02003029#ifdef CONFIG_COMPAT
3030 .compat_ioctl = raw1394_compat_ioctl,
3031#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 .poll = raw1394_poll,
3033 .open = raw1394_open,
3034 .release = raw1394_release,
3035};
3036
3037static int __init init_raw1394(void)
3038{
3039 int ret = 0;
3040
3041 hpsb_register_highlevel(&raw1394_highlevel);
3042
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003043 if (IS_ERR
Greg Kroah-Hartman6229df32008-07-21 20:03:34 -07003044 (device_create(hpsb_protocol_class, NULL,
3045 MKDEV(IEEE1394_MAJOR,
3046 IEEE1394_MINOR_BLOCK_RAW1394 * 16),
3047 NULL, RAW1394_DEVICE_NAME))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 ret = -EFAULT;
3049 goto out_unreg;
3050 }
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003051
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 cdev_init(&raw1394_cdev, &raw1394_fops);
3053 raw1394_cdev.owner = THIS_MODULE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054 ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1);
3055 if (ret) {
3056 HPSB_ERR("raw1394 failed to register minor device block");
3057 goto out_dev;
3058 }
3059
3060 HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME);
3061
3062 ret = hpsb_register_protocol(&raw1394_driver);
3063 if (ret) {
3064 HPSB_ERR("raw1394: failed to register protocol");
3065 cdev_del(&raw1394_cdev);
3066 goto out_dev;
3067 }
3068
3069 goto out;
3070
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003071 out_dev:
Kay Sieversdd7f2922007-05-25 11:50:53 +02003072 device_destroy(hpsb_protocol_class,
3073 MKDEV(IEEE1394_MAJOR,
3074 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003075 out_unreg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 hpsb_unregister_highlevel(&raw1394_highlevel);
Jens-Michael Hoffmannc64d4722005-11-22 12:37:10 -05003077 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 return ret;
3079}
3080
3081static void __exit cleanup_raw1394(void)
3082{
Kay Sieversdd7f2922007-05-25 11:50:53 +02003083 device_destroy(hpsb_protocol_class,
3084 MKDEV(IEEE1394_MAJOR,
3085 IEEE1394_MINOR_BLOCK_RAW1394 * 16));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 cdev_del(&raw1394_cdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 hpsb_unregister_highlevel(&raw1394_highlevel);
3088 hpsb_unregister_protocol(&raw1394_driver);
3089}
3090
3091module_init(init_raw1394);
3092module_exit(cleanup_raw1394);
3093MODULE_LICENSE("GPL");