arch/mips/loongson64/hpet.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/init.h>
   3 #include <linux/pci.h>
   4 #include <linux/percpu.h>
   5 #include <linux/delay.h>
   6 #include <linux/spinlock.h>
   7 #include <linux/interrupt.h>
   8
   9 #include <asm/hpet.h>
  10 #include <asm/time.h>
  11
  12 #define SMBUS_CFG_BASE          (loongson_sysconf.ht_control_base + 0x0300a000)
  13 #define SMBUS_PCI_REG40         0x40
  14 #define SMBUS_PCI_REG64         0x64
  15 #define SMBUS_PCI_REGB4         0xb4
  16
  17 #define HPET_MIN_CYCLES         16
  18 #define HPET_MIN_PROG_DELTA     (HPET_MIN_CYCLES * 12)
  19
  20 static DEFINE_SPINLOCK(hpet_lock);
  21 DEFINE_PER_CPU(struct clock_event_device, hpet_clockevent_device);
  22
  23 static unsigned int smbus_read(int offset)
  24 {
  25         return *(volatile unsigned int *)(SMBUS_CFG_BASE + offset);
  26 }
  27
  28 static void smbus_write(int offset, int data)
  29 {
  30         *(volatile unsigned int *)(SMBUS_CFG_BASE + offset) = data;
  31 }
  32
  33 static void smbus_enable(int offset, int bit)
  34 {
  35         unsigned int cfg = smbus_read(offset);
  36
  37         cfg |= bit;
  38         smbus_write(offset, cfg);
  39 }
  40
  41 static int hpet_read(int offset)
  42 {
  43         return *(volatile unsigned int *)(HPET_MMIO_ADDR + offset);
  44 }
  45
  46 static void hpet_write(int offset, int data)
  47 {
  48         *(volatile unsigned int *)(HPET_MMIO_ADDR + offset) = data;
  49 }
  50
  51 static void hpet_start_counter(void)
  52 {
  53         unsigned int cfg = hpet_read(HPET_CFG);
  54
  55         cfg |= HPET_CFG_ENABLE;
  56         hpet_write(HPET_CFG, cfg);
  57 }
  58
  59 static void hpet_stop_counter(void)
  60 {
  61         unsigned int cfg = hpet_read(HPET_CFG);
  62
  63         cfg &= ~HPET_CFG_ENABLE;
  64         hpet_write(HPET_CFG, cfg);
  65 }
  66
  67 static void hpet_reset_counter(void)
  68 {
  69         hpet_write(HPET_COUNTER, 0);
  70         hpet_write(HPET_COUNTER + 4, 0);
  71 }
  72
  73 static void hpet_restart_counter(void)
  74 {
  75         hpet_stop_counter();
  76         hpet_reset_counter();
  77         hpet_start_counter();
  78 }
  79
  80 static void hpet_enable_legacy_int(void)
  81 {
  82         /* Do nothing on Loongson-3 */
  83 }
  84
  85 static int hpet_set_state_periodic(struct clock_event_device *evt)
  86 {
  87         int cfg;
  88
  89         spin_lock(&hpet_lock);
  90
  91         pr_info("set clock event to periodic mode!\n");
  92         /* stop counter */
  93         hpet_stop_counter();
  94
  95         /* enables the timer0 to generate a periodic interrupt */
  96         cfg = hpet_read(HPET_T0_CFG);
  97         cfg &= ~HPET_TN_LEVEL;
  98         cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
  99                 HPET_TN_32BIT;
 100         hpet_write(HPET_T0_CFG, cfg);
 101
 102         /* set the comparator */
 103         hpet_write(HPET_T0_CMP, HPET_COMPARE_VAL);
 104         udelay(1);
 105         hpet_write(HPET_T0_CMP, HPET_COMPARE_VAL);
 106
 107         /* start counter */
 108         hpet_start_counter();
 109
 110         spin_unlock(&hpet_lock);
 111         return 0;
 112 }
 113
 114 static int hpet_set_state_shutdown(struct clock_event_device *evt)
 115 {
 116         int cfg;
 117
 118         spin_lock(&hpet_lock);
 119
 120         cfg = hpet_read(HPET_T0_CFG);
 121         cfg &= ~HPET_TN_ENABLE;
 122         hpet_write(HPET_T0_CFG, cfg);
 123
 124         spin_unlock(&hpet_lock);
 125         return 0;
 126 }
 127
 128 static int hpet_set_state_oneshot(struct clock_event_device *evt)
 129 {
 130         int cfg;
 131
 132         spin_lock(&hpet_lock);
 133
 134         pr_info("set clock event to one shot mode!\n");
 135         cfg = hpet_read(HPET_T0_CFG);
 136         /*
 137          * set timer0 type
 138          * 1 : periodic interrupt
 139          * 0 : non-periodic(oneshot) interrupt
 140          */
 141         cfg &= ~HPET_TN_PERIODIC;
 142         cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
 143         hpet_write(HPET_T0_CFG, cfg);
 144
 145         spin_unlock(&hpet_lock);
 146         return 0;
 147 }
 148
 149 static int hpet_tick_resume(struct clock_event_device *evt)
 150 {
 151         spin_lock(&hpet_lock);
 152         hpet_enable_legacy_int();
 153         spin_unlock(&hpet_lock);
 154
 155         return 0;
 156 }
 157
 158 static int hpet_next_event(unsigned long delta,
 159                 struct clock_event_device *evt)
 160 {
 161         u32 cnt;
 162         s32 res;
 163
 164         cnt = hpet_read(HPET_COUNTER);
 165         cnt += (u32) delta;
 166         hpet_write(HPET_T0_CMP, cnt);
 167
 168         res = (s32)(cnt - hpet_read(HPET_COUNTER));
 169
 170         return res < HPET_MIN_CYCLES ? -ETIME : 0;
 171 }
 172
 173 static irqreturn_t hpet_irq_handler(int irq, void *data)
 174 {
 175         int is_irq;
 176         struct clock_event_device *cd;
 177         unsigned int cpu = smp_processor_id();
 178
 179         is_irq = hpet_read(HPET_STATUS);
 180         if (is_irq & HPET_T0_IRS) {
 181                 /* clear the TIMER0 irq status register */
 182                 hpet_write(HPET_STATUS, HPET_T0_IRS);
 183                 cd = &per_cpu(hpet_clockevent_device, cpu);
 184                 cd->event_handler(cd);
 185                 return IRQ_HANDLED;
 186         }
 187         return IRQ_NONE;
 188 }
 189
 190 /*
 191  * hpet address assignation and irq setting should be done in bios.
 192  * but pmon don't do this, we just setup here directly.
 193  * The operation under is normal. unfortunately, hpet_setup process
 194  * is before pci initialize.
 195  *
 196  * {
 197  *      struct pci_dev *pdev;
 198  *
 199  *      pdev = pci_get_device(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
 200  *      pci_write_config_word(pdev, SMBUS_PCI_REGB4, HPET_ADDR);
 201  *
 202  *      ...
 203  * }
 204  */
 205 static void hpet_setup(void)
 206 {
 207         /* set hpet base address */
 208         smbus_write(SMBUS_PCI_REGB4, HPET_ADDR);
 209
 210         /* enable decoding of access to HPET MMIO*/
 211         smbus_enable(SMBUS_PCI_REG40, (1 << 28));
 212
 213         /* HPET irq enable */
 214         smbus_enable(SMBUS_PCI_REG64, (1 << 10));
 215
 216         hpet_enable_legacy_int();
 217 }
 218
 219 void __init setup_hpet_timer(void)
 220 {
 221         unsigned long flags = IRQF_NOBALANCING | IRQF_TIMER;
 222         unsigned int cpu = smp_processor_id();
 223         struct clock_event_device *cd;
 224
 225         hpet_setup();
 226
 227         cd = &per_cpu(hpet_clockevent_device, cpu);
 228         cd->name = "hpet";
 229         cd->rating = 100;
 230         cd->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
 231         cd->set_state_shutdown = hpet_set_state_shutdown;
 232         cd->set_state_periodic = hpet_set_state_periodic;
 233         cd->set_state_oneshot = hpet_set_state_oneshot;
 234         cd->tick_resume = hpet_tick_resume;
 235         cd->set_next_event = hpet_next_event;
 236         cd->irq = HPET_T0_IRQ;
 237         cd->cpumask = cpumask_of(cpu);
 238         clockevent_set_clock(cd, HPET_FREQ);
 239         cd->max_delta_ns = clockevent_delta2ns(0x7fffffff, cd);
 240         cd->max_delta_ticks = 0x7fffffff;
 241         cd->min_delta_ns = clockevent_delta2ns(HPET_MIN_PROG_DELTA, cd);
 242         cd->min_delta_ticks = HPET_MIN_PROG_DELTA;
 243
 244         clockevents_register_device(cd);
 245         if (request_irq(HPET_T0_IRQ, hpet_irq_handler, flags, "hpet", NULL))
 246                 pr_err("Failed to request irq %d (hpet)\n", HPET_T0_IRQ);
 247         pr_info("hpet clock event device register\n");
 248 }
 249
 250 static u64 hpet_read_counter(struct clocksource *cs)
 251 {
 252         return (u64)hpet_read(HPET_COUNTER);
 253 }
 254
 255 static void hpet_suspend(struct clocksource *cs)
 256 {
 257 }
 258
 259 static void hpet_resume(struct clocksource *cs)
 260 {
 261         hpet_setup();
 262         hpet_restart_counter();
 263 }
 264
 265 static struct clocksource csrc_hpet = {
 266         .name = "hpet",
 267         /* mips clocksource rating is less than 300, so hpet is better. */
 268         .rating = 300,
 269         .read = hpet_read_counter,
 270         .mask = CLOCKSOURCE_MASK(32),
 271         /* oneshot mode work normal with this flag */
 272         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
 273         .suspend = hpet_suspend,
 274         .resume = hpet_resume,
 275         .mult = 0,
 276         .shift = 10,
 277 };
 278
 279 int __init init_hpet_clocksource(void)
 280 {
 281         csrc_hpet.mult = clocksource_hz2mult(HPET_FREQ, csrc_hpet.shift);
 282         return clocksource_register_hz(&csrc_hpet, HPET_FREQ);
 283 }
 284
 285 arch_initcall(init_hpet_clocksource);