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