~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sparc/kernel/ldc.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp