rom/devs/ahci/ahci_aros.c

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