Lines Matching refs:ec
58 ecard_t *ec;
70 void (*init)(ecard_t *ec);
77 static void atomwide_3p_quirk(ecard_t *ec);
121 struct expansion_card *ec = req->ec;
124 res = ec->slot_no == 8
125 ? &ec->resource[ECARD_RES_MEMC]
126 : ec->easi
127 ? &ec->resource[ECARD_RES_EASI]
128 : &ec->resource[ECARD_RES_IOCSYNC];
130 ecard_loader_reset(res->start, ec->loader);
135 struct expansion_card *ec = req->ec;
140 if (ec->slot_no == 8) {
142 ec->resource[ECARD_RES_MEMC].start;
181 unsigned long base = (ec->easi
182 ? &ec->resource[ECARD_RES_EASI]
183 : &ec->resource[ECARD_RES_IOCSYNC])->start;
186 if (!req->use_loader || !ec->loader) {
200 ec->loader);
312 ecard_readbytes(void *addr, ecard_t *ec, int off, int len, int useld)
317 req.ec = ec;
326 int ecard_readchunk(struct in_chunk_dir *cd, ecard_t *ec, int id, int num)
332 if (!ec->cid.cd)
336 ecard_readbytes(&excd, ec, index, 8, useld);
339 if (!useld && ec->loader) {
351 if (!ec->loader) {
352 ec->loader = kmalloc(c_len(&excd),
354 if (ec->loader)
355 ecard_readbytes(ec->loader, ec,
370 ecard_readbytes((unsigned char *)excd.d.string, ec,
385 static void ecard_def_irq_enable(ecard_t *ec, int irqnr)
389 static void ecard_def_irq_disable(ecard_t *ec, int irqnr)
393 static int ecard_def_irq_pending(ecard_t *ec)
395 return !ec->irqmask || readb(ec->irqaddr) & ec->irqmask;
398 static void ecard_def_fiq_enable(ecard_t *ec, int fiqnr)
403 static void ecard_def_fiq_disable(ecard_t *ec, int fiqnr)
408 static int ecard_def_fiq_pending(ecard_t *ec)
410 return !ec->fiqmask || readb(ec->fiqaddr) & ec->fiqmask;
430 ecard_t *ec = irq_data_get_irq_chip_data(d);
432 if (ec) {
433 if (!ec->ops)
434 ec->ops = &ecard_default_ops;
436 if (ec->claimed && ec->ops->irqenable)
437 ec->ops->irqenable(ec, d->irq);
446 ecard_t *ec = irq_data_get_irq_chip_data(d);
448 if (ec) {
449 if (!ec->ops)
450 ec->ops = &ecard_default_ops;
452 if (ec->ops && ec->ops->irqdisable)
453 ec->ops->irqdisable(ec, d->irq);
466 ecard_t *ec = slot_to_ecard(fiqnr);
468 if (ec) {
469 if (!ec->ops)
470 ec->ops = &ecard_default_ops;
472 if (ec->claimed && ec->ops->fiqenable)
473 ec->ops->fiqenable(ec, fiqnr);
482 ecard_t *ec = slot_to_ecard(fiqnr);
484 if (ec) {
485 if (!ec->ops)
486 ec->ops = &ecard_default_ops;
488 if (ec->ops->fiqdisable)
489 ec->ops->fiqdisable(ec, fiqnr);
495 ecard_t *ec;
499 for (ec = cards; ec; ec = ec->next) {
502 if (ec->slot_no == 8)
505 claimed = ec->claimed ? "" : "not ";
507 if (ec->ops && ec->ops->irqpending &&
508 ec->ops != &ecard_default_ops)
510 ec->slot_no, claimed,
511 ec->ops->irqpending(ec) ? "" : "not ");
514 ec->slot_no, claimed,
515 ec->irqaddr, ec->irqmask, readb(ec->irqaddr));
558 ecard_t *ec;
562 for (ec = cards; ec; ec = ec->next) {
565 if (!ec->claimed || !ec->irq || ec->slot_no == 8)
568 if (ec->ops && ec->ops->irqpending)
569 pending = ec->ops->irqpending(ec);
571 pending = ecard_default_ops.irqpending(ec);
574 generic_handle_irq(ec->irq);
584 static void __iomem *__ecard_address(ecard_t *ec, card_type_t type, card_speed_t speed)
587 int slot = ec->slot_no;
589 if (ec->slot_no == 8)
625 static int ecard_prints(struct seq_file *m, ecard_t *ec)
627 seq_printf(m, " %d: %s ", ec->slot_no, ec->easi ? "EASI" : " ");
629 if (ec->cid.id == 0) {
633 ec->cid.manufacturer, ec->cid.product);
635 if (!ec->card_desc && ec->cid.cd &&
636 ecard_readchunk(&incd, ec, 0xf5, 0)) {
637 ec->card_desc = kmalloc(strlen(incd.d.string)+1, GFP_KERNEL);
639 if (ec->card_desc)
640 strcpy((char *)ec->card_desc, incd.d.string);
643 seq_printf(m, "%s\n", ec->card_desc ? ec->card_desc : "*unknown*");
645 seq_printf(m, "Simple card %d\n", ec->cid.id);
652 ecard_t *ec = cards;
654 while (ec) {
655 ecard_prints(m, ec);
656 ec = ec->next;
670 #define ec_set_resource(ec,nr,st,sz) \
672 (ec)->resource[nr].name = dev_name(&ec->dev); \
673 (ec)->resource[nr].start = st; \
674 (ec)->resource[nr].end = (st) + (sz) - 1; \
675 (ec)->resource[nr].flags = IORESOURCE_MEM; \
678 static void __init ecard_free_card(struct expansion_card *ec)
683 if (ec->resource[i].flags)
684 release_resource(&ec->resource[i]);
686 kfree(ec);
691 struct expansion_card *ec;
695 ec = kzalloc(sizeof(ecard_t), GFP_KERNEL);
696 if (!ec) {
697 ec = ERR_PTR(-ENOMEM);
701 ec->slot_no = slot;
702 ec->easi = type == ECARD_EASI;
703 ec->irq = 0;
704 ec->fiq = 0;
705 ec->dma = NO_DMA;
706 ec->ops = &ecard_default_ops;
708 dev_set_name(&ec->dev, "ecard%d", slot);
709 ec->dev.parent = NULL;
710 ec->dev.bus = &ecard_bus_type;
711 ec->dev.dma_mask = &ec->dma_mask;
712 ec->dma_mask = (u64)0xffffffff;
713 ec->dev.coherent_dma_mask = ec->dma_mask;
716 ec_set_resource(ec, ECARD_RES_MEMC,
725 ec_set_resource(ec, ECARD_RES_EASI,
731 ec_set_resource(ec, ECARD_RES_MEMC, NETSLOT_BASE, NETSLOT_SIZE);
736 ec_set_resource(ec, i + ECARD_RES_IOCSLOW,
740 if (ec->resource[i].flags &&
741 request_resource(&iomem_resource, &ec->resource[i])) {
742 dev_err(&ec->dev, "resource(s) not available\n");
743 ec->resource[i].end -= ec->resource[i].start;
744 ec->resource[i].start = 0;
745 ec->resource[i].flags = 0;
750 return ec;
755 struct expansion_card *ec = ECARD_DEV(dev);
756 return sprintf(buf, "%u\n", ec->irq);
762 struct expansion_card *ec = ECARD_DEV(dev);
763 return sprintf(buf, "%u\n", ec->dma);
769 struct expansion_card *ec = ECARD_DEV(dev);
775 ec->resource[i].start,
776 ec->resource[i].end,
777 ec->resource[i].flags);
785 struct expansion_card *ec = ECARD_DEV(dev);
786 return sprintf(buf, "%u\n", ec->cid.manufacturer);
792 struct expansion_card *ec = ECARD_DEV(dev);
793 return sprintf(buf, "%u\n", ec->cid.product);
799 struct expansion_card *ec = ECARD_DEV(dev);
800 return sprintf(buf, "%s\n", ec->easi ? "EASI" : "IOC");
815 int ecard_request_resources(struct expansion_card *ec)
820 if (ecard_resource_end(ec, i) &&
821 !request_mem_region(ecard_resource_start(ec, i),
822 ecard_resource_len(ec, i),
823 ec->dev.driver->name)) {
831 if (ecard_resource_end(ec, i))
832 release_mem_region(ecard_resource_start(ec, i),
833 ecard_resource_len(ec, i));
839 void ecard_release_resources(struct expansion_card *ec)
844 if (ecard_resource_end(ec, i))
845 release_mem_region(ecard_resource_start(ec, i),
846 ecard_resource_len(ec, i));
850 void ecard_setirq(struct expansion_card *ec, const struct expansion_card_ops *ops, void *irq_data)
852 ec->irq_data = irq_data;
854 ec->ops = ops;
858 void __iomem *ecardm_iomap(struct expansion_card *ec, unsigned int res,
861 unsigned long start = ecard_resource_start(ec, res);
862 unsigned long end = ecard_resource_end(ec, res);
871 return devm_ioremap(&ec->dev, start, end - start);
875 static void atomwide_3p_quirk(ecard_t *ec)
877 void __iomem *addr = __ecard_address(ec, ECARD_IOC, ECARD_SYNC);
894 ecard_t *ec;
899 ec = ecard_alloc_card(type, slot);
900 if (IS_ERR(ec)) {
901 rc = PTR_ERR(ec);
906 if ((addr = __ecard_address(ec, type, ECARD_SYNC)) == NULL)
910 ecard_readbytes(&cid, ec, 0, 16, 0);
914 ec->cid.id = cid.r_id;
915 ec->cid.cd = cid.r_cd;
916 ec->cid.is = cid.r_is;
917 ec->cid.w = cid.r_w;
918 ec->cid.manufacturer = ecard_getu16(cid.r_manu);
919 ec->cid.product = ecard_getu16(cid.r_prod);
920 ec->cid.country = cid.r_country;
921 ec->cid.irqmask = cid.r_irqmask;
922 ec->cid.irqoff = ecard_gets24(cid.r_irqoff);
923 ec->cid.fiqmask = cid.r_fiqmask;
924 ec->cid.fiqoff = ecard_gets24(cid.r_fiqoff);
925 ec->fiqaddr =
926 ec->irqaddr = addr;
928 if (ec->cid.is) {
929 ec->irqmask = ec->cid.irqmask;
930 ec->irqaddr += ec->cid.irqoff;
931 ec->fiqmask = ec->cid.fiqmask;
932 ec->fiqaddr += ec->cid.fiqoff;
934 ec->irqmask = 1;
935 ec->fiqmask = 4;
939 if (quirklist[i].manufacturer == ec->cid.manufacturer &&
940 quirklist[i].product == ec->cid.product) {
942 ec->card_desc = quirklist[i].type;
944 quirklist[i].init(ec);
948 ec->irq = irq;
954 irq_set_chip_and_handler(ec->irq, &ecard_chip,
956 irq_set_chip_data(ec->irq, ec);
957 irq_clear_status_flags(ec->irq, IRQ_NOREQUEST);
963 ec->dma = 2 + slot;
968 *ecp = ec;
969 slot_to_expcard[slot] = ec;
971 rc = device_register(&ec->dev);
978 ecard_free_card(ec);
1027 ecard_match_device(const struct ecard_id *ids, struct expansion_card *ec)
1032 if (ec->cid.manufacturer == ids[i].manufacturer &&
1033 ec->cid.product == ids[i].product)
1041 struct expansion_card *ec = ECARD_DEV(dev);
1046 id = ecard_match_device(drv->id_table, ec);
1048 ec->claimed = 1;
1049 ret = drv->probe(ec, id);
1051 ec->claimed = 0;
1057 struct expansion_card *ec = ECARD_DEV(dev);
1060 drv->remove(ec);
1061 ec->claimed = 0;
1067 ec->ops = &ecard_default_ops;
1069 ec->irq_data = NULL;
1080 struct expansion_card *ec = ECARD_DEV(dev);
1086 drv->shutdown(ec);
1087 ec->claimed = 0;
1093 if (ec->loader) {
1095 req.ec = ec;
1114 struct expansion_card *ec = ECARD_DEV(_dev);
1119 ret = ecard_match_device(drv->id_table, ec) != NULL;
1121 ret = ec->cid.id == drv->id;