![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ju.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to ju.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: /* Jupiter driver -- both 8 bit programmed i/o and 16 bit dma i/o */ ! 2: ! 3: #include "ju.h" ! 4: #if NJU>0 ! 5: #include "../h/param.h" ! 6: #include "../h/dir.h" ! 7: #include "../h/user.h" ! 8: #include "../h/buf.h" ! 9: #include "../h/pte.h" ! 10: #include "../h/ubavar.h" ! 11: #include "../h/ubareg.h" ! 12: #include "../h/systm.h" ! 13: ! 14: #define JUPRI PZERO+10 ! 15: #define JULOWAT 50 ! 16: ! 17: struct judevice { ! 18: unsigned short jucsr, /* interface card csr */ ! 19: jutc, /* transfer count */ ! 20: juba, /* bus address */ ! 21: juxba, /* extended bus address */ ! 22: judcsr, /* device csr */ ! 23: judcw, /* device command word */ ! 24: judsw, /* device status word */ ! 25: juvec; /* interrupt vector */ ! 26: }; ! 27: ! 28: #define JBUFSIZ 512 ! 29: #define JUSIZ (2*JBUFSIZ) ! 30: ! 31: #define JNTRIES 2000 ! 32: #define MAXSAME 60 ! 33: struct ju { ! 34: unsigned char jucbuf[JUSIZ]; /* one buffer */ ! 35: unsigned char *jur, *juw; /* two chasing pointers */ ! 36: int jucc; /* char count to dismbiguate */ ! 37: unsigned short flag; /* the case of jur == juw */ ! 38: unsigned int writes, lastwrite; ! 39: unsigned short samewrite; ! 40: int waitcount; ! 41: } jutab[NJU]; ! 42: ! 43: int jutimeout; ! 44: int waitpoke, timerpoke; ! 45: /* FLAG BITS */ ! 46: #define OPEN 010 ! 47: #define DIWAIT 020 ! 48: #define DEBUG 040 ! 49: #define ASLP 0100 ! 50: #define ESLP 0200 ! 51: #define DMA 0400 ! 52: #define TIWAIT 01000 ! 53: ! 54: /* I/O LOCATIONS */ ! 55: #define DA 0777320 ! 56: #define CSR DA+0 ! 57: #define TC DA+02 ! 58: #define BA DA+04 ! 59: #define XBA DA+06 ! 60: #define DCSR DA+010 ! 61: #define DCW DA+012 ! 62: #define DSW DA+014 ! 63: #define VEC DA+016 ! 64: /* ! 65: DA device base address ! 66: CSR csr for interface card ! 67: TC transfer count ! 68: BA bus address ! 69: XBA extended bus address ! 70: DCSR csr for device ! 71: DCW command word to device ! 72: DSW status word from device ! 73: VEC interrupt vector ! 74: */ ! 75: ! 76: /* BIT DEFINITIONS: */ ! 77: ! 78: /* interface csr register */ ! 79: #define C_GO 1 ! 80: #define C_DFD 2 ! 81: #define C_BY 020 ! 82: #define C_DIR 040 ! 83: #define C_TIE 0100 ! 84: #define C_DON 0200 ! 85: #define C_FIFO 01400 ! 86: #define C_WDF 02000 ! 87: #define C_PGE 010000 ! 88: #define C_VE 020000 ! 89: #define C_MTO 040000 ! 90: #define C_ERR 0100000 ! 91: /* ! 92: C_GO dma go bit ! 93: C_DFD data flag done ! 94: C_BY byte mode ! 95: C_DIR xfer direction (1 for read from device) ! 96: C_TIE enable transfer complete interrupt ! 97: C_DON transfer done ! 98: C_FIFO fifo level ! 99: C_WDF waiting for data flag ! 100: C_PGE program error ! 101: C_VE vector error ! 102: C_MTO memory timeout ! 103: C_ERR any error ! 104: */ ! 105: ! 106: /* device csr register */ ! 107: #define D_RST 1 ! 108: #define D_SNS 2 ! 109: #define D_DIE 0100 ! 110: #define D_DIR 0200 ! 111: /* ! 112: D_RST reset terminal ! 113: D_SNS sense line ! 114: D_DIE enable devive interrupt ! 115: D_DIR device interrupt request ! 116: */ ! 117: ! 118: /* device command word */ ! 119: #define DC_SI 01000 ! 120: #define DC_RST 0400 ! 121: /* ! 122: DC_SI suppress interrupt from terminal ! 123: DC_RST reset terminal ! 124: */ ! 125: /* device status word */ ! 126: #define DS_BSY 0100000 ! 127: #define DS_PBR 040000 ! 128: #define DS_KSR 020000 ! 129: /* ! 130: DS_BSY device busy ! 131: DS_PBR parallel byte ready ! 132: DS_KSR keystroke ready ! 133: */ ! 134: ! 135: int juattach(), juprobe(), judgo(), judintr(), jutintr(); ! 136: int justrategy(), justart(); ! 137: ! 138: struct uba_ctlr *jucinfo[NJU]; ! 139: struct uba_ctlr juctlr[NJU]; /* juattach() sets jucinfo to point to this */ ! 140: struct uba_device *judinfo[NJU]; ! 141: u_short justd[] = { 0 }; ! 142: struct uba_driver judriver = ! 143: { juprobe, 0, juattach, judgo, justd, "ju", judinfo ,"ju", jucinfo }; ! 144: ! 145: #define ui_open ui_type ! 146: struct buf jubuf[NJU]; ! 147: struct buf judtab[NJU]; ! 148: juprobe(reg) ! 149: caddr_t reg; ! 150: { ! 151: register int br, cvec; ! 152: register struct judevice *juaddr = (struct judevice *)reg; ! 153: ! 154: juaddr->juvec = 0500; /* set interrupt vector xxx ? */ ! 155: /* ! 156: juaddr->judcsr &= ~D_DIR; |* clear interrupt request bit *| ! 157: juaddr->judcsr |= D_DIE; |* enable interrupt, the one that *| ! 158: |* happens when terminal is ready *| ! 159: juaddr->judcsr |= D_DIR; |*cause an interrupt *| ! 160: DELAY(10000); ! 161: */ ! 162: br = 0x14; /* BR Level 14 = UNIBUS 4 */ ! 163: cvec = 0500; ! 164: return(1); ! 165: } ! 166: ! 167: juattach(ui) /* initialization on system boot */ ! 168: register struct uba_device *ui; ! 169: { ! 170: register struct uba_ctlr *um; ! 171: register int unit; ! 172: ! 173: unit = ui->ui_unit; ! 174: ! 175: um = &juctlr[unit]; ! 176: jucinfo[unit] = um; ! 177: ui->ui_ctlr = unit; ! 178: ui->ui_mi = um; ! 179: um->um_driver = ui->ui_driver; ! 180: um->um_ctlr = unit; ! 181: um->um_ubanum = ui->ui_ubanum; ! 182: um->um_alive = 1; ! 183: um->um_intr = ui->ui_intr; ! 184: um->um_addr = ui->ui_addr; ! 185: um->um_hd = ui->ui_hd; ! 186: } ! 187: ! 188: static int jerror, ! 189: entries,direntries,breturns,oreturns, ! 190: impossible, jutotali, jubytes; ! 191: static int jwrites, jwaits, jwritepokes, jfullpokes, jreads; ! 192: juopen(dev, flag) ! 193: dev_t dev; ! 194: { ! 195: register int s; ! 196: register unit, d; ! 197: int jutimer(); ! 198: register struct ju *ju; ! 199: register struct uba_device *ui; ! 200: ! 201: d = minor(dev); ! 202: unit = d&07; ! 203: ju = &jutab[unit]; ! 204: ui = judinfo[unit]; ! 205: if(unit >= NJU || ui->ui_alive == 0 || (ju->flag & OPEN)) { ! 206: u.u_error = ENXIO; ! 207: return; ! 208: } ! 209: jerror=waitpoke=timerpoke=0; ! 210: entries=direntries=breturns=oreturns=0; ! 211: jwrites=jwaits=jwritepokes=jfullpokes=jreads=0; ! 212: jubytes=jutotali=impossible=0; ! 213: ju->flag = (d&077)|OPEN; ! 214: ju->juw = ju->jur = ju->jucbuf; ! 215: ju->jucc = 0; ! 216: ! 217: ui->ui_open++; ! 218: while(((struct judevice *)ui->ui_addr)->judsw&DS_BSY) ! 219: sleep((caddr_t)&lbolt,JUPRI); ! 220: if(jutimeout == 0) { /* i.e. there is not a timer already going */ ! 221: jutimeout++; ! 222: timeout(jutimer, (caddr_t)0, 60); ! 223: } ! 224: ! 225: } ! 226: ! 227: jutimer() ! 228: { ! 229: register struct ju *ju; ! 230: register unit, flag, ps; ! 231: register struct judevice *juaddr; ! 232: ! 233: for (unit=flag=0; unit < NJU; unit++) { ! 234: ju = &jutab[unit]; ! 235: if (ju->flag&OPEN==0) { ! 236: continue; ! 237: } ! 238: juaddr = (struct judevice *)(judinfo[unit]->ui_addr); ! 239: flag++; /* unit is active */ ! 240: ps = spl4(); ! 241: if (ju->flag & TIWAIT) { ! 242: if (ju->writes == ju->lastwrite) { ! 243: if (++(ju->samewrite) > MAXSAME) { ! 244: if(ju->flag & DEBUG)printf("timer TIWAIT\n"); ! 245: juaddr->jucsr &= ~C_GO; ! 246: jutintr(unit); ! 247: } ! 248: } else ! 249: ju->lastwrite = ju->writes; ! 250: } ! 251: if (ju->flag&DIWAIT) { ! 252: /* judintr thinks it has work to do, */ ! 253: /* is waiting for a device interrupt */ ! 254: if ((juaddr->judsw & DS_BSY) == 0) { ! 255: /* device is not busy! */ ! 256: timerpoke++; ! 257: judintr(unit); ! 258: } ! 259: } ! 260: splx(ps); ! 261: } ! 262: if(flag) { /* keep timer going */ ! 263: timeout(jutimer, (caddr_t)0, 60); ! 264: } else { /* no active devices, shut down timer */ ! 265: jutimeout = 0; ! 266: } ! 267: } ! 268: #define DEBUGON (('J'<<8)|1) ! 269: #define DEBUGOFF (('J'<<8)|2) ! 270: #define DMAON (('J'<<8)|3) ! 271: #define DMAOFF (('J'<<8)|4) ! 272: #define READREGS (('J'<<8)|6) ! 273: ! 274: struct juregs { ! 275: unsigned short jucsr, ! 276: judcsr, ! 277: judsw; ! 278: }; ! 279: ! 280: juioctl(dev, cmd, addr) ! 281: register dev_t dev; ! 282: register struct juregs *addr; ! 283: register cmd; ! 284: { ! 285: int unit; ! 286: struct ju *ju; ! 287: struct judevice *juaddr; ! 288: ! 289: unit = minor(dev)&07; ! 290: ju = &jutab[unit]; ! 291: juaddr = (struct judevice *)judinfo[unit]->ui_addr; ! 292: ! 293: switch(cmd){ ! 294: case DMAON: ! 295: if(ju->jucc > 0)juwait(ju,0); /* flush pg buffer */ ! 296: ju->flag |= DMA; ! 297: if(ju->flag & DEBUG)printf("ju: DMAON\n"); ! 298: break; ! 299: case DMAOFF: ! 300: ju->flag &= ~DMA; ! 301: break; ! 302: case READREGS: ! 303: addr->jucsr = juaddr->jucsr; ! 304: addr->judcsr = juaddr->judcsr; ! 305: addr->judsw = juaddr->judsw; ! 306: break; ! 307: case DEBUGON: ! 308: ju->flag |= DEBUG; ! 309: printf("ju: DEBUGON\n"); ! 310: break; ! 311: case DEBUGOFF: ! 312: ju->flag &= ~DEBUG; ! 313: break; ! 314: default: ! 315: u.u_error = EFAULT; ! 316: } ! 317: } ! 318: juclose(dev) ! 319: register dev_t dev; ! 320: { ! 321: register unit; ! 322: register struct ju *ju; ! 323: ! 324: unit = minor(dev)&07; ! 325: ju = &jutab[unit]; ! 326: ! 327: ju->flag &= ~OPEN; /* to shut off timer */ ! 328: juwait(ju,0); ! 329: ((struct judevice *)judinfo[unit]->ui_addr)->jucsr = 0; ! 330: ((struct judevice *)judinfo[unit]->ui_addr)->judcsr = 0; ! 331: ! 332: judinfo[unit]->ui_open = 0; ! 333: if(ju->flag&DEBUG) { ! 334: printf("juclose: errors %d waitpokes %d timerpokes %d\n", ! 335: jerror,waitpoke,timerpoke); ! 336: printf(" judintr: %d entries, of which %d had D_DIR set\n", ! 337: entries, direntries); ! 338: printf(" %d returns on busy, %d out bottom\n", ! 339: breturns, oreturns); ! 340: printf("%d writes, %d reads, %d writepokes, %d fullpokes, %d waits\n", ! 341: jwrites,jreads,jwritepokes,jfullpokes,jwaits); ! 342: if(jubytes) ! 343: printf("totali %d on %d bytes sent, %d average\n",jutotali,jubytes, ! 344: jutotali/jubytes); ! 345: } ! 346: ju->flag = 0; ! 347: } ! 348: ! 349: juwait(ju, count) ! 350: register struct ju *ju; ! 351: register count; ! 352: { ! 353: register int s, times; ! 354: register r; ! 355: ! 356: jwaits++; ! 357: times = 60; ! 358: ju->waitcount = count; ! 359: while(ju->jucc > count){ ! 360: ju->flag |= ASLP; ! 361: r = tsleep((caddr_t)ju, JUPRI, 1); ! 362: if(r == TS_TIME) { /* timed out */ ! 363: if ((ju->flag&DIWAIT) == 0) { ! 364: /* oddly enough judintr doesn't think it has */ ! 365: /* any work to do */ ! 366: s = spl4(); ! 367: waitpoke++; ! 368: judintr(ju-jutab); ! 369: splx(s); ! 370: } ! 371: times--; ! 372: if(times==0) { ! 373: printf("jupiter timeout, buffer flushed\n"); ! 374: goto flush; ! 375: } ! 376: } ! 377: if (r==TS_SIG) { ! 378: flush: ! 379: ju->jur = ju->juw = ju->jucbuf; ! 380: ju->jucc = 0; ! 381: } ! 382: } ! 383: } ! 384: ! 385: unsigned short jcheck(addr,bitmask,value) ! 386: register unsigned short *addr; ! 387: register unsigned int bitmask, value; ! 388: { ! 389: register int times; ! 390: unsigned short data; ! 391: ! 392: times = 0; ! 393: while (((data = *addr) & bitmask) != value) ! 394: if (times++ >= JNTRIES) { ! 395: times = 0; ! 396: if (tsleep((caddr_t)addr, JUPRI, 1) == TS_SIG) ! 397: return 0; ! 398: } ! 399: ! 400: return data; ! 401: } ! 402: ! 403: juread(dev) ! 404: { ! 405: register struct judevice *addr; ! 406: register struct ju *ju; ! 407: register int unit, count; ! 408: register unsigned char *bptr; ! 409: ! 410: unit = dev & 07; ! 411: ju = &jutab[unit]; ! 412: addr = (struct judevice *)judinfo[unit]->ui_addr; ! 413: jreads++; ! 414: ! 415: if (ju->jucc) ! 416: juwait(ju, 0); ! 417: if(ju->flag&DMA) { ! 418: if(ju->flag&DEBUG) ! 419: printf("attempting dma read to ju\n"); ! 420: ju->flag |= TIWAIT; ! 421: physio(justrategy,&jubuf[unit],dev,B_READ,minphys); ! 422: return; ! 423: } ! 424: count = u.u_count; ! 425: bptr = ju->jucbuf; ! 426: ! 427: addr->judcsr &= ~D_DIR; ! 428: if(ju->flag&DEBUG)printf("DSW address %o\n",&(addr->judsw)); ! 429: while (count--) { ! 430: *bptr++ = (unsigned char)(jcheck(&(addr->judsw),DS_PBR, DS_PBR) ! 431: &0xFF) ; ! 432: if(ju->flag&DEBUG)printf("DSW is %x\n",(unsigned int)addr->judsw); ! 433: jcheck(&(addr->judsw), DS_PBR, 0); ! 434: /* send PBA command */ ! 435: jcheck(&(addr->judsw), DS_BSY, 0); ! 436: addr->judcw = 033; ! 437: if(ju->flag & DEBUG)printf("end of read loop, data %x\n", ! 438: (int)(*(bptr-1))); ! 439: } ! 440: ! 441: iomove(ju->jucbuf, u.u_count, B_READ); ! 442: } ! 443: ! 444: juwrite(dev) ! 445: { ! 446: register struct ju *ju; ! 447: register unsigned char *p; ! 448: register c, cc; ! 449: register s; ! 450: register unsigned char *jur; ! 451: register int unit; ! 452: ! 453: unit = minor(dev) & 07; ! 454: ju = &jutab[unit]; ! 455: ju->writes++; ! 456: jwrites++; ! 457: ! 458: if(ju->flag&DMA) { ! 459: if(ju->flag&DEBUG) ! 460: printf("attempting dma write to ju\n"); ! 461: ju->flag |= TIWAIT; ! 462: physio(justrategy,&jubuf[unit],dev,B_WRITE,minphys); ! 463: } ! 464: else { ! 465: while(u.u_count) { ! 466: jur = ju->jur; ! 467: if(jur > ju->juw) ! 468: cc = jur - ju->juw; ! 469: else if (jur == ju->juw && ju->jucc != 0) ! 470: cc = 0; /* buffer full */ ! 471: else /* from juw to end of buffer */ ! 472: cc = ju->jucbuf + JUSIZ - ju->juw; ! 473: if(u.u_count < cc) ! 474: cc = u.u_count; ! 475: if(cc == 0) { /* the buffer must be full */ ! 476: s = spl4(); /* correct priority?xxx */ ! 477: if ((ju->flag&DIWAIT) == 0) { ! 478: jfullpokes++; ! 479: judintr(unit); ! 480: } ! 481: splx(s); ! 482: juwait(ju,JULOWAT); ! 483: } ! 484: else { /* queue up some characters */ ! 485: iomove(ju->juw, cc, B_WRITE); ! 486: if((ju->juw += cc) >= ju->jucbuf + JUSIZ) ! 487: ju->juw = ju->jucbuf; ! 488: s = spl4(); ! 489: ju->jucc += cc; ! 490: if (( ju->flag&DIWAIT) == 0) { ! 491: jwritepokes++; ! 492: judintr(unit); ! 493: } ! 494: splx(s); ! 495: } ! 496: } ! 497: } ! 498: } ! 499: ! 500: /* Since justrategy is currently called only by juwrite ! 501: via physio, there will be only one transaction in each ! 502: DMA-U's queue at a given time. So we tack the given buffer ! 503: header pointer on at the end of the queue, and call justart ! 504: */ ! 505: justrategy(bp) ! 506: register struct buf *bp; ! 507: { ! 508: register struct uba_device *ui; ! 509: register struct uba_ctlr *um; ! 510: register struct buf *dp; ! 511: register judvma; ! 512: dev_t unit; ! 513: int ps; ! 514: ! 515: ps = spl4(); ! 516: unit = minor(bp->b_dev); ! 517: ui = judinfo[unit]; ! 518: um = ui->ui_mi; /* ctlr pointer */ ! 519: dp = &judtab[unit]; ! 520: dp->b_actf = bp; ! 521: dp->b_actl = bp; ! 522: bp->av_forw = NULL; ! 523: um->um_tab.b_actf = dp; ! 524: um->um_tab.b_actl = dp; ! 525: um->um_cmd = C_TIE | C_GO; ! 526: if (bp->b_flags & B_READ) ! 527: um->um_cmd |= C_DIR; ! 528: ! 529: justart(um); ! 530: splx(ps); ! 531: } ! 532: ! 533: justart(um) ! 534: register struct uba_ctlr *um; ! 535: { ! 536: register struct buf *bp, *dp; ! 537: register struct judevice *juaddr; ! 538: ! 539: dp = um->um_tab.b_actf; ! 540: bp = dp->b_actf; ! 541: um->um_tab.b_active++; ! 542: juaddr = (struct judevice *)um->um_addr; ! 543: jcheck(&(juaddr->judsw), DS_BSY, 0); ! 544: juaddr->jutc = -bp->b_bcount / sizeof(short); ! 545: juaddr->judcsr = juaddr->jucsr = 0; ! 546: (void) ubago(judinfo[minor(bp->b_dev)]); ! 547: } ! 548: ! 549: judgo(um) ! 550: register struct uba_ctlr *um; ! 551: { ! 552: register struct judevice *juaddr = (struct judevice *)um->um_addr; ! 553: ! 554: juaddr->juba = um->um_ubinfo; ! 555: juaddr->juxba = (um->um_ubinfo>>16) & 3; ! 556: juaddr->jucsr = um->um_cmd; ! 557: } ! 558: jutintr(dev) ! 559: register dev_t dev; ! 560: { ! 561: register struct buf *bp, *dp; ! 562: register struct judevice *juaddr; ! 563: register struct uba_ctlr *um; ! 564: register unit; ! 565: register struct ju *ju; ! 566: ! 567: unit = minor(dev) & 07; ! 568: um = jucinfo[unit]; ! 569: ! 570: ju = &jutab[unit]; ! 571: ju->flag &= ~TIWAIT; ! 572: ju->samewrite = 0; ! 573: juaddr = (struct judevice *)um->um_addr; ! 574: juaddr->jucsr = 0; ! 575: if(um->um_tab.b_active == 0) ! 576: return; ! 577: ! 578: dp = um->um_tab.b_actf; ! 579: bp = dp->b_actf; ! 580: ! 581: /* should check for errors? */ ! 582: ! 583: um->um_tab.b_active = 0; ! 584: um->um_tab.b_errcnt = 0; ! 585: um->um_tab.b_actf = dp->b_forw; ! 586: dp->b_errcnt = 0; ! 587: dp->b_active = 0; ! 588: bp->b_resid = (-juaddr->jutc * sizeof(short)); ! 589: ubadone(um); ! 590: iodone(bp); ! 591: } ! 592: ! 593: static int jcount; ! 594: judintr(dev) ! 595: register dev_t dev; ! 596: { ! 597: register struct ju *ju; ! 598: register struct judevice *addr; ! 599: register c, cc, unit; ! 600: ! 601: unit = minor(dev) & 07; ! 602: ju = &jutab[unit]; ! 603: ju->flag &= ~DIWAIT; ! 604: addr = (struct judevice *)judinfo[unit]->ui_addr; ! 605: ! 606: entries++; if(addr->judcsr&D_DIR)direntries++; ! 607: ! 608: if (addr->jucsr&C_ERR) { ! 609: printf("error: ju %d %x\n",dev,(int)addr->jucsr); ! 610: addr->jucsr &= ~C_ERR; ! 611: ju->flag &= ~DIWAIT; ! 612: ju->flag |= ESLP; ! 613: jerror++; ! 614: return; ! 615: } ! 616: ! 617: cc = 0; ! 618: while (ju->jucc > 0) { ! 619: addr->judcsr &= ~D_DIR; /* clear interrupt request bit */ ! 620: for(jcount=0;jcount<JNTRIES;jcount++) ! 621: if( (addr->judsw&DS_BSY) == 0 )goto putout; ! 622: /* busy too long -- sleep */ ! 623: addr->judcsr |= D_DIE; ! 624: ju->flag |= DIWAIT; ! 625: if(ju->flag&ASLP && ju->jucc <= ju->waitcount){ ! 626: ju->flag &= ~ASLP; ! 627: wakeup((caddr_t)ju); ! 628: } ! 629: breturns++; ! 630: return; ! 631: putout: /* not busy: output a byte */ ! 632: addr->judcw = *(ju->jur)++; ! 633: if (ju->jur == ju->jucbuf + JUSIZ) ! 634: ju->jur = ju->jucbuf; ! 635: ju->jucc--; ! 636: cc++; ! 637: jutotali += jcount; ! 638: jubytes++; ! 639: } ! 640: ! 641: ! 642: out: if(cc && ju->flag&ASLP && ju->jucc <= ju->waitcount) { ! 643: ju->flag &= ~ASLP; ! 644: wakeup ((caddr_t)ju); ! 645: } ! 646: oreturns++; ! 647: } ! 648: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.