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