Changeset 8565a42 in mainline for uspace/drv/block


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (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:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/drv/block
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 r8565a42  
    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}

  • uspace/drv/block/ahci/ahci.h

    r3061bc1 r8565a42  
    4545        /** Pointer to ddf device. */
    4646        ddf_dev_t *dev;
    47        
     47
    4848        /** Pointer to AHCI memory registers. */
    4949        volatile ahci_memregs_t *memregs;
    50        
     50
    5151        /** Pointers to sata devices. */
    5252        void *sata_devs[AHCI_MAX_PORTS];
    … …  
    6060        /** Pointer to AHCI device. */
    6161        ahci_dev_t *ahci;
    62        
     62
    6363        /** Pointer to ddf function. */
    6464        ddf_fun_t *fun;
    65        
     65
    6666        /** SATA port number (0-31). */
    6767        uint8_t port_num;
    68        
     68
    6969        /** Device in invalid state (disconnected and so on). */
    7070        bool is_invalid_device;
    71        
     71
    7272        /** Pointer to SATA port. */
    7373        volatile ahci_port_t *port;
    74        
     74
    7575        /** Pointer to command header. */
    7676        volatile ahci_cmdhdr_t *cmd_header;
    77        
     77
    7878        /** Pointer to command table. */
    7979        volatile uint32_t *cmd_table;
    80        
     80
    8181        /** Mutex for single operation on device. */
    8282        fibril_mutex_t lock;
    83        
     83
    8484        /** Mutex for event signaling condition variable. */
    8585        fibril_mutex_t event_lock;
    86        
     86
    8787        /** Event signaling condition variable. */
    8888        fibril_condvar_t event_condvar;
    89        
     89
    9090        /** Event interrupt state. */
    9191        ahci_port_is_t event_pxis;
    92        
     92
    9393        /** Number of device data blocks. */
    9494        uint64_t blocks;
    95        
     95
    9696        /** Size of device data blocks. */
    9797        size_t block_size;
    98        
     98
    9999        /** Name of SATA device. */
    100100        char model[STR_BOUNDS(40) + 1];
    101        
     101
    102102        /** Device in invalid state (disconnected and so on). */
    103103        bool is_packet_device;
    104        
     104
    105105        /** Highest UDMA mode supported. */
    106106        uint8_t highest_udma_mode;

  • uspace/drv/block/ahci/ahci_sata.h

    r3061bc1 r8565a42  
    146146        uint16_t _vs8;
    147147        uint16_t _vs9;
    148        
     148
    149149        uint16_t serial_number[10];
    150150        uint16_t _vs20;
    … …  
    153153        uint16_t firmware_rev[4];
    154154        uint16_t model_name[20];
    155        
     155
    156156        uint16_t max_rw_multiple;
    157157        uint16_t reserved48;
    … …  
    161161        uint16_t pio_timing;
    162162        uint16_t dma_timing;
    163        
     163
    164164        uint16_t validity;
    165165        uint16_t cur_cyl;
    … …  
    178178        uint16_t min_raw_pio_cycle;
    179179        uint16_t min_iordy_pio_cycle;
    180        
     180
    181181        uint16_t reserved69;
    182182        uint16_t reserved70;
    … …  
    185185        uint16_t reserved73;
    186186        uint16_t reserved74;
    187        
     187
    188188        uint16_t queue_depth;
    189189        /** SATA capatibilities - different meaning for packet device. */
    … …  
    201201        uint16_t csf_default;
    202202        uint16_t udma;
    203        
     203
    204204        uint16_t reserved89[1 + 99 - 89];
    205        
     205
    206206        /* Total number of blocks in LBA-48 addressing. */
    207207        uint16_t total_lba48_0;
    … …  
    209209        uint16_t total_lba48_2;
    210210        uint16_t total_lba48_3;
    211        
     211
    212212        uint16_t reserved104[1 + 105 - 104];
    213213        uint16_t physical_logic_sector_size;
    … …  
    248248        /** Supports recepits of host-initiated interface power management. */
    249249        sata_np_cap_host_pmngmnt = 0x0200,
    250        
     250
    251251        /** Supports NCQ. */
    252252        sata_np_cap_ncq = 0x0100,
    253        
     253
    254254        /** Supports SATA 3. */
    255255        sata_np_cap_sata_3 = 0x0008,
    … …  
    272272        /** Supports recepits of host-initiated interface power management. */
    273273        sata_pt_cap_host_pmngmnt = 0x0200,
    274        
     274
    275275        /** Supports SATA 3. */
    276276        sata_pt_cap_sat_3 = 0x0008,

  • uspace/drv/block/ddisk/ddisk.c

    r3061bc1 r8565a42  
    182182
    183183        ddisk_t *ddisk = (ddisk_t *) ddf_dev_data_get(dev);
    184        
     184
    185185        fibril_mutex_lock(&ddisk->lock);
    186186        fibril_condvar_broadcast(&ddisk->io_cv);
    … …  
    216216        if (!read)
    217217                memcpy(ddisk->dma_buffer, buf, DDISK_BLOCK_SIZE);
    218        
     218
    219219        pio_write_32(&ddisk->ddisk_regs->dma_buffer,
    220220            ddisk->dma_buffer_phys);
    … …  
    546546
    547547        unregister_interrupt_handler(ddisk->dev, ddisk->irq_cap);
    548        
     548
    549549        rc = pio_disable(ddisk->ddisk_regs, sizeof(ddisk_regs_t));
    550550        if (rc != EOK) {
Note: See TracChangeset for help on using the changeset viewer.