Lines Matching refs:ec
55 ecard_t *ec;
85 ecard_match_device(const struct ecard_id *ids, struct expansion_card *ec);
123 struct expansion_card *ec = req->ec;
124 if (ec->loader)
125 ecard_loader_reset(POD_INT_ADDR(ec->podaddr), ec->loader);
133 (volatile unsigned char *)POD_INT_ADDR(req->ec->podaddr);
137 if (!req->use_loader || !req->ec->loader) {
151 req->ec->loader);
178 ecard_readbytes(void *addr, ecard_t *ec, int off, int len, int useld)
183 req.ec = ec;
192 int ecard_readchunk(struct in_chunk_dir *cd, ecard_t *ec, int id, int num)
198 if (!ec->cid.cd)
202 ecard_readbytes(&excd, ec, index, 8, useld);
205 if (!useld && ec->loader) {
217 if (!ec->loader) {
218 ec->loader = kmalloc(c_len(&excd),
220 if (ec->loader)
221 ecard_readbytes(ec->loader, ec,
236 ecard_readbytes((unsigned char *)excd.d.string, ec,
251 static void ecard_def_irq_enable(ecard_t *ec, int irqnr)
255 static void ecard_def_irq_disable(ecard_t *ec, int irqnr)
259 static int ecard_def_irq_pending(ecard_t *ec)
261 return !ec->irqmask || ec->irqaddr[0] & ec->irqmask;
264 static void ecard_def_fiq_enable(ecard_t *ec, int fiqnr)
269 static void ecard_def_fiq_disable(ecard_t *ec, int fiqnr)
274 static int ecard_def_fiq_pending(ecard_t *ec)
276 return !ec->fiqmask || ec->fiqaddr[0] & ec->fiqmask;
296 ecard_t *ec = slot_to_ecard(irqnr - 32);
298 if (ec) {
299 if (!ec->ops)
300 ec->ops = &ecard_default_ops;
302 if (ec->claimed && ec->ops->irqenable)
303 ec->ops->irqenable(ec, irqnr);
312 ecard_t *ec = slot_to_ecard(irqnr - 32);
314 if (ec) {
315 if (!ec->ops)
316 ec->ops = &ecard_default_ops;
318 if (ec->ops && ec->ops->irqdisable)
319 ec->ops->irqdisable(ec, irqnr);
331 ecard_t *ec = slot_to_ecard(fiqnr);
333 if (ec) {
334 if (!ec->ops)
335 ec->ops = &ecard_default_ops;
337 if (ec->claimed && ec->ops->fiqenable)
338 ec->ops->fiqenable(ec, fiqnr);
347 ecard_t *ec = slot_to_ecard(fiqnr);
349 if (ec) {
350 if (!ec->ops)
351 ec->ops = &ecard_default_ops;
353 if (ec->ops->fiqdisable)
354 ec->ops->fiqdisable(ec, fiqnr);
359 ecard_dump_irq_state(ecard_t *ec)
362 ec->slot_no,
363 ec->claimed ? "" : "not ");
365 if (ec->ops && ec->ops->irqpending &&
366 ec->ops != &ecard_default_ops)
368 ec->ops->irqpending(ec) ? "" : "not ");
371 ec->irqaddr, ec->irqmask, *ec->irqaddr);
377 ecard_t *ec;
398 for (ec = cards; ec; ec = ec->next)
399 ecard_dump_irq_state(ec);
417 ecard_t *ec;
421 for (ec = cards; ec; ec = ec->next) {
424 if (!ec->claimed || ec->irq == NO_IRQ)
427 if (ec->ops && ec->ops->irqpending)
428 pending = ec->ops->irqpending(ec);
430 pending = ecard_default_ops.irqpending(ec);
433 struct irqdesc *d = irq_desc + ec->irq;
434 d->handle(ec->irq, d, regs);
447 unsigned int ecard_address(ecard_t *ec, card_type_t type, card_speed_t speed)
450 int slot = ec->slot_no;
470 static int ecard_prints(char *buffer, ecard_t *ec)
474 buffer += sprintf(buffer, " %d: ", ec->slot_no);
476 if (ec->cid.id == 0) {
480 ec->cid.manufacturer, ec->cid.product);
482 if (!ec->card_desc && ec->cid.cd &&
483 ecard_readchunk(&incd, ec, 0xf5, 0)) {
484 ec->card_desc = kmalloc(strlen(incd.d.string)+1, GFP_KERNEL);
486 if (ec->card_desc)
487 strcpy((char *)ec->card_desc, incd.d.string);
490 buffer += sprintf(buffer, "%s\n", ec->card_desc ? ec->card_desc : "*unknown*");
492 buffer += sprintf(buffer, "Simple card %d\n", ec->cid.id);
499 ecard_t *ec = cards;
504 while (ec && count > cnt) {
505 len = ecard_prints(buf, ec);
515 ec = ec->next;
529 #define ec_set_resource(ec,nr,st,sz,flg) \
531 (ec)->resource[nr].name = ec->dev.bus_id; \
532 (ec)->resource[nr].start = st; \
533 (ec)->resource[nr].end = (st) + (sz) - 1; \
534 (ec)->resource[nr].flags = flg; \
537 static void __init ecard_init_resources(struct expansion_card *ec)
540 unsigned int slot = ec->slot_no;
543 ec_set_resource(ec, ECARD_RES_MEMC,
548 ec_set_resource(ec, i + ECARD_RES_IOCSLOW,
554 if (ec->resource[i].start &&
555 request_resource(&iomem_resource, &ec->resource[i])) {
557 ec->dev.bus_id);
558 ec->resource[i].end -= ec->resource[i].start;
559 ec->resource[i].start = 0;
566 struct expansion_card *ec = ECARD_DEV(dev);
567 return sprintf(buf, "%u\n", ec->irq);
572 struct expansion_card *ec = ECARD_DEV(dev);
573 return sprintf(buf, "%u\n", ec->cid.manufacturer);
578 struct expansion_card *ec = ECARD_DEV(dev);
579 return sprintf(buf, "%u\n", ec->cid.product);
584 struct expansion_card *ec = ECARD_DEV(dev);
585 return sprintf(buf, "%u\n", ec->dma);
590 struct expansion_card *ec = ECARD_DEV(dev);
596 ec->resource[i].start,
597 ec->resource[i].end,
598 ec->resource[i].flags);
619 ecard_t *ec;
623 ec = kzalloc(sizeof(ecard_t), GFP_KERNEL);
624 if (!ec)
627 ec->slot_no = slot;
628 ec->type = type;
629 ec->irq = NO_IRQ;
630 ec->fiq = NO_IRQ;
631 ec->dma = NO_DMA;
632 ec->card_desc = NULL;
633 ec->ops = &ecard_default_ops;
636 if ((ec->podaddr = ecard_address(ec, type, ECARD_SYNC)) == 0)
640 ecard_readbytes(&cid, ec, 0, 16, 0);
644 ec->cid.id = cid.r_id;
645 ec->cid.cd = cid.r_cd;
646 ec->cid.is = cid.r_is;
647 ec->cid.w = cid.r_w;
648 ec->cid.manufacturer = ecard_getu16(cid.r_manu);
649 ec->cid.product = ecard_getu16(cid.r_prod);
650 ec->cid.country = cid.r_country;
651 ec->cid.irqmask = cid.r_irqmask;
652 ec->cid.irqoff = ecard_gets24(cid.r_irqoff);
653 ec->cid.fiqmask = cid.r_fiqmask;
654 ec->cid.fiqoff = ecard_gets24(cid.r_fiqoff);
655 ec->fiqaddr =
656 ec->irqaddr = (unsigned char *)ioaddr(ec->podaddr);
658 if (ec->cid.is) {
659 ec->irqmask = ec->cid.irqmask;
660 ec->irqaddr += ec->cid.irqoff;
661 ec->fiqmask = ec->cid.fiqmask;
662 ec->fiqaddr += ec->cid.fiqoff;
664 ec->irqmask = 1;
665 ec->fiqmask = 4;
669 if (blacklist[i].manufacturer == ec->cid.manufacturer &&
670 blacklist[i].product == ec->cid.product) {
671 ec->card_desc = blacklist[i].type;
675 snprintf(ec->dev.bus_id, sizeof(ec->dev.bus_id), "ecard%d", slot);
676 ec->dev.parent = NULL;
677 ec->dev.bus = &ecard_bus_type;
678 ec->dev.dma_mask = &ec->dma_mask;
679 ec->dma_mask = (u64)0xffffffff;
681 ecard_init_resources(ec);
686 ec->irq = 32 + slot;
687 set_irq_chip(ec->irq, &ecard_chip);
688 set_irq_handler(ec->irq, do_level_IRQ);
689 set_irq_flags(ec->irq, IRQF_VALID);
693 *ecp = ec;
694 slot_to_expcard[slot] = ec;
696 device_register(&ec->dev);
697 device_create_file(&ec->dev, &dev_attr_dma);
698 device_create_file(&ec->dev, &dev_attr_irq);
699 device_create_file(&ec->dev, &dev_attr_resource);
700 device_create_file(&ec->dev, &dev_attr_vendor);
701 device_create_file(&ec->dev, &dev_attr_device);
706 kfree(ec);
742 ecard_match_device(const struct ecard_id *ids, struct expansion_card *ec)
747 if (ec->cid.manufacturer == ids[i].manufacturer &&
748 ec->cid.product == ids[i].product)
756 struct expansion_card *ec = ECARD_DEV(dev);
761 id = ecard_match_device(drv->id_table, ec);
763 ecard_claim(ec);
764 ret = drv->probe(ec, id);
766 ecard_release(ec);
772 struct expansion_card *ec = ECARD_DEV(dev);
775 drv->remove(ec);
776 ecard_release(ec);
789 struct expansion_card *ec = ECARD_DEV(dev);
794 drv->shutdown(ec);
795 ecard_release(ec);
797 req.ec = ec;
818 struct expansion_card *ec = ECARD_DEV(_dev);
823 ret = ecard_match_device(drv->id_table, ec) != NULL;
825 ret = ec->cid.id == drv->id;