Annotation of margi2/margi.c, revision 1.1
1.1 ! cvs 1: /*
! 2: margi.c
! 3:
! 4: Copyright (C) Marcus Metzler for convergence integrated media.
! 5:
! 6: This program is free software; you can redistribute it and/or modify
! 7: it under the terms of the GNU General Public License as published by
! 8: the Free Software Foundation; either version 2 of the License, or
! 9: (at your option) any later version.
! 10:
! 11: This program is distributed in the hope that it will be useful,
! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 14: GNU General Public License for more details.
! 15:
! 16: You should have received a copy of the GNU General Public License
! 17: along with this program; if not, write to the Free Software
! 18: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 19: */
! 20:
! 21: #include "margi.h"
! 22:
! 23: #include <pcmcia/version.h>
! 24: #include <pcmcia/cs_types.h>
! 25: #include <pcmcia/cs.h>
! 26: #include <pcmcia/cistpl.h>
! 27: #include <pcmcia/cisreg.h>
! 28: #include <pcmcia/bus_ops.h>
! 29: #include <pcmcia/ds.h>
! 30:
! 31:
! 32:
! 33: #include "l64014.h"
! 34: #include "l64021.h"
! 35: #include "i2c.h"
! 36: #include "decoder.h"
! 37: #include "dram.h"
! 38: #include "video.h"
! 39: #include "cvdv.h"
! 40:
! 41: //#define USE_BH 1
! 42: #ifdef USE_BH
! 43: #define MARGI_BH 31
! 44: // shouldn't be a number, but then MARGI_BH must be entered into interrupt.h
! 45: #endif
! 46:
! 47: MODULE_AUTHOR(AUTHOR);
! 48: MODULE_DESCRIPTION(MEDDEVNAME " Driver V." DVERSION);
! 49:
! 50: #ifdef PCMCIA_DEBUG
! 51: static int pc_debug = PCMCIA_DEBUG;
! 52: MODULE_PARM(pc_debug, "i");
! 53: #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
! 54: static char *version = "margi_cs.c 0.42 11/1/2000 (Marcus Metzler)";
! 55: #else
! 56: #define DEBUG(n, args...)
! 57: #endif
! 58:
! 59: #define MAX_DEV 4
! 60: #define DEVICE_NR(minor) ((minor)>>4)
! 61:
! 62: /*====================================================================*/
! 63:
! 64: /* Parameters that can be set with 'insmod' */
! 65:
! 66: /* Release IO ports after configuration? */
! 67: static int free_ports = 0;
! 68:
! 69: /* The old way: bit map of interrupts to choose from */
! 70: /* This means pick from 15, 14, 12, 11, 10, 9, 7, 5, 4, and 3 */
! 71: static u_int irq_mask = 0xdeb8;
! 72: /* Newer, simpler way of listing specific interrupts */
! 73: static int irq_list[4] = { -1 };
! 74:
! 75: MODULE_PARM(free_ports, "i");
! 76: MODULE_PARM(irq_mask, "i");
! 77: MODULE_PARM(irq_list, "1-4i");
! 78:
! 79: extern unsigned int major_device_number;
! 80: extern struct file_operations cvdv_fileops;
! 81:
! 82:
! 83: typedef struct margi_info_t {
! 84: dev_link_t link;
! 85: dev_node_t node;
! 86: struct cvdv_cards card;
! 87: int stop;
! 88: } margi_info_t;
! 89:
! 90:
! 91:
! 92: /*
! 93: The event() function is this driver's Card Services event handler.
! 94: It will be called by Card Services when an appropriate card status
! 95: event is received. The config() and release() entry points are
! 96: used to configure or release a socket, in response to card
! 97: insertion and ejection events. They are invoked from the margi
! 98: event handler.
! 99: */
! 100:
! 101: static void margi_config(dev_link_t * link);
! 102: static void margi_release(u_long arg);
! 103: static int margi_event(event_t event, int priority,
! 104: event_callback_args_t * args);
! 105: /*
! 106: The attach() and detach() entry points are used to create and destroy
! 107: "instances" of the driver, where each instance represents everything
! 108: needed to manage one actual PCMCIA card.
! 109: */
! 110:
! 111: static dev_link_t *margi_attach(void);
! 112: static void margi_detach(dev_link_t *);
! 113: static u_char read_lsi_status(struct cvdv_cards *card);
! 114:
! 115: /*
! 116: You'll also need to prototype all the functions that will actually
! 117: be used to talk to your device. See 'memory_cs' for a good example
! 118: of a fully self-sufficient driver; the other drivers rely more or
! 119: less on other parts of the kernel.
! 120: */
! 121:
! 122: /*
! 123: The dev_info variable is the "key" that is used to match up this
! 124: device driver with appropriate cards, through the card configuration
! 125: database.
! 126: */
! 127:
! 128: static dev_link_t *dev_table[MAX_DEV] = { NULL, /* ... */ };
! 129:
! 130: static dev_info_t dev_info = "margi_cs";
! 131:
! 132: /*
! 133: A linked list of "instances" of the margi device. Each actual
! 134: PCMCIA card corresponds to one device instance, and is described
! 135: by one dev_link_t structure (defined in ds.h).
! 136:
! 137: You may not want to use a linked list for this -- for example, the
! 138: memory card driver uses an array of dev_link_t pointers, where minor
! 139: device numbers are used to derive the corresponding array index.
! 140: */
! 141:
! 142: static dev_link_t *dev_list = NULL;
! 143:
! 144: /*
! 145: A dev_link_t structure has fields for most things that are needed
! 146: to keep track of a socket, but there will usually be some device
! 147: specific information that also needs to be kept track of. The
! 148: 'priv' pointer in a dev_link_t structure can be used to point to
! 149: a device-specific private data structure, like this.
! 150:
! 151: To simplify the data structure handling, we actually include the
! 152: dev_link_t structure in the device's private data structure.
! 153:
! 154: A driver needs to provide a dev_node_t structure for each device
! 155: on a card. In some cases, there is only one device per card (for
! 156: example, ethernet cards, modems). In other cases, there may be
! 157: many actual or logical devices (SCSI adapters, memory cards with
! 158: multiple partitions). The dev_node_t structures need to be kept
! 159: in a linked list starting at the 'dev' field of a dev_link_t
! 160: structure. We allocate them in the card's private data structure,
! 161: because they generally shouldn't be allocated dynamically.
! 162:
! 163: In this case, we also provide a flag to indicate if a device is
! 164: "stopped" due to a power management event, or card ejection. The
! 165: device IO routines can use a flag like this to throttle IO to a
! 166: card that is not ready to accept it.
! 167:
! 168: The bus_operations pointer is used on platforms for which we need
! 169: to use special socket-specific versions of normal IO primitives
! 170: (inb, outb, readb, writeb, etc) for card IO.
! 171: */
! 172:
! 173:
! 174: void DACSetFrequency(struct cvdv_cards *card, int khz, int multiple) {
! 175: u8 b = read_indexed_register(card, IIO_OSC_AUD);
! 176:
! 177: b &= 0xf8;
! 178:
! 179: switch (khz){
! 180: case 48:
! 181: b |= 0x00;
! 182: break;
! 183: case 44:
! 184: b |= 0x01;
! 185: break;
! 186: case 96:
! 187: b |= 0x02;
! 188: break;
! 189: default:
! 190: b |= 0x00;
! 191: break;
! 192: }
! 193: write_indexed_register(card, IIO_OSC_AUD, b);
! 194:
! 195: }
! 196:
! 197: int MargiFreeBuffers(struct cvdv_cards *card)
! 198: {
! 199: printk(KERN_DEBUG LOGNAME ": -- MargiFreeBuffers\n");
! 200:
! 201: ring_destroy(&(card->rbuf));
! 202: card->use_ring = 0;
! 203: return 0;
! 204: }
! 205:
! 206:
! 207: int MargiSetBuffers(struct cvdv_cards *card, u32 size)
! 208: {
! 209: MargiFreeBuffers(card);
! 210: printk(KERN_DEBUG LOGNAME ": -- MargiSetBuffers(%d)\n",
! 211: size);
! 212:
! 213: ring_init(&(card->rbuf),size);
! 214: card->use_ring = 1;
! 215: return 0;
! 216:
! 217: }
! 218:
! 219: int MargiFlush (struct cvdv_cards *card)
! 220: {
! 221: int co = 0;
! 222: int i;
! 223: for (i=0;i<100;i++)
! 224: MargiPush(card, 32, FlushPacket);
! 225: while (ring_write_rest(&(card->rbuf)) && co<100) co++;
! 226: VideoSetBackground(card, 1, 0, 0, 0); // black
! 227:
! 228: ring_flush(&(card->rbuf));
! 229: card->DMAABusy = 0;
! 230:
! 231:
! 232: DecoderStopChannel(card);
! 233: DecoderStreamReset(card);
! 234: DecoderSetupReset(card);
! 235: card->channelrun = 0;
! 236:
! 237: printk(KERN_DEBUG LOGNAME ": Margi Flush \n");
! 238: return 0;
! 239: }
! 240:
! 241:
! 242:
! 243:
! 244: void init_p2t(p2t_t *p)
! 245: {
! 246: memset(p->pes,0,PBUFFER);
! 247: p->type = AUDIO;
! 248: p->pos = 0;
! 249: p->frags = 0;
! 250: }
! 251:
! 252: void clear_p2t(p2t_t *p)
! 253: {
! 254: memset(p->pes,0,PBUFFER);
! 255: p->pos = 0;
! 256: p->frags = 0;
! 257: }
! 258:
! 259:
! 260: long int find_pes_header(u8 const *buf, long int length, int *frags)
! 261: {
! 262: int c = 0;
! 263: int found = 0;
! 264:
! 265: *frags = 0;
! 266:
! 267: while (c < length-3 && !found) {
! 268: if (buf[c] == 0x00 && buf[c+1] == 0x00 &&
! 269: buf[c+2] == 0x01) {
! 270: switch ( buf[c+3] ) {
! 271:
! 272: case PROG_STREAM_MAP:
! 273: case PRIVATE_STREAM2:
! 274: case PROG_STREAM_DIR:
! 275: case ECM_STREAM :
! 276: case EMM_STREAM :
! 277: case PADDING_STREAM :
! 278: case DSM_CC_STREAM :
! 279: case ISO13522_STREAM:
! 280: case PRIVATE_STREAM1:
! 281: case AUDIO_STREAM_S ... AUDIO_STREAM_E:
! 282: case VIDEO_STREAM_S ... VIDEO_STREAM_E:
! 283: found = 1;
! 284: break;
! 285:
! 286: default:
! 287: c++;
! 288: break;
! 289: }
! 290: } else c++;
! 291: }
! 292: if (c == length-3 && !found){
! 293: if (buf[length-1] == 0x00) *frags = 1;
! 294: if (buf[length-2] == 0x00 &&
! 295: buf[length-1] == 0x00) *frags = 2;
! 296: if (buf[length-3] == 0x00 &&
! 297: buf[length-2] == 0x00 &&
! 298: buf[length-1] == 0x01) *frags = 3;
! 299: return -1;
! 300: }
! 301:
! 302: return c;
! 303: }
! 304:
! 305: void pes_out( u8 const *buf, long int length,p2t_t *p)
! 306: {
! 307:
! 308: if ( length > 3 &&
! 309: buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01 )
! 310: switch (buf[3]){
! 311: case PROG_STREAM_MAP:
! 312: case PRIVATE_STREAM2:
! 313: case PROG_STREAM_DIR:
! 314: case ECM_STREAM :
! 315: case EMM_STREAM :
! 316: case PADDING_STREAM :
! 317: case DSM_CC_STREAM :
! 318: case ISO13522_STREAM:
! 319: case PRIVATE_STREAM1:
! 320: case AUDIO_STREAM_S ... AUDIO_STREAM_E:
! 321: p->type = AUDIO;
! 322: break;
! 323: case VIDEO_STREAM_S ... VIDEO_STREAM_E:
! 324: p->type = VIDEO;
! 325: break;
! 326: default:
! 327: break;
! 328: }
! 329:
! 330:
! 331: }
! 332:
! 333: void get_pes( u8 const *buf, long int length, p2t_t *p)
! 334: {
! 335: int c,c2,l,add;
! 336: int check;
! 337:
! 338: c = 0;
! 339: c2 = 0;
! 340: if (p->frags){
! 341: check = 0;
! 342: switch(p->frags){
! 343: case 1:
! 344: if ( buf[c] == 0x00 && buf[c+1] == 0x01 ){
! 345: check = 1;
! 346: c += 2;
! 347: }
! 348: break;
! 349: case 2:
! 350: if ( buf[c] == 0x01 ){
! 351: check = 1;
! 352: c++;
! 353: }
! 354: break;
! 355: case 3:
! 356: check = 1;
! 357: }
! 358: if(check){
! 359: switch ( buf[c] ) {
! 360:
! 361: case PROG_STREAM_MAP:
! 362: case PRIVATE_STREAM2:
! 363: case PROG_STREAM_DIR:
! 364: case ECM_STREAM :
! 365: case EMM_STREAM :
! 366: case PADDING_STREAM :
! 367: case DSM_CC_STREAM :
! 368: case ISO13522_STREAM:
! 369: case PRIVATE_STREAM1:
! 370: case AUDIO_STREAM_S ... AUDIO_STREAM_E:
! 371: case VIDEO_STREAM_S ... VIDEO_STREAM_E:
! 372: p->pes[0] = 0x00;
! 373: p->pes[1] = 0x00;
! 374: p->pes[2] = 0x01;
! 375: p->pes[3] = buf[c];
! 376: p->pos=4;
! 377: /*
! 378: memcpy(p->pes+p->pos,buf+c,
! 379: PBUFFER-p->pos);
! 380: c += PBUFFER-p->pos;
! 381: p->pos = PBUFFER;
! 382: */
! 383: pes_out(p->pes,p->pos,p);
! 384: clear_p2t(p);
! 385: break;
! 386:
! 387: default:
! 388: c=0;
! 389: break;
! 390: }
! 391: }
! 392: p->frags = 0;
! 393: }
! 394:
! 395: add = 0;
! 396: while (c < length){
! 397: c2 = find_pes_header(buf+c+add,length-c-add,&p->frags);
! 398: if (c2 >= 0) {
! 399: c2 += c+add;
! 400: if (c2 > c){
! 401: pes_out(buf+c,c2-c,p);
! 402: c = c2;
! 403: clear_p2t(p);
! 404: add = 0;
! 405: } else add = 1;
! 406: } else {
! 407: l = length-c;
! 408: pes_out(buf+c,l,p);
! 409: c = length;
! 410: }
! 411: }
! 412: }
! 413:
! 414:
! 415:
! 416: int MargiPush(struct cvdv_cards *card, int count, const char *data)
! 417: {
! 418: // printk(KERN_DEBUG LOGNAME ": -- MargiPush(%d,0x%08lX)\n",count,(long)data);
! 419: if (!card->use_ring)
! 420: return 0;
! 421:
! 422: if (!card->channelrun){
! 423: DecoderStartChannel(card);
! 424: }
! 425:
! 426: card->DMAABusy = 1;
! 427: /*
! 428: while (ring_write_rest(&(card->rbuf)) < count && co < 100){
! 429: printk("buffer waiting to write\n");
! 430: co++;
! 431: // interruptible_sleep_on(&card->wqA);
! 432: // if (signal_pending(current))
! 433: // return 0;
! 434: }
! 435: */
! 436: count = ring_write(&(card->rbuf),data,count);
! 437: return count;
! 438: }
! 439:
! 440: int DecoderStartChannel(struct cvdv_cards *card)
! 441: {
! 442: //DecoderSetByte(card,0x007,0x01); // channel start
! 443: DecoderMaskByte(card, 0x007, 0xC3, 0xC3); // channel start
! 444: //DecoderSetByte(card,0x005,0x01); // invert channel clock on
! 445: //DecoderDelByte(card,0x005,0x02); // channel request mode off
! 446: //DecoderDelByte(card,0x005,0x04); // channel pause off
! 447: //DecoderDelByte(card,0x005,0x08); // channel bypass enable off
! 448: #ifdef BYPASS
! 449: DecoderMaskByte(card,0x005,0x0F,0x08);
! 450: #else
! 451: DecoderMaskByte(card,0x005,0x0F,0x01);
! 452: #endif
! 453: card->channelrun = 1;
! 454: return 0;
! 455: }
! 456:
! 457: int DecoderStopChannel(struct cvdv_cards *card)
! 458: {
! 459: // DecoderDelByte(card,0x007,0x01); // channel reset
! 460: DecoderMaskByte(card, 0x007, 0xC3, 0xC2); // channel reset
! 461: DecoderSetByte(card, 0x005, 0x04); // channel pause
! 462: card->channelrun = 0;
! 463: return 0;
! 464: }
! 465:
! 466: u32 DecoderGetAudioBufferSpace(struct cvdv_cards *card)
! 467: {
! 468:
! 469: u32 MaxSize, Size;
! 470:
! 471: MaxSize = card->AudioESSize;
! 472: Size = DecoderGetAudioESLevel(card);
! 473:
! 474: if (Size>MaxSize)
! 475: return 0;
! 476: return (MaxSize - Size);
! 477:
! 478: }
! 479:
! 480: u32 DecoderGetVideoBufferSpace(struct cvdv_cards *card)
! 481: {
! 482:
! 483: u32 MaxSize, Size;
! 484:
! 485: MaxSize = card->VideoESSize;
! 486: Size = DecoderGetVideoESLevel(card);
! 487:
! 488: if (Size>MaxSize)
! 489: return 0;
! 490: return (MaxSize - Size);
! 491:
! 492: }
! 493:
! 494: u32 DecoderGetBufferSpace(struct cvdv_cards *card)
! 495: {
! 496: u32 audio,video;
! 497:
! 498: audio = DecoderGetAudioBufferSpace(card);
! 499: video = DecoderGetVideoBufferSpace(card);
! 500:
! 501: if (audio > 2048) audio -= 2048;
! 502: if (video > 16384) video -= 16384;
! 503:
! 504: if (audio < video) return audio;
! 505: return video;
! 506: }
! 507:
! 508: static int ringDMA (struct cvdv_cards *card){
! 509:
! 510: u32 size = 0;
! 511: u_char stat;
! 512: dev_link_t *link = &(((margi_info_t *) card->margi)->link);
! 513: u32 count=0;
! 514: u8 data;
! 515:
! 516: count = ring_read_rest(&(card->rbuf));
! 517: if (count < 4096) {
! 518: card->DMAABusy = 0;
! 519: wake_up_interruptible(&(card->wqA));
! 520: return 0;
! 521: } else if ( card->stream.sh.valid &&
! 522: card->setup.audioselect == audio_none)
! 523: DecoderStartDecode(card);
! 524:
! 525:
! 526: stat = read_lsi_status(card);
! 527: /*
! 528: printk(KERN_DEBUG LOGNAME
! 529: ": -- stat: %d readpos: %d writepos: %d \n",
! 530: stat,card->rbuf.read_pos,card->rbuf.write_pos);
! 531: */
! 532: if (stat & LSI_ARQ) {
! 533: stat = read_lsi_status(card);
! 534: }
! 535:
! 536: if (stat & LSI_READY){
! 537: data = read_indexed_register(card, IIO_LSI_CONTROL);
! 538: data |= RR;
! 539: write_indexed_register(card, IIO_LSI_CONTROL, data);
! 540: return 0;
! 541: }
! 542:
! 543: if ((stat & LSI_ARQ) == 0) {
! 544: size = DecoderGetBufferSpace(card);
! 545: if (count > size) count = size & 0xfffffffc;
! 546: if (count>=2048) count &=0xfffff800;
! 547: count &=0xfffffffc;
! 548:
! 549: /*
! 550: printk(KERN_DEBUG LOGNAME
! 551: ": -- stat: %d length: %d size: %d\n",
! 552: stat,count,size);
! 553: */
! 554: if (count) {
! 555: ring_read_direct(&(card->rbuf),
! 556: link->io.BasePort1+DIO_LSI_STATUS,
! 557: count);
! 558: }
! 559: } else {
! 560: count = 0;
! 561: //card->DMAABusy = 0;
! 562: }
! 563:
! 564: return count;
! 565: }
! 566:
! 567:
! 568: u_char read_indexed_register(struct cvdv_cards * card, int addr)
! 569: {
! 570: dev_link_t *link = &(((margi_info_t *) card->margi)->link);
! 571:
! 572: outb(addr, link->io.BasePort1 + DIO_CONTROL_INDEX);
! 573: return (inb(link->io.BasePort1 + DIO_CONTROL_DATA));
! 574: }
! 575:
! 576:
! 577: void write_indexed_register(struct cvdv_cards *card, int addr, u_char data)
! 578: {
! 579: dev_link_t *link = &(((margi_info_t *) card->margi)->link);
! 580:
! 581: outb(addr, link->io.BasePort1 + DIO_CONTROL_INDEX);
! 582: outb(data, link->io.BasePort1 + DIO_CONTROL_DATA);
! 583: }
! 584:
! 585: void WriteByte(struct cvdv_cards *card, int addr, u_char data)
! 586: {
! 587: dev_link_t *link = &(((margi_info_t *) card->margi)->link);
! 588:
! 589: outb((u_char) (addr & 255),
! 590: link->io.BasePort1 + DIO_LSI_INDEX_LOW);
! 591: outb(((addr & 256) ? 1 : 0),
! 592: link->io.BasePort1 + DIO_LSI_INDEX_HIGH);
! 593: outb(data, link->io.BasePort1 + DIO_LSI_DATA);
! 594: }
! 595:
! 596: u_char ReadByte(struct cvdv_cards *card, int addr)
! 597: {
! 598: dev_link_t *link = &(((margi_info_t *) card->margi)->link);
! 599:
! 600: outb((u_char) (addr & 255),
! 601: link->io.BasePort1 + DIO_LSI_INDEX_LOW);
! 602: outb(((addr & 256) ? 1 : 0),
! 603: link->io.BasePort1 + DIO_LSI_INDEX_HIGH);
! 604: return inb(link->io.BasePort1 + DIO_LSI_DATA);
! 605: }
! 606:
! 607: void MaskByte(struct cvdv_cards *card, int addr, u_char mask, u_char bits)
! 608: {
! 609: WriteByte(card, addr, (ReadByte(card, addr) & ~(mask)) | (bits));
! 610: }
! 611:
! 612:
! 613:
! 614: #define MAXWRITE 49000
! 615: #define MAX_COUNT 10
! 616:
! 617: #ifdef USE_BH
! 618: struct cvdv_cards *bh_card;
! 619:
! 620: static void do_margi_bh(void)
! 621: {
! 622: struct cvdv_cards *card = bh_card;
! 623: #else
! 624:
! 625: static void do_margi(struct cvdv_cards *card)
! 626: {
! 627:
! 628: #endif
! 629: int countA, countB;
! 630: int try;
! 631:
! 632: countA = 0;
! 633: countB = 0;
! 634:
! 635: card->currentType = 0;
! 636: for ( try = 0; try < MAX_COUNT ;try++)
! 637: if (countA < MAXWRITE){
! 638: int count = 0;
! 639: count = ringDMA(card);
! 640: countA += count;
! 641: if (!count)
! 642: try=MAX_COUNT;
! 643: } else break;
! 644:
! 645:
! 646: }
! 647:
! 648: void L64014Intr(int irq, void *dev_id, struct pt_regs *regs)
! 649: {
! 650: margi_info_t *margi = dev_id;
! 651: struct cvdv_cards *card = &(margi->card);
! 652: u_char dio_index, lsi_index_low, lsi_index_high;
! 653: u8 control,mask,stat;
! 654: int try;
! 655:
! 656: //save registers
! 657: dio_index = inb(margi->link.io.BasePort1 + DIO_CONTROL_INDEX);
! 658: lsi_index_low = inb(margi->link.io.BasePort1 + DIO_LSI_INDEX_LOW);
! 659: lsi_index_high =
! 660: inb(margi->link.io.BasePort1 + DIO_LSI_INDEX_HIGH);
! 661:
! 662: control= read_indexed_register(card, IIO_IRQ_CONTROL);
! 663: if (control & IRQ_EN){
! 664: mask = 0;
! 665: if ( control & DEC_EN ) mask |= DEC_INT;
! 666: if ( control & VSYNC_EN ) mask |= VSYNC_INT;
! 667: stat = read_indexed_register(card, IIO_IRQ_STATUS);
! 668: try = 0;
! 669: while ( (try++ < 100) && (stat & mask) ){
! 670:
! 671: if (stat & DEC_INT) {
! 672: write_indexed_register(card,IIO_IRQ_CONTROL,
! 673: control & (~DEC_EN));
! 674: write_indexed_register(card,IIO_IRQ_CONTROL,
! 675: control);
! 676:
! 677: if(card->use_ring){
! 678: L64021Intr(card);
! 679: }
! 680: }
! 681: if (stat & VSYNC_INT) {
! 682:
! 683: write_indexed_register(card,IIO_IRQ_CONTROL,
! 684: control & (~VSYNC_EN));
! 685: write_indexed_register(card,IIO_IRQ_CONTROL,
! 686: control);
! 687: if(card->use_ring){
! 688: L64021Intr(card);
! 689: }
! 690: if (card->DMAABusy){
! 691:
! 692: #ifdef USE_BH
! 693: bh_card = card;
! 694: mark_bh(MARGI_BH);
! 695: #else
! 696: do_margi(card);
! 697: #endif
! 698: }
! 699: }
! 700:
! 701: stat = read_indexed_register(card, IIO_IRQ_STATUS);
! 702: }
! 703: }
! 704:
! 705: //load registers
! 706: outb(dio_index, margi->link.io.BasePort1 + DIO_CONTROL_INDEX);
! 707: outb(lsi_index_low, margi->link.io.BasePort1 + DIO_LSI_INDEX_LOW);
! 708: outb(lsi_index_high,margi->link.io.BasePort1 + DIO_LSI_INDEX_HIGH);
! 709: }
! 710:
! 711: int L64014RemoveIntr(struct cvdv_cards *card)
! 712: {
! 713: printk(KERN_DEBUG LOGNAME ": -- L64014RemoveIntr\n");
! 714: // Disable the IRQ's
! 715: write_indexed_register(card, IIO_IRQ_CONTROL, 0x00);
! 716: if (!card->IntInstalled)
! 717: return 1;
! 718: L64021RemoveIntr(card);
! 719: return 0;
! 720: }
! 721:
! 722: void l64020Reset(struct cvdv_cards *card){
! 723: u8 data;
! 724:
! 725:
! 726: data = read_indexed_register(card, IIO_LSI_CONTROL);
! 727: data &= ~(RR | DR);
! 728: write_indexed_register(card, IIO_LSI_CONTROL, data);
! 729: mdelay(100);
! 730: data = read_indexed_register(card, IIO_LSI_CONTROL);
! 731: data |= DR;
! 732: write_indexed_register(card, IIO_LSI_CONTROL, data);
! 733:
! 734: data = read_indexed_register(card,IIO_GPIO_PINS);
! 735: data &= ~0x01;
! 736: write_indexed_register(card,IIO_GPIO_PINS,data);
! 737: data |= 0x01;
! 738: write_indexed_register(card,IIO_GPIO_PINS,data);
! 739:
! 740: //write_indexed_register(card, IIO_LSI_CONTROL, DR);
! 741: }
! 742:
! 743: int L64014Init(struct cvdv_cards *card)
! 744: {
! 745: u16 testram[16];
! 746: int i, err;
! 747:
! 748: printk(KERN_DEBUG LOGNAME ": -- L64014Init\n");
! 749: card->videomode = VIDEO_MODE;
! 750:
! 751: /* Reset 64020 */
! 752: write_indexed_register(card, IIO_GPIO_CONTROL, 0x01);
! 753: l64020Reset(card);
! 754: /* init GPIO */
! 755: write_indexed_register(card, IIO_GPIO_CONTROL, 0x01);
! 756: write_indexed_register(card, IIO_GPIO_PINS, 0xff);
! 757:
! 758: /* Set to PAL */
! 759: write_indexed_register(card, IIO_VIDEO_CONTROL0, 0);
! 760: write_indexed_register(card, IIO_VIDEO_CONTROL1, VMS_PAL);
! 761:
! 762: /* Set Audio freq */
! 763: write_indexed_register(card, IIO_OSC_AUD, 0x12);
! 764:
! 765: write_indexed_register(card, CSS_COMMAND, 0x01);
! 766:
! 767:
! 768: printk("CSID: %02x\n", I2CRead(card, 0, 0x3d));
! 769: card->i2c_addr = I2CRead(card, 0, 0x0f);
! 770: printk("I2CADDR: %02x\n", card->i2c_addr);
! 771:
! 772: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x4a);
! 773: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
! 774: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
! 775: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x96);
! 776: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x15);
! 777: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0x13);
! 778: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x54);
! 779:
! 780: I2CWrite(card, card->i2c_addr, CS_DAC, 0x87);
! 781: I2CWrite(card, card->i2c_addr, CS_BKG_COL, 0x03);
! 782:
! 783: printk("Decoder Status: %d\n", read_lsi_status(card));
! 784: printk("lsi stat %d\n", DecoderReadByte(card, 0x005));
! 785:
! 786: L64021Init(card);
! 787:
! 788: // Find out how much DRAM we have
! 789: card->DRAMSize = 0x00200000; // maximum size
! 790: do {
! 791: printk(KERN_DEBUG LOGNAME
! 792: ": Probing DRAM Size: 0x%08X (%d kByte) ... ",
! 793: card->DRAMSize, card->DRAMSize / 512);
! 794: for (i = 0; i < 8; i++)
! 795: testram[i] = rnd(0x100) | (rnd(0x100) << 8);
! 796: if (DRAMWriteWord(card, 0, 4, &testram[0], 0))
! 797: printk(KERN_DEBUG LOGNAME ": DRAM Write error.\n");
! 798: if (DRAMWriteWord
! 799: (card, card->DRAMSize - 4, 4, &testram[4],
! 800: 0)) printk(KERN_DEBUG LOGNAME
! 801: ": DRAM Write error.\n");
! 802: if (DRAMReadWord(card, 0, 4, &testram[8], 0))
! 803: printk(KERN_DEBUG LOGNAME ": DRAM Read error.\n");
! 804: if (DRAMReadWord
! 805: (card, card->DRAMSize - 4, 4, &testram[12],
! 806: 0)) printk(KERN_DEBUG LOGNAME ": DRAM Read error.\n");
! 807: err = 0;
! 808: for (i = 0; (!err) && (i < 8); i++)
! 809: if (testram[i] != testram[i + 8])
! 810: err = i + 1;
! 811: if (err) printk(" failed\n");
! 812: else printk(" ok\n");
! 813: /*
! 814: if (err)
! 815: printk(KERN_DEBUG LOGNAME
! 816: ": DRAM compare error at cell %d: 0x%04X %04X %04X %04X->0x%04X %04X %04X %04X / 0x%04X %04X %04X %04X->0x%04X %04X %04X %04X\n",
! 817: err, testram[0], testram[1], testram[2],
! 818: testram[3], testram[8], testram[9],
! 819: testram[10], testram[11], testram[4],
! 820: testram[5], testram[6], testram[7],
! 821: testram[12], testram[13], testram[14],
! 822: testram[15]);
! 823: */
! 824: if (err)
! 825: card->DRAMSize >>= 1;
! 826: } while (err && (card->DRAMSize >= 0x00100000));
! 827: printk(KERN_INFO LOGNAME ": DRAM Size: 0x%08X (%d kByte)\n",
! 828: card->DRAMSize, card->DRAMSize / 512);
! 829: if (card->DRAMSize < 0x00100000) { // minimum size
! 830: printk(KERN_INFO LOGNAME
! 831: ": DRAM ERROR: Not enough memory on card!\n");
! 832: return 1;
! 833: }
! 834: return 0;
! 835: }
! 836:
! 837:
! 838: void CardDeInit(struct cvdv_cards *card)
! 839: {
! 840: CloseCard(card);
! 841: MargiFlush(card);
! 842: MargiFreeBuffers(card);
! 843: L64014RemoveIntr(card);
! 844: }
! 845:
! 846:
! 847: static u_char read_lsi_status(struct cvdv_cards *card)
! 848: {
! 849: margi_info_t *margi = (margi_info_t *) card->margi;
! 850: return (inb(margi->link.io.BasePort1 + DIO_LSI_STATUS) & 15);
! 851:
! 852: }
! 853:
! 854: /*====================================================================*/
! 855:
! 856: static void cs_error(client_handle_t handle, int func, int ret)
! 857: {
! 858: error_info_t err = { func, ret };
! 859: CardServices(ReportError, handle, &err);
! 860: }
! 861:
! 862: /*======================================================================
! 863:
! 864: margi_attach() creates an "instance" of the driver, allocating
! 865: local data structures for one device. The device is registered
! 866: with Card Services.
! 867:
! 868: The dev_link structure is initialized, but we don't actually
! 869: configure the card at this point -- we wait until we receive a
! 870: card insertion event.
! 871:
! 872: ======================================================================*/
! 873:
! 874: static dev_link_t *margi_attach(void)
! 875: {
! 876: margi_info_t *local;
! 877: dev_link_t *link;
! 878: client_reg_t client_reg;
! 879: int ret, i;
! 880:
! 881: DEBUG(0, "margi_attach()\n");
! 882:
! 883: for (i = 0; i < MAX_DEV; i++)
! 884: if (dev_table[i] == NULL)
! 885: break;
! 886: if (i == MAX_DEV) {
! 887: printk(KERN_NOTICE "margi_cs: no devices available\n");
! 888: return NULL;
! 889: }
! 890:
! 891: /* Allocate space for private device-specific data */
! 892: local = kmalloc(sizeof(margi_info_t), GFP_KERNEL);
! 893: if (!local)
! 894: return NULL;
! 895: memset(local, 0, sizeof(margi_info_t));
! 896: link = &local->link;
! 897: link->priv = local;
! 898: local->card.margi = (void *) local;
! 899: dev_table[i] = link;
! 900:
! 901: /* Initialize the dev_link_t structure */
! 902: link->release.function = &margi_release;
! 903: link->release.data = (u_long) link;
! 904:
! 905: /* Interrupt setup */
! 906: link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
! 907: link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
! 908: if (irq_list[0] == -1)
! 909: link->irq.IRQInfo2 = irq_mask;
! 910: else
! 911: for (i = 0; i < 4; i++)
! 912: link->irq.IRQInfo2 |= 1 << irq_list[i];
! 913: link->irq.Handler = NULL;
! 914:
! 915: /*
! 916: General socket configuration defaults can go here. In this
! 917: client, we assume very little, and rely on the CIS for almost
! 918: everything. In most clients, many details (i.e., number, sizes,
! 919: and attributes of IO windows) are fixed by the nature of the
! 920: device, and can be hard-wired here.
! 921: */
! 922: link->conf.Attributes = 0;
! 923: link->conf.Vcc = 50;
! 924: link->conf.IntType = INT_MEMORY_AND_IO;
! 925:
! 926: /* Register with Card Services */
! 927: link->next = dev_list;
! 928: dev_list = link;
! 929: client_reg.dev_info = &dev_info;
! 930: client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
! 931: client_reg.EventMask =
! 932: CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
! 933: CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
! 934: CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
! 935: client_reg.event_handler = &margi_event;
! 936: client_reg.Version = 0x0210;
! 937: client_reg.event_callback_args.client_data = link;
! 938: ret = CardServices(RegisterClient, &link->handle, &client_reg);
! 939: if (ret != CS_SUCCESS) {
! 940: cs_error(link->handle, RegisterClient, ret);
! 941: margi_detach(link);
! 942: return NULL;
! 943: }
! 944:
! 945: return link;
! 946: } /* margi_attach */
! 947:
! 948: /*======================================================================
! 949:
! 950: This deletes a driver "instance". The device is de-registered
! 951: with Card Services. If it has been released, all local data
! 952: structures are freed. Otherwise, the structures will be freed
! 953: when the device is released.
! 954:
! 955: ======================================================================*/
! 956:
! 957: static void margi_detach(dev_link_t * link)
! 958: {
! 959: dev_link_t **linkp;
! 960:
! 961: int nd;
! 962:
! 963: DEBUG(0, "margi_detach(0x%p)\n", link);
! 964:
! 965: for (nd = 0; nd < MAX_DEV; nd++)
! 966: if (dev_table[nd] == link)
! 967: break;
! 968: if (nd == MAX_DEV)
! 969: return;
! 970:
! 971: /* Locate device structure */
! 972: for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
! 973: if (*linkp == link)
! 974: break;
! 975: if (*linkp == NULL)
! 976: return;
! 977:
! 978: /*
! 979: If the device is currently configured and active, we won't
! 980: actually delete it yet. Instead, it is marked so that when
! 981: the release() function is called, that will trigger a proper
! 982: detach().
! 983: */
! 984: if (link->state & DEV_CONFIG) {
! 985: #ifdef PCMCIA_DEBUG
! 986: printk(KERN_DEBUG "margi_cs: detach postponed, '%s' "
! 987: "still locked\n", link->dev->dev_name);
! 988: #endif
! 989: link->state |= DEV_STALE_LINK;
! 990: return;
! 991: }
! 992:
! 993: /* Break the link with Card Services */
! 994: if (link->handle)
! 995: CardServices(DeregisterClient, link->handle);
! 996:
! 997: /* Unlink device structure, and free it */
! 998: *linkp = link->next;
! 999: /* This points to the parent struct cvdv_cards struct */
! 1000: dev_table[nd] = NULL;
! 1001:
! 1002: kfree(link->priv);
! 1003:
! 1004: } /* margi_detach */
! 1005:
! 1006: /*======================================================================
! 1007:
! 1008: margi_config() is scheduled to run after a CARD_INSERTION event
! 1009: is received, to configure the PCMCIA socket, and to make the
! 1010: device available to the system.
! 1011:
! 1012: ======================================================================*/
! 1013:
! 1014: #define CS_CHECK(fn, args...) \
! 1015: while ((last_ret=CardServices(last_fn=(fn),args))!=0) goto cs_failed
! 1016:
! 1017: #define CFG_CHECK(fn, args...) \
! 1018: if (CardServices(fn, args) != 0) goto next_entry
! 1019:
! 1020: static void margi_config(dev_link_t * link)
! 1021: {
! 1022: client_handle_t handle = link->handle;
! 1023: margi_info_t *dev = link->priv;
! 1024: struct cvdv_cards *card = &(dev->card);
! 1025: tuple_t tuple;
! 1026: cisparse_t parse;
! 1027: int last_fn, last_ret, i;
! 1028: u_char buf[64];
! 1029: config_info_t conf;
! 1030: win_req_t req;
! 1031: memreq_t map;
! 1032: int minor = 0;
! 1033:
! 1034: DEBUG(0, "margi_config(0x%p)\n", link);
! 1035:
! 1036: /*
! 1037: This reads the card's CONFIG tuple to find its configuration
! 1038: registers.
! 1039: */
! 1040: tuple.DesiredTuple = CISTPL_CONFIG;
! 1041: tuple.Attributes = 0;
! 1042: tuple.TupleData = buf;
! 1043: tuple.TupleDataMax = sizeof(buf);
! 1044: tuple.TupleOffset = 0;
! 1045: CS_CHECK(GetFirstTuple, handle, &tuple);
! 1046: CS_CHECK(GetTupleData, handle, &tuple);
! 1047: CS_CHECK(ParseTuple, handle, &tuple, &parse);
! 1048: link->conf.ConfigBase = parse.config.base;
! 1049: link->conf.Present = parse.config.rmask[0];
! 1050:
! 1051: /* Configure card */
! 1052: link->state |= DEV_CONFIG;
! 1053:
! 1054: /* Look up the current Vcc */
! 1055: CS_CHECK(GetConfigurationInfo, handle, &conf);
! 1056: link->conf.Vcc = conf.Vcc;
! 1057:
! 1058: /*
! 1059: In this loop, we scan the CIS for configuration table entries,
! 1060: each of which describes a valid card configuration, including
! 1061: voltage, IO window, memory window, and interrupt settings.
! 1062:
! 1063: We make no assumptions about the card to be configured: we use
! 1064: just the information available in the CIS. In an ideal world,
! 1065: this would work for any PCMCIA card, but it requires a complete
! 1066: and accurate CIS. In practice, a driver usually "knows" most of
! 1067: these things without consulting the CIS, and most client drivers
! 1068: will only use the CIS to fill in implementation-defined details.
! 1069: */
! 1070: tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
! 1071: CS_CHECK(GetFirstTuple, handle, &tuple);
! 1072: while (1) {
! 1073: cistpl_cftable_entry_t dflt = { 0 };
! 1074: cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
! 1075: CFG_CHECK(GetTupleData, handle, &tuple);
! 1076: CFG_CHECK(ParseTuple, handle, &tuple, &parse);
! 1077:
! 1078: if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
! 1079: dflt = *cfg;
! 1080: if (cfg->index == 0)
! 1081: goto next_entry;
! 1082: link->conf.ConfigIndex = cfg->index;
! 1083:
! 1084: /* Does this card need audio output? */
! 1085: if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
! 1086: link->conf.Attributes |= CONF_ENABLE_SPKR;
! 1087: link->conf.Status = CCSR_AUDIO_ENA;
! 1088: }
! 1089:
! 1090: /* Use power settings for Vcc and Vpp if present */
! 1091: /* Note that the CIS values need to be rescaled */
! 1092: if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
! 1093: if (conf.Vcc !=
! 1094: cfg->vcc.param[CISTPL_POWER_VNOM] /
! 1095: 10000) goto next_entry;
! 1096: } else if (dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
! 1097: if (conf.Vcc !=
! 1098: dflt.vcc.param[CISTPL_POWER_VNOM] /
! 1099: 10000) goto next_entry;
! 1100: }
! 1101:
! 1102: if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
! 1103: link->conf.Vpp1 = link->conf.Vpp2 =
! 1104: cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
! 1105: else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
! 1106: link->conf.Vpp1 = link->conf.Vpp2 =
! 1107: dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
! 1108:
! 1109: /* Do we need to allocate an interrupt? */
! 1110: // if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
! 1111: //link->conf.Attributes |= CONF_ENABLE_IRQ;
! 1112: /*
! 1113: Allocate an interrupt line. Note that this does not assign a
! 1114: handler to the interrupt, unless the 'Handler' member of the
! 1115: irq structure is initialized.
! 1116: */
! 1117:
! 1118: link->irq.Attributes =
! 1119: IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
! 1120: link->irq.Handler = &L64014Intr;
! 1121: link->irq.Instance = link;
! 1122: link->conf.Attributes |= CONF_ENABLE_IRQ;
! 1123:
! 1124: #ifdef USE_BH
! 1125: init_bh(MARGI_BH, do_margi_bh);
! 1126: #endif
! 1127: if (link->conf.Attributes & CONF_ENABLE_IRQ)
! 1128: CS_CHECK(RequestIRQ, link->handle, &link->irq);
! 1129:
! 1130: /* IO window settings */
! 1131: link->io.NumPorts1 = link->io.NumPorts2 = 0;
! 1132: if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
! 1133: cistpl_io_t *io =
! 1134: (cfg->io.nwin) ? &cfg->io : &dflt.io;
! 1135: link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
! 1136: if (!(io->flags & CISTPL_IO_8BIT))
! 1137: link->io.Attributes1 =
! 1138: IO_DATA_PATH_WIDTH_16;
! 1139: if (!(io->flags & CISTPL_IO_16BIT))
! 1140: link->io.Attributes1 =
! 1141: IO_DATA_PATH_WIDTH_8;
! 1142: link->io.IOAddrLines =
! 1143: io->flags & CISTPL_IO_LINES_MASK;
! 1144: link->io.BasePort1 = io->win[0].base;
! 1145: link->io.NumPorts1 = io->win[0].len;
! 1146: if (io->nwin > 1) {
! 1147: link->io.Attributes2 =
! 1148: link->io.Attributes1;
! 1149: link->io.BasePort2 = io->win[1].base;
! 1150: link->io.NumPorts2 = io->win[1].len;
! 1151: }
! 1152: }
! 1153:
! 1154: /* This reserves IO space but doesn't actually enable it */
! 1155: CFG_CHECK(RequestIO, link->handle, &link->io);
! 1156:
! 1157: /*
! 1158: Now set up a common memory window, if needed. There is room
! 1159: in the dev_link_t structure for one memory window handle,
! 1160: but if the base addresses need to be saved, or if multiple
! 1161: windows are needed, the info should go in the private data
! 1162: structure for this device.
! 1163:
! 1164: Note that the memory window base is a physical address, and
! 1165: needs to be mapped to virtual space with ioremap() before it
! 1166: is used.
! 1167: */
! 1168: if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
! 1169: cistpl_mem_t *mem =
! 1170: (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
! 1171: req.Attributes =
! 1172: WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM;
! 1173: req.Attributes |= WIN_ENABLE;
! 1174: req.Base = mem->win[0].host_addr;
! 1175: req.Size = mem->win[0].len;
! 1176: req.AccessSpeed = 0;
! 1177: link->win = (window_handle_t) link->handle;
! 1178: CFG_CHECK(RequestWindow, &link->win, &req);
! 1179: map.Page = 0;
! 1180: map.CardOffset = mem->win[0].card_addr;
! 1181: CFG_CHECK(MapMemPage, link->win, &map);
! 1182: }
! 1183: /* If we got this far, we're cool! */
! 1184: break;
! 1185:
! 1186: next_entry:
! 1187: CS_CHECK(GetNextTuple, handle, &tuple);
! 1188: }
! 1189:
! 1190: /*
! 1191: This actually configures the PCMCIA socket -- setting up
! 1192: the I/O windows and the interrupt mapping, and putting the
! 1193: card and host interface into "Memory and IO" mode.
! 1194: */
! 1195: CS_CHECK(RequestConfiguration, link->handle, &link->conf);
! 1196:
! 1197: /*
! 1198: We can release the IO port allocations here, if some other
! 1199: driver for the card is going to loaded, and will expect the
! 1200: ports to be available.
! 1201: */
! 1202: if (free_ports) {
! 1203: if (link->io.BasePort1)
! 1204: release_region(link->io.BasePort1,
! 1205: link->io.NumPorts1);
! 1206: if (link->io.BasePort2)
! 1207: release_region(link->io.BasePort2,
! 1208: link->io.NumPorts2);
! 1209: }
! 1210:
! 1211: /*
! 1212: At this point, the dev_node_t structure(s) need to be
! 1213: initialized and arranged in a linked list at link->dev.
! 1214: */
! 1215:
! 1216: first_card = card;
! 1217: minor=0;
! 1218: card->next = NULL;
! 1219: card_init(card, minor);
! 1220: card->tqueue_decoder.routine =
! 1221: (void *) (void *) L64021Intr;
! 1222: if ((i = register_chrdev(CVDV_MAJOR, CVDV_PROCNAME, &cvdv_fileops))
! 1223: >= 0) {
! 1224: major_device_number = ((i) ? i : CVDV_MAJOR);
! 1225: printk(KERN_INFO LOGNAME
! 1226: ": Char-device with major number %d installed\n",
! 1227: major_device_number);
! 1228: } else {
! 1229: printk(KERN_ERR LOGNAME
! 1230: ": ERROR: Failed to install Char-device %d, error %d\n",
! 1231: CVDV_MAJOR, i);
! 1232: }
! 1233: sprintf(dev->node.dev_name, "margi");
! 1234: dev->node.major = major_device_number;
! 1235: dev->node.minor = minor;
! 1236: link->dev = &dev->node;
! 1237:
! 1238: /* Finally, report what we've done */
! 1239: printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
! 1240: dev->node.dev_name, link->conf.ConfigIndex,
! 1241: link->conf.Vcc / 10, link->conf.Vcc % 10);
! 1242: if (link->conf.Vpp1)
! 1243: printk(", Vpp %d.%d", link->conf.Vpp1 / 10,
! 1244: link->conf.Vpp1 % 10);
! 1245: if (link->conf.Attributes & CONF_ENABLE_IRQ)
! 1246: printk(", irq %d", link->irq.AssignedIRQ);
! 1247: if (link->io.NumPorts1)
! 1248: printk(", io 0x%04x-0x%04x", link->io.BasePort1,
! 1249: link->io.BasePort1 + link->io.NumPorts1 - 1);
! 1250: if (link->io.NumPorts2)
! 1251: printk(" & 0x%04x-0x%04x", link->io.BasePort2,
! 1252: link->io.BasePort2 + link->io.NumPorts2 - 1);
! 1253: if (link->win)
! 1254: printk(", mem 0x%06lx-0x%06lx", req.Base,
! 1255: req.Base + req.Size - 1);
! 1256: printk("\n");
! 1257:
! 1258: link->state &= ~DEV_CONFIG_PENDING;
! 1259: if (0xdd == read_indexed_register(card, IIO_ID)) {
! 1260: printk("L64014 Version %d in mode %d detected\n",
! 1261: (read_indexed_register(card, IIO_MODE) & 248) >> 3,
! 1262: read_indexed_register(card, IIO_MODE) & 7);
! 1263: write_indexed_register(card, IIO_GPIO_CONTROL, 0x07);
! 1264:
! 1265: L64014Init(card);
! 1266:
! 1267: // default: color bars
! 1268: VideoSetBackground(card, 1, 0, 0, 0); // black
! 1269: SetVideoSystem(card);
! 1270: minorlist[minor] = card; // fast access for the char driver
! 1271:
! 1272:
! 1273: /*enable L64014 IRQ */
! 1274: write_indexed_register(card, IIO_IRQ_CONTROL,
! 1275: IRQ_POL | IRQ_EN | VSYNC_EN);
! 1276: // write_indexed_register(card, IIO_IRQ_CONTROL, 0x24);
! 1277: }
! 1278: return;
! 1279:
! 1280: cs_failed:
! 1281: cs_error(link->handle, last_fn, last_ret);
! 1282: margi_release((u_long) link);
! 1283:
! 1284: } /* margi_config */
! 1285:
! 1286: /*======================================================================
! 1287:
! 1288: After a card is removed, margi_release() will unregister the
! 1289: device, and release the PCMCIA configuration. If the device is
! 1290: still open, this will be postponed until it is closed.
! 1291:
! 1292: ======================================================================*/
! 1293:
! 1294: static void margi_release(u_long arg)
! 1295: {
! 1296: dev_link_t *link = (dev_link_t *) arg;
! 1297: margi_info_t *dev = link->priv;
! 1298: struct cvdv_cards *card = &(dev->card);
! 1299:
! 1300: DEBUG(0, "margi_release(0x%p)\n", link);
! 1301: /*
! 1302: If the device is currently in use, we won't release until it
! 1303: is actually closed, because until then, we can't be sure that
! 1304: no one will try to access the device or its data structures.
! 1305: */
! 1306: if (link->open) {
! 1307: DEBUG(1, "margi_cs: release postponed, '%s' still open\n",
! 1308: link->dev->dev_name);
! 1309: link->state |= DEV_STALE_CONFIG;
! 1310: return;
! 1311: }
! 1312:
! 1313: /* Unlink the device chain */
! 1314: link->dev = NULL;
! 1315:
! 1316: /*
! 1317: In a normal driver, additional code may be needed to release
! 1318: other kernel data structures associated with this device.
! 1319: */
! 1320:
! 1321: printk(KERN_INFO LOGNAME ": Unloading device driver\n");
! 1322: if (major_device_number)
! 1323: unregister_chrdev(major_device_number, CVDV_PROCNAME);
! 1324: CardDeInit(card);
! 1325:
! 1326: #ifdef USE_BH
! 1327: remove_bh(MARGI_BH);
! 1328: #endif
! 1329: mdelay(100);
! 1330: /* Don't bother checking to see if these succeed or not */
! 1331: if (link->win)
! 1332: CardServices(ReleaseWindow, link->win);
! 1333: CardServices(ReleaseConfiguration, link->handle);
! 1334: if (link->io.NumPorts1)
! 1335: CardServices(ReleaseIO, link->handle, &link->io);
! 1336: if (link->irq.AssignedIRQ)
! 1337: CardServices(ReleaseIRQ, link->handle, &link->irq);
! 1338: link->state &= ~DEV_CONFIG;
! 1339:
! 1340: if (link->state & DEV_STALE_LINK)
! 1341: margi_detach(link);
! 1342:
! 1343: } /* margi_release */
! 1344:
! 1345: /*======================================================================
! 1346:
! 1347: The card status event handler. Mostly, this schedules other
! 1348: stuff to run after an event is received.
! 1349:
! 1350: When a CARD_REMOVAL event is received, we immediately set a
! 1351: private flag to block future accesses to this device. All the
! 1352: functions that actually access the device should check this flag
! 1353: to make sure the card is still present.
! 1354:
! 1355: ======================================================================*/
! 1356:
! 1357: static int margi_event(event_t event, int priority,
! 1358: event_callback_args_t * args)
! 1359: {
! 1360: dev_link_t *link = args->client_data;
! 1361: margi_info_t *dev = link->priv;
! 1362:
! 1363: DEBUG(1, "margi_event(0x%06x)\n", event);
! 1364:
! 1365: switch (event) {
! 1366: case CS_EVENT_CARD_REMOVAL:
! 1367: link->state &= ~DEV_PRESENT;
! 1368: if (link->state & DEV_CONFIG) {
! 1369: ((margi_info_t *) link->priv)->stop = 1;
! 1370: link->release.expires = jiffies + HZ / 20;
! 1371: add_timer(&link->release);
! 1372: }
! 1373: break;
! 1374: case CS_EVENT_CARD_INSERTION:
! 1375: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
! 1376: dev->card.bus = args->bus;
! 1377: margi_config(link);
! 1378: break;
! 1379: case CS_EVENT_PM_SUSPEND:
! 1380: link->state |= DEV_SUSPEND;
! 1381: /* Fall through... */
! 1382: case CS_EVENT_RESET_PHYSICAL:
! 1383: /* Mark the device as stopped, to block IO until later */
! 1384: dev->stop = 1;
! 1385: if (link->state & DEV_CONFIG)
! 1386: CardServices(ReleaseConfiguration, link->handle);
! 1387: break;
! 1388: case CS_EVENT_PM_RESUME:
! 1389: link->state &= ~DEV_SUSPEND;
! 1390: /* Fall through... */
! 1391: case CS_EVENT_CARD_RESET:
! 1392: if (link->state & DEV_CONFIG)
! 1393: CardServices(RequestConfiguration, link->handle,
! 1394: &link->conf);
! 1395: dev->stop = 0;
! 1396: /*
! 1397: In a normal driver, additional code may go here to restore
! 1398: the device state and restart IO.
! 1399: */
! 1400: break;
! 1401: }
! 1402: return 0;
! 1403: } /* margi_event */
! 1404:
! 1405: /*====================================================================*/
! 1406:
! 1407: static int __init init_margi_cs(void)
! 1408: {
! 1409: servinfo_t serv;
! 1410: DEBUG(0, "%s\n", version);
! 1411: CardServices(GetCardServicesInfo, &serv);
! 1412: if (serv.Revision != CS_RELEASE_CODE) {
! 1413: printk(KERN_NOTICE "margi_cs: Card Services release "
! 1414: "does not match!\n");
! 1415: return -1;
! 1416: }
! 1417: register_pccard_driver(&dev_info, &margi_attach, &margi_detach);
! 1418: return 0;
! 1419: }
! 1420:
! 1421: static void __exit exit_margi_cs(void)
! 1422: {
! 1423: DEBUG(0, "margi_cs: unloading\n");
! 1424: unregister_pccard_driver(&dev_info);
! 1425: while (dev_list != NULL) {
! 1426: if (dev_list->state & DEV_CONFIG)
! 1427: margi_release((u_long) dev_list);
! 1428: margi_detach(dev_list);
! 1429: }
! 1430: }
! 1431:
! 1432: module_init(init_margi_cs);
! 1433: module_exit(exit_margi_cs);
LinuxTV legacy CVS <linuxtv.org/cvs>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to margi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / margi2