uspace/drv/block/pci-ide/main.c

   1 /*
   2  * Copyright (c) 2024 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup pci-ide
  30  * @{
  31  */
  32
  33 /** @file
  34  */
  35
  36 #include <assert.h>
  37 #include <stdio.h>
  38 #include <errno.h>
  39 #include <str_error.h>
  40 #include <ddf/driver.h>
  41 #include <ddf/log.h>
  42 #include <device/hw_res_parsed.h>
  43
  44 #include "pci-ide.h"
  45 #include "pci-ide_hw.h"
  46 #include "main.h"
  47
  48 static errno_t pci_ide_dev_add(ddf_dev_t *dev);
  49 static errno_t pci_ide_dev_remove(ddf_dev_t *dev);
  50 static errno_t pci_ide_dev_gone(ddf_dev_t *dev);
  51 static errno_t pci_ide_fun_online(ddf_fun_t *fun);
  52 static errno_t pci_ide_fun_offline(ddf_fun_t *fun);
  53
  54 static void pci_ide_connection(ipc_call_t *, void *);
  55
  56 static driver_ops_t driver_ops = {
  57         .dev_add = &pci_ide_dev_add,
  58         .dev_remove = &pci_ide_dev_remove,
  59         .dev_gone = &pci_ide_dev_gone,
  60         .fun_online = &pci_ide_fun_online,
  61         .fun_offline = &pci_ide_fun_offline
  62 };
  63
  64 static driver_t pci_ide_driver = {
  65         .name = NAME,
  66         .driver_ops = &driver_ops
  67 };
  68
  69 static errno_t pci_ide_get_res(ddf_dev_t *dev, pci_ide_hwres_t *res)
  70 {
  71         async_sess_t *parent_sess;
  72         hw_res_list_parsed_t hw_res;
  73         errno_t rc;
  74
  75         parent_sess = ddf_dev_parent_sess_get(dev);
  76         if (parent_sess == NULL)
  77                 return ENOMEM;
  78
  79         hw_res_list_parsed_init(&hw_res);
  80         rc = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
  81         if (rc != EOK)
  82                 return rc;
  83
  84         if (hw_res.io_ranges.count != 1) {
  85                 rc = EINVAL;
  86                 goto error;
  87         }
  88
  89         /* Legacty ISA I/O ranges are fixed */
  90
  91         res->cmd1 = pci_ide_ata_cmd_p;
  92         res->ctl1 = pci_ide_ata_ctl_p;
  93         res->cmd2 = pci_ide_ata_cmd_s;
  94         res->ctl2 = pci_ide_ata_ctl_s;
  95
  96         /* PCI I/O range */
  97         addr_range_t *bmregs_rng = &hw_res.io_ranges.ranges[0];
  98         res->bmregs = RNGABS(*bmregs_rng);
  99
 100         ddf_msg(LVL_NOTE, "sizes: %zu", RNGSZ(*bmregs_rng));
 101
 102         if (RNGSZ(*bmregs_rng) < sizeof(pci_ide_regs_t)) {
 103                 rc = EINVAL;
 104                 goto error;
 105         }
 106
 107         /* IRQ */
 108         if (hw_res.irqs.count > 0) {
 109                 res->irq1 = hw_res.irqs.irqs[0];
 110         } else {
 111                 res->irq1 = -1;
 112         }
 113
 114         if (hw_res.irqs.count > 1) {
 115                 res->irq2 = hw_res.irqs.irqs[1];
 116         } else {
 117                 res->irq2 = -1;
 118         }
 119
 120         return EOK;
 121 error:
 122         hw_res_list_parsed_clean(&hw_res);
 123         return rc;
 124 }
 125
 126 /** Add new device
 127  *
 128  * @param  dev New device
 129  * @return     EOK on success or an error code.
 130  */
 131 static errno_t pci_ide_dev_add(ddf_dev_t *dev)
 132 {
 133         pci_ide_ctrl_t *ctrl;
 134         pci_ide_hwres_t res;
 135         errno_t rc;
 136
 137         rc = pci_ide_get_res(dev, &res);
 138         if (rc != EOK) {
 139                 ddf_msg(LVL_ERROR, "Invalid HW resource configuration.");
 140                 return EINVAL;
 141         }
 142
 143         ctrl = ddf_dev_data_alloc(dev, sizeof(pci_ide_ctrl_t));
 144         if (ctrl == NULL) {
 145                 ddf_msg(LVL_ERROR, "Failed allocating soft state.");
 146                 rc = ENOMEM;
 147                 goto error;
 148         }
 149
 150         ctrl->dev = dev;
 151
 152         rc = pci_ide_ctrl_init(ctrl, &res);
 153         if (rc != EOK)
 154                 goto error;
 155
 156         rc = pci_ide_channel_init(ctrl, &ctrl->channel[0], 0, &res);
 157         if (rc == ENOENT)
 158                 goto error;
 159
 160         rc = pci_ide_channel_init(ctrl, &ctrl->channel[1], 1, &res);
 161         if (rc == ENOENT)
 162                 goto error;
 163
 164         if (rc != EOK) {
 165                 ddf_msg(LVL_ERROR, "Failed initializing ATA controller.");
 166                 rc = EIO;
 167                 goto error;
 168         }
 169
 170         return EOK;
 171 error:
 172         return rc;
 173 }
 174
 175 static char *pci_ide_fun_name(pci_ide_channel_t *chan, unsigned idx)
 176 {
 177         char *fun_name;
 178
 179         if (asprintf(&fun_name, "c%ud%u", chan->chan_id, idx) < 0)
 180                 return NULL;
 181
 182         return fun_name;
 183 }
 184
 185 errno_t pci_ide_fun_create(pci_ide_channel_t *chan, unsigned idx, void *charg)
 186 {
 187         errno_t rc;
 188         char *fun_name = NULL;
 189         ddf_fun_t *fun = NULL;
 190         pci_ide_fun_t *ifun = NULL;
 191         bool bound = false;
 192
 193         fun_name = pci_ide_fun_name(chan, idx);
 194         if (fun_name == NULL) {
 195                 ddf_msg(LVL_ERROR, "Out of memory.");
 196                 rc = ENOMEM;
 197                 goto error;
 198         }
 199
 200         fun = ddf_fun_create(chan->ctrl->dev, fun_exposed, fun_name);
 201         if (fun == NULL) {
 202                 ddf_msg(LVL_ERROR, "Failed creating DDF function.");
 203                 rc = ENOMEM;
 204                 goto error;
 205         }
 206
 207         /* Allocate soft state */
 208         ifun = ddf_fun_data_alloc(fun, sizeof(pci_ide_fun_t));
 209         if (ifun == NULL) {
 210                 ddf_msg(LVL_ERROR, "Failed allocating softstate.");
 211                 rc = ENOMEM;
 212                 goto error;
 213         }
 214
 215         ifun->fun = fun;
 216         ifun->charg = charg;
 217
 218         /* Set up a connection handler. */
 219         ddf_fun_set_conn_handler(fun, pci_ide_connection);
 220
 221         rc = ddf_fun_bind(fun);
 222         if (rc != EOK) {
 223                 ddf_msg(LVL_ERROR, "Failed binding DDF function %s: %s",
 224                     fun_name, str_error(rc));
 225                 goto error;
 226         }
 227
 228         bound = true;
 229
 230         rc = ddf_fun_add_to_category(fun, "disk");
 231         if (rc != EOK) {
 232                 ddf_msg(LVL_ERROR, "Failed adding function %s to "
 233                     "category 'disk': %s", fun_name, str_error(rc));
 234                 goto error;
 235         }
 236
 237         free(fun_name);
 238         return EOK;
 239 error:
 240         if (bound)
 241                 ddf_fun_unbind(fun);
 242         if (fun != NULL)
 243                 ddf_fun_destroy(fun);
 244         if (fun_name != NULL)
 245                 free(fun_name);
 246
 247         return rc;
 248 }
 249
 250 errno_t pci_ide_fun_remove(pci_ide_channel_t *chan, unsigned idx)
 251 {
 252         errno_t rc;
 253         char *fun_name;
 254         pci_ide_fun_t *ifun = chan->fun[idx];
 255
 256         fun_name = pci_ide_fun_name(chan, idx);
 257         if (fun_name == NULL) {
 258                 ddf_msg(LVL_ERROR, "Out of memory.");
 259                 rc = ENOMEM;
 260                 goto error;
 261         }
 262
 263         ddf_msg(LVL_DEBUG, "pci_ide_fun_remove(%p, '%s')", ifun, fun_name);
 264         rc = ddf_fun_offline(ifun->fun);
 265         if (rc != EOK) {
 266                 ddf_msg(LVL_ERROR, "Error offlining function '%s'.", fun_name);
 267                 goto error;
 268         }
 269
 270         rc = ddf_fun_unbind(ifun->fun);
 271         if (rc != EOK) {
 272                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", fun_name);
 273                 goto error;
 274         }
 275
 276         ddf_fun_destroy(ifun->fun);
 277         free(fun_name);
 278         return EOK;
 279 error:
 280         if (fun_name != NULL)
 281                 free(fun_name);
 282         return rc;
 283 }
 284
 285 errno_t pci_ide_fun_unbind(pci_ide_channel_t *chan, unsigned idx)
 286 {
 287         errno_t rc;
 288         char *fun_name;
 289         pci_ide_fun_t *ifun = chan->fun[idx];
 290
 291         fun_name = pci_ide_fun_name(chan, idx);
 292         if (fun_name == NULL) {
 293                 ddf_msg(LVL_ERROR, "Out of memory.");
 294                 rc = ENOMEM;
 295                 goto error;
 296         }
 297
 298         ddf_msg(LVL_DEBUG, "pci_ide_fun_unbind(%p, '%s')", ifun, fun_name);
 299         rc = ddf_fun_unbind(ifun->fun);
 300         if (rc != EOK) {
 301                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", fun_name);
 302                 goto error;
 303         }
 304
 305         ddf_fun_destroy(ifun->fun);
 306         free(fun_name);
 307         return EOK;
 308 error:
 309         if (fun_name != NULL)
 310                 free(fun_name);
 311         return rc;
 312 }
 313
 314 static errno_t pci_ide_dev_remove(ddf_dev_t *dev)
 315 {
 316         pci_ide_ctrl_t *ctrl = (pci_ide_ctrl_t *)ddf_dev_data_get(dev);
 317         errno_t rc;
 318
 319         ddf_msg(LVL_DEBUG, "pci_ide_dev_remove(%p)", dev);
 320
 321         rc = pci_ide_channel_fini(&ctrl->channel[0]);
 322         if (rc != EOK)
 323                 return rc;
 324
 325         rc = pci_ide_channel_fini(&ctrl->channel[1]);
 326         if (rc != EOK)
 327                 return rc;
 328
 329         return EOK;
 330 }
 331
 332 static errno_t pci_ide_dev_gone(ddf_dev_t *dev)
 333 {
 334         pci_ide_ctrl_t *ctrl = (pci_ide_ctrl_t *)ddf_dev_data_get(dev);
 335         errno_t rc;
 336
 337         ddf_msg(LVL_DEBUG, "pci_ide_dev_gone(%p)", dev);
 338
 339         rc = pci_ide_ctrl_fini(ctrl);
 340         if (rc != EOK)
 341                 return rc;
 342
 343         rc = pci_ide_channel_fini(&ctrl->channel[0]);
 344         if (rc != EOK)
 345                 return rc;
 346
 347         rc = pci_ide_channel_fini(&ctrl->channel[1]);
 348         if (rc != EOK)
 349                 return rc;
 350
 351         return EOK;
 352 }
 353
 354 static errno_t pci_ide_fun_online(ddf_fun_t *fun)
 355 {
 356         ddf_msg(LVL_DEBUG, "pci_ide_fun_online()");
 357         return ddf_fun_online(fun);
 358 }
 359
 360 static errno_t pci_ide_fun_offline(ddf_fun_t *fun)
 361 {
 362         ddf_msg(LVL_DEBUG, "pci_ide_fun_offline()");
 363         return ddf_fun_offline(fun);
 364 }
 365
 366 static void pci_ide_connection(ipc_call_t *icall, void *arg)
 367 {
 368         pci_ide_fun_t *ifun;
 369
 370         ifun = (pci_ide_fun_t *) ddf_fun_data_get((ddf_fun_t *)arg);
 371         ata_connection(icall, ifun->charg);
 372 }
 373
 374 int main(int argc, char *argv[])
 375 {
 376         printf(NAME ": HelenOS PCI IDE device driver\n");
 377         ddf_log_init(NAME);
 378         return ddf_driver_main(&pci_ide_driver);
 379 }
 380
 381 /**
 382  * @}
 383  */