arch/ppc/amiga/cia.c

   1 /*
   2  *  linux/arch/m68k/amiga/cia.c - CIA support
   3  *
   4  *  Copyright (C) 1996 Roman Zippel
   5  *
   6  *  The concept of some functions bases on the original Amiga OS function
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file COPYING in the main directory of this archive
  10  * for more details.
  11  */
  12
  13 #include <linux/types.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/errno.h>
  17 #include <linux/kernel_stat.h>
  18 #include <linux/init.h>
  19
  20 #include <asm/irq.h>
  21 #include <asm/amigahw.h>
  22 #include <asm/amigaints.h>
  23
  24 struct ciabase {
  25         volatile struct CIA *cia;
  26         u_char icr_mask, icr_data;
  27         u_short int_mask;
  28         int handler_irq, cia_irq, server_irq;
  29         char *name;
  30         struct irq_server server;
  31         irq_handler_t irq_list[CIA_IRQS];
  32 } ciaa_base = {
  33         &ciaa, 0, 0, IF_PORTS,
  34         IRQ_AMIGA_AUTO_2, IRQ_AMIGA_CIAA,
  35         IRQ_AMIGA_PORTS,
  36         "CIAA handler", {0, 0}
  37 }, ciab_base = {
  38         &ciab, 0, 0, IF_EXTER,
  39         IRQ_AMIGA_AUTO_6, IRQ_AMIGA_CIAB,
  40         IRQ_AMIGA_EXTER,
  41         "CIAB handler", {0, 0}
  42 };
  43
  44 #define CIA_SET_BASE_ADJUST_IRQ(base, irq)      \
  45 do {                                            \
  46         if (irq >= IRQ_AMIGA_CIAB) {            \
  47                 base = &ciab_base;              \
  48                 irq -= IRQ_AMIGA_CIAB;          \
  49         } else {                                \
  50                 base = &ciaa_base;              \
  51                 irq -= IRQ_AMIGA_CIAA;          \
  52         }                                       \
  53 } while (0)
  54
  55 /*
  56  *  Cause or clear CIA interrupts, return old interrupt status.
  57  */
  58
  59 static unsigned char cia_set_irq_private(struct ciabase *base,
  60                                          unsigned char mask)
  61 {
  62         u_char old;
  63
  64         old = (base->icr_data |= base->cia->icr);
  65         if (mask & CIA_ICR_SETCLR)
  66                 base->icr_data |= mask;
  67         else
  68                 base->icr_data &= ~mask;
  69         if (base->icr_data & base->icr_mask)
  70                 custom.intreq = IF_SETCLR | base->int_mask;
  71         return old & base->icr_mask;
  72 }
  73
  74 unsigned char cia_set_irq(unsigned int irq, int set)
  75 {
  76         struct ciabase *base;
  77         unsigned char mask;
  78
  79         if (irq >= IRQ_AMIGA_CIAB)
  80                 mask = (1 << (irq - IRQ_AMIGA_CIAB));
  81         else
  82                 mask = (1 << (irq - IRQ_AMIGA_CIAA));
  83         mask |= (set) ? CIA_ICR_SETCLR : 0;
  84
  85         CIA_SET_BASE_ADJUST_IRQ(base, irq);
  86
  87         return cia_set_irq_private(base, mask);
  88 }
  89
  90 unsigned char cia_get_irq_mask(unsigned int irq)
  91 {
  92         struct ciabase *base;
  93
  94         CIA_SET_BASE_ADJUST_IRQ(base, irq);
  95
  96         return base->cia->icr;
  97 }
  98
  99 /*
 100  *  Enable or disable CIA interrupts, return old interrupt mask,
 101  *  interrupts will only be enabled if a handler exists
 102  */
 103
 104 static unsigned char cia_able_irq_private(struct ciabase *base,
 105                                           unsigned char mask)
 106 {
 107         u_char old, tmp;
 108         int i;
 109
 110         old = base->icr_mask;
 111         base->icr_data |= base->cia->icr;
 112         base->cia->icr = mask;
 113         if (mask & CIA_ICR_SETCLR)
 114                 base->icr_mask |= mask;
 115         else
 116                 base->icr_mask &= ~mask;
 117         base->icr_mask &= CIA_ICR_ALL;
 118         for (i = 0, tmp = 1; i < CIA_IRQS; i++, tmp <<= 1) {
 119                 if ((tmp & base->icr_mask) && !base->irq_list[i].handler) {
 120                         base->icr_mask &= ~tmp;
 121                         base->cia->icr = tmp;
 122                 }
 123         }
 124         if (base->icr_data & base->icr_mask)
 125                 custom.intreq = IF_SETCLR | base->int_mask;
 126         return old;
 127 }
 128
 129 unsigned char cia_able_irq(unsigned int irq, int enable)
 130 {
 131         struct ciabase *base;
 132         unsigned char mask;
 133
 134         if (irq >= IRQ_AMIGA_CIAB)
 135                 mask = (1 << (irq - IRQ_AMIGA_CIAB));
 136         else
 137                 mask = (1 << (irq - IRQ_AMIGA_CIAA));
 138         mask |= (enable) ? CIA_ICR_SETCLR : 0;
 139
 140         CIA_SET_BASE_ADJUST_IRQ(base, irq);
 141
 142         return cia_able_irq_private(base, mask);
 143 }
 144
 145 int cia_request_irq(unsigned int irq,
 146                     void (*handler)(int, void *, struct pt_regs *),
 147                     unsigned long flags, const char *devname, void *dev_id)
 148 {
 149         u_char mask;
 150         struct ciabase *base;
 151
 152         CIA_SET_BASE_ADJUST_IRQ(base, irq);
 153
 154         base->irq_list[irq].handler = handler;
 155         base->irq_list[irq].flags   = flags;
 156         base->irq_list[irq].dev_id  = dev_id;
 157         base->irq_list[irq].devname = devname;
 158
 159         /* enable the interrupt */
 160         mask = 1 << irq;
 161         cia_set_irq_private(base, mask);
 162         cia_able_irq_private(base, CIA_ICR_SETCLR | mask);
 163         return 0;
 164 }
 165
 166 void cia_free_irq(unsigned int irq, void *dev_id)
 167 {
 168         struct ciabase *base;
 169
 170         CIA_SET_BASE_ADJUST_IRQ(base, irq);
 171
 172         if (base->irq_list[irq].dev_id != dev_id)
 173                 printk("%s: removing probably wrong IRQ %i from %s\n",
 174                        __FUNCTION__, base->cia_irq + irq,
 175                        base->irq_list[irq].devname);
 176
 177         base->irq_list[irq].handler = NULL;
 178         base->irq_list[irq].flags   = 0;
 179
 180         cia_able_irq_private(base, 1 << irq);
 181 }
 182
 183 static void cia_handler(int irq, void *dev_id, struct pt_regs *fp)
 184 {
 185         struct ciabase *base = (struct ciabase *)dev_id;
 186         int mach_irq, i;
 187         unsigned char ints;
 188
 189         mach_irq = base->cia_irq;
 190         irq = SYS_IRQS + mach_irq;
 191         ints = cia_set_irq_private(base, CIA_ICR_ALL);
 192         custom.intreq = base->int_mask;
 193         for (i = 0; i < CIA_IRQS; i++, irq++, mach_irq++) {
 194                 if (ints & 1) {
 195                         kstat.irqs[0][irq]++;
 196                         base->irq_list[i].handler(mach_irq, base->irq_list[i].dev_id, fp);
 197                 }
 198                 ints >>= 1;
 199         }
 200         amiga_do_irq_list(base->server_irq, fp, &base->server);
 201 }
 202
 203 void __init cia_init_IRQ(struct ciabase *base)
 204 {
 205         int i;
 206
 207         /* init isr handlers */
 208         for (i = 0; i < CIA_IRQS; i++) {
 209                 base->irq_list[i].handler = NULL;
 210                 base->irq_list[i].flags   = 0;
 211         }
 212
 213         /* clear any pending interrupt and turn off all interrupts */
 214         cia_set_irq_private(base, CIA_ICR_ALL);
 215         cia_able_irq_private(base, CIA_ICR_ALL);
 216
 217         /* install CIA handler */
 218         request_irq(base->handler_irq, cia_handler, 0, base->name, base);
 219
 220         custom.intena = IF_SETCLR | base->int_mask;
 221 }
 222
 223 int cia_get_irq_list(struct ciabase *base, char *buf)
 224 {
 225         int i, j, len = 0;
 226
 227         j = base->cia_irq;
 228         for (i = 0; i < CIA_IRQS; i++) {
 229                 len += sprintf(buf+len, "cia  %2d: %10d ", j + i,
 230                                kstat.irqs[0][SYS_IRQS + j + i]);
 231                         len += sprintf(buf+len, "  ");
 232                 len += sprintf(buf+len, "%s\n", base->irq_list[i].devname);
 233         }
 234         return len;
 235 }