Changeset a35b458 in mainline for uspace/drv/block/ahci/ahci.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/block/ahci/ahci.c

    r3061bc1 ra35b458  
    229229{
    230230        sata_dev_t *sata = fun_sata_dev(fun);
    231        
     231
    232232        uintptr_t phys;
    233233        void *ibuf = AS_AREA_ANY;
    … …  
    238238                return rc;
    239239        }
    240        
     240
    241241        memset(buf, 0, sata->block_size);
    242        
     242
    243243        fibril_mutex_lock(&sata->lock);
    244        
     244
    245245        for (size_t cur = 0; cur < count; cur++) {
    246246                rc = ahci_rb_fpdma(sata, phys, blocknum + cur);
    247247                if (rc != EOK)
    248248                        break;
    249                
     249
    250250                memcpy((void *) (((uint8_t *) buf) + (sata->block_size * cur)),
    251251                    ibuf, sata->block_size);
    252252        }
    253        
     253
    254254        fibril_mutex_unlock(&sata->lock);
    255255        dmamem_unmap_anonymous(ibuf);
    256        
     256
    257257        return rc;
    258258}
    … …  
    272272{
    273273        sata_dev_t *sata = fun_sata_dev(fun);
    274        
     274
    275275        uintptr_t phys;
    276276        void *ibuf = AS_AREA_ANY;
    … …  
    281281                return rc;
    282282        }
    283        
     283
    284284        fibril_mutex_lock(&sata->lock);
    285        
     285
    286286        for (size_t cur = 0; cur < count; cur++) {
    287287                memcpy(ibuf, (void *) (((uint8_t *) buf) + (sata->block_size * cur)),
    … …  
    291291                        break;
    292292        }
    293        
     293
    294294        fibril_mutex_unlock(&sata->lock);
    295295        dmamem_unmap_anonymous(ibuf);
    296        
     296
    297297        return rc;
    298298}
    … …  
    312312{
    313313        fibril_mutex_lock(&sata->event_lock);
    314        
     314
    315315        sata->event_pxis = 0;
    316316        while (sata->event_pxis == 0)
    317317                fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    318        
     318
    319319        ahci_port_is_t pxis = sata->event_pxis;
    320        
     320
    321321        if (ahci_port_is_permanent_error(pxis))
    322322                sata->is_invalid_device = true;
    323        
     323
    324324        fibril_mutex_unlock(&sata->event_lock);
    325        
     325
    326326        return pxis;
    327327}
    … …  
    337337        volatile sata_std_command_frame_t *cmd =
    338338            (sata_std_command_frame_t *) sata->cmd_table;
    339        
     339
    340340        cmd->fis_type = SATA_CMD_FIS_TYPE;
    341341        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    … …  
    350350        cmd->control = 0;
    351351        cmd->reserved2 = 0;
    352        
     352
    353353        volatile ahci_cmd_prdt_t *prdt =
    354354            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    355        
     355
    356356        prdt->data_address_low = LO(phys);
    357357        prdt->data_address_upper = HI(phys);
    … …  
    360360        prdt->reserved2 = 0;
    361361        prdt->ioc = 0;
    362        
     362
    363363        sata->cmd_header->prdtl = 1;
    364364        sata->cmd_header->flags =
    … …  
    366366            AHCI_CMDHDR_FLAGS_2DWCMD;
    367367        sata->cmd_header->bytesprocessed = 0;
    368        
     368
    369369        /* Run command. */
    370370        sata->port->pxsact |= 1;
    … …  
    382382        volatile sata_std_command_frame_t *cmd =
    383383            (sata_std_command_frame_t *) sata->cmd_table;
    384        
     384
    385385        cmd->fis_type = SATA_CMD_FIS_TYPE;
    386386        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    … …  
    395395        cmd->control = 0;
    396396        cmd->reserved2 = 0;
    397        
     397
    398398        volatile ahci_cmd_prdt_t *prdt =
    399399            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    400        
     400
    401401        prdt->data_address_low = LO(phys);
    402402        prdt->data_address_upper = HI(phys);
    … …  
    405405        prdt->reserved2 = 0;
    406406        prdt->ioc = 0;
    407        
     407
    408408        sata->cmd_header->prdtl = 1;
    409409        sata->cmd_header->flags =
    … …  
    411411            AHCI_CMDHDR_FLAGS_2DWCMD;
    412412        sata->cmd_header->bytesprocessed = 0;
    413        
     413
    414414        /* Run command. */
    415415        sata->port->pxsact |= 1;
    … …  
    431431                return EINTR;
    432432        }
    433        
     433
    434434        uintptr_t phys;
    435435        sata_identify_data_t *idata = AS_AREA_ANY;
    … …  
    441441                return rc;
    442442        }
    443        
     443
    444444        memset(idata, 0, SATA_IDENTIFY_DEVICE_BUFFER_LENGTH);
    445        
     445
    446446        fibril_mutex_lock(&sata->lock);
    447        
     447
    448448        ahci_identify_device_cmd(sata, phys);
    449449        ahci_port_is_t pxis = ahci_wait_event(sata);
    450        
     450
    451451        if (sata->is_invalid_device) {
    452452                ddf_msg(LVL_ERROR,
    … …  
    454454                goto error;
    455455        }
    456        
     456
    457457        if (ahci_port_is_tfes(pxis)) {
    458458                ahci_identify_packet_device_cmd(sata, phys);
    459459                pxis = ahci_wait_event(sata);
    460                
     460
    461461                if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    462462                        ddf_msg(LVL_ERROR,
    … …  
    464464                        goto error;
    465465                }
    466                
     466
    467467                sata->is_packet_device = true;
    468468        }
    469        
     469
    470470        ahci_get_model_name(idata->model_name, sata->model);
    471        
     471
    472472        /*
    473473         * Due to QEMU limitation (as of 2012-06-22),
    … …  
    478478                goto error;
    479479        }
    480        
     480
    481481        uint16_t logsec = idata->physical_logic_sector_size;
    482482        if ((logsec & 0xc000) == 0x4000) {
    … …  
    489489                        goto error;
    490490                }
    491                
     491
    492492                if ((logsec & 0x0200) && ((logsec & 0x000f) != 0)) {
    493493                        /* Physical sectors per logical sector is greather than 1 */
    … …  
    498498                }
    499499        }
    500        
     500
    501501        if (sata->is_packet_device) {
    502502                /*
    … …  
    509509        } else {
    510510                sata->block_size = SATA_DEFAULT_SECTOR_SIZE;
    511                
     511
    512512                if ((idata->caps & sata_rd_cap_lba) == 0) {
    513513                        ddf_msg(LVL_ERROR, "%s: LBA for NCQ must be supported",
    … …  
    525525                }
    526526        }
    527        
     527
    528528        uint8_t udma_mask = idata->udma & 0x007f;
    529529        sata->highest_udma_mode = (uint8_t) -1;
    … …  
    539539                }
    540540        }
    541        
     541
    542542        fibril_mutex_unlock(&sata->lock);
    543543        dmamem_unmap_anonymous(idata);
    544        
     544
    545545        return EOK;
    546        
     546
    547547error:
    548548        fibril_mutex_unlock(&sata->lock);
    549549        dmamem_unmap_anonymous(idata);
    550        
     550
    551551        return EINTR;
    552552}
    … …  
    563563        volatile sata_std_command_frame_t *cmd =
    564564            (sata_std_command_frame_t *) sata->cmd_table;
    565        
     565
    566566        cmd->fis_type = SATA_CMD_FIS_TYPE;
    567567        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    … …  
    576576        cmd->control = 0;
    577577        cmd->reserved2 = 0;
    578        
     578
    579579        volatile ahci_cmd_prdt_t *prdt =
    580580            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    581        
     581
    582582        prdt->data_address_low = LO(phys);
    583583        prdt->data_address_upper = HI(phys);
    … …  
    586586        prdt->reserved2 = 0;
    587587        prdt->ioc = 0;
    588        
     588
    589589        sata->cmd_header->prdtl = 1;
    590590        sata->cmd_header->flags =
    … …  
    592592            AHCI_CMDHDR_FLAGS_2DWCMD;
    593593        sata->cmd_header->bytesprocessed = 0;
    594        
     594
    595595        /* Run command. */
    596596        sata->port->pxsact |= 1;
    … …  
    613613                return EINTR;
    614614        }
    615        
     615
    616616        if (sata->highest_udma_mode == (uint8_t) -1) {
    617617                ddf_msg(LVL_ERROR,
    … …  
    619619                return EINTR;
    620620        }
    621        
     621
    622622        if (sata->highest_udma_mode > 6) {
    623623                ddf_msg(LVL_ERROR,
    … …  
    625625                return EINTR;
    626626        }
    627        
     627
    628628        uintptr_t phys;
    629629        sata_identify_data_t *idata = AS_AREA_ANY;
    … …  
    635635                return rc;
    636636        }
    637        
     637
    638638        memset(idata, 0, SATA_SET_FEATURE_BUFFER_LENGTH);
    639        
     639
    640640        fibril_mutex_lock(&sata->lock);
    641        
     641
    642642        uint8_t mode = 0x40 | (sata->highest_udma_mode & 0x07);
    643643        ahci_set_mode_cmd(sata, phys, mode);
    644644        ahci_port_is_t pxis = ahci_wait_event(sata);
    645        
     645
    646646        if (sata->is_invalid_device) {
    647647                ddf_msg(LVL_ERROR,
    … …  
    650650                goto error;
    651651        }
    652        
     652
    653653        if (ahci_port_is_error(pxis)) {
    654654                ddf_msg(LVL_ERROR,
    … …  
    656656                goto error;
    657657        }
    658        
     658
    659659        fibril_mutex_unlock(&sata->lock);
    660660        dmamem_unmap_anonymous(idata);
    661        
     661
    662662        return EOK;
    663        
     663
    664664error:
    665665        fibril_mutex_unlock(&sata->lock);
    666666        dmamem_unmap_anonymous(idata);
    667        
     667
    668668        return EINTR;
    669669}
    … …  
    681681        volatile sata_ncq_command_frame_t *cmd =
    682682            (sata_ncq_command_frame_t *) sata->cmd_table;
    683        
     683
    684684        cmd->fis_type = SATA_CMD_FIS_TYPE;
    685685        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    … …  
    687687        cmd->tag = 0;
    688688        cmd->control = 0;
    689        
     689
    690690        cmd->reserved1 = 0;
    691691        cmd->reserved2 = 0;
    … …  
    694694        cmd->reserved5 = 0;
    695695        cmd->reserved6 = 0;
    696        
     696
    697697        cmd->sector_count_low = 1;
    698698        cmd->sector_count_high = 0;
    699        
     699
    700700        cmd->lba0 = blocknum & 0xff;
    701701        cmd->lba1 = (blocknum >> 8) & 0xff;
    … …  
    704704        cmd->lba4 = (blocknum >> 32) & 0xff;
    705705        cmd->lba5 = (blocknum >> 40) & 0xff;
    706        
     706
    707707        volatile ahci_cmd_prdt_t *prdt =
    708708            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    709        
     709
    710710        prdt->data_address_low = LO(phys);
    711711        prdt->data_address_upper = HI(phys);
    … …  
    714714        prdt->reserved2 = 0;
    715715        prdt->ioc = 0;
    716        
     716
    717717        sata->cmd_header->prdtl = 1;
    718718        sata->cmd_header->flags =
    … …  
    720720            AHCI_CMDHDR_FLAGS_5DWCMD;
    721721        sata->cmd_header->bytesprocessed = 0;
    722        
     722
    723723        sata->port->pxsact |= 1;
    724724        sata->port->pxci |= 1;
    … …  
    741741                return EINTR;
    742742        }
    743        
     743
    744744        ahci_rb_fpdma_cmd(sata, phys, blocknum);
    745745        ahci_port_is_t pxis = ahci_wait_event(sata);
    746        
     746
    747747        if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    748748                ddf_msg(LVL_ERROR,
    … …  
    750750                return EINTR;
    751751        }
    752        
     752
    753753        return EOK;
    754754}
    … …  
    768768        volatile sata_ncq_command_frame_t *cmd =
    769769            (sata_ncq_command_frame_t *) sata->cmd_table;
    770        
     770
    771771        cmd->fis_type = SATA_CMD_FIS_TYPE;
    772772        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    … …  
    774774        cmd->tag = 0;
    775775        cmd->control = 0;
    776        
     776
    777777        cmd->reserved1 = 0;
    778778        cmd->reserved2 = 0;
    … …  
    781781        cmd->reserved5 = 0;
    782782        cmd->reserved6 = 0;
    783        
     783
    784784        cmd->sector_count_low = 1;
    785785        cmd->sector_count_high = 0;
    786        
     786
    787787        cmd->lba0 = blocknum & 0xff;
    788788        cmd->lba1 = (blocknum >> 8) & 0xff;
    … …  
    791791        cmd->lba4 = (blocknum >> 32) & 0xff;
    792792        cmd->lba5 = (blocknum >> 40) & 0xff;
    793        
     793
    794794        volatile ahci_cmd_prdt_t *prdt =
    795795            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    796        
     796
    797797        prdt->data_address_low = LO(phys);
    798798        prdt->data_address_upper = HI(phys);
    … …  
    801801        prdt->reserved2 = 0;
    802802        prdt->ioc = 0;
    803        
     803
    804804        sata->cmd_header->prdtl = 1;
    805805        sata->cmd_header->flags =
    … …  
    808808            AHCI_CMDHDR_FLAGS_5DWCMD;
    809809        sata->cmd_header->bytesprocessed = 0;
    810        
     810
    811811        sata->port->pxsact |= 1;
    812812        sata->port->pxci |= 1;
    … …  
    829829                return EINTR;
    830830        }
    831        
     831
    832832        ahci_wb_fpdma_cmd(sata, phys, blocknum);
    833833        ahci_port_is_t pxis = ahci_wait_event(sata);
    834        
     834
    835835        if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    836836                ddf_msg(LVL_ERROR,
    … …  
    838838                return EINTR;
    839839        }
    840        
     840
    841841        return EOK;
    842842}
    … …  
    899899        unsigned int port = IPC_GET_ARG1(*icall);
    900900        ahci_port_is_t pxis = IPC_GET_ARG2(*icall);
    901        
     901
    902902        if (port >= AHCI_MAX_PORTS)
    903903                return;
    904        
     904
    905905        sata_dev_t *sata = (sata_dev_t *) ahci->sata_devs[port];
    906906        if (sata == NULL)
    907907                return;
    908        
     908
    909909        /* Evaluate port event */
    910910        if ((ahci_port_is_end_of_operation(pxis)) ||
    911911            (ahci_port_is_error(pxis))) {
    912912                fibril_mutex_lock(&sata->event_lock);
    913                
     913
    914914                sata->event_pxis = pxis;
    915915                fibril_condvar_signal(&sata->event_condvar);
    916                
     916
    917917                fibril_mutex_unlock(&sata->event_lock);
    918918        }
    … …  
    938938        void *virt_table = AS_AREA_ANY;
    939939        ddf_fun_t *fun;
    940        
     940
    941941        fun = ddf_fun_create(ahci->dev, fun_exposed, NULL);
    942        
     942
    943943        sata_dev_t *sata = ddf_fun_data_alloc(fun, sizeof(sata_dev_t));
    944944        if (sata == NULL)
    945945                return NULL;
    946        
     946
    947947        sata->fun = fun;
    948948        sata->port = port;
    949        
     949
    950950        /* Allocate and init retfis structure. */
    951951        errno_t rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
    … …  
    953953        if (rc != EOK)
    954954                goto error_retfis;
    955        
     955
    956956        memset(virt_fb, 0, size);
    957957        sata->port->pxfbu = HI(phys);
    958958        sata->port->pxfb = LO(phys);
    959        
     959
    960960        /* Allocate and init command header structure. */
    961961        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
    … …  
    963963        if (rc != EOK)
    964964                goto error_cmd;
    965        
     965
    966966        memset(virt_cmd, 0, size);
    967967        sata->port->pxclbu = HI(phys);
    968968        sata->port->pxclb = LO(phys);
    969969        sata->cmd_header = (ahci_cmdhdr_t *) virt_cmd;
    970        
     970
    971971        /* Allocate and init command table structure. */
    972972        rc = dmamem_map_anonymous(size, DMAMEM_4GiB,
    … …  
    974974        if (rc != EOK)
    975975                goto error_table;
    976        
     976
    977977        memset(virt_table, 0, size);
    978978        sata->cmd_header->cmdtableu = HI(phys);
    979979        sata->cmd_header->cmdtable = LO(phys);
    980980        sata->cmd_table = (uint32_t*) virt_table;
    981        
     981
    982982        return sata;
    983        
     983
    984984error_table:
    985985        dmamem_unmap(virt_cmd, size);
    … …  
    999999{
    10001000        ahci_port_cmd_t pxcmd;
    1001        
     1001
    10021002        pxcmd.u32 = sata->port->pxcmd;
    1003        
     1003
    10041004        /* Frame receiver disabled. */
    10051005        pxcmd.fre = 0;
    1006        
     1006
    10071007        /* Disable process the command list. */
    10081008        pxcmd.st = 0;
    1009        
     1009
    10101010        sata->port->pxcmd = pxcmd.u32;
    1011        
     1011
    10121012        /* Clear interrupt status. */
    10131013        sata->port->pxis = 0xffffffff;
    1014        
     1014
    10151015        /* Clear error status. */
    10161016        sata->port->pxserr = 0xffffffff;
    1017        
     1017
    10181018        /* Enable all interrupts. */
    10191019        sata->port->pxie = 0xffffffff;
    1020        
     1020
    10211021        /* Frame receiver enabled. */
    10221022        pxcmd.fre = 1;
    1023        
     1023
    10241024        /* Enable process the command list. */
    10251025        pxcmd.st = 1;
    1026        
     1026
    10271027        sata->port->pxcmd = pxcmd.u32;
    10281028}
    … …  
    10431043        ddf_fun_t *fun = NULL;
    10441044        errno_t rc;
    1045        
     1045
    10461046        sata_dev_t *sata = ahci_sata_allocate(ahci, port);
    10471047        if (sata == NULL)
    10481048                return EINTR;
    1049        
     1049
    10501050        /* Set pointers between SATA and AHCI structures. */
    10511051        sata->ahci = ahci;
    10521052        sata->port_num = port_num;
    10531053        ahci->sata_devs[port_num] = sata;
    1054        
     1054
    10551055        /* Initialize synchronization structures */
    10561056        fibril_mutex_initialize(&sata->lock);
    10571057        fibril_mutex_initialize(&sata->event_lock);
    10581058        fibril_condvar_initialize(&sata->event_condvar);
    1059        
     1059
    10601060        ahci_sata_hw_start(sata);
    1061        
     1061
    10621062        /* Identify device. */
    10631063        if (ahci_identify_device(sata) != EOK)
    10641064                goto error;
    1065        
     1065
    10661066        /* Set required UDMA mode */
    10671067        if (ahci_set_highest_ultra_dma_mode(sata) != EOK)
    10681068                goto error;
    1069        
     1069
    10701070        /* Add device to the system */
    10711071        char sata_dev_name[16];
    10721072        snprintf(sata_dev_name, 16, "ahci_%u", sata_devices_count);
    1073        
     1073
    10741074        fibril_mutex_lock(&sata_devices_count_lock);
    10751075        sata_devices_count++;
    10761076        fibril_mutex_unlock(&sata_devices_count_lock);
    1077        
     1077
    10781078        rc= ddf_fun_set_name(sata->fun, sata_dev_name);
    10791079        if (rc != EOK) {
    … …  
    10811081                goto error;
    10821082        }
    1083        
     1083
    10841084        ddf_fun_set_ops(fun, &ahci_ops);
    1085        
     1085
    10861086        rc = ddf_fun_bind(fun);
    10871087        if (rc != EOK) {
    … …  
    10891089                goto error;
    10901090        }
    1091        
     1091
    10921092        return EOK;
    1093        
     1093
    10941094error:
    10951095        sata->is_invalid_device = true;
    10961096        if (fun != NULL)
    10971097                ddf_fun_destroy(fun);
    1098        
     1098
    10991099        return EINTR;
    11001100}
    … …  
    11121112                if (!(ahci->memregs->ghc.pi & (1 << port_num)))
    11131113                        continue;
    1114                
     1114
    11151115                volatile ahci_port_t *port = ahci->memregs->ports + port_num;
    1116                
     1116
    11171117                /* Active devices only */
    11181118                ahci_port_ssts_t pxssts;
    … …  
    11201120                if (pxssts.det != AHCI_PORT_SSTS_DET_ACTIVE)
    11211121                        continue;
    1122                
     1122
    11231123                ahci_sata_create(ahci, dev, port, port_num);
    11241124        }
    … …  
    11371137        if (!ahci)
    11381138                return NULL;
    1139        
     1139
    11401140        /* Connect to parent device */
    11411141        ahci->parent_sess = ddf_dev_parent_sess_get(dev);
    11421142        if (ahci->parent_sess == NULL)
    11431143                return NULL;
    1144        
     1144
    11451145        ahci->dev = dev;
    1146        
     1146
    11471147        hw_res_list_parsed_t hw_res_parsed;
    11481148        hw_res_list_parsed_init(&hw_res_parsed);
    11491149        if (hw_res_get_list_parsed(ahci->parent_sess, &hw_res_parsed, 0) != EOK)
    11501150                goto error_get_res_parsed;
    1151        
     1151
    11521152        /* Map AHCI registers. */
    11531153        ahci->memregs = AS_AREA_ANY;
    1154        
     1154
    11551155        physmem_map(RNGABS(hw_res_parsed.mem_ranges.ranges[0]),
    11561156            AHCI_MEMREGS_PAGES_COUNT, AS_AREA_READ | AS_AREA_WRITE,
    … …  
    11581158        if (ahci->memregs == NULL)
    11591159                goto error_map_registers;
    1160        
     1160
    11611161        /* Register interrupt handler */
    11621162        ahci_ranges[0].base = RNGABS(hw_res_parsed.mem_ranges.ranges[0]);
    11631163        ahci_ranges[0].size = sizeof(ahci_memregs_t);
    1164        
     1164
    11651165        for (unsigned int port = 0; port < AHCI_MAX_PORTS; port++) {
    11661166                size_t base = port * 7;
    1167                
     1167
    11681168                ahci_cmds[base].addr =
    11691169                    ((uint32_t *) RNGABSPTR(hw_res_parsed.mem_ranges.ranges[0])) +
    … …  
    11711171                    AHCI_PORT_IS_REGISTER_OFFSET;
    11721172                ahci_cmds[base + 2].addr = ahci_cmds[base].addr;
    1173                
     1173
    11741174                ahci_cmds[base + 3].addr =
    11751175                    ((uint32_t *) RNGABSPTR(hw_res_parsed.mem_ranges.ranges[0])) +
    … …  
    11771177                ahci_cmds[base + 4].addr = ahci_cmds[base + 3].addr;
    11781178        }
    1179        
     1179
    11801180        irq_code_t ct;
    11811181        ct.cmdcount = sizeof(ahci_cmds) / sizeof(irq_cmd_t);
    … …  
    11831183        ct.rangecount = sizeof(ahci_ranges) / sizeof(irq_pio_range_t);
    11841184        ct.ranges = ahci_ranges;
    1185        
     1185
    11861186        int irq_cap;
    11871187        errno_t rc = register_interrupt_handler(dev,
    … …  
    11911191                goto error_register_interrupt_handler;
    11921192        }
    1193        
     1193
    11941194        rc = hw_res_enable_interrupt(ahci->parent_sess,
    11951195            hw_res_parsed.irqs.irqs[0]);
    … …  
    11981198                goto error_enable_interrupt;
    11991199        }
    1200        
     1200
    12011201        hw_res_list_parsed_clean(&hw_res_parsed);
    12021202        return ahci;
    1203        
     1203
    12041204error_enable_interrupt:
    12051205        unregister_interrupt_handler(dev, irq_cap);
    1206        
     1206
    12071207error_register_interrupt_handler:
    12081208        // FIXME: unmap physical memory
    1209        
     1209
    12101210error_map_registers:
    12111211        hw_res_list_parsed_clean(&hw_res_parsed);
    1212        
     1212
    12131213error_get_res_parsed:
    12141214        free(ahci);
    … …  
    12251225        /* Disable command completion coalescing feature */
    12261226        ahci_ghc_ccc_ctl_t ccc;
    1227        
     1227
    12281228        ccc.u32 = ahci->memregs->ghc.ccc_ctl;
    12291229        ccc.en = 0;
    12301230        ahci->memregs->ghc.ccc_ctl = ccc.u32;
    1231        
     1231
    12321232        /* Set master latency timer. */
    12331233        pci_config_space_write_8(ahci->parent_sess, AHCI_PCI_MLT, 32);
    1234        
     1234
    12351235        /* Enable PCI interrupt and bus mastering */
    12361236        ahci_pcireg_cmd_t cmd;
    1237        
     1237
    12381238        pci_config_space_read_16(ahci->parent_sess, AHCI_PCI_CMD, &cmd.u16);
    12391239        cmd.id = 0;
    12401240        cmd.bme = 1;
    12411241        pci_config_space_write_16(ahci->parent_sess, AHCI_PCI_CMD, cmd.u16);
    1242        
     1242
    12431243        /* Enable AHCI and interrupt. */
    12441244        ahci->memregs->ghc.ghc = AHCI_GHC_GHC_AE | AHCI_GHC_GHC_IE;
    … …  
    12601260        if (ahci == NULL)
    12611261                goto error;
    1262        
     1262
    12631263        /* Start AHCI hardware. */
    12641264        ahci_ahci_hw_start(ahci);
    1265        
     1265
    12661266        /* Create device structures for sata devices attached to AHCI. */
    12671267        ahci_sata_devices_create(ahci, dev);
    1268        
     1268
    12691269        return EOK;
    1270        
     1270
    12711271error:
    12721272        return EINTR;
    … …  
    12901290        uint8_t model[40];
    12911291        memset(model, 0, 40);
    1292        
     1292
    12931293        for (unsigned int i = 0; i < 20; i++) {
    12941294                uint16_t w = src[i];
    … …  
    12961296                model[2 * i + 1] = w & 0x00ff;
    12971297        }
    1298        
     1298
    12991299        uint32_t len = 40;
    13001300        while ((len > 0) && (model[len - 1] == 0x20))
    13011301                len--;
    1302        
     1302
    13031303        size_t pos = 0;
    13041304        for (unsigned int i = 0; i < len; i++) {
    … …  
    13061306                if (c >= 0x80)
    13071307                        c = '?';
    1308                
     1308
    13091309                chr_encode(c, dst, &pos, 40);
    13101310        }
    1311        
     1311
    13121312        dst[pos] = '\0';
    13131313}
Note: See TracChangeset for help on using the changeset viewer.