git.oblomov.eu Git - linux-2.6/blob - drivers/ieee1394/raw1394.c

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