git.oblomov.eu Git - linux-2.6/blob - arch/sparc64/kernel/ldc.c

   1 /* ldc.c: Logical Domain Channel link-layer protocol driver.
   2  *
   3  * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/slab.h>
   9 #include <linux/spinlock.h>
  10 #include <linux/delay.h>
  11 #include <linux/errno.h>
  12 #include <linux/string.h>
  13 #include <linux/scatterlist.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/list.h>
  16 #include <linux/init.h>
  17
  18 #include <asm/hypervisor.h>
  19 #include <asm/iommu.h>
  20 #include <asm/page.h>
  21 #include <asm/ldc.h>
  22 #include <asm/mdesc.h>
  23
  24 #define DRV_MODULE_NAME         "ldc"
  25 #define PFX DRV_MODULE_NAME     ": "
  26 #define DRV_MODULE_VERSION      "1.0"
  27 #define DRV_MODULE_RELDATE      "June 25, 2007"
  28
  29 static char version[] __devinitdata =
  30         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  31 #define LDC_PACKET_SIZE         64
  32
  33 /* Packet header layout for unreliable and reliable mode frames.
  34  * When in RAW mode, packets are simply straight 64-byte payloads
  35  * with no headers.
  36  */
  37 struct ldc_packet {
  38         u8                      type;
  39 #define LDC_CTRL                0x01
  40 #define LDC_DATA                0x02
  41 #define LDC_ERR                 0x10
  42
  43         u8                      stype;
  44 #define LDC_INFO                0x01
  45 #define LDC_ACK                 0x02
  46 #define LDC_NACK                0x04
  47
  48         u8                      ctrl;
  49 #define LDC_VERS                0x01 /* Link Version            */
  50 #define LDC_RTS                 0x02 /* Request To Send         */
  51 #define LDC_RTR                 0x03 /* Ready To Receive        */
  52 #define LDC_RDX                 0x04 /* Ready for Data eXchange */
  53 #define LDC_CTRL_MSK            0x0f
  54
  55         u8                      env;
  56 #define LDC_LEN                 0x3f
  57 #define LDC_FRAG_MASK           0xc0
  58 #define LDC_START               0x40
  59 #define LDC_STOP                0x80
  60
  61         u32                     seqid;
  62
  63         union {
  64                 u8              u_data[LDC_PACKET_SIZE - 8];
  65                 struct {
  66                         u32     pad;
  67                         u32     ackid;
  68                         u8      r_data[LDC_PACKET_SIZE - 8 - 8];
  69                 } r;
  70         } u;
  71 };
  72
  73 struct ldc_version {
  74         u16 major;
  75         u16 minor;
  76 };
  77
  78 /* Ordered from largest major to lowest.  */
  79 static struct ldc_version ver_arr[] = {
  80         { .major = 1, .minor = 0 },
  81 };
  82
  83 #define LDC_DEFAULT_MTU                 (4 * LDC_PACKET_SIZE)
  84 #define LDC_DEFAULT_NUM_ENTRIES         (PAGE_SIZE / LDC_PACKET_SIZE)
  85
  86 struct ldc_channel;
  87
  88 struct ldc_mode_ops {
  89         int (*write)(struct ldc_channel *, const void *, unsigned int);
  90         int (*read)(struct ldc_channel *, void *, unsigned int);
  91 };
  92
  93 static const struct ldc_mode_ops raw_ops;
  94 static const struct ldc_mode_ops nonraw_ops;
  95 static const struct ldc_mode_ops stream_ops;
  96
  97 int ldom_domaining_enabled;
  98
  99 struct ldc_iommu {
 100         /* Protects arena alloc/free.  */
 101         spinlock_t                      lock;
 102         struct iommu_arena              arena;
 103         struct ldc_mtable_entry         *page_table;
 104 };
 105
 106 struct ldc_channel {
 107         /* Protects all operations that depend upon channel state.  */
 108         spinlock_t                      lock;
 109
 110         unsigned long                   id;
 111
 112         u8                              *mssbuf;
 113         u32                             mssbuf_len;
 114         u32                             mssbuf_off;
 115
 116         struct ldc_packet               *tx_base;
 117         unsigned long                   tx_head;
 118         unsigned long                   tx_tail;
 119         unsigned long                   tx_num_entries;
 120         unsigned long                   tx_ra;
 121
 122         unsigned long                   tx_acked;
 123
 124         struct ldc_packet               *rx_base;
 125         unsigned long                   rx_head;
 126         unsigned long                   rx_tail;
 127         unsigned long                   rx_num_entries;
 128         unsigned long                   rx_ra;
 129
 130         u32                             rcv_nxt;
 131         u32                             snd_nxt;
 132
 133         unsigned long                   chan_state;
 134
 135         struct ldc_channel_config       cfg;
 136         void                            *event_arg;
 137
 138         const struct ldc_mode_ops       *mops;
 139
 140         struct ldc_iommu                iommu;
 141
 142         struct ldc_version              ver;
 143
 144         u8                              hs_state;
 145 #define LDC_HS_CLOSED                   0x00
 146 #define LDC_HS_OPEN                     0x01
 147 #define LDC_HS_GOTVERS                  0x02
 148 #define LDC_HS_SENTRTR                  0x03
 149 #define LDC_HS_GOTRTR                   0x04
 150 #define LDC_HS_COMPLETE                 0x10
 151
 152         u8                              flags;
 153 #define LDC_FLAG_ALLOCED_QUEUES         0x01
 154 #define LDC_FLAG_REGISTERED_QUEUES      0x02
 155 #define LDC_FLAG_REGISTERED_IRQS        0x04
 156 #define LDC_FLAG_RESET                  0x10
 157
 158         u8                              mss;
 159         u8                              state;
 160
 161 #define LDC_IRQ_NAME_MAX                32
 162         char                            rx_irq_name[LDC_IRQ_NAME_MAX];
 163         char                            tx_irq_name[LDC_IRQ_NAME_MAX];
 164
 165         struct hlist_head               mh_list;
 166
 167         struct hlist_node               list;
 168 };
 169
 170 #define ldcdbg(TYPE, f, a...) \
 171 do {    if (lp->cfg.debug & LDC_DEBUG_##TYPE) \
 172                 printk(KERN_INFO PFX "ID[%lu] " f, lp->id, ## a); \
 173 } while (0)
 174
 175 static const char *state_to_str(u8 state)
 176 {
 177         switch (state) {
 178         case LDC_STATE_INVALID:
 179                 return "INVALID";
 180         case LDC_STATE_INIT:
 181                 return "INIT";
 182         case LDC_STATE_BOUND:
 183                 return "BOUND";
 184         case LDC_STATE_READY:
 185                 return "READY";
 186         case LDC_STATE_CONNECTED:
 187                 return "CONNECTED";
 188         default:
 189                 return "<UNKNOWN>";
 190         }
 191 }
 192
 193 static void ldc_set_state(struct ldc_channel *lp, u8 state)
 194 {
 195         ldcdbg(STATE, "STATE (%s) --> (%s)\n",
 196                state_to_str(lp->state),
 197                state_to_str(state));
 198
 199         lp->state = state;
 200 }
 201
 202 static unsigned long __advance(unsigned long off, unsigned long num_entries)
 203 {
 204         off += LDC_PACKET_SIZE;
 205         if (off == (num_entries * LDC_PACKET_SIZE))
 206                 off = 0;
 207
 208         return off;
 209 }
 210
 211 static unsigned long rx_advance(struct ldc_channel *lp, unsigned long off)
 212 {
 213         return __advance(off, lp->rx_num_entries);
 214 }
 215
 216 static unsigned long tx_advance(struct ldc_channel *lp, unsigned long off)
 217 {
 218         return __advance(off, lp->tx_num_entries);
 219 }
 220
 221 static struct ldc_packet *handshake_get_tx_packet(struct ldc_channel *lp,
 222                                                   unsigned long *new_tail)
 223 {
 224         struct ldc_packet *p;
 225         unsigned long t;
 226
 227         t = tx_advance(lp, lp->tx_tail);
 228         if (t == lp->tx_head)
 229                 return NULL;
 230
 231         *new_tail = t;
 232
 233         p = lp->tx_base;
 234         return p + (lp->tx_tail / LDC_PACKET_SIZE);
 235 }
 236
 237 /* When we are in reliable or stream mode, have to track the next packet
 238  * we haven't gotten an ACK for in the TX queue using tx_acked.  We have
 239  * to be careful not to stomp over the queue past that point.  During
 240  * the handshake, we don't have TX data packets pending in the queue
 241  * and that's why handshake_get_tx_packet() need not be mindful of
 242  * lp->tx_acked.
 243  */
 244 static unsigned long head_for_data(struct ldc_channel *lp)
 245 {
 246         if (lp->cfg.mode == LDC_MODE_STREAM)
 247                 return lp->tx_acked;
 248         return lp->tx_head;
 249 }
 250
 251 static int tx_has_space_for(struct ldc_channel *lp, unsigned int size)
 252 {
 253         unsigned long limit, tail, new_tail, diff;
 254         unsigned int mss;
 255
 256         limit = head_for_data(lp);
 257         tail = lp->tx_tail;
 258         new_tail = tx_advance(lp, tail);
 259         if (new_tail == limit)
 260                 return 0;
 261
 262         if (limit > new_tail)
 263                 diff = limit - new_tail;
 264         else
 265                 diff = (limit +
 266                         ((lp->tx_num_entries * LDC_PACKET_SIZE) - new_tail));
 267         diff /= LDC_PACKET_SIZE;
 268         mss = lp->mss;
 269
 270         if (diff * mss < size)
 271                 return 0;
 272
 273         return 1;
 274 }
 275
 276 static struct ldc_packet *data_get_tx_packet(struct ldc_channel *lp,
 277                                              unsigned long *new_tail)
 278 {
 279         struct ldc_packet *p;
 280         unsigned long h, t;
 281
 282         h = head_for_data(lp);
 283         t = tx_advance(lp, lp->tx_tail);
 284         if (t == h)
 285                 return NULL;
 286
 287         *new_tail = t;
 288
 289         p = lp->tx_base;
 290         return p + (lp->tx_tail / LDC_PACKET_SIZE);
 291 }
 292
 293 static int set_tx_tail(struct ldc_channel *lp, unsigned long tail)
 294 {
 295         unsigned long orig_tail = lp->tx_tail;
 296         int limit = 1000;
 297
 298         lp->tx_tail = tail;
 299         while (limit-- > 0) {
 300                 unsigned long err;
 301
 302                 err = sun4v_ldc_tx_set_qtail(lp->id, tail);
 303                 if (!err)
 304                         return 0;
 305
 306                 if (err != HV_EWOULDBLOCK) {
 307                         lp->tx_tail = orig_tail;
 308                         return -EINVAL;
 309                 }
 310                 udelay(1);
 311         }
 312
 313         lp->tx_tail = orig_tail;
 314         return -EBUSY;
 315 }
 316
 317 /* This just updates the head value in the hypervisor using
 318  * a polling loop with a timeout.  The caller takes care of
 319  * upating software state representing the head change, if any.
 320  */
 321 static int __set_rx_head(struct ldc_channel *lp, unsigned long head)
 322 {
 323         int limit = 1000;
 324
 325         while (limit-- > 0) {
 326                 unsigned long err;
 327
 328                 err = sun4v_ldc_rx_set_qhead(lp->id, head);
 329                 if (!err)
 330                         return 0;
 331
 332                 if (err != HV_EWOULDBLOCK)
 333                         return -EINVAL;
 334
 335                 udelay(1);
 336         }
 337
 338         return -EBUSY;
 339 }
 340
 341 static int send_tx_packet(struct ldc_channel *lp,
 342                           struct ldc_packet *p,
 343                           unsigned long new_tail)
 344 {
 345         BUG_ON(p != (lp->tx_base + (lp->tx_tail / LDC_PACKET_SIZE)));
 346
 347         return set_tx_tail(lp, new_tail);
 348 }
 349
 350 static struct ldc_packet *handshake_compose_ctrl(struct ldc_channel *lp,
 351                                                  u8 stype, u8 ctrl,
 352                                                  void *data, int dlen,
 353                                                  unsigned long *new_tail)
 354 {
 355         struct ldc_packet *p = handshake_get_tx_packet(lp, new_tail);
 356
 357         if (p) {
 358                 memset(p, 0, sizeof(*p));
 359                 p->type = LDC_CTRL;
 360                 p->stype = stype;
 361                 p->ctrl = ctrl;
 362                 if (data)
 363                         memcpy(p->u.u_data, data, dlen);
 364         }
 365         return p;
 366 }
 367
 368 static int start_handshake(struct ldc_channel *lp)
 369 {
 370         struct ldc_packet *p;
 371         struct ldc_version *ver;
 372         unsigned long new_tail;
 373
 374         ver = &ver_arr[0];
 375
 376         ldcdbg(HS, "SEND VER INFO maj[%u] min[%u]\n",
 377                ver->major, ver->minor);
 378
 379         p = handshake_compose_ctrl(lp, LDC_INFO, LDC_VERS,
 380                                    ver, sizeof(*ver), &new_tail);
 381         if (p) {
 382                 int err = send_tx_packet(lp, p, new_tail);
 383                 if (!err)
 384                         lp->flags &= ~LDC_FLAG_RESET;
 385                 return err;
 386         }
 387         return -EBUSY;
 388 }
 389
 390 static int send_version_nack(struct ldc_channel *lp,
 391                              u16 major, u16 minor)
 392 {
 393         struct ldc_packet *p;
 394         struct ldc_version ver;
 395         unsigned long new_tail;
 396
 397         ver.major = major;
 398         ver.minor = minor;
 399
 400         p = handshake_compose_ctrl(lp, LDC_NACK, LDC_VERS,
 401                                    &ver, sizeof(ver), &new_tail);
 402         if (p) {
 403                 ldcdbg(HS, "SEND VER NACK maj[%u] min[%u]\n",
 404                        ver.major, ver.minor);
 405
 406                 return send_tx_packet(lp, p, new_tail);
 407         }
 408         return -EBUSY;
 409 }
 410
 411 static int send_version_ack(struct ldc_channel *lp,
 412                             struct ldc_version *vp)
 413 {
 414         struct ldc_packet *p;
 415         unsigned long new_tail;
 416
 417         p = handshake_compose_ctrl(lp, LDC_ACK, LDC_VERS,
 418                                    vp, sizeof(*vp), &new_tail);
 419         if (p) {
 420                 ldcdbg(HS, "SEND VER ACK maj[%u] min[%u]\n",
 421                        vp->major, vp->minor);
 422
 423                 return send_tx_packet(lp, p, new_tail);
 424         }
 425         return -EBUSY;
 426 }
 427
 428 static int send_rts(struct ldc_channel *lp)
 429 {
 430         struct ldc_packet *p;
 431         unsigned long new_tail;
 432
 433         p = handshake_compose_ctrl(lp, LDC_INFO, LDC_RTS, NULL, 0,
 434                                    &new_tail);
 435         if (p) {
 436                 p->env = lp->cfg.mode;
 437                 p->seqid = 0;
 438                 lp->rcv_nxt = 0;
 439
 440                 ldcdbg(HS, "SEND RTS env[0x%x] seqid[0x%x]\n",
 441                        p->env, p->seqid);
 442
 443                 return send_tx_packet(lp, p, new_tail);
 444         }
 445         return -EBUSY;
 446 }
 447
 448 static int send_rtr(struct ldc_channel *lp)
 449 {
 450         struct ldc_packet *p;
 451         unsigned long new_tail;
 452
 453         p = handshake_compose_ctrl(lp, LDC_INFO, LDC_RTR, NULL, 0,
 454                                    &new_tail);
 455         if (p) {
 456                 p->env = lp->cfg.mode;
 457                 p->seqid = 0;
 458
 459                 ldcdbg(HS, "SEND RTR env[0x%x] seqid[0x%x]\n",
 460                        p->env, p->seqid);
 461
 462                 return send_tx_packet(lp, p, new_tail);
 463         }
 464         return -EBUSY;
 465 }
 466
 467 static int send_rdx(struct ldc_channel *lp)
 468 {
 469         struct ldc_packet *p;
 470         unsigned long new_tail;
 471
 472         p = handshake_compose_ctrl(lp, LDC_INFO, LDC_RDX, NULL, 0,
 473                                    &new_tail);
 474         if (p) {
 475                 p->env = 0;
 476                 p->seqid = ++lp->snd_nxt;
 477                 p->u.r.ackid = lp->rcv_nxt;
 478
 479                 ldcdbg(HS, "SEND RDX env[0x%x] seqid[0x%x] ackid[0x%x]\n",
 480                        p->env, p->seqid, p->u.r.ackid);
 481
 482                 return send_tx_packet(lp, p, new_tail);
 483         }
 484         return -EBUSY;
 485 }
 486
 487 static int send_data_nack(struct ldc_channel *lp, struct ldc_packet *data_pkt)
 488 {
 489         struct ldc_packet *p;
 490         unsigned long new_tail;
 491         int err;
 492
 493         p = data_get_tx_packet(lp, &new_tail);
 494         if (!p)
 495                 return -EBUSY;
 496         memset(p, 0, sizeof(*p));
 497         p->type = data_pkt->type;
 498         p->stype = LDC_NACK;
 499         p->ctrl = data_pkt->ctrl & LDC_CTRL_MSK;
 500         p->seqid = lp->snd_nxt + 1;
 501         p->u.r.ackid = lp->rcv_nxt;
 502
 503         ldcdbg(HS, "SEND DATA NACK type[0x%x] ctl[0x%x] seq[0x%x] ack[0x%x]\n",
 504                p->type, p->ctrl, p->seqid, p->u.r.ackid);
 505
 506         err = send_tx_packet(lp, p, new_tail);
 507         if (!err)
 508                 lp->snd_nxt++;
 509
 510         return err;
 511 }
 512
 513 static int ldc_abort(struct ldc_channel *lp)
 514 {
 515         unsigned long hv_err;
 516
 517         ldcdbg(STATE, "ABORT\n");
 518
 519         /* We report but do not act upon the hypervisor errors because
 520          * there really isn't much we can do if they fail at this point.
 521          */
 522         hv_err = sun4v_ldc_tx_qconf(lp->id, lp->tx_ra, lp->tx_num_entries);
 523         if (hv_err)
 524                 printk(KERN_ERR PFX "ldc_abort: "
 525                        "sun4v_ldc_tx_qconf(%lx,%lx,%lx) failed, err=%lu\n",
 526                        lp->id, lp->tx_ra, lp->tx_num_entries, hv_err);
 527
 528         hv_err = sun4v_ldc_tx_get_state(lp->id,
 529                                         &lp->tx_head,
 530                                         &lp->tx_tail,
 531                                         &lp->chan_state);
 532         if (hv_err)
 533                 printk(KERN_ERR PFX "ldc_abort: "
 534                        "sun4v_ldc_tx_get_state(%lx,...) failed, err=%lu\n",
 535                        lp->id, hv_err);
 536
 537         hv_err = sun4v_ldc_rx_qconf(lp->id, lp->rx_ra, lp->rx_num_entries);
 538         if (hv_err)
 539                 printk(KERN_ERR PFX "ldc_abort: "
 540                        "sun4v_ldc_rx_qconf(%lx,%lx,%lx) failed, err=%lu\n",
 541                        lp->id, lp->rx_ra, lp->rx_num_entries, hv_err);
 542
 543         /* Refetch the RX queue state as well, because we could be invoked
 544          * here in the queue processing context.
 545          */
 546         hv_err = sun4v_ldc_rx_get_state(lp->id,
 547                                         &lp->rx_head,
 548                                         &lp->rx_tail,
 549                                         &lp->chan_state);
 550         if (hv_err)
 551                 printk(KERN_ERR PFX "ldc_abort: "
 552                        "sun4v_ldc_rx_get_state(%lx,...) failed, err=%lu\n",
 553                        lp->id, hv_err);
 554
 555         return -ECONNRESET;
 556 }
 557
 558 static struct ldc_version *find_by_major(u16 major)
 559 {
 560         struct ldc_version *ret = NULL;
 561         int i;
 562
 563         for (i = 0; i < ARRAY_SIZE(ver_arr); i++) {
 564                 struct ldc_version *v = &ver_arr[i];
 565                 if (v->major <= major) {
 566                         ret = v;
 567                         break;
 568                 }
 569         }
 570         return ret;
 571 }
 572
 573 static int process_ver_info(struct ldc_channel *lp, struct ldc_version *vp)
 574 {
 575         struct ldc_version *vap;
 576         int err;
 577
 578         ldcdbg(HS, "GOT VERSION INFO major[%x] minor[%x]\n",
 579                vp->major, vp->minor);
 580
 581         if (lp->hs_state == LDC_HS_GOTVERS) {
 582                 lp->hs_state = LDC_HS_OPEN;
 583                 memset(&lp->ver, 0, sizeof(lp->ver));
 584         }
 585
 586         vap = find_by_major(vp->major);
 587         if (!vap) {
 588                 err = send_version_nack(lp, 0, 0);
 589         } else if (vap->major != vp->major) {
 590                 err = send_version_nack(lp, vap->major, vap->minor);
 591         } else {
 592                 struct ldc_version ver = *vp;
 593                 if (ver.minor > vap->minor)
 594                         ver.minor = vap->minor;
 595                 err = send_version_ack(lp, &ver);
 596                 if (!err) {
 597                         lp->ver = ver;
 598                         lp->hs_state = LDC_HS_GOTVERS;
 599                 }
 600         }
 601         if (err)
 602                 return ldc_abort(lp);
 603
 604         return 0;
 605 }
 606
 607 static int process_ver_ack(struct ldc_channel *lp, struct ldc_version *vp)
 608 {
 609         ldcdbg(HS, "GOT VERSION ACK major[%x] minor[%x]\n",
 610                vp->major, vp->minor);
 611
 612         if (lp->hs_state == LDC_HS_GOTVERS) {
 613                 if (lp->ver.major != vp->major ||
 614                     lp->ver.minor != vp->minor)
 615                         return ldc_abort(lp);
 616         } else {
 617                 lp->ver = *vp;
 618                 lp->hs_state = LDC_HS_GOTVERS;
 619         }
 620         if (send_rts(lp))
 621                 return ldc_abort(lp);
 622         return 0;
 623 }
 624
 625 static int process_ver_nack(struct ldc_channel *lp, struct ldc_version *vp)
 626 {
 627         struct ldc_version *vap;
 628
 629         if ((vp->major == 0 && vp->minor == 0) ||
 630             !(vap = find_by_major(vp->major))) {
 631                 return ldc_abort(lp);
 632         } else {
 633                 struct ldc_packet *p;
 634                 unsigned long new_tail;
 635
 636                 p = handshake_compose_ctrl(lp, LDC_INFO, LDC_VERS,
 637                                            vap, sizeof(*vap),
 638                                            &new_tail);
 639                 if (p)
 640                         return send_tx_packet(lp, p, new_tail);
 641                 else
 642                         return ldc_abort(lp);
 643         }
 644 }
 645
 646 static int process_version(struct ldc_channel *lp,
 647                            struct ldc_packet *p)
 648 {
 649         struct ldc_version *vp;
 650
 651         vp = (struct ldc_version *) p->u.u_data;
 652
 653         switch (p->stype) {
 654         case LDC_INFO:
 655                 return process_ver_info(lp, vp);
 656
 657         case LDC_ACK:
 658                 return process_ver_ack(lp, vp);
 659
 660         case LDC_NACK:
 661                 return process_ver_nack(lp, vp);
 662
 663         default:
 664                 return ldc_abort(lp);
 665         }
 666 }
 667
 668 static int process_rts(struct ldc_channel *lp,
 669                        struct ldc_packet *p)
 670 {
 671         ldcdbg(HS, "GOT RTS stype[%x] seqid[%x] env[%x]\n",
 672                p->stype, p->seqid, p->env);
 673
 674         if (p->stype     != LDC_INFO       ||
 675             lp->hs_state != LDC_HS_GOTVERS ||
 676             p->env       != lp->cfg.mode)
 677                 return ldc_abort(lp);
 678
 679         lp->snd_nxt = p->seqid;
 680         lp->rcv_nxt = p->seqid;
 681         lp->hs_state = LDC_HS_SENTRTR;
 682         if (send_rtr(lp))
 683                 return ldc_abort(lp);
 684
 685         return 0;
 686 }
 687
 688 static int process_rtr(struct ldc_channel *lp,
 689                        struct ldc_packet *p)
 690 {
 691         ldcdbg(HS, "GOT RTR stype[%x] seqid[%x] env[%x]\n",
 692                p->stype, p->seqid, p->env);
 693
 694         if (p->stype     != LDC_INFO ||
 695             p->env       != lp->cfg.mode)
 696                 return ldc_abort(lp);
 697
 698         lp->snd_nxt = p->seqid;
 699         lp->hs_state = LDC_HS_COMPLETE;
 700         ldc_set_state(lp, LDC_STATE_CONNECTED);
 701         send_rdx(lp);
 702
 703         return LDC_EVENT_UP;
 704 }
 705
 706 static int rx_seq_ok(struct ldc_channel *lp, u32 seqid)
 707 {
 708         return lp->rcv_nxt + 1 == seqid;
 709 }
 710
 711 static int process_rdx(struct ldc_channel *lp,
 712                        struct ldc_packet *p)
 713 {
 714         ldcdbg(HS, "GOT RDX stype[%x] seqid[%x] env[%x] ackid[%x]\n",
 715                p->stype, p->seqid, p->env, p->u.r.ackid);
 716
 717         if (p->stype != LDC_INFO ||
 718             !(rx_seq_ok(lp, p->seqid)))
 719                 return ldc_abort(lp);
 720
 721         lp->rcv_nxt = p->seqid;
 722
 723         lp->hs_state = LDC_HS_COMPLETE;
 724         ldc_set_state(lp, LDC_STATE_CONNECTED);
 725
 726         return LDC_EVENT_UP;
 727 }
 728
 729 static int process_control_frame(struct ldc_channel *lp,
 730                                  struct ldc_packet *p)
 731 {
 732         switch (p->ctrl) {
 733         case LDC_VERS:
 734                 return process_version(lp, p);
 735
 736         case LDC_RTS:
 737                 return process_rts(lp, p);
 738
 739         case LDC_RTR:
 740                 return process_rtr(lp, p);
 741
 742         case LDC_RDX:
 743                 return process_rdx(lp, p);
 744
 745         default:
 746                 return ldc_abort(lp);
 747         }
 748 }
 749
 750 static int process_error_frame(struct ldc_channel *lp,
 751                                struct ldc_packet *p)
 752 {
 753         return ldc_abort(lp);
 754 }
 755
 756 static int process_data_ack(struct ldc_channel *lp,
 757                             struct ldc_packet *ack)
 758 {
 759         unsigned long head = lp->tx_acked;
 760         u32 ackid = ack->u.r.ackid;
 761
 762         while (1) {
 763                 struct ldc_packet *p = lp->tx_base + (head / LDC_PACKET_SIZE);
 764
 765                 head = tx_advance(lp, head);
 766
 767                 if (p->seqid == ackid) {
 768                         lp->tx_acked = head;
 769                         return 0;
 770                 }
 771                 if (head == lp->tx_tail)
 772                         return ldc_abort(lp);
 773         }
 774
 775         return 0;
 776 }
 777
 778 static void send_events(struct ldc_channel *lp, unsigned int event_mask)
 779 {
 780         if (event_mask & LDC_EVENT_RESET)
 781                 lp->cfg.event(lp->event_arg, LDC_EVENT_RESET);
 782         if (event_mask & LDC_EVENT_UP)
 783                 lp->cfg.event(lp->event_arg, LDC_EVENT_UP);
 784         if (event_mask & LDC_EVENT_DATA_READY)
 785                 lp->cfg.event(lp->event_arg, LDC_EVENT_DATA_READY);
 786 }
 787
 788 static irqreturn_t ldc_rx(int irq, void *dev_id)
 789 {
 790         struct ldc_channel *lp = dev_id;
 791         unsigned long orig_state, hv_err, flags;
 792         unsigned int event_mask;
 793
 794         spin_lock_irqsave(&lp->lock, flags);
 795
 796         orig_state = lp->chan_state;
 797         hv_err = sun4v_ldc_rx_get_state(lp->id,
 798                                         &lp->rx_head,
 799                                         &lp->rx_tail,
 800                                         &lp->chan_state);
 801
 802         ldcdbg(RX, "RX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
 803                orig_state, lp->chan_state, lp->rx_head, lp->rx_tail);
 804
 805         event_mask = 0;
 806
 807         if (lp->cfg.mode == LDC_MODE_RAW &&
 808             lp->chan_state == LDC_CHANNEL_UP) {
 809                 lp->hs_state = LDC_HS_COMPLETE;
 810                 ldc_set_state(lp, LDC_STATE_CONNECTED);
 811
 812                 event_mask |= LDC_EVENT_UP;
 813
 814                 orig_state = lp->chan_state;
 815         }
 816
 817         /* If we are in reset state, flush the RX queue and ignore
 818          * everything.
 819          */
 820         if (lp->flags & LDC_FLAG_RESET) {
 821                 (void) __set_rx_head(lp, lp->rx_tail);
 822                 goto out;
 823         }
 824
 825         /* Once we finish the handshake, we let the ldc_read()
 826          * paths do all of the control frame and state management.
 827          * Just trigger the callback.
 828          */
 829         if (lp->hs_state == LDC_HS_COMPLETE) {
 830 handshake_complete:
 831                 if (lp->chan_state != orig_state) {
 832                         unsigned int event = LDC_EVENT_RESET;
 833
 834                         if (lp->chan_state == LDC_CHANNEL_UP)
 835                                 event = LDC_EVENT_UP;
 836
 837                         event_mask |= event;
 838                 }
 839                 if (lp->rx_head != lp->rx_tail)
 840                         event_mask |= LDC_EVENT_DATA_READY;
 841
 842                 goto out;
 843         }
 844
 845         if (lp->chan_state != orig_state)
 846                 goto out;
 847
 848         while (lp->rx_head != lp->rx_tail) {
 849                 struct ldc_packet *p;
 850                 unsigned long new;
 851                 int err;
 852
 853                 p = lp->rx_base + (lp->rx_head / LDC_PACKET_SIZE);
 854
 855                 switch (p->type) {
 856                 case LDC_CTRL:
 857                         err = process_control_frame(lp, p);
 858                         if (err > 0)
 859                                 event_mask |= err;
 860                         break;
 861
 862                 case LDC_DATA:
 863                         event_mask |= LDC_EVENT_DATA_READY;
 864                         err = 0;
 865                         break;
 866
 867                 case LDC_ERR:
 868                         err = process_error_frame(lp, p);
 869                         break;
 870
 871                 default:
 872                         err = ldc_abort(lp);
 873                         break;
 874                 }
 875
 876                 if (err < 0)
 877                         break;
 878
 879                 new = lp->rx_head;
 880                 new += LDC_PACKET_SIZE;
 881                 if (new == (lp->rx_num_entries * LDC_PACKET_SIZE))
 882                         new = 0;
 883                 lp->rx_head = new;
 884
 885                 err = __set_rx_head(lp, new);
 886                 if (err < 0) {
 887                         (void) ldc_abort(lp);
 888                         break;
 889                 }
 890                 if (lp->hs_state == LDC_HS_COMPLETE)
 891                         goto handshake_complete;
 892         }
 893
 894 out:
 895         spin_unlock_irqrestore(&lp->lock, flags);
 896
 897         send_events(lp, event_mask);
 898
 899         return IRQ_HANDLED;
 900 }
 901
 902 static irqreturn_t ldc_tx(int irq, void *dev_id)
 903 {
 904         struct ldc_channel *lp = dev_id;
 905         unsigned long flags, hv_err, orig_state;
 906         unsigned int event_mask = 0;
 907
 908         spin_lock_irqsave(&lp->lock, flags);
 909
 910         orig_state = lp->chan_state;
 911         hv_err = sun4v_ldc_tx_get_state(lp->id,
 912                                         &lp->tx_head,
 913                                         &lp->tx_tail,
 914                                         &lp->chan_state);
 915
 916         ldcdbg(TX, " TX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
 917                orig_state, lp->chan_state, lp->tx_head, lp->tx_tail);
 918
 919         if (lp->cfg.mode == LDC_MODE_RAW &&
 920             lp->chan_state == LDC_CHANNEL_UP) {
 921                 lp->hs_state = LDC_HS_COMPLETE;
 922                 ldc_set_state(lp, LDC_STATE_CONNECTED);
 923
 924                 event_mask |= LDC_EVENT_UP;
 925         }
 926
 927         spin_unlock_irqrestore(&lp->lock, flags);
 928
 929         send_events(lp, event_mask);
 930
 931         return IRQ_HANDLED;
 932 }
 933
 934 /* XXX ldc_alloc() and ldc_free() needs to run under a mutex so
 935  * XXX that addition and removal from the ldc_channel_list has
 936  * XXX atomicity, otherwise the __ldc_channel_exists() check is
 937  * XXX totally pointless as another thread can slip into ldc_alloc()
 938  * XXX and add a channel with the same ID.  There also needs to be
 939  * XXX a spinlock for ldc_channel_list.
 940  */
 941 static HLIST_HEAD(ldc_channel_list);
 942
 943 static int __ldc_channel_exists(unsigned long id)
 944 {
 945         struct ldc_channel *lp;
 946         struct hlist_node *n;
 947
 948         hlist_for_each_entry(lp, n, &ldc_channel_list, list) {
 949                 if (lp->id == id)
 950                         return 1;
 951         }
 952         return 0;
 953 }
 954
 955 static int alloc_queue(const char *name, unsigned long num_entries,
 956                        struct ldc_packet **base, unsigned long *ra)
 957 {
 958         unsigned long size, order;
 959         void *q;
 960
 961         size = num_entries * LDC_PACKET_SIZE;
 962         order = get_order(size);
 963
 964         q = (void *) __get_free_pages(GFP_KERNEL, order);
 965         if (!q) {
 966                 printk(KERN_ERR PFX "Alloc of %s queue failed with "
 967                        "size=%lu order=%lu\n", name, size, order);
 968                 return -ENOMEM;
 969         }
 970
 971         memset(q, 0, PAGE_SIZE << order);
 972
 973         *base = q;
 974         *ra = __pa(q);
 975
 976         return 0;
 977 }
 978
 979 static void free_queue(unsigned long num_entries, struct ldc_packet *q)
 980 {
 981         unsigned long size, order;
 982
 983         if (!q)
 984                 return;
 985
 986         size = num_entries * LDC_PACKET_SIZE;
 987         order = get_order(size);
 988
 989         free_pages((unsigned long)q, order);
 990 }
 991
 992 /* XXX Make this configurable... XXX */
 993 #define LDC_IOTABLE_SIZE        (8 * 1024)
 994
 995 static int ldc_iommu_init(struct ldc_channel *lp)
 996 {
 997         unsigned long sz, num_tsb_entries, tsbsize, order;
 998         struct ldc_iommu *iommu = &lp->iommu;
 999         struct ldc_mtable_entry *table;
1000         unsigned long hv_err;
1001         int err;
1002
1003         num_tsb_entries = LDC_IOTABLE_SIZE;
1004         tsbsize = num_tsb_entries * sizeof(struct ldc_mtable_entry);
1005
1006         spin_lock_init(&iommu->lock);
1007
1008         sz = num_tsb_entries / 8;
1009         sz = (sz + 7UL) & ~7UL;
1010         iommu->arena.map = kzalloc(sz, GFP_KERNEL);
1011         if (!iommu->arena.map) {
1012                 printk(KERN_ERR PFX "Alloc of arena map failed, sz=%lu\n", sz);
1013                 return -ENOMEM;
1014         }
1015
1016         iommu->arena.limit = num_tsb_entries;
1017
1018         order = get_order(tsbsize);
1019
1020         table = (struct ldc_mtable_entry *)
1021                 __get_free_pages(GFP_KERNEL, order);
1022         err = -ENOMEM;
1023         if (!table) {
1024                 printk(KERN_ERR PFX "Alloc of MTE table failed, "
1025                        "size=%lu order=%lu\n", tsbsize, order);
1026                 goto out_free_map;
1027         }
1028
1029         memset(table, 0, PAGE_SIZE << order);
1030
1031         iommu->page_table = table;
1032
1033         hv_err = sun4v_ldc_set_map_table(lp->id, __pa(table),
1034                                          num_tsb_entries);
1035         err = -EINVAL;
1036         if (hv_err)
1037                 goto out_free_table;
1038
1039         return 0;
1040
1041 out_free_table:
1042         free_pages((unsigned long) table, order);
1043         iommu->page_table = NULL;
1044
1045 out_free_map:
1046         kfree(iommu->arena.map);
1047         iommu->arena.map = NULL;
1048
1049         return err;
1050 }
1051
1052 static void ldc_iommu_release(struct ldc_channel *lp)
1053 {
1054         struct ldc_iommu *iommu = &lp->iommu;
1055         unsigned long num_tsb_entries, tsbsize, order;
1056
1057         (void) sun4v_ldc_set_map_table(lp->id, 0, 0);
1058
1059         num_tsb_entries = iommu->arena.limit;
1060         tsbsize = num_tsb_entries * sizeof(struct ldc_mtable_entry);
1061         order = get_order(tsbsize);
1062
1063         free_pages((unsigned long) iommu->page_table, order);
1064         iommu->page_table = NULL;
1065
1066         kfree(iommu->arena.map);
1067         iommu->arena.map = NULL;
1068 }
1069
1070 struct ldc_channel *ldc_alloc(unsigned long id,
1071                               const struct ldc_channel_config *cfgp,
1072                               void *event_arg)
1073 {
1074         struct ldc_channel *lp;
1075         const struct ldc_mode_ops *mops;
1076         unsigned long dummy1, dummy2, hv_err;
1077         u8 mss, *mssbuf;
1078         int err;
1079
1080         err = -ENODEV;
1081         if (!ldom_domaining_enabled)
1082                 goto out_err;
1083
1084         err = -EINVAL;
1085         if (!cfgp)
1086                 goto out_err;
1087
1088         switch (cfgp->mode) {
1089         case LDC_MODE_RAW:
1090                 mops = &raw_ops;
1091                 mss = LDC_PACKET_SIZE;
1092                 break;
1093
1094         case LDC_MODE_UNRELIABLE:
1095                 mops = &nonraw_ops;
1096                 mss = LDC_PACKET_SIZE - 8;
1097                 break;
1098
1099         case LDC_MODE_STREAM:
1100                 mops = &stream_ops;
1101                 mss = LDC_PACKET_SIZE - 8 - 8;
1102                 break;
1103
1104         default:
1105                 goto out_err;
1106         }
1107
1108         if (!cfgp->event || !event_arg || !cfgp->rx_irq || !cfgp->tx_irq)
1109                 goto out_err;
1110
1111         hv_err = sun4v_ldc_tx_qinfo(id, &dummy1, &dummy2);
1112         err = -ENODEV;
1113         if (hv_err == HV_ECHANNEL)
1114                 goto out_err;
1115
1116         err = -EEXIST;
1117         if (__ldc_channel_exists(id))
1118                 goto out_err;
1119
1120         mssbuf = NULL;
1121
1122         lp = kzalloc(sizeof(*lp), GFP_KERNEL);
1123         err = -ENOMEM;
1124         if (!lp)
1125                 goto out_err;
1126
1127         spin_lock_init(&lp->lock);
1128
1129         lp->id = id;
1130
1131         err = ldc_iommu_init(lp);
1132         if (err)
1133                 goto out_free_ldc;
1134
1135         lp->mops = mops;
1136         lp->mss = mss;
1137
1138         lp->cfg = *cfgp;
1139         if (!lp->cfg.mtu)
1140                 lp->cfg.mtu = LDC_DEFAULT_MTU;
1141
1142         if (lp->cfg.mode == LDC_MODE_STREAM) {
1143                 mssbuf = kzalloc(lp->cfg.mtu, GFP_KERNEL);
1144                 if (!mssbuf) {
1145                         err = -ENOMEM;
1146                         goto out_free_iommu;
1147                 }
1148                 lp->mssbuf = mssbuf;
1149         }
1150
1151         lp->event_arg = event_arg;
1152
1153         /* XXX allow setting via ldc_channel_config to override defaults
1154          * XXX or use some formula based upon mtu
1155          */
1156         lp->tx_num_entries = LDC_DEFAULT_NUM_ENTRIES;
1157         lp->rx_num_entries = LDC_DEFAULT_NUM_ENTRIES;
1158
1159         err = alloc_queue("TX", lp->tx_num_entries,
1160                           &lp->tx_base, &lp->tx_ra);
1161         if (err)
1162                 goto out_free_mssbuf;
1163
1164         err = alloc_queue("RX", lp->rx_num_entries,
1165                           &lp->rx_base, &lp->rx_ra);
1166         if (err)
1167                 goto out_free_txq;
1168
1169         lp->flags |= LDC_FLAG_ALLOCED_QUEUES;
1170
1171         lp->hs_state = LDC_HS_CLOSED;
1172         ldc_set_state(lp, LDC_STATE_INIT);
1173
1174         INIT_HLIST_NODE(&lp->list);
1175         hlist_add_head(&lp->list, &ldc_channel_list);
1176
1177         INIT_HLIST_HEAD(&lp->mh_list);
1178
1179         return lp;
1180
1181 out_free_txq:
1182         free_queue(lp->tx_num_entries, lp->tx_base);
1183
1184 out_free_mssbuf:
1185         if (mssbuf)
1186                 kfree(mssbuf);
1187
1188 out_free_iommu:
1189         ldc_iommu_release(lp);
1190
1191 out_free_ldc:
1192         kfree(lp);
1193
1194 out_err:
1195         return ERR_PTR(err);
1196 }
1197 EXPORT_SYMBOL(ldc_alloc);
1198
1199 void ldc_free(struct ldc_channel *lp)
1200 {
1201         if (lp->flags & LDC_FLAG_REGISTERED_IRQS) {
1202                 free_irq(lp->cfg.rx_irq, lp);
1203                 free_irq(lp->cfg.tx_irq, lp);
1204         }
1205
1206         if (lp->flags & LDC_FLAG_REGISTERED_QUEUES) {
1207                 sun4v_ldc_tx_qconf(lp->id, 0, 0);
1208                 sun4v_ldc_rx_qconf(lp->id, 0, 0);
1209                 lp->flags &= ~LDC_FLAG_REGISTERED_QUEUES;
1210         }
1211         if (lp->flags & LDC_FLAG_ALLOCED_QUEUES) {
1212                 free_queue(lp->tx_num_entries, lp->tx_base);
1213                 free_queue(lp->rx_num_entries, lp->rx_base);
1214                 lp->flags &= ~LDC_FLAG_ALLOCED_QUEUES;
1215         }
1216
1217         hlist_del(&lp->list);
1218
1219         if (lp->mssbuf)
1220                 kfree(lp->mssbuf);
1221
1222         ldc_iommu_release(lp);
1223
1224         kfree(lp);
1225 }
1226 EXPORT_SYMBOL(ldc_free);
1227
1228 /* Bind the channel.  This registers the LDC queues with
1229  * the hypervisor and puts the channel into a pseudo-listening
1230  * state.  This does not initiate a handshake, ldc_connect() does
1231  * that.
1232  */
1233 int ldc_bind(struct ldc_channel *lp, const char *name)
1234 {
1235         unsigned long hv_err, flags;
1236         int err = -EINVAL;
1237
1238         spin_lock_irqsave(&lp->lock, flags);
1239
1240         if (!name)
1241                 goto out_err;
1242
1243         if (lp->state != LDC_STATE_INIT)
1244                 goto out_err;
1245
1246         snprintf(lp->rx_irq_name, LDC_IRQ_NAME_MAX, "%s RX", name);
1247         snprintf(lp->tx_irq_name, LDC_IRQ_NAME_MAX, "%s TX", name);
1248
1249         err = request_irq(lp->cfg.rx_irq, ldc_rx,
1250                           IRQF_SAMPLE_RANDOM | IRQF_SHARED,
1251                           lp->rx_irq_name, lp);
1252         if (err)
1253                 goto out_err;
1254
1255         err = request_irq(lp->cfg.tx_irq, ldc_tx,
1256                           IRQF_SAMPLE_RANDOM | IRQF_SHARED,
1257                           lp->tx_irq_name, lp);
1258         if (err)
1259                 goto out_free_rx_irq;
1260
1261
1262         lp->flags |= LDC_FLAG_REGISTERED_IRQS;
1263
1264         err = -ENODEV;
1265         hv_err = sun4v_ldc_tx_qconf(lp->id, 0, 0);
1266         if (hv_err)
1267                 goto out_free_tx_irq;
1268
1269         hv_err = sun4v_ldc_tx_qconf(lp->id, lp->tx_ra, lp->tx_num_entries);
1270         if (hv_err)
1271                 goto out_free_tx_irq;
1272
1273         hv_err = sun4v_ldc_rx_qconf(lp->id, 0, 0);
1274         if (hv_err)
1275                 goto out_unmap_tx;
1276
1277         hv_err = sun4v_ldc_rx_qconf(lp->id, lp->rx_ra, lp->rx_num_entries);
1278         if (hv_err)
1279                 goto out_unmap_tx;
1280
1281         lp->flags |= LDC_FLAG_REGISTERED_QUEUES;
1282
1283         hv_err = sun4v_ldc_tx_get_state(lp->id,
1284                                         &lp->tx_head,
1285                                         &lp->tx_tail,
1286                                         &lp->chan_state);
1287         err = -EBUSY;
1288         if (hv_err)
1289                 goto out_unmap_rx;
1290
1291         lp->tx_acked = lp->tx_head;
1292
1293         lp->hs_state = LDC_HS_OPEN;
1294         ldc_set_state(lp, LDC_STATE_BOUND);
1295
1296         spin_unlock_irqrestore(&lp->lock, flags);
1297
1298         return 0;
1299
1300 out_unmap_rx:
1301         lp->flags &= ~LDC_FLAG_REGISTERED_QUEUES;
1302         sun4v_ldc_rx_qconf(lp->id, 0, 0);
1303
1304 out_unmap_tx:
1305         sun4v_ldc_tx_qconf(lp->id, 0, 0);
1306
1307 out_free_tx_irq:
1308         lp->flags &= ~LDC_FLAG_REGISTERED_IRQS;
1309         free_irq(lp->cfg.tx_irq, lp);
1310
1311 out_free_rx_irq:
1312         free_irq(lp->cfg.rx_irq, lp);
1313
1314 out_err:
1315         spin_unlock_irqrestore(&lp->lock, flags);
1316
1317         return err;
1318 }
1319 EXPORT_SYMBOL(ldc_bind);
1320
1321 int ldc_connect(struct ldc_channel *lp)
1322 {
1323         unsigned long flags;
1324         int err;
1325
1326         if (lp->cfg.mode == LDC_MODE_RAW)
1327                 return -EINVAL;
1328
1329         spin_lock_irqsave(&lp->lock, flags);
1330
1331         if (!(lp->flags & LDC_FLAG_ALLOCED_QUEUES) ||
1332             !(lp->flags & LDC_FLAG_REGISTERED_QUEUES) ||
1333             lp->hs_state != LDC_HS_OPEN)
1334                 err = -EINVAL;
1335         else
1336                 err = start_handshake(lp);
1337
1338         spin_unlock_irqrestore(&lp->lock, flags);
1339
1340         return err;
1341 }
1342 EXPORT_SYMBOL(ldc_connect);
1343
1344 int ldc_disconnect(struct ldc_channel *lp)
1345 {
1346         unsigned long hv_err, flags;
1347         int err;
1348
1349         if (lp->cfg.mode == LDC_MODE_RAW)
1350                 return -EINVAL;
1351
1352         if (!(lp->flags & LDC_FLAG_ALLOCED_QUEUES) ||
1353             !(lp->flags & LDC_FLAG_REGISTERED_QUEUES))
1354                 return -EINVAL;
1355
1356         spin_lock_irqsave(&lp->lock, flags);
1357
1358         err = -ENODEV;
1359         hv_err = sun4v_ldc_tx_qconf(lp->id, 0, 0);
1360         if (hv_err)
1361                 goto out_err;
1362
1363         hv_err = sun4v_ldc_tx_qconf(lp->id, lp->tx_ra, lp->tx_num_entries);
1364         if (hv_err)
1365                 goto out_err;
1366
1367         hv_err = sun4v_ldc_rx_qconf(lp->id, 0, 0);
1368         if (hv_err)
1369                 goto out_err;
1370
1371         hv_err = sun4v_ldc_rx_qconf(lp->id, lp->rx_ra, lp->rx_num_entries);
1372         if (hv_err)
1373                 goto out_err;
1374
1375         ldc_set_state(lp, LDC_STATE_BOUND);
1376         lp->hs_state = LDC_HS_OPEN;
1377         lp->flags |= LDC_FLAG_RESET;
1378
1379         spin_unlock_irqrestore(&lp->lock, flags);
1380
1381         return 0;
1382
1383 out_err:
1384         sun4v_ldc_tx_qconf(lp->id, 0, 0);
1385         sun4v_ldc_rx_qconf(lp->id, 0, 0);
1386         free_irq(lp->cfg.tx_irq, lp);
1387         free_irq(lp->cfg.rx_irq, lp);
1388         lp->flags &= ~(LDC_FLAG_REGISTERED_IRQS |
1389                        LDC_FLAG_REGISTERED_QUEUES);
1390         ldc_set_state(lp, LDC_STATE_INIT);
1391
1392         spin_unlock_irqrestore(&lp->lock, flags);
1393
1394         return err;
1395 }
1396 EXPORT_SYMBOL(ldc_disconnect);
1397
1398 int ldc_state(struct ldc_channel *lp)
1399 {
1400         return lp->state;
1401 }
1402 EXPORT_SYMBOL(ldc_state);
1403
1404 static int write_raw(struct ldc_channel *lp, const void *buf, unsigned int size)
1405 {
1406         struct ldc_packet *p;
1407         unsigned long new_tail;
1408         int err;
1409
1410         if (size > LDC_PACKET_SIZE)
1411                 return -EMSGSIZE;
1412
1413         p = data_get_tx_packet(lp, &new_tail);
1414         if (!p)
1415                 return -EAGAIN;
1416
1417         memcpy(p, buf, size);
1418
1419         err = send_tx_packet(lp, p, new_tail);
1420         if (!err)
1421                 err = size;
1422
1423         return err;
1424 }
1425
1426 static int read_raw(struct ldc_channel *lp, void *buf, unsigned int size)
1427 {
1428         struct ldc_packet *p;
1429         unsigned long hv_err, new;
1430         int err;
1431
1432         if (size < LDC_PACKET_SIZE)
1433                 return -EINVAL;
1434
1435         hv_err = sun4v_ldc_rx_get_state(lp->id,
1436                                         &lp->rx_head,
1437                                         &lp->rx_tail,
1438                                         &lp->chan_state);
1439         if (hv_err)
1440                 return ldc_abort(lp);
1441
1442         if (lp->chan_state == LDC_CHANNEL_DOWN ||
1443             lp->chan_state == LDC_CHANNEL_RESETTING)
1444                 return -ECONNRESET;
1445
1446         if (lp->rx_head == lp->rx_tail)
1447                 return 0;
1448
1449         p = lp->rx_base + (lp->rx_head / LDC_PACKET_SIZE);
1450         memcpy(buf, p, LDC_PACKET_SIZE);
1451
1452         new = rx_advance(lp, lp->rx_head);
1453         lp->rx_head = new;
1454
1455         err = __set_rx_head(lp, new);
1456         if (err < 0)
1457                 err = -ECONNRESET;
1458         else
1459                 err = LDC_PACKET_SIZE;
1460
1461         return err;
1462 }
1463
1464 static const struct ldc_mode_ops raw_ops = {
1465         .write          =       write_raw,
1466         .read           =       read_raw,
1467 };
1468
1469 static int write_nonraw(struct ldc_channel *lp, const void *buf,
1470                         unsigned int size)
1471 {
1472         unsigned long hv_err, tail;
1473         unsigned int copied;
1474         u32 seq;
1475         int err;
1476
1477         hv_err = sun4v_ldc_tx_get_state(lp->id, &lp->tx_head, &lp->tx_tail,
1478                                         &lp->chan_state);
1479         if (unlikely(hv_err))
1480                 return -EBUSY;
1481
1482         if (unlikely(lp->chan_state != LDC_CHANNEL_UP))
1483                 return ldc_abort(lp);
1484
1485         if (!tx_has_space_for(lp, size))
1486                 return -EAGAIN;
1487
1488         seq = lp->snd_nxt;
1489         copied = 0;
1490         tail = lp->tx_tail;
1491         while (copied < size) {
1492                 struct ldc_packet *p = lp->tx_base + (tail / LDC_PACKET_SIZE);
1493                 u8 *data = ((lp->cfg.mode == LDC_MODE_UNRELIABLE) ?
1494                             p->u.u_data :
1495                             p->u.r.r_data);
1496                 int data_len;
1497
1498                 p->type = LDC_DATA;
1499                 p->stype = LDC_INFO;
1500                 p->ctrl = 0;
1501
1502                 data_len = size - copied;
1503                 if (data_len > lp->mss)
1504                         data_len = lp->mss;
1505
1506                 BUG_ON(data_len > LDC_LEN);
1507
1508                 p->env = (data_len |
1509                           (copied == 0 ? LDC_START : 0) |
1510                           (data_len == size - copied ? LDC_STOP : 0));
1511
1512                 p->seqid = ++seq;
1513
1514                 ldcdbg(DATA, "SENT DATA [%02x:%02x:%02x:%02x:%08x]\n",
1515                        p->type,
1516                        p->stype,
1517                        p->ctrl,
1518                        p->env,
1519                        p->seqid);
1520
1521                 memcpy(data, buf, data_len);
1522                 buf += data_len;
1523                 copied += data_len;
1524
1525                 tail = tx_advance(lp, tail);
1526         }
1527
1528         err = set_tx_tail(lp, tail);
1529         if (!err) {
1530                 lp->snd_nxt = seq;
1531                 err = size;
1532         }
1533
1534         return err;
1535 }
1536
1537 static int rx_bad_seq(struct ldc_channel *lp, struct ldc_packet *p,
1538                       struct ldc_packet *first_frag)
1539 {
1540         int err;
1541
1542         if (first_frag)
1543                 lp->rcv_nxt = first_frag->seqid - 1;
1544
1545         err = send_data_nack(lp, p);
1546         if (err)
1547                 return err;
1548
1549         err = __set_rx_head(lp, lp->rx_tail);
1550         if (err < 0)
1551                 return ldc_abort(lp);
1552
1553         return 0;
1554 }
1555
1556 static int data_ack_nack(struct ldc_channel *lp, struct ldc_packet *p)
1557 {
1558         if (p->stype & LDC_ACK) {
1559                 int err = process_data_ack(lp, p);
1560                 if (err)
1561                         return err;
1562         }
1563         if (p->stype & LDC_NACK)
1564                 return ldc_abort(lp);
1565
1566         return 0;
1567 }
1568
1569 static int rx_data_wait(struct ldc_channel *lp, unsigned long cur_head)
1570 {
1571         unsigned long dummy;
1572         int limit = 1000;
1573
1574         ldcdbg(DATA, "DATA WAIT cur_head[%lx] rx_head[%lx] rx_tail[%lx]\n",
1575                cur_head, lp->rx_head, lp->rx_tail);
1576         while (limit-- > 0) {
1577                 unsigned long hv_err;
1578
1579                 hv_err = sun4v_ldc_rx_get_state(lp->id,
1580                                                 &dummy,
1581                                                 &lp->rx_tail,
1582                                                 &lp->chan_state);
1583                 if (hv_err)
1584                         return ldc_abort(lp);
1585
1586                 if (lp->chan_state == LDC_CHANNEL_DOWN ||
1587                     lp->chan_state == LDC_CHANNEL_RESETTING)
1588                         return -ECONNRESET;
1589
1590                 if (cur_head != lp->rx_tail) {
1591                         ldcdbg(DATA, "DATA WAIT DONE "
1592                                "head[%lx] tail[%lx] chan_state[%lx]\n",
1593                                dummy, lp->rx_tail, lp->chan_state);
1594                         return 0;
1595                 }
1596
1597                 udelay(1);
1598         }
1599         return -EAGAIN;
1600 }
1601
1602 static int rx_set_head(struct ldc_channel *lp, unsigned long head)
1603 {
1604         int err = __set_rx_head(lp, head);
1605
1606         if (err < 0)
1607                 return ldc_abort(lp);
1608
1609         lp->rx_head = head;
1610         return 0;
1611 }
1612
1613 static void send_data_ack(struct ldc_channel *lp)
1614 {
1615         unsigned long new_tail;
1616         struct ldc_packet *p;
1617
1618         p = data_get_tx_packet(lp, &new_tail);
1619         if (likely(p)) {
1620                 int err;
1621
1622                 memset(p, 0, sizeof(*p));
1623                 p->type = LDC_DATA;
1624                 p->stype = LDC_ACK;
1625                 p->ctrl = 0;
1626                 p->seqid = lp->snd_nxt + 1;
1627                 p->u.r.ackid = lp->rcv_nxt;
1628
1629                 err = send_tx_packet(lp, p, new_tail);
1630                 if (!err)
1631                         lp->snd_nxt++;
1632         }
1633 }
1634
1635 static int read_nonraw(struct ldc_channel *lp, void *buf, unsigned int size)
1636 {
1637         struct ldc_packet *first_frag;
1638         unsigned long hv_err, new;
1639         int err, copied;
1640
1641         hv_err = sun4v_ldc_rx_get_state(lp->id,
1642                                         &lp->rx_head,
1643                                         &lp->rx_tail,
1644                                         &lp->chan_state);
1645         if (hv_err)
1646                 return ldc_abort(lp);
1647
1648         if (lp->chan_state == LDC_CHANNEL_DOWN ||
1649             lp->chan_state == LDC_CHANNEL_RESETTING)
1650                 return -ECONNRESET;
1651
1652         if (lp->rx_head == lp->rx_tail)
1653                 return 0;
1654
1655         first_frag = NULL;
1656         copied = err = 0;
1657         new = lp->rx_head;
1658         while (1) {
1659                 struct ldc_packet *p;
1660                 int pkt_len;
1661
1662                 BUG_ON(new == lp->rx_tail);
1663                 p = lp->rx_base + (new / LDC_PACKET_SIZE);
1664
1665                 ldcdbg(RX, "RX read pkt[%02x:%02x:%02x:%02x:%08x:%08x] "
1666                        "rcv_nxt[%08x]\n",
1667                        p->type,
1668                        p->stype,
1669                        p->ctrl,
1670                        p->env,
1671                        p->seqid,
1672                        p->u.r.ackid,
1673                        lp->rcv_nxt);
1674
1675                 if (unlikely(!rx_seq_ok(lp, p->seqid))) {
1676                         err = rx_bad_seq(lp, p, first_frag);
1677                         copied = 0;
1678                         break;
1679                 }
1680
1681                 if (p->type & LDC_CTRL) {
1682                         err = process_control_frame(lp, p);
1683                         if (err < 0)
1684                                 break;
1685                         err = 0;
1686                 }
1687
1688                 lp->rcv_nxt = p->seqid;
1689
1690                 if (!(p->type & LDC_DATA)) {
1691                         new = rx_advance(lp, new);
1692                         goto no_data;
1693                 }
1694                 if (p->stype & (LDC_ACK | LDC_NACK)) {
1695                         err = data_ack_nack(lp, p);
1696                         if (err)
1697                                 break;
1698                 }
1699                 if (!(p->stype & LDC_INFO)) {
1700                         new = rx_advance(lp, new);
1701                         err = rx_set_head(lp, new);
1702                         if (err)
1703                                 break;
1704                         goto no_data;
1705                 }
1706
1707                 pkt_len = p->env & LDC_LEN;
1708
1709                 /* Every initial packet starts with the START bit set.
1710                  *
1711                  * Singleton packets will have both START+STOP set.
1712                  *
1713                  * Fragments will have START set in the first frame, STOP
1714                  * set in the last frame, and neither bit set in middle
1715                  * frames of the packet.
1716                  *
1717                  * Therefore if we are at the beginning of a packet and
1718                  * we don't see START, or we are in the middle of a fragmented
1719                  * packet and do see START, we are unsynchronized and should
1720                  * flush the RX queue.
1721                  */
1722                 if ((first_frag == NULL && !(p->env & LDC_START)) ||
1723                     (first_frag != NULL &&  (p->env & LDC_START))) {
1724                         if (!first_frag)
1725                                 new = rx_advance(lp, new);
1726
1727                         err = rx_set_head(lp, new);
1728                         if (err)
1729                                 break;
1730
1731                         if (!first_frag)
1732                                 goto no_data;
1733                 }
1734                 if (!first_frag)
1735                         first_frag = p;
1736
1737                 if (pkt_len > size - copied) {
1738                         /* User didn't give us a big enough buffer,
1739                          * what to do?  This is a pretty serious error.
1740                          *
1741                          * Since we haven't updated the RX ring head to
1742                          * consume any of the packets, signal the error
1743                          * to the user and just leave the RX ring alone.
1744                          *
1745                          * This seems the best behavior because this allows
1746                          * a user of the LDC layer to start with a small
1747                          * RX buffer for ldc_read() calls and use -EMSGSIZE
1748                          * as a cue to enlarge it's read buffer.
1749                          */
1750                         err = -EMSGSIZE;
1751                         break;
1752                 }
1753
1754                 /* Ok, we are gonna eat this one.  */
1755                 new = rx_advance(lp, new);
1756
1757                 memcpy(buf,
1758                        (lp->cfg.mode == LDC_MODE_UNRELIABLE ?
1759                         p->u.u_data : p->u.r.r_data), pkt_len);
1760                 buf += pkt_len;
1761                 copied += pkt_len;
1762
1763                 if (p->env & LDC_STOP)
1764                         break;
1765
1766 no_data:
1767                 if (new == lp->rx_tail) {
1768                         err = rx_data_wait(lp, new);
1769                         if (err)
1770                                 break;
1771                 }
1772         }
1773
1774         if (!err)
1775                 err = rx_set_head(lp, new);
1776
1777         if (err && first_frag)
1778                 lp->rcv_nxt = first_frag->seqid - 1;
1779
1780         if (!err) {
1781                 err = copied;
1782                 if (err > 0 && lp->cfg.mode != LDC_MODE_UNRELIABLE)
1783                         send_data_ack(lp);
1784         }
1785
1786         return err;
1787 }
1788
1789 static const struct ldc_mode_ops nonraw_ops = {
1790         .write          =       write_nonraw,
1791         .read           =       read_nonraw,
1792 };
1793
1794 static int write_stream(struct ldc_channel *lp, const void *buf,
1795                         unsigned int size)
1796 {
1797         if (size > lp->cfg.mtu)
1798                 size = lp->cfg.mtu;
1799         return write_nonraw(lp, buf, size);
1800 }
1801
1802 static int read_stream(struct ldc_channel *lp, void *buf, unsigned int size)
1803 {
1804         if (!lp->mssbuf_len) {
1805                 int err = read_nonraw(lp, lp->mssbuf, lp->cfg.mtu);
1806                 if (err < 0)
1807                         return err;
1808
1809                 lp->mssbuf_len = err;
1810                 lp->mssbuf_off = 0;
1811         }
1812
1813         if (size > lp->mssbuf_len)
1814                 size = lp->mssbuf_len;
1815         memcpy(buf, lp->mssbuf + lp->mssbuf_off, size);
1816
1817         lp->mssbuf_off += size;
1818         lp->mssbuf_len -= size;
1819
1820         return size;
1821 }
1822
1823 static const struct ldc_mode_ops stream_ops = {
1824         .write          =       write_stream,
1825         .read           =       read_stream,
1826 };
1827
1828 int ldc_write(struct ldc_channel *lp, const void *buf, unsigned int size)
1829 {
1830         unsigned long flags;
1831         int err;
1832
1833         if (!buf)
1834                 return -EINVAL;
1835
1836         if (!size)
1837                 return 0;
1838
1839         spin_lock_irqsave(&lp->lock, flags);
1840
1841         if (lp->hs_state != LDC_HS_COMPLETE)
1842                 err = -ENOTCONN;
1843         else
1844                 err = lp->mops->write(lp, buf, size);
1845
1846         spin_unlock_irqrestore(&lp->lock, flags);
1847
1848         return err;
1849 }
1850 EXPORT_SYMBOL(ldc_write);
1851
1852 int ldc_read(struct ldc_channel *lp, void *buf, unsigned int size)
1853 {
1854         unsigned long flags;
1855         int err;
1856
1857         if (!buf)
1858                 return -EINVAL;
1859
1860         if (!size)
1861                 return 0;
1862
1863         spin_lock_irqsave(&lp->lock, flags);
1864
1865         if (lp->hs_state != LDC_HS_COMPLETE)
1866                 err = -ENOTCONN;
1867         else
1868                 err = lp->mops->read(lp, buf, size);
1869
1870         spin_unlock_irqrestore(&lp->lock, flags);
1871
1872         return err;
1873 }
1874 EXPORT_SYMBOL(ldc_read);
1875
1876 static long arena_alloc(struct ldc_iommu *iommu, unsigned long npages)
1877 {
1878         struct iommu_arena *arena = &iommu->arena;
1879         unsigned long n, i, start, end, limit;
1880         int pass;
1881
1882         limit = arena->limit;
1883         start = arena->hint;
1884         pass = 0;
1885
1886 again:
1887         n = find_next_zero_bit(arena->map, limit, start);
1888         end = n + npages;
1889         if (unlikely(end >= limit)) {
1890                 if (likely(pass < 1)) {
1891                         limit = start;
1892                         start = 0;
1893                         pass++;
1894                         goto again;
1895                 } else {
1896                         /* Scanned the whole thing, give up. */
1897                         return -1;
1898                 }
1899         }
1900
1901         for (i = n; i < end; i++) {
1902                 if (test_bit(i, arena->map)) {
1903                         start = i + 1;
1904                         goto again;
1905                 }
1906         }
1907
1908         for (i = n; i < end; i++)
1909                 __set_bit(i, arena->map);
1910
1911         arena->hint = end;
1912
1913         return n;
1914 }
1915
1916 #define COOKIE_PGSZ_CODE        0xf000000000000000ULL
1917 #define COOKIE_PGSZ_CODE_SHIFT  60ULL
1918
1919 static u64 pagesize_code(void)
1920 {
1921         switch (PAGE_SIZE) {
1922         default:
1923         case (8ULL * 1024ULL):
1924                 return 0;
1925         case (64ULL * 1024ULL):
1926                 return 1;
1927         case (512ULL * 1024ULL):
1928                 return 2;
1929         case (4ULL * 1024ULL * 1024ULL):
1930                 return 3;
1931         case (32ULL * 1024ULL * 1024ULL):
1932                 return 4;
1933         case (256ULL * 1024ULL * 1024ULL):
1934                 return 5;
1935         }
1936 }
1937
1938 static u64 make_cookie(u64 index, u64 pgsz_code, u64 page_offset)
1939 {
1940         return ((pgsz_code << COOKIE_PGSZ_CODE_SHIFT) |
1941                 (index << PAGE_SHIFT) |
1942                 page_offset);
1943 }
1944
1945 static u64 cookie_to_index(u64 cookie, unsigned long *shift)
1946 {
1947         u64 szcode = cookie >> COOKIE_PGSZ_CODE_SHIFT;
1948
1949         cookie &= ~COOKIE_PGSZ_CODE;
1950
1951         *shift = szcode * 3;
1952
1953         return (cookie >> (13ULL + (szcode * 3ULL)));
1954 }
1955
1956 static struct ldc_mtable_entry *alloc_npages(struct ldc_iommu *iommu,
1957                                              unsigned long npages)
1958 {
1959         long entry;
1960
1961         entry = arena_alloc(iommu, npages);
1962         if (unlikely(entry < 0))
1963                 return NULL;
1964
1965         return iommu->page_table + entry;
1966 }
1967
1968 static u64 perm_to_mte(unsigned int map_perm)
1969 {
1970         u64 mte_base;
1971
1972         mte_base = pagesize_code();
1973
1974         if (map_perm & LDC_MAP_SHADOW) {
1975                 if (map_perm & LDC_MAP_R)
1976                         mte_base |= LDC_MTE_COPY_R;
1977                 if (map_perm & LDC_MAP_W)
1978                         mte_base |= LDC_MTE_COPY_W;
1979         }
1980         if (map_perm & LDC_MAP_DIRECT) {
1981                 if (map_perm & LDC_MAP_R)
1982                         mte_base |= LDC_MTE_READ;
1983                 if (map_perm & LDC_MAP_W)
1984                         mte_base |= LDC_MTE_WRITE;
1985                 if (map_perm & LDC_MAP_X)
1986                         mte_base |= LDC_MTE_EXEC;
1987         }
1988         if (map_perm & LDC_MAP_IO) {
1989                 if (map_perm & LDC_MAP_R)
1990                         mte_base |= LDC_MTE_IOMMU_R;
1991                 if (map_perm & LDC_MAP_W)
1992                         mte_base |= LDC_MTE_IOMMU_W;
1993         }
1994
1995         return mte_base;
1996 }
1997
1998 static int pages_in_region(unsigned long base, long len)
1999 {
2000         int count = 0;
2001
2002         do {
2003                 unsigned long new = (base + PAGE_SIZE) & PAGE_MASK;
2004
2005                 len -= (new - base);
2006                 base = new;
2007                 count++;
2008         } while (len > 0);
2009
2010         return count;
2011 }
2012
2013 struct cookie_state {
2014         struct ldc_mtable_entry         *page_table;
2015         struct ldc_trans_cookie         *cookies;
2016         u64                             mte_base;
2017         u64                             prev_cookie;
2018         u32                             pte_idx;
2019         u32                             nc;
2020 };
2021
2022 static void fill_cookies(struct cookie_state *sp, unsigned long pa,
2023                          unsigned long off, unsigned long len)
2024 {
2025         do {
2026                 unsigned long tlen, new = pa + PAGE_SIZE;
2027                 u64 this_cookie;
2028
2029                 sp->page_table[sp->pte_idx].mte = sp->mte_base | pa;
2030
2031                 tlen = PAGE_SIZE;
2032                 if (off)
2033                         tlen = PAGE_SIZE - off;
2034                 if (tlen > len)
2035                         tlen = len;
2036
2037                 this_cookie = make_cookie(sp->pte_idx,
2038                                           pagesize_code(), off);
2039
2040                 off = 0;
2041
2042                 if (this_cookie == sp->prev_cookie) {
2043                         sp->cookies[sp->nc - 1].cookie_size += tlen;
2044                 } else {
2045                         sp->cookies[sp->nc].cookie_addr = this_cookie;
2046                         sp->cookies[sp->nc].cookie_size = tlen;
2047                         sp->nc++;
2048                 }
2049                 sp->prev_cookie = this_cookie + tlen;
2050
2051                 sp->pte_idx++;
2052
2053                 len -= tlen;
2054                 pa = new;
2055         } while (len > 0);
2056 }
2057
2058 static int sg_count_one(struct scatterlist *sg)
2059 {
2060         unsigned long base = page_to_pfn(sg_page(sg)) << PAGE_SHIFT;
2061         long len = sg->length;
2062
2063         if ((sg->offset | len) & (8UL - 1))
2064                 return -EFAULT;
2065
2066         return pages_in_region(base + sg->offset, len);
2067 }
2068
2069 static int sg_count_pages(struct scatterlist *sg, int num_sg)
2070 {
2071         int count;
2072         int i;
2073
2074         count = 0;
2075         for (i = 0; i < num_sg; i++) {
2076                 int err = sg_count_one(sg + i);
2077                 if (err < 0)
2078                         return err;
2079                 count += err;
2080         }
2081
2082         return count;
2083 }
2084
2085 int ldc_map_sg(struct ldc_channel *lp,
2086                struct scatterlist *sg, int num_sg,
2087                struct ldc_trans_cookie *cookies, int ncookies,
2088                unsigned int map_perm)
2089 {
2090         unsigned long i, npages, flags;
2091         struct ldc_mtable_entry *base;
2092         struct cookie_state state;
2093         struct ldc_iommu *iommu;
2094         int err;
2095
2096         if (map_perm & ~LDC_MAP_ALL)
2097                 return -EINVAL;
2098
2099         err = sg_count_pages(sg, num_sg);
2100         if (err < 0)
2101                 return err;
2102
2103         npages = err;
2104         if (err > ncookies)
2105                 return -EMSGSIZE;
2106
2107         iommu = &lp->iommu;
2108
2109         spin_lock_irqsave(&iommu->lock, flags);
2110         base = alloc_npages(iommu, npages);
2111         spin_unlock_irqrestore(&iommu->lock, flags);
2112
2113         if (!base)
2114                 return -ENOMEM;
2115
2116         state.page_table = iommu->page_table;
2117         state.cookies = cookies;
2118         state.mte_base = perm_to_mte(map_perm);
2119         state.prev_cookie = ~(u64)0;
2120         state.pte_idx = (base - iommu->page_table);
2121         state.nc = 0;
2122
2123         for (i = 0; i < num_sg; i++)
2124                 fill_cookies(&state, page_to_pfn(sg[i].page) << PAGE_SHIFT,
2125                              sg[i].offset, sg[i].length);
2126
2127         return state.nc;
2128 }
2129 EXPORT_SYMBOL(ldc_map_sg);
2130
2131 int ldc_map_single(struct ldc_channel *lp,
2132                    void *buf, unsigned int len,
2133                    struct ldc_trans_cookie *cookies, int ncookies,
2134                    unsigned int map_perm)
2135 {
2136         unsigned long npages, pa, flags;
2137         struct ldc_mtable_entry *base;
2138         struct cookie_state state;
2139         struct ldc_iommu *iommu;
2140
2141         if ((map_perm & ~LDC_MAP_ALL) || (ncookies < 1))
2142                 return -EINVAL;
2143
2144         pa = __pa(buf);
2145         if ((pa | len) & (8UL - 1))
2146                 return -EFAULT;
2147
2148         npages = pages_in_region(pa, len);
2149
2150         iommu = &lp->iommu;
2151
2152         spin_lock_irqsave(&iommu->lock, flags);
2153         base = alloc_npages(iommu, npages);
2154         spin_unlock_irqrestore(&iommu->lock, flags);
2155
2156         if (!base)
2157                 return -ENOMEM;
2158
2159         state.page_table = iommu->page_table;
2160         state.cookies = cookies;
2161         state.mte_base = perm_to_mte(map_perm);
2162         state.prev_cookie = ~(u64)0;
2163         state.pte_idx = (base - iommu->page_table);
2164         state.nc = 0;
2165         fill_cookies(&state, (pa & PAGE_MASK), (pa & ~PAGE_MASK), len);
2166         BUG_ON(state.nc != 1);
2167
2168         return state.nc;
2169 }
2170 EXPORT_SYMBOL(ldc_map_single);
2171
2172 static void free_npages(unsigned long id, struct ldc_iommu *iommu,
2173                         u64 cookie, u64 size)
2174 {
2175         struct iommu_arena *arena = &iommu->arena;
2176         unsigned long i, shift, index, npages;
2177         struct ldc_mtable_entry *base;
2178
2179         npages = PAGE_ALIGN(((cookie & ~PAGE_MASK) + size)) >> PAGE_SHIFT;
2180         index = cookie_to_index(cookie, &shift);
2181         base = iommu->page_table + index;
2182
2183         BUG_ON(index > arena->limit ||
2184                (index + npages) > arena->limit);
2185
2186         for (i = 0; i < npages; i++) {
2187                 if (base->cookie)
2188                         sun4v_ldc_revoke(id, cookie + (i << shift),
2189                                          base->cookie);
2190                 base->mte = 0;
2191                 __clear_bit(index + i, arena->map);
2192         }
2193 }
2194
2195 void ldc_unmap(struct ldc_channel *lp, struct ldc_trans_cookie *cookies,
2196                int ncookies)
2197 {
2198         struct ldc_iommu *iommu = &lp->iommu;
2199         unsigned long flags;
2200         int i;
2201
2202         spin_lock_irqsave(&iommu->lock, flags);
2203         for (i = 0; i < ncookies; i++) {
2204                 u64 addr = cookies[i].cookie_addr;
2205                 u64 size = cookies[i].cookie_size;
2206
2207                 free_npages(lp->id, iommu, addr, size);
2208         }
2209         spin_unlock_irqrestore(&iommu->lock, flags);
2210 }
2211 EXPORT_SYMBOL(ldc_unmap);
2212
2213 int ldc_copy(struct ldc_channel *lp, int copy_dir,
2214              void *buf, unsigned int len, unsigned long offset,
2215              struct ldc_trans_cookie *cookies, int ncookies)
2216 {
2217         unsigned int orig_len;
2218         unsigned long ra;
2219         int i;
2220
2221         if (copy_dir != LDC_COPY_IN && copy_dir != LDC_COPY_OUT) {
2222                 printk(KERN_ERR PFX "ldc_copy: ID[%lu] Bad copy_dir[%d]\n",
2223                        lp->id, copy_dir);
2224                 return -EINVAL;
2225         }
2226
2227         ra = __pa(buf);
2228         if ((ra | len | offset) & (8UL - 1)) {
2229                 printk(KERN_ERR PFX "ldc_copy: ID[%lu] Unaligned buffer "
2230                        "ra[%lx] len[%x] offset[%lx]\n",
2231                        lp->id, ra, len, offset);
2232                 return -EFAULT;
2233         }
2234
2235         if (lp->hs_state != LDC_HS_COMPLETE ||
2236             (lp->flags & LDC_FLAG_RESET)) {
2237                 printk(KERN_ERR PFX "ldc_copy: ID[%lu] Link down hs_state[%x] "
2238                        "flags[%x]\n", lp->id, lp->hs_state, lp->flags);
2239                 return -ECONNRESET;
2240         }
2241
2242         orig_len = len;
2243         for (i = 0; i < ncookies; i++) {
2244                 unsigned long cookie_raddr = cookies[i].cookie_addr;
2245                 unsigned long this_len = cookies[i].cookie_size;
2246                 unsigned long actual_len;
2247
2248                 if (unlikely(offset)) {
2249                         unsigned long this_off = offset;
2250
2251                         if (this_off > this_len)
2252                                 this_off = this_len;
2253
2254                         offset -= this_off;
2255                         this_len -= this_off;
2256                         if (!this_len)
2257                                 continue;
2258                         cookie_raddr += this_off;
2259                 }
2260
2261                 if (this_len > len)
2262                         this_len = len;
2263
2264                 while (1) {
2265                         unsigned long hv_err;
2266
2267                         hv_err = sun4v_ldc_copy(lp->id, copy_dir,
2268                                                 cookie_raddr, ra,
2269                                                 this_len, &actual_len);
2270                         if (unlikely(hv_err)) {
2271                                 printk(KERN_ERR PFX "ldc_copy: ID[%lu] "
2272                                        "HV error %lu\n",
2273                                        lp->id, hv_err);
2274                                 if (lp->hs_state != LDC_HS_COMPLETE ||
2275                                     (lp->flags & LDC_FLAG_RESET))
2276                                         return -ECONNRESET;
2277                                 else
2278                                         return -EFAULT;
2279                         }
2280
2281                         cookie_raddr += actual_len;
2282                         ra += actual_len;
2283                         len -= actual_len;
2284                         if (actual_len == this_len)
2285                                 break;
2286
2287                         this_len -= actual_len;
2288                 }
2289
2290                 if (!len)
2291                         break;
2292         }
2293
2294         /* It is caller policy what to do about short copies.
2295          * For example, a networking driver can declare the
2296          * packet a runt and drop it.
2297          */
2298
2299         return orig_len - len;
2300 }
2301 EXPORT_SYMBOL(ldc_copy);
2302
2303 void *ldc_alloc_exp_dring(struct ldc_channel *lp, unsigned int len,
2304                           struct ldc_trans_cookie *cookies, int *ncookies,
2305                           unsigned int map_perm)
2306 {
2307         void *buf;
2308         int err;
2309
2310         if (len & (8UL - 1))
2311                 return ERR_PTR(-EINVAL);
2312
2313         buf = kzalloc(len, GFP_KERNEL);
2314         if (!buf)
2315                 return ERR_PTR(-ENOMEM);
2316
2317         err = ldc_map_single(lp, buf, len, cookies, *ncookies, map_perm);
2318         if (err < 0) {
2319                 kfree(buf);
2320                 return ERR_PTR(err);
2321         }
2322         *ncookies = err;
2323
2324         return buf;
2325 }
2326 EXPORT_SYMBOL(ldc_alloc_exp_dring);
2327
2328 void ldc_free_exp_dring(struct ldc_channel *lp, void *buf, unsigned int len,
2329                         struct ldc_trans_cookie *cookies, int ncookies)
2330 {
2331         ldc_unmap(lp, cookies, ncookies);
2332         kfree(buf);
2333 }
2334 EXPORT_SYMBOL(ldc_free_exp_dring);
2335
2336 static int __init ldc_init(void)
2337 {
2338         unsigned long major, minor;
2339         struct mdesc_handle *hp;
2340         const u64 *v;
2341         u64 mp;
2342
2343         hp = mdesc_grab();
2344         if (!hp)
2345                 return -ENODEV;
2346
2347         mp = mdesc_node_by_name(hp, MDESC_NODE_NULL, "platform");
2348         if (mp == MDESC_NODE_NULL)
2349                 return -ENODEV;
2350
2351         v = mdesc_get_property(hp, mp, "domaining-enabled", NULL);
2352         if (!v)
2353                 return -ENODEV;
2354
2355         major = 1;
2356         minor = 0;
2357         if (sun4v_hvapi_register(HV_GRP_LDOM, major, &minor)) {
2358                 printk(KERN_INFO PFX "Could not register LDOM hvapi.\n");
2359                 return -ENODEV;
2360         }
2361
2362         printk(KERN_INFO "%s", version);
2363
2364         if (!*v) {
2365                 printk(KERN_INFO PFX "Domaining disabled.\n");
2366                 return -ENODEV;
2367         }
2368         ldom_domaining_enabled = 1;
2369
2370         return 0;
2371 }
2372
2373 core_initcall(ldc_init);