![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_is.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to if_is.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*-
2: * Copyright (c) 1990, 1991 William F. Jolitz.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. All advertising materials mentioning features or use of this software
15: * must display the following acknowledgement:
16: * This product includes software developed by the University of
17: * California, Berkeley and its contributors.
18: * 4. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: *
34: * @(#)if_ne.c 7.4 (Berkeley) 5/21/91
35: */
36:
37: /*
38: * Isolink 4110-2 Ethernet driver
39: */
40:
41: #include "is.h"
42: #if NIS > 0
43:
44: #include "param.h"
45: #include "systm.h"
46: #include "mbuf.h"
47: #include "buf.h"
48: #include "protosw.h"
49: #include "socket.h"
50: #include "ioctl.h"
51: #include "errno.h"
52: #include "syslog.h"
53:
54: #include "net/if.h"
55: #include "net/netisr.h"
56: #include "net/route.h"
57:
58: #ifdef INET
59: #include "netinet/in.h"
60: #include "netinet/in_systm.h"
61: #include "netinet/in_var.h"
62: #include "netinet/ip.h"
63: #include "netinet/if_ether.h"
64: #endif
65:
66: #ifdef NS
67: #include "netns/ns.h"
68: #include "netns/ns_if.h"
69: #endif
70:
71: #include "i386/isa/isa_device.h"
72: #include "i386/isa/if_isreg.h"
73: #include "i386/isa/icu.h"
74:
75: #include "vm/vm.h"
76:
77: /* Function prototypes */
78: int isprobe(), isattach();
79: int isioctl(),isinit(),isstart();
80:
81: struct isa_driver isdriver = {
82: isprobe, isattach, "is",
83: };
84:
85:
86: struct mbuf *isget();
87:
88: #define ETHER_MIN_LEN 64
89:
90: /*
91: * Ethernet software status per interface.
92: *
93: * Each interface is referenced by a network interface structure,
94: * ns_if, which the routing code uses to locate the interface.
95: * This structure contains the output queue for the interface, its address, ...
96: */
97: struct is_softc {
98: struct arpcom ns_ac; /* Ethernet common part */
99: #define ns_if ns_ac.ac_if /* network-visible interface */
100: #define ns_addr ns_ac.ac_enaddr /* hardware Ethernet address */
101: int last_rd;
102: int last_td;
103: int no_td;
104: } is_softc[NIS] ;
105:
106: struct init_block init_block;
107: struct mds *td, *rd;
108: unsigned char *rbuf,*tbuf;
109:
110: int isc;
111:
112: iswrcsr(port,val)
113: u_short port;
114: u_short val;
115: {
116: outw(isc+RAP,port);
117: outw(isc+RDP,val);
118: }
119:
120: u_short isrdcsr(port)
121: u_short port;
122: {
123: outw(isc+RAP,port);
124: return(inw(isc+RDP));
125: }
126:
127: isprobe(dvp)
128: struct isa_device *dvp;
129: {
130: int val,i,s;
131: register struct is_softc *ns = &is_softc[0];
132:
133: isc = dvp->id_iobase;
134: s = splimp();
135:
136: /* Stop the lance chip, put it known state */
137: iswrcsr(0,STOP);
138: DELAY(100);
139:
140: /* is there a lance? */
141: iswrcsr(3, 0xffff);
142: if (isrdcsr(3) != 7) {
143: isc = 0;
144: return (0);
145: }
146: iswrcsr(3, 0);
147:
148: /* Extract board address */
149: for(i=0; i < 6; i++) ns->ns_addr[i] = inb(isc+(i*2));
150:
151: splx(s);
152: return (1);
153: }
154:
155:
156:
157: /*
158: * Reset of interface.
159: */
160: isreset(unit, uban)
161: int unit, uban;
162: {
163: if (unit >= NIS)
164: return;
165: printf("is%d: reset\n", unit);
166: isinit(unit);
167: }
168:
169: /*
170: * Interface exists: make available by filling in network interface
171: * record. System will initialize the interface when it is ready
172: * to accept packets. We get the ethernet address here.
173: */
174: isattach(dvp)
175: struct isa_device *dvp;
176: {
177: int unit = dvp->id_unit;
178: register struct is_softc *is = &is_softc[unit];
179: register struct ifnet *ifp = &is->ns_if;
180:
181: /* Set up DMA */
182: isa_dmacascade(dvp->id_drq);
183:
184: ifp->if_unit = unit;
185: ifp->if_name = isdriver.name ;
186: ifp->if_mtu = ETHERMTU;
187: printf (" ethernet address %s", ether_sprintf(is->ns_addr)) ;
188: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
189: ifp->if_init = isinit;
190: ifp->if_output = ether_output;
191: ifp->if_start = isstart;
192: ifp->if_ioctl = isioctl;
193: ifp->if_reset = isreset;
194: ifp->if_watchdog = 0;
195: if_attach(ifp);
196: }
197:
198:
199: /* Lance initialisation block set up */
200: init_mem()
201: {
202: int i;
203: u_long temp;
204:
205: /* Allocate memory */
206: /* Temporary hack, will use kmem_alloc in future */
207: #define MAXMEM ((NRBUF+NTBUF)*(BUFSIZE) + (NRBUF+NTBUF)*sizeof(struct mds) + 8)
208: static u_char lance_mem[MAXMEM];
209:
210:
211: /* Align message descriptors on quad word boundary
212: (this is essential) */
213:
214: temp = (u_long) &lance_mem;
215: temp = (temp+8) - (temp%8);
216: rd = (struct mds *) temp;
217: td = (struct mds *) (temp + (NRBUF*sizeof(struct mds)));
218: temp += (NRBUF+NTBUF) * sizeof(struct mds);
219:
220: init_block.mode = 0;
221:
222: /* Get ethernet address */
223: for (i=0; i<6; i++)
224: init_block.padr[i] = inb(isc+(i*2));
225:
226: /* Clear multicast address for now */
227: for (i=0; i<8; i++)
228: init_block.ladrf[i] = 0;
229:
230: init_block.rdra = kvtop(rd);
231: init_block.rlen = ((kvtop(rd) >> 16) & 0xff) | (RLEN<<13);
232: init_block.tdra = kvtop(td);
233: init_block.tlen = ((kvtop(td) >> 16) & 0xff) | (TLEN<<13);
234:
235: /* Set up receive ring descriptors */
236: rbuf = (unsigned char *)temp;
237: for (i=0; i<NRBUF; i++) {
238: (rd+i)->addr = kvtop(temp);
239: (rd+i)->flags= ((kvtop(temp) >> 16) & 0xff) | OWN;
240: (rd+i)->bcnt = -BUFSIZE;
241: (rd+i)->mcnt = 0;
242: temp += BUFSIZE;
243: }
244:
245: /* Set up transmit ring descriptors */
246: tbuf = (unsigned char *)temp;
247: #ifdef ISDEBUG
248: printf("rd = %x,td = %x, rbuf = %x, tbuf = %x,td+1=%x\n",rd,td,rbuf,tbuf,td+1);
249: #endif
250: for (i=0; i<NTBUF; i++) {
251: (td+i)->addr = kvtop(temp);
252: (td+i)->flags= ((kvtop(temp) >> 16) & 0xff);
253: (td+i)->bcnt = 0;
254: (td+i)->mcnt = 0;
255: temp += BUFSIZE;
256: }
257:
258: }
259:
260: /*
261: * Initialization of interface; set up initialization block
262: * and transmit/receive descriptor rings.
263: */
264: isinit(unit)
265: int unit;
266: {
267: register struct is_softc *ns = &is_softc[unit];
268: struct ifnet *ifp = &ns->ns_if;
269: int s;
270: register i;
271:
272: if (ifp->if_addrlist == (struct ifaddr *)0) return;
273:
274: ns->last_rd = ns->last_td = ns->no_td = 0;
275: s = splimp();
276:
277: /* Set up lance's memory area */
278: init_mem();
279:
280: /* Stop Lance to get access to other registers */
281: iswrcsr(0,STOP);
282:
283: /* I wish I knew what this was */
284: iswrcsr(3,0);
285:
286: /* Give lance the physical address of its memory area */
287: iswrcsr(1,kvtop(&init_block));
288: iswrcsr(2,(kvtop(&init_block) >> 16) & 0xff);
289:
290: /* OK, let's try and initialise the Lance */
291: iswrcsr(0,INIT);
292:
293: /* Wait for initialisation to finish */
294: for(i=0; i<1000; i++){
295: if (isrdcsr(0)&IDON)
296: break;
297: }
298: if (isrdcsr(0)&IDON) {
299: /* Start lance */
300: iswrcsr(0,STRT|IDON|INEA);
301: ns->ns_if.if_flags |= IFF_RUNNING;
302: isstart(ifp);
303: }
304: else
305: printf("Isolink card failed to initialise\n");
306:
307: splx(s);
308: }
309:
310: /*
311: * Setup output on interface.
312: * Get another datagram to send off of the interface queue,
313: * and map it to the interface before starting the output.
314: * called only at splimp or interrupt level.
315: */
316: isstart(ifp)
317: struct ifnet *ifp;
318: {
319: register struct is_softc *ns = &is_softc[ifp->if_unit];
320: struct mbuf *m0, *m;
321: unsigned char *buffer;
322: u_short len;
323: int i;
324: struct mds *cdm;
325:
326:
327: if ((ns->ns_if.if_flags & IFF_RUNNING) == 0)
328: return;
329:
330: do {
331: cdm = (td + ns->last_td);
332: if (cdm->flags&OWN)
333: return;
334:
335: IF_DEQUEUE(&ns->ns_if.if_snd, m);
336:
337: if (m == 0)
338: return;
339:
340: /*
341: * Copy the mbuf chain into the transmit buffer
342: */
343:
344: buffer = tbuf+(BUFSIZE*ns->last_td);
345: len=0;
346: for (m0=m; m != 0; m=m->m_next) {
347: bcopy(mtod(m,caddr_t),buffer,m->m_len);
348: buffer += m->m_len;
349: len += m->m_len;
350: }
351:
352: m_freem(m0);
353: len = MAX(len,ETHER_MIN_LEN);
354:
355: /*
356: * Init transmit registers, and set transmit start flag.
357: */
358:
359: cdm->flags |= (OWN|STP|ENP);
360: cdm->bcnt = -len;
361: cdm->mcnt = 0;
362: #ifdef ISDEBUG
363: xmit_print(ns->last_td);
364: #endif
365:
366: iswrcsr(0,TDMD|INEA);
367: if (++ns->last_td >= NTBUF)
368: ns->last_td=0;
369: }while(++ns->no_td < NTBUF);
370: ns->no_td = NTBUF;
371: ns->ns_if.if_flags |= IFF_OACTIVE;
372: #ifdef ISDEBUG
373: printf("no_td = %x, last_td = %x\n",ns->no_td, ns->last_td);
374: #endif
375: return(0);
376: }
377:
378:
379: /*
380: * Controller interrupt.
381: */
382: isintr(unit)
383: {
384: register struct is_softc *ns = &is_softc[unit];
385: u_short isr;
386:
387: while((isr=isrdcsr(0))&INTR) {
388: if (isr&ERR) {
389: if (isr&BABL)
390: printf("BABL\n");
391: if (isr&CERR)
392: printf("CERR\n");
393: if (isr&MISS)
394: printf("MISS\n");
395: if (isr&MERR)
396: printf("MERR\n");
397: iswrcsr(0,BABL|CERR|MISS|MERR|INEA);
398: }
399: if (!(isr&TXON)) {
400: isreset(unit);
401: return(1);
402: }
403: if (!(isr&RXON)) {
404: isreset(unit);
405: return(1);
406: }
407: if (isr&RINT) {
408: isrint(unit);
409: }
410: if (isr&TINT) {
411: iswrcsr(0,TINT|INEA);
412: istint(unit);
413: }
414: }
415: }
416:
417: istint(unit)
418: int unit;
419: {
420: struct is_softc *is = &is_softc[unit];
421: register struct ifnet *ifp = &is->ns_if;
422: int i,loopcount=0;
423: struct mds *cdm;
424:
425: do {
426: if ((i=is->last_td - is->no_td) < 0)
427: i+=NTBUF;
428: cdm = (td+i);
429: #ifdef ISDEBUG
430: printf("Trans cdm = %x\n",cdm);
431: #endif
432: if (cdm->flags&OWN) {
433: if (loopcount)
434: break;
435: return;
436: }
437: loopcount++;
438: is->ns_if.if_flags &= ~IFF_OACTIVE;
439: }while(--is->no_td > 0);
440: isstart(ifp);
441:
442: }
443:
444: #define NEXTRDS \
445: if (++rmd == NRBUF) rmd=0, cdm=rd; else ++cdm
446:
447: isrint(unit)
448: int unit;
449: {
450: register struct is_softc *is=&is_softc[unit];
451: register int rmd = is->last_rd;
452: struct mds *cdm = (rd + rmd);
453:
454: /* Out of sync with hardware, should never happen */
455:
456: if (cdm->flags & OWN) {
457: printf("is0 error: out of sync\n");
458: iswrcsr(0,RINT|INEA);
459: return;
460: }
461:
462: /* Process all buffers with valid data */
463: while (!(cdm->flags&OWN)) {
464: /* Clear interrupt to avoid race condition */
465: iswrcsr(0,RINT|INEA);
466: if (cdm->flags&ERR) {
467: if (cdm->flags&FRAM)
468: printf("FRAM\n");
469: if (cdm->flags&OFLO)
470: printf("OFLO\n");
471: if (cdm->flags&CRC)
472: printf("CRC\n");
473: if (cdm->flags&RBUFF)
474: printf("RBUFF\n");
475: }else
476: if (cdm->flags&(STP|ENP) != (STP|ENP)) {
477: do {
478: iswrcsr(0,RINT|INEA);
479: cdm->mcnt = 0;
480: cdm->flags |= OWN;
481: NEXTRDS;
482: }while (!(cdm->flags&(OWN|ERR|STP|ENP)));
483: is->last_rd = rmd;
484: printf("Chained buffer\n");
485: if ((cdm->flags & (OWN|ERR|STP|ENP)) != ENP) {
486: isreset(unit);
487: return;
488: }
489: }else
490: {
491: #ifdef ISDEBUG
492: recv_print(is->last_rd);
493: #endif
494: isread(is,rbuf+(BUFSIZE*rmd),cdm->mcnt);
495: }
496:
497: cdm->flags |= OWN;
498: cdm->mcnt = 0;
499: NEXTRDS;
500: #ifdef ISDEBUG
501: printf("is->last_rd = %x, cdm = %x\n",is->last_rd,cdm);
502: #endif
503: } /* while */
504: is->last_rd = rmd;
505: } /* isrint */
506:
507: /*
508: * Pass a packet to the higher levels.
509: * We deal with the trailer protocol here.
510: */
511: isread(ns, buf, len)
512: register struct is_softc *ns;
513: char *buf;
514: int len;
515: {
516: register struct ether_header *eh;
517: struct mbuf *m;
518: int off, resid;
519: register struct ifqueue *inq;
520:
521: /*
522: * Deal with trailer protocol: if type is trailer type
523: * get true type from first 16-bit word past data.
524: * Remember that type was trailer by setting off.
525: */
526: eh = (struct ether_header *)buf;
527: eh->ether_type = ntohs((u_short)eh->ether_type);
528: len = len - sizeof(struct ether_header) - 4;
529: #define nedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
530: if (eh->ether_type >= ETHERTYPE_TRAIL &&
531: eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
532: off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
533: if (off >= ETHERMTU) return; /* sanity */
534: eh->ether_type = ntohs(*nedataaddr(eh, off, u_short *));
535: resid = ntohs(*(nedataaddr(eh, off+2, u_short *)));
536: if (off + resid > len) return; /* sanity */
537: len = off + resid;
538: } else off = 0;
539:
540: if (len == 0) return;
541:
542: /*
543: * Pull packet off interface. Off is nonzero if packet
544: * has trailing header; neget will then force this header
545: * information to be at the front, but we still have to drop
546: * the type and length which are at the front of any trailer data.
547: */
548: m = isget(buf, len, off, &ns->ns_if);
549: if (m == 0) return;
550:
551: ether_input(&ns->ns_if, eh, m);
552: }
553:
554: /*
555: * Supporting routines
556: */
557:
558: /*
559: * Pull read data off a interface.
560: * Len is length of data, with local net header stripped.
561: * Off is non-zero if a trailer protocol was used, and
562: * gives the offset of the trailer information.
563: * We copy the trailer information and then all the normal
564: * data into mbufs. When full cluster sized units are present
565: * we copy into clusters.
566: */
567: struct mbuf *
568: isget(buf, totlen, off0, ifp)
569: caddr_t buf;
570: int totlen, off0;
571: struct ifnet *ifp;
572: {
573: struct mbuf *top, **mp, *m, *p;
574: int off = off0, len;
575: register caddr_t cp = buf;
576: char *epkt;
577:
578: buf += sizeof(struct ether_header);
579: cp = buf;
580: epkt = cp + totlen;
581:
582:
583: if (off) {
584: cp += off + 2 * sizeof(u_short);
585: totlen -= 2 * sizeof(u_short);
586: }
587:
588: MGETHDR(m, M_DONTWAIT, MT_DATA);
589: if (m == 0)
590: return (0);
591: m->m_pkthdr.rcvif = ifp;
592: m->m_pkthdr.len = totlen;
593: m->m_len = MHLEN;
594:
595: top = 0;
596: mp = ⊤
597: while (totlen > 0) {
598: if (top) {
599: MGET(m, M_DONTWAIT, MT_DATA);
600: if (m == 0) {
601: m_freem(top);
602: return (0);
603: }
604: m->m_len = MLEN;
605: }
606: len = min(totlen, epkt - cp);
607: if (len >= MINCLSIZE) {
608: MCLGET(m, M_DONTWAIT);
609: if (m->m_flags & M_EXT)
610: m->m_len = len = min(len, MCLBYTES);
611: else
612: len = m->m_len;
613: } else {
614: /*
615: * Place initial small packet/header at end of mbuf.
616: */
617: if (len < m->m_len) {
618: if (top == 0 && len + max_linkhdr <= m->m_len)
619: m->m_data += max_linkhdr;
620: m->m_len = len;
621: } else
622: len = m->m_len;
623: }
624: bcopy(cp, mtod(m, caddr_t), (unsigned)len);
625: cp += len;
626: *mp = m;
627: mp = &m->m_next;
628: totlen -= len;
629: if (cp == epkt)
630: cp = buf;
631: }
632: return (top);
633: }
634:
635: /*
636: * Process an ioctl request.
637: */
638: isioctl(ifp, cmd, data)
639: register struct ifnet *ifp;
640: int cmd;
641: caddr_t data;
642: {
643: register struct ifaddr *ifa = (struct ifaddr *)data;
644: struct is_softc *ns = &is_softc[ifp->if_unit];
645: struct ifreq *ifr = (struct ifreq *)data;
646: int s = splimp(), error = 0;
647:
648:
649: switch (cmd) {
650:
651: case SIOCSIFADDR:
652: ifp->if_flags |= IFF_UP;
653:
654: switch (ifa->ifa_addr->sa_family) {
655: #ifdef INET
656: case AF_INET:
657: isinit(ifp->if_unit); /* before arpwhohas */
658: ((struct arpcom *)ifp)->ac_ipaddr =
659: IA_SIN(ifa)->sin_addr;
660: arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
661: break;
662: #endif
663: #ifdef NS
664: case AF_NS:
665: {
666: register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
667:
668: if (ns_nullhost(*ina))
669: ina->x_host = *(union ns_host *)(ns->ns_addr);
670: else {
671: /*
672: * The manual says we can't change the address
673: * while the receiver is armed,
674: * so reset everything
675: */
676: ifp->if_flags &= ~IFF_RUNNING;
677: bcopy((caddr_t)ina->x_host.c_host,
678: (caddr_t)ns->ns_addr, sizeof(ns->ns_addr));
679: }
680: isinit(ifp->if_unit); /* does ne_setaddr() */
681: break;
682: }
683: #endif
684: default:
685: isinit(ifp->if_unit);
686: break;
687: }
688: break;
689:
690: case SIOCSIFFLAGS:
691: if ((ifp->if_flags & IFF_UP) == 0 &&
692: ifp->if_flags & IFF_RUNNING) {
693: ifp->if_flags &= ~IFF_RUNNING;
694: iswrcsr(0,STOP);
695: } else if (ifp->if_flags & IFF_UP &&
696: (ifp->if_flags & IFF_RUNNING) == 0)
697: isinit(ifp->if_unit);
698: break;
699:
700: #ifdef notdef
701: case SIOCGHWADDR:
702: bcopy((caddr_t)ns->ns_addr, (caddr_t) &ifr->ifr_data,
703: sizeof(ns->ns_addr));
704: break;
705: #endif
706:
707: default:
708: error = EINVAL;
709: }
710: splx(s);
711: return (error);
712: }
713:
714: recv_print(no)
715: int no;
716: {
717: struct mds *rmd;
718: int len,i;
719:
720: rmd = (rd+no);
721: len = rmd->mcnt;
722: printf("Receive buffer %d, len = %d\n",no,len);
723: printf("Status %x\n",isrdcsr(0));
724: for (i=0; i<len; i++)
725: printf("%x ",*(rbuf+(BUFSIZE*no)+i));
726: printf("\n");
727: }
728:
729: xmit_print(no)
730: int no;
731: {
732: struct mds *rmd;
733: int i;
734: u_short len;
735:
736: rmd = (td+no);
737: len = -(rmd->bcnt);
738: printf("Transmit buffer %d, len = %d\n",no,len);
739: printf("Status %x\n",isrdcsr(0));
740: printf("addr %x, flags %x, bcnt %x, mcnt %x\n",
741: rmd->addr,rmd->flags,rmd->bcnt,rmd->mcnt);
742: for (i=0; i<len; i++)
743: printf("%x ",*(tbuf+(BUFSIZE*no)+i));
744: printf("\n");
745: }
746:
747: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.