drivers/ieee1394/ieee1394_transactions.c

   1 /*
   2  * IEEE 1394 for Linux
   3  *
   4  * Transaction support.
   5  *
   6  * Copyright (C) 1999 Andreas E. Bombe
   7  *
   8  * This code is licensed under the GPL.  See the file COPYING in the root
   9  * directory of the kernel sources for details.
  10  */
  11
  12 #include <linux/sched.h>
  13 #include <asm/errno.h>
  14 #include <asm/bitops.h>
  15
  16 #include "ieee1394.h"
  17 #include "ieee1394_types.h"
  18 #include "hosts.h"
  19 #include "ieee1394_core.h"
  20 #include "highlevel.h"
  21
  22
  23 #define PREP_ASYNC_HEAD_ADDRESS(tc) \
  24         packet->tcode = tc; \
  25         packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
  26                 | (1 << 8) | (tc << 4); \
  27         packet->header[1] = (packet->host->node_id << 16) | (addr >> 32); \
  28         packet->header[2] = addr & 0xffffffff
  29
  30 #define PREP_ASYNC_HEAD_RCODE(tc) \
  31         packet->tcode = tc; \
  32         packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
  33                 | (1 << 8) | (tc << 4); \
  34         packet->header[1] = (packet->host->node_id << 16) | (rcode << 12); \
  35         packet->header[2] = 0
  36
  37
  38 void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
  39 {
  40         PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ);
  41         packet->header_size = 12;
  42         packet->data_size = 0;
  43         packet->expect_response = 1;
  44 }
  45
  46 void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode,
  47                               quadlet_t data)
  48 {
  49         PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE);
  50         packet->header[3] = data;
  51         packet->header_size = 16;
  52         packet->data_size = 0;
  53 }
  54
  55 void fill_async_readblock(struct hpsb_packet *packet, u64 addr, int length)
  56 {
  57         PREP_ASYNC_HEAD_ADDRESS(TCODE_READB);
  58         packet->header[3] = length << 16;
  59         packet->header_size = 16;
  60         packet->data_size = 0;
  61         packet->expect_response = 1;
  62 }
  63
  64 void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode,
  65                                int length)
  66 {
  67         if (rcode != RCODE_COMPLETE) {
  68                 length = 0;
  69         }
  70
  71         PREP_ASYNC_HEAD_RCODE(TCODE_READB_RESPONSE);
  72         packet->header[3] = length << 16;
  73         packet->header_size = 16;
  74         packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
  75 }
  76
  77 void fill_async_writequad(struct hpsb_packet *packet, u64 addr, quadlet_t data)
  78 {
  79         PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ);
  80         packet->header[3] = data;
  81         packet->header_size = 16;
  82         packet->data_size = 0;
  83         packet->expect_response = 1;
  84 }
  85
  86 void fill_async_writeblock(struct hpsb_packet *packet, u64 addr, int length)
  87 {
  88         PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB);
  89         packet->header[3] = length << 16;
  90         packet->header_size = 16;
  91         packet->expect_response = 1;
  92         packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
  93 }
  94
  95 void fill_async_write_resp(struct hpsb_packet *packet, int rcode)
  96 {
  97         PREP_ASYNC_HEAD_RCODE(TCODE_WRITE_RESPONSE);
  98         packet->header[2] = 0;
  99         packet->header_size = 12;
 100         packet->data_size = 0;
 101 }
 102
 103 void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
 104                      int length)
 105 {
 106         PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST);
 107         packet->header[3] = (length << 16) | extcode;
 108         packet->header_size = 16;
 109         packet->data_size = length;
 110         packet->expect_response = 1;
 111 }
 112
 113 void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode,
 114                           int length)
 115 {
 116         if (rcode != RCODE_COMPLETE) {
 117                 length = 0;
 118         }
 119
 120         PREP_ASYNC_HEAD_RCODE(TCODE_LOCK_RESPONSE);
 121         packet->header[3] = (length << 16) | extcode;
 122         packet->header_size = 16;
 123         packet->data_size = length;
 124 }
 125
 126 void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
 127                      int tag, int sync)
 128 {
 129         packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
 130                 | (TCODE_ISO_DATA << 4) | sync;
 131
 132         packet->header_size = 4;
 133         packet->data_size = length;
 134         packet->type = hpsb_iso;
 135         packet->tcode = TCODE_ISO_DATA;
 136 }
 137
 138 void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
 139 {
 140         packet->header[0] = data;
 141         packet->header[1] = ~data;
 142         packet->header_size = 8;
 143         packet->data_size = 0;
 144         packet->expect_response = 0;
 145         packet->type = hpsb_raw;             /* No CRC added */
 146         packet->speed_code = SPEED_100; /* Force speed to be 100Mbps */
 147 }
 148
 149
 150 /**
 151  * get_tlabel - allocate a transaction label
 152  * @host: host to be used for transmission
 153  * @nodeid: the node ID of the transmission target
 154  * @wait: whether to sleep if no tlabel is available
 155  *
 156  * Every asynchronous transaction on the 1394 bus needs a transaction label to
 157  * match the response to the request.  This label has to be different from any
 158  * other transaction label in an outstanding request to the same node to make
 159  * matching possible without ambiguity.
 160  *
 161  * There are 64 different tlabels, so an allocated tlabel has to be freed with
 162  * free_tlabel() after the transaction is complete (unless it's reused again for
 163  * the same target node).
 164  *
 165  * @wait must not be set to true if you are calling from interrupt context.
 166  *
 167  * Return value: The allocated transaction label or -1 if there was no free
 168  * tlabel and @wait is false.
 169  */
 170 int get_tlabel(struct hpsb_host *host, nodeid_t nodeid, int wait)
 171 {
 172         int tlabel = 0;
 173         unsigned long flags;
 174         int found_tlabel = 0;
 175
 176         if (wait) {
 177                 down(&host->tlabel_count);
 178         } else {
 179                 if (down_trylock(&host->tlabel_count)) return -1;
 180         }
 181
 182         spin_lock_irqsave(&host->tlabel_lock, flags);
 183
 184         while (!found_tlabel) {
 185                 tlabel = host->tlabel_current;
 186                 if (tlabel < 32 && !(host->tlabel_pool[0] & 1 << tlabel)) {
 187                         host->tlabel_pool[0] |= 1 << tlabel;
 188                         found_tlabel = 1;
 189                 } else if (!(host->tlabel_pool[1] & 1 << (tlabel - 32))) {
 190                         host->tlabel_pool[1] |= 1 << (tlabel - 32);
 191                         found_tlabel = 1;
 192                 }
 193                 host->tlabel_current = (host->tlabel_current + 1) % 64;
 194         }
 195
 196         spin_unlock_irqrestore(&host->tlabel_lock, flags);
 197
 198         return tlabel;
 199 }
 200
 201 /**
 202  * free_tlabel - free an allocated transaction label
 203  * @host: host to be used for transmission
 204  * @nodeid: the node ID of the transmission target
 205  * @tlabel: the transaction label to free
 206  *
 207  * Frees the transaction label allocated with get_tlabel().  The tlabel has to
 208  * be freed after the transaction is complete (i.e. response was received for a
 209  * split transaction or packet was sent for a unified transaction).
 210  *
 211  * A tlabel must not be freed twice.
 212  */
 213 void free_tlabel(struct hpsb_host *host, nodeid_t nodeid, int tlabel)
 214 {
 215         unsigned long flags;
 216
 217         spin_lock_irqsave(&host->tlabel_lock, flags);
 218
 219         if (tlabel < 32) {
 220                 host->tlabel_pool[0] &= ~(1 << tlabel);
 221         } else {
 222                 host->tlabel_pool[1] &= ~(1 << (tlabel-32));
 223         }
 224
 225         spin_unlock_irqrestore(&host->tlabel_lock, flags);
 226
 227         up(&host->tlabel_count);
 228 }
 229
 230
 231
 232 int hpsb_packet_success(struct hpsb_packet *packet)
 233 {
 234         switch (packet->ack_code) {
 235         case ACK_PENDING:
 236                 switch ((packet->header[1] >> 12) & 0xf) {
 237                 case RCODE_COMPLETE:
 238                         return 0;
 239                 case RCODE_CONFLICT_ERROR:
 240                         return -EAGAIN;
 241                 case RCODE_DATA_ERROR:
 242                         return -EREMOTEIO;
 243                 case RCODE_TYPE_ERROR:
 244                         return -EACCES;
 245                 case RCODE_ADDRESS_ERROR:
 246                         return -EINVAL;
 247                 default:
 248                         HPSB_ERR("received reserved rcode %d from node %d",
 249                                  (packet->header[1] >> 12) & 0xf,
 250                                  packet->node_id);
 251                         return -EAGAIN;
 252                 }
 253                 HPSB_PANIC("reached unreachable code 1 in %s", __FUNCTION__);
 254
 255         case ACK_BUSY_X:
 256         case ACK_BUSY_A:
 257         case ACK_BUSY_B:
 258                 return -EBUSY;
 259
 260         case ACK_TYPE_ERROR:
 261                 return -EACCES;
 262
 263         case ACK_COMPLETE:
 264                 if (packet->tcode == TCODE_WRITEQ
 265                     || packet->tcode == TCODE_WRITEB) {
 266                         return 0;
 267                 } else {
 268                         HPSB_ERR("impossible ack_complete from node %d "
 269                                  "(tcode %d)", packet->node_id, packet->tcode);
 270                         return -EAGAIN;
 271                 }
 272
 273
 274         case ACK_DATA_ERROR:
 275                 if (packet->tcode == TCODE_WRITEB
 276                     || packet->tcode == TCODE_LOCK_REQUEST) {
 277                         return -EAGAIN;
 278                 } else {
 279                         HPSB_ERR("impossible ack_data_error from node %d "
 280                                  "(tcode %d)", packet->node_id, packet->tcode);
 281                         return -EAGAIN;
 282                 }
 283
 284         case ACKX_NONE:
 285         case ACKX_SEND_ERROR:
 286         case ACKX_ABORTED:
 287         case ACKX_TIMEOUT:
 288                 /* error while sending */
 289                 return -EAGAIN;
 290
 291         default:
 292                 HPSB_ERR("got invalid ack %d from node %d (tcode %d)",
 293                          packet->ack_code, packet->node_id, packet->tcode);
 294                 return -EAGAIN;
 295         }
 296
 297         HPSB_PANIC("reached unreachable code 2 in %s", __FUNCTION__);
 298 }
 299
 300 struct hpsb_packet *hpsb_make_readqpacket(struct hpsb_host *host, nodeid_t node,
 301                                           u64 addr)
 302 {
 303         struct hpsb_packet *p;
 304
 305         p = alloc_hpsb_packet(0);
 306         if (!p) return NULL;
 307
 308         p->host = host;
 309         p->tlabel = get_tlabel(host, node, 1);
 310         p->node_id = node;
 311         fill_async_readquad(p, addr);
 312
 313         return p;
 314 }
 315
 316 struct hpsb_packet *hpsb_make_readbpacket(struct hpsb_host *host, nodeid_t node,
 317                                           u64 addr, size_t length)
 318 {
 319         struct hpsb_packet *p;
 320
 321         p = alloc_hpsb_packet(length + (length % 4 ? 4 - (length % 4) : 0));
 322         if (!p) return NULL;
 323
 324         p->host = host;
 325         p->tlabel = get_tlabel(host, node, 1);
 326         p->node_id = node;
 327         fill_async_readblock(p, addr, length);
 328
 329         return p;
 330 }
 331
 332 struct hpsb_packet *hpsb_make_writeqpacket(struct hpsb_host *host,
 333                                            nodeid_t node, u64 addr,
 334                                            quadlet_t data)
 335 {
 336         struct hpsb_packet *p;
 337
 338         p = alloc_hpsb_packet(0);
 339         if (!p) return NULL;
 340
 341         p->host = host;
 342         p->tlabel = get_tlabel(host, node, 1);
 343         p->node_id = node;
 344         fill_async_writequad(p, addr, data);
 345
 346         return p;
 347 }
 348
 349 struct hpsb_packet *hpsb_make_writebpacket(struct hpsb_host *host,
 350                                            nodeid_t node, u64 addr,
 351                                            size_t length)
 352 {
 353         struct hpsb_packet *p;
 354
 355         p = alloc_hpsb_packet(length + (length % 4 ? 4 - (length % 4) : 0));
 356         if (!p) return NULL;
 357
 358         if (length % 4) {
 359                 p->data[length / 4] = 0;
 360         }
 361
 362         p->host = host;
 363         p->tlabel = get_tlabel(host, node, 1);
 364         p->node_id = node;
 365         fill_async_writeblock(p, addr, length);
 366
 367         return p;
 368 }
 369
 370 struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node,
 371                                          u64 addr, int extcode)
 372 {
 373         struct hpsb_packet *p;
 374
 375         p = alloc_hpsb_packet(8);
 376         if (!p) return NULL;
 377
 378         p->host = host;
 379         p->tlabel = get_tlabel(host, node, 1);
 380         p->node_id = node;
 381
 382         switch (extcode) {
 383         case EXTCODE_FETCH_ADD:
 384         case EXTCODE_LITTLE_ADD:
 385                 fill_async_lock(p, addr, extcode, 4);
 386                 break;
 387         default:
 388                 fill_async_lock(p, addr, extcode, 8);
 389                 break;
 390         }
 391
 392         return p;
 393 }
 394
 395 struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host, nodeid_t node,
 396                                            u64 addr, int extcode)
 397 {
 398         struct hpsb_packet *p;
 399
 400         p = alloc_hpsb_packet(16);
 401         if (!p) return NULL;
 402
 403         p->host = host;
 404         p->tlabel = get_tlabel(host, node, 1);
 405         p->node_id = node;
 406
 407         switch (extcode) {
 408         case EXTCODE_FETCH_ADD:
 409         case EXTCODE_LITTLE_ADD:
 410                 fill_async_lock(p, addr, extcode, 8);
 411                 break;
 412         default:
 413                 fill_async_lock(p, addr, extcode, 16);
 414                 break;
 415         }
 416
 417         return p;
 418 }
 419
 420 struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host,
 421                                         quadlet_t data)
 422 {
 423         struct hpsb_packet *p;
 424
 425         p = alloc_hpsb_packet(0);
 426         if (!p) return NULL;
 427
 428         p->host = host;
 429         fill_phy_packet(p, data);
 430
 431         return p;
 432 }
 433
 434 /*
 435  * FIXME - these functions should probably read from / write to user space to
 436  * avoid in kernel buffers for user space callers
 437  */
 438
 439 int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation,
 440               u64 addr, quadlet_t *buffer, size_t length)
 441 {
 442         struct hpsb_packet *packet;
 443         int retval = 0;
 444
 445         if (length == 0) {
 446                 return -EINVAL;
 447         }
 448
 449         if (length == 4) {
 450                 packet = hpsb_make_readqpacket(host, node, addr);
 451         } else {
 452                 packet = hpsb_make_readbpacket(host, node, addr, length);
 453         }
 454
 455         if (!packet) {
 456                 return -ENOMEM;
 457         }
 458
 459         packet->generation = generation;
 460         if (!hpsb_send_packet(packet)) {
 461                 retval = -EINVAL;
 462                 goto hpsb_read_fail;
 463         }
 464
 465         down(&packet->state_change);
 466         down(&packet->state_change);
 467         retval = hpsb_packet_success(packet);
 468
 469         if (retval == 0) {
 470                 if (length == 4) {
 471                         *buffer = packet->header[3];
 472                 } else {
 473                         memcpy(buffer, packet->data, length);
 474                 }
 475         }
 476
 477 hpsb_read_fail:
 478         free_tlabel(host, node, packet->tlabel);
 479         free_hpsb_packet(packet);
 480
 481         return retval;
 482 }
 483
 484 struct hpsb_packet *hpsb_make_packet (struct hpsb_host *host, nodeid_t node,
 485                                       u64 addr, quadlet_t *buffer, size_t length)
 486 {
 487         struct hpsb_packet *packet;
 488
 489         if (length == 0)
 490                 return NULL;
 491
 492         if (length == 4)
 493                 packet = hpsb_make_writeqpacket(host, node, addr, *buffer);
 494         else
 495                 packet = hpsb_make_writebpacket(host, node, addr, length);
 496
 497         if (!packet)
 498                 return NULL;
 499
 500         /* Sometimes this may be called without data, just to allocate the
 501          * packet. */
 502         if (length != 4 && buffer)
 503                 memcpy(packet->data, buffer, length);
 504
 505         return packet;
 506 }
 507
 508 int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
 509                u64 addr, quadlet_t *buffer, size_t length)
 510 {
 511         struct hpsb_packet *packet;
 512         int retval;
 513
 514         if (length == 0)
 515                 return -EINVAL;
 516
 517         packet = hpsb_make_packet (host, node, addr, buffer, length);
 518
 519         if (!packet)
 520                 return -ENOMEM;
 521
 522         packet->generation = generation;
 523         if (!hpsb_send_packet(packet)) {
 524                 retval = -EINVAL;
 525                 goto hpsb_write_fail;
 526         }
 527
 528         down(&packet->state_change);
 529         down(&packet->state_change);
 530         retval = hpsb_packet_success(packet);
 531
 532 hpsb_write_fail:
 533         free_tlabel(host, node, packet->tlabel);
 534         free_hpsb_packet(packet);
 535
 536         return retval;
 537 }
 538
 539
 540 /* We need a hpsb_lock64 function for the 64 bit equivalent.  Probably. */
 541 int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
 542               u64 addr, int extcode, quadlet_t *data, quadlet_t arg)
 543 {
 544         struct hpsb_packet *packet;
 545         int retval = 0, length;
 546
 547         packet = alloc_hpsb_packet(8);
 548         if (!packet) {
 549                 return -ENOMEM;
 550         }
 551
 552         packet->host = host;
 553         packet->tlabel = get_tlabel(host, node, 1);
 554         packet->node_id = node;
 555
 556         switch (extcode) {
 557         case EXTCODE_MASK_SWAP:
 558         case EXTCODE_COMPARE_SWAP:
 559         case EXTCODE_BOUNDED_ADD:
 560         case EXTCODE_WRAP_ADD:
 561                 length = 8;
 562                 packet->data[0] = arg;
 563                 packet->data[1] = *data;
 564                 break;
 565         case EXTCODE_FETCH_ADD:
 566         case EXTCODE_LITTLE_ADD:
 567                 length = 4;
 568                 packet->data[0] = *data;
 569                 break;
 570         default:
 571                 return -EINVAL;
 572         }
 573         fill_async_lock(packet, addr, extcode, length);
 574
 575         packet->generation = generation;
 576         if (!hpsb_send_packet(packet)) {
 577                 retval = -EINVAL;
 578                 goto hpsb_lock_fail;
 579         }
 580         down(&packet->state_change);
 581         down(&packet->state_change);
 582         retval = hpsb_packet_success(packet);
 583
 584         if (retval == 0) {
 585                 *data = packet->data[0];
 586         }
 587
 588 hpsb_lock_fail:
 589         free_tlabel(host, node, packet->tlabel);
 590         free_hpsb_packet(packet);
 591
 592         return retval;
 593 }