rom/devs/ahci/ahci_aros.c

   1 /*
   2  * Copyright (C) 2012, The AROS Development Team.  All rights reserved.
   3  * Author: Jason S. McMullan <jason.mcmullan@gmail.com>
   4  *
   5  * Licensed under the AROS PUBLIC LICENSE (APL) Version 1.1
   6  */
   7
   8 #include <aros/atomic.h>
   9
  10 #include <proto/exec.h>
  11 #include <proto/oop.h>
  12
  13 #include <hidd/pci.h>
  14
  15 #include <devices/timer.h>
  16
  17 #include "ahci.h"
  18 #include "timer.h"
  19
  20 void callout_init(struct callout *co)
  21 {
  22     memset(co, 0, sizeof(*co));
  23 }
  24
  25 void callout_stop(struct callout *co)
  26 {
  27     Forbid();
  28     if (co->co_Task) {
  29         Signal(co->co_Task, SIGF_ABORT);
  30         co->co_Task = NULL;
  31     }
  32     Permit();
  33 }
  34
  35 static void callout_handler(struct callout *co, unsigned ticks, timeout_t *func, void *arg)
  36 {
  37     struct IORequest *io;
  38     ULONG signals = 0;
  39     ULONG us = (ticks * 1000000) / hz;
  40
  41     if ((io = ahci_OpenTimer())) {
  42         signals = ahci_WaitTO(io, us / 1000000, us % 1000000, SIGF_ABORT);
  43         ahci_CloseTimer(io);
  44     }
  45
  46     if (!(signals & SIGF_ABORT)) {
  47         co->co_Task = NULL;
  48         func(arg);
  49     }
  50 }
  51
  52 int callout_reset(struct callout *co, unsigned ticks, timeout_t *func, void *arg)
  53 {
  54     struct Task *t;
  55
  56     callout_stop(co);
  57
  58     t = NewCreateTask(TASKTAG_NAME, "AHCI Callout",
  59                       TASKTAG_PC, callout_handler,
  60                       TASKTAG_PRI, 21,
  61                       TASKTAG_ARG1, co,
  62                       TASKTAG_ARG2, ticks,
  63                       TASKTAG_ARG3, func,
  64                       TASKTAG_ARG4, arg,
  65                       TAG_END);
  66     co->co_Task = t;
  67
  68     return (t == NULL) ? ENOMEM : 0;
  69 }
  70
  71 void    ahci_os_sleep(int ms)
  72 {
  73     struct IORequest *io = ahci_OpenTimer();
  74     if (io != NULL) {
  75         ahci_WaitTO(io, ms / 1000, (ms % 1000) * 1000, 0);
  76         ahci_CloseTimer(io);
  77     }
  78 }
  79
  80 void    ahci_os_hardsleep(int us)
  81 {
  82     ahci_WaitNano((ULONG)us * 1000);
  83 }
  84
  85 /*
  86  * Sleep for a minimum interval and return the number of milliseconds
  87  * that was.  The minimum value returned is 1
  88  *
  89  * UNIT_MICROHZ is only guaranteed to work down to 2 microseconds.
  90  */
  91 int     ahci_os_softsleep(void)
  92 {
  93     struct IORequest *io = ahci_OpenTimer();
  94     if (io != NULL) {
  95         ahci_WaitTO(io, 0, 100 * 1000, 0);
  96         ahci_CloseTimer(io);
  97     }
  98     return 100;
  99 }
 100
 101 /*
 102  * Per-port thread helper.  This helper thread is responsible for
 103  * atomically retrieving and clearing the signal mask and calling
 104  * the machine-independant driver core.
 105  *
 106  * MPSAFE
 107  */
 108 static void ahci_port_thread(void *arg)
 109 {
 110         struct ahci_port *ap = arg;
 111         int mask;
 112
 113         /*
 114          * The helper thread is responsible for the initial port init,
 115          * so all the ports can be inited in parallel.
 116          *
 117          * We also run the state machine which should do all probes.
 118          * Since CAM is not attached yet we will not get out-of-order
 119          * SCSI attachments.
 120          */
 121         ahci_os_lock_port(ap);
 122         ahci_port_init(ap);
 123         atomic_clear_int(&ap->ap_signal, AP_SIGF_THREAD_SYNC);
 124         ahci_port_state_machine(ap, 1);
 125         ahci_os_unlock_port(ap);
 126         atomic_clear_int(&ap->ap_signal, AP_SIGF_INIT);
 127
 128         /*
 129          * Then loop on the helper core.
 130          */
 131         mask = ap->ap_signal;
 132         while ((mask & AP_SIGF_STOP) == 0) {
 133                 atomic_clear_int(&ap->ap_signal, mask);
 134                 ahci_port_thread_core(ap, mask);
 135                 if (ap->ap_signal == 0)
 136                         Wait(SIGF_DOS);
 137                 mask = ap->ap_signal;
 138         }
 139         ap->ap_thread = NULL;
 140 }
 141
 142 void    ahci_os_start_port(struct ahci_port *ap)
 143 {
 144         char name[16];
 145
 146         atomic_set_int(&ap->ap_signal, AP_SIGF_INIT | AP_SIGF_THREAD_SYNC);
 147         lockinit(&ap->ap_lock, "ahcipo", 0, 0);
 148         lockinit(&ap->ap_sim_lock, "ahcicam", 0, LK_CANRECURSE);
 149         ksnprintf(name, sizeof(name), "%d", ap->ap_num);
 150
 151         kthread_create(ahci_port_thread, ap, &ap->ap_thread,
 152                        "%s", PORTNAME(ap));
 153 }
 154
 155 /*
 156  * Stop the OS-specific port helper thread and kill the per-port lock.
 157  */
 158 void ahci_os_stop_port(struct ahci_port *ap)
 159 {
 160         if (ap->ap_thread) {
 161                 ahci_os_signal_port_thread(ap, AP_SIGF_STOP);
 162                 ahci_os_sleep(10);
 163                 if (ap->ap_thread) {
 164                         kprintf("%s: Waiting for thread to terminate\n",
 165                                 PORTNAME(ap));
 166                         while (ap->ap_thread)
 167                                 ahci_os_sleep(100);
 168                         kprintf("%s: thread terminated\n",
 169                                 PORTNAME(ap));
 170                 }
 171         }
 172         lockuninit(&ap->ap_lock);
 173 }
 174
 175 /*
 176  * Add (mask) to the set of bits being sent to the per-port thread helper
 177  * and wake the helper up if necessary.
 178  *
 179  * We use SIGF_DOS, since these are Threads, not Processes, and
 180  * won't already be using SIGF_DOS for messages.
 181  */
 182 void ahci_os_signal_port_thread(struct ahci_port *ap, int mask)
 183 {
 184         atomic_set_int(&ap->ap_signal, mask);
 185         Signal(ap->ap_thread, SIGF_DOS);
 186 }
 187
 188 /*
 189  * Unconditionally lock the port structure for access.
 190  */
 191 void ahci_os_lock_port(struct ahci_port *ap)
 192 {
 193         lockmgr(&ap->ap_lock, LK_EXCLUSIVE);
 194 }
 195
 196 /*
 197  * Conditionally lock the port structure for access.
 198  *
 199  * Returns 0 on success, non-zero on failure.
 200  */
 201 int ahci_os_lock_port_nb(struct ahci_port *ap)
 202 {
 203         return 1;
 204 }
 205
 206 /*
 207  * Unlock a previously locked port.
 208  */
 209 void ahci_os_unlock_port(struct ahci_port *ap)
 210 {
 211         lockmgr(&ap->ap_lock, LK_RELEASE);
 212 }
 213
 214 AROS_INTH1(ahci_Interrupt, void **, fa)
 215 {
 216     AROS_INTFUNC_INIT
 217
 218     driver_intr_t *func = fa[0];
 219     void *arg =  fa[1];
 220
 221     func(arg);
 222
 223     return FALSE;
 224
 225     AROS_INTFUNC_EXIT
 226 }
 227
 228 /* IRQ management */
 229 int bus_setup_intr(device_t dev, struct resource *r, int flags, driver_intr_t func, void *arg, void **cookiep, void *serializer)
 230 {
 231     struct Interrupt *handler = AllocVec(sizeof(struct Interrupt)+sizeof(void *)*2, MEMF_PUBLIC);
 232     void **fa;
 233
 234     if (handler == NULL)
 235         return ENOMEM;
 236
 237     handler->is_Node.ln_Pri = 10;
 238     handler->is_Node.ln_Name = device_get_name(dev);
 239     handler->is_Code = (VOID_FUNC)ahci_Interrupt;
 240     fa = (void **)&handler[1];
 241     fa[0] = func;
 242     fa[1] = arg;
 243     handler->is_Data = fa;
 244
 245     AddIntServer(INTB_KERNEL + r->res_tag, handler);
 246     *cookiep = handler;
 247
 248     return 0;
 249 }
 250
 251 int bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
 252 {
 253     RemIntServer(INTB_KERNEL + r->res_tag, (struct Interrupt *)cookie);
 254     FreeVec(cookie);
 255
 256     return 0;
 257 }