Changeset ebb1489 in mainline for uspace/drv/block/pci-ide/main.c


Ignore:
Timestamp:
2024-10-13T08:23:40Z (8 weeks ago)
Author:
GitHub <noreply@…>
Children:
0472cf17
Parents:
2a0c827c (diff), b3b79981 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
boba-buba <120932204+boba-buba@…> (2024-10-13 08:23:40)
git-committer:
GitHub <noreply@…> (2024-10-13 08:23:40)
Message:

Merge branch 'HelenOS:master' into topic/packet-capture

File:
1 moved

Legend:

Unmodified
Added
Removed

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

    r2a0c827c rebb1489  
    11/*
    2  * Copyright (c) 2013 Jiri Svoboda
     2 * Copyright (c) 2024 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup ata_bd
     29/** @addtogroup pci-ide
    3030 * @{
    3131 */
    … …  
    4242#include <device/hw_res_parsed.h>
    4343
    44 #include "ata_bd.h"
     44#include "pci-ide.h"
     45#include "pci-ide_hw.h"
    4546#include "main.h"
    4647
    47 static errno_t ata_dev_add(ddf_dev_t *dev);
    48 static errno_t ata_dev_remove(ddf_dev_t *dev);
    49 static errno_t ata_dev_gone(ddf_dev_t *dev);
    50 static errno_t ata_fun_online(ddf_fun_t *fun);
    51 static errno_t ata_fun_offline(ddf_fun_t *fun);
    52 
    53 static void ata_bd_connection(ipc_call_t *, void *);
     48static errno_t pci_ide_dev_add(ddf_dev_t *dev);
     49static errno_t pci_ide_dev_remove(ddf_dev_t *dev);
     50static errno_t pci_ide_dev_gone(ddf_dev_t *dev);
     51static errno_t pci_ide_fun_online(ddf_fun_t *fun);
     52static errno_t pci_ide_fun_offline(ddf_fun_t *fun);
     53
     54static void pci_ide_connection(ipc_call_t *, void *);
    5455
    5556static driver_ops_t driver_ops = {
    56         .dev_add = &ata_dev_add,
    57         .dev_remove = &ata_dev_remove,
    58         .dev_gone = &ata_dev_gone,
    59         .fun_online = &ata_fun_online,
    60         .fun_offline = &ata_fun_offline
     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
    6162};
    6263
    63 static driver_t ata_driver = {
     64static driver_t pci_ide_driver = {
    6465        .name = NAME,
    6566        .driver_ops = &driver_ops
    6667};
    6768
    68 static errno_t ata_get_res(ddf_dev_t *dev, ata_base_t *ata_res)
     69static errno_t pci_ide_get_res(ddf_dev_t *dev, pci_ide_hwres_t *res)
    6970{
    7071        async_sess_t *parent_sess;
    … …  
    8182                return rc;
    8283
    83         if (hw_res.io_ranges.count != 2) {
     84        if (hw_res.io_ranges.count != 1) {
    8485                rc = EINVAL;
    8586                goto error;
    8687        }
    8788
    88         addr_range_t *cmd_rng = &hw_res.io_ranges.ranges[0];
    89         addr_range_t *ctl_rng = &hw_res.io_ranges.ranges[1];
    90         ata_res->cmd = RNGABS(*cmd_rng);
    91         ata_res->ctl = RNGABS(*ctl_rng);
    92 
    93         if (RNGSZ(*ctl_rng) < sizeof(ata_ctl_t)) {
     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)) {
    94103                rc = EINVAL;
    95104                goto error;
    96105        }
    97106
    98         if (RNGSZ(*cmd_rng) < sizeof(ata_cmd_t)) {
    99                 rc = EINVAL;
    100                 goto error;
     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;
    101118        }
    102119
    … …  
    112129 * @return     EOK on success or an error code.
    113130 */
    114 static errno_t ata_dev_add(ddf_dev_t *dev)
    115 {
    116         ata_ctrl_t *ctrl;
    117         ata_base_t res;
    118         errno_t rc;
    119 
    120         rc = ata_get_res(dev, &res);
     131static 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);
    121138        if (rc != EOK) {
    122139                ddf_msg(LVL_ERROR, "Invalid HW resource configuration.");
    … …  
    124141        }
    125142
    126         ctrl = ddf_dev_data_alloc(dev, sizeof(ata_ctrl_t));
     143        ctrl = ddf_dev_data_alloc(dev, sizeof(pci_ide_ctrl_t));
    127144        if (ctrl == NULL) {
    128145                ddf_msg(LVL_ERROR, "Failed allocating soft state.");
    … …  
    133150        ctrl->dev = dev;
    134151
    135         rc = ata_ctrl_init(ctrl, &res);
     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);
    136161        if (rc == ENOENT)
    137162                goto error;
    … …  
    148173}
    149174
    150 static char *ata_fun_name(disk_t *disk)
     175static char *pci_ide_fun_name(pci_ide_channel_t *chan, unsigned idx)
    151176{
    152177        char *fun_name;
    153178
    154         if (asprintf(&fun_name, "d%u", disk->disk_id) < 0)
     179        if (asprintf(&fun_name, "c%ud%u", chan->chan_id, idx) < 0)
    155180                return NULL;
    156181
    … …  
    158183}
    159184
    160 errno_t ata_fun_create(disk_t *disk)
    161 {
    162         ata_ctrl_t *ctrl = disk->ctrl;
     185errno_t pci_ide_fun_create(pci_ide_channel_t *chan, unsigned idx, void *charg)
     186{
    163187        errno_t rc;
    164188        char *fun_name = NULL;
    165189        ddf_fun_t *fun = NULL;
    166         ata_fun_t *afun = NULL;
     190        pci_ide_fun_t *ifun = NULL;
    167191        bool bound = false;
    168192
    169         fun_name = ata_fun_name(disk);
     193        fun_name = pci_ide_fun_name(chan, idx);
    170194        if (fun_name == NULL) {
    171195                ddf_msg(LVL_ERROR, "Out of memory.");
    … …  
    174198        }
    175199
    176         fun = ddf_fun_create(ctrl->dev, fun_exposed, fun_name);
     200        fun = ddf_fun_create(chan->ctrl->dev, fun_exposed, fun_name);
    177201        if (fun == NULL) {
    178202                ddf_msg(LVL_ERROR, "Failed creating DDF function.");
    … …  
    182206
    183207        /* Allocate soft state */
    184         afun = ddf_fun_data_alloc(fun, sizeof(ata_fun_t));
    185         if (afun == NULL) {
     208        ifun = ddf_fun_data_alloc(fun, sizeof(pci_ide_fun_t));
     209        if (ifun == NULL) {
    186210                ddf_msg(LVL_ERROR, "Failed allocating softstate.");
    187211                rc = ENOMEM;
    … …  
    189213        }
    190214
    191         afun->fun = fun;
    192         afun->disk = disk;
    193 
    194         bd_srvs_init(&afun->bds);
    195         afun->bds.ops = &ata_bd_ops;
    196         afun->bds.sarg = disk;
     215        ifun->fun = fun;
     216        ifun->charg = charg;
    197217
    198218        /* Set up a connection handler. */
    199         ddf_fun_set_conn_handler(fun, ata_bd_connection);
     219        ddf_fun_set_conn_handler(fun, pci_ide_connection);
    200220
    201221        rc = ddf_fun_bind(fun);
    … …  
    216236
    217237        free(fun_name);
    218         disk->afun = afun;
    219238        return EOK;
    220239error:
    … …  
    229248}
    230249
    231 errno_t ata_fun_remove(disk_t *disk)
     250errno_t pci_ide_fun_remove(pci_ide_channel_t *chan, unsigned idx)
    232251{
    233252        errno_t rc;
    234253        char *fun_name;
    235 
    236         if (disk->afun == NULL)
    237                 return EOK;
    238 
    239         fun_name = ata_fun_name(disk);
     254        pci_ide_fun_t *ifun = chan->fun[idx];
     255
     256        fun_name = pci_ide_fun_name(chan, idx);
    240257        if (fun_name == NULL) {
    241258                ddf_msg(LVL_ERROR, "Out of memory.");
    … …  
    244261        }
    245262
    246         ddf_msg(LVL_DEBUG, "ata_fun_remove(%p, '%s')", disk, fun_name);
    247         rc = ddf_fun_offline(disk->afun->fun);
     263        ddf_msg(LVL_DEBUG, "pci_ide_fun_remove(%p, '%s')", ifun, fun_name);
     264        rc = ddf_fun_offline(ifun->fun);
    248265        if (rc != EOK) {
    249266                ddf_msg(LVL_ERROR, "Error offlining function '%s'.", fun_name);
    … …  
    251268        }
    252269
    253         rc = ddf_fun_unbind(disk->afun->fun);
     270        rc = ddf_fun_unbind(ifun->fun);
    254271        if (rc != EOK) {
    255272                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", fun_name);
    … …  
    257274        }
    258275
    259         ddf_fun_destroy(disk->afun->fun);
    260         disk->afun = NULL;
     276        ddf_fun_destroy(ifun->fun);
    261277        free(fun_name);
    262278        return EOK;
    … …  
    267283}
    268284
    269 errno_t ata_fun_unbind(disk_t *disk)
     285errno_t pci_ide_fun_unbind(pci_ide_channel_t *chan, unsigned idx)
    270286{
    271287        errno_t rc;
    272288        char *fun_name;
    273 
    274         if (disk->afun == NULL)
    275                 return EOK;
    276 
    277         fun_name = ata_fun_name(disk);
     289        pci_ide_fun_t *ifun = chan->fun[idx];
     290
     291        fun_name = pci_ide_fun_name(chan, idx);
    278292        if (fun_name == NULL) {
    279293                ddf_msg(LVL_ERROR, "Out of memory.");
    … …  
    282296        }
    283297
    284         ddf_msg(LVL_DEBUG, "ata_fun_unbind(%p, '%s')", disk, fun_name);
    285         rc = ddf_fun_unbind(disk->afun->fun);
     298        ddf_msg(LVL_DEBUG, "pci_ide_fun_unbind(%p, '%s')", ifun, fun_name);
     299        rc = ddf_fun_unbind(ifun->fun);
    286300        if (rc != EOK) {
    287301                ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", fun_name);
    … …  
    289303        }
    290304
    291         ddf_fun_destroy(disk->afun->fun);
    292         disk->afun = NULL;
     305        ddf_fun_destroy(ifun->fun);
    293306        free(fun_name);
    294307        return EOK;
    … …  
    299312}
    300313
    301 static errno_t ata_dev_remove(ddf_dev_t *dev)
    302 {
    303         ata_ctrl_t *ctrl = (ata_ctrl_t *)ddf_dev_data_get(dev);
    304 
    305         ddf_msg(LVL_DEBUG, "ata_dev_remove(%p)", dev);
    306 
    307         return ata_ctrl_remove(ctrl);
    308 }
    309 
    310 static errno_t ata_dev_gone(ddf_dev_t *dev)
    311 {
    312         ata_ctrl_t *ctrl = (ata_ctrl_t *)ddf_dev_data_get(dev);
    313 
    314         ddf_msg(LVL_DEBUG, "ata_dev_gone(%p)", dev);
    315 
    316         return ata_ctrl_gone(ctrl);
    317 }
    318 
    319 static errno_t ata_fun_online(ddf_fun_t *fun)
    320 {
    321         ddf_msg(LVL_DEBUG, "ata_fun_online()");
     314static 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
     332static 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
     354static errno_t pci_ide_fun_online(ddf_fun_t *fun)
     355{
     356        ddf_msg(LVL_DEBUG, "pci_ide_fun_online()");
    322357        return ddf_fun_online(fun);
    323358}
    324359
    325 static errno_t ata_fun_offline(ddf_fun_t *fun)
    326 {
    327         ddf_msg(LVL_DEBUG, "ata_fun_offline()");
     360static errno_t pci_ide_fun_offline(ddf_fun_t *fun)
     361{
     362        ddf_msg(LVL_DEBUG, "pci_ide_fun_offline()");
    328363        return ddf_fun_offline(fun);
    329364}
    330365
    331 /** Block device connection handler */
    332 static void ata_bd_connection(ipc_call_t *icall, void *arg)
    333 {
    334         ata_fun_t *afun;
    335 
    336         afun = (ata_fun_t *) ddf_fun_data_get((ddf_fun_t *)arg);
    337         bd_conn(icall, &afun->bds);
     366static 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);
    338372}
    339373
    340374int main(int argc, char *argv[])
    341375{
    342         printf(NAME ": HelenOS ATA(PI) device driver\n");
     376        printf(NAME ": HelenOS PCI IDE device driver\n");
    343377        ddf_log_init(NAME);
    344         return ddf_driver_main(&ata_driver);
     378        return ddf_driver_main(&pci_ide_driver);
    345379}
    346380
Note: See TracChangeset for help on using the changeset viewer.