Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/block/ahci/ahci.c

    r730dce77 r267f235  
    3434#include <errno.h>
    3535#include <stdio.h>
    36 #include <devman.h>
    3736#include <ddf/interrupt.h>
    3837#include <ddf/log.h>
     
    4948#define NAME  "ahci"
    5049
    51 #define AHCI_TIMER_TICKS  1000000000
    52 
    5350#define LO(ptr) \
    5451        ((uint32_t) (((uint64_t) ((uintptr_t) (ptr))) & 0xffffffff))
     
    5653#define HI(ptr) \
    5754        ((uint32_t) (((uint64_t) ((uintptr_t) (ptr))) >> 32))
     55
     56/** Interrupt pseudocode for a single port
     57 *
     58 * The interrupt handling works as follows:
     59 *
     60 * 1. Port interrupt status register is read
     61 *    (stored as arg2).
     62 * 2. If port interrupt is indicated, then:
     63 *    3. Port interrupt status register is cleared.
     64 *    4. Global interrupt status register is read
     65 *       and cleared (any potential interrupts from
     66 *       other ports are reasserted automatically).
     67 *    5. Port number is stored as arg1.
     68 *    6. The interrupt is accepted.
     69 *
     70 */
     71#define AHCI_PORT_CMDS(port) \
     72        { \
     73                /* Read port interrupt status register */ \
     74                .cmd = CMD_PIO_READ_32, \
     75                .addr = NULL, \
     76                .dstarg = 2 \
     77        }, \
     78        { \
     79                /* Check if port asserted interrupt */ \
     80                .cmd = CMD_PREDICATE, \
     81                .value = 5, \
     82                .srcarg = 2, \
     83        }, \
     84        { \
     85                /* Clear port interrupt status register */ \
     86                .cmd = CMD_PIO_WRITE_A_32, \
     87                .addr = NULL, \
     88                .srcarg = 2 \
     89        }, \
     90        { \
     91                /* Read global interrupt status register */ \
     92                .cmd = CMD_PIO_READ_32, \
     93                .addr = NULL, \
     94                .dstarg = 0 \
     95        }, \
     96        { \
     97                /* Clear global interrupt status register */ \
     98                .cmd = CMD_PIO_WRITE_A_32, \
     99                .addr = NULL, \
     100                .srcarg = 0 \
     101        }, \
     102        { \
     103                /* Indicate port interrupt assertion */ \
     104                .cmd = CMD_LOAD, \
     105                .value = (port), \
     106                .dstarg = 1 \
     107        }, \
     108        { \
     109                /* Accept the interrupt */ \
     110                .cmd = CMD_ACCEPT \
     111        }
    58112
    59113static int ahci_get_sata_device_name(ddf_fun_t *, size_t, char *);
     
    70124static void ahci_sata_devices_create(ahci_dev_t *, ddf_dev_t *);
    71125static ahci_dev_t *ahci_ahci_create(ddf_dev_t *);
    72 static void ahci_ahci_init(ahci_dev_t *);
     126static void ahci_ahci_hw_start(ahci_dev_t *);
    73127
    74128static int ahci_dev_add(ddf_dev_t *);
    75129
    76130static void ahci_get_model_name(uint16_t *, char *);
    77 static int ahci_pciintel_enable_interrupt(int);
     131static int ahci_enable_interrupt(int);
    78132
    79133static fibril_mutex_t sata_devices_count_lock;
     
    105159};
    106160
     161/** Get SATA structure from DDF function. */
     162static sata_dev_t *fun_sata_dev(ddf_fun_t *fun)
     163{
     164        return ddf_fun_data_get(fun);
     165}
     166
     167/** Get AHCI structure from DDF device. */
     168static ahci_dev_t *dev_ahci_dev(ddf_dev_t *dev)
     169{
     170        return ddf_dev_data_get(dev);
     171}
     172
     173/** Get SATA device name.
     174 *
     175 * @param fun                  Device function handling the call.
     176 * @param sata_dev_name_length Length of the sata_dev_name buffer.
     177 * @param sata_dev_name        Buffer for SATA device name.
     178 *
     179 * @return EOK.
     180 *
     181 */
    107182static int ahci_get_sata_device_name(ddf_fun_t *fun,
    108183    size_t sata_dev_name_length, char *sata_dev_name)
    109184{
    110         sata_dev_t *sata = (sata_dev_t *) fun->driver_data;
     185        sata_dev_t *sata = fun_sata_dev(fun);
    111186        str_cpy(sata_dev_name, sata_dev_name_length, sata->model);
    112187        return EOK;
    113188}
    114189
     190/** Get Number of blocks in SATA device.
     191 *
     192 * @param fun    Device function handling the call.
     193 * @param blocks Return number of blocks in SATA device.
     194 *
     195 * @return EOK.
     196 *
     197 */
    115198static int ahci_get_num_blocks(ddf_fun_t *fun, uint64_t *num_blocks)
    116199{
    117         sata_dev_t *sata = (sata_dev_t *) fun->driver_data;
     200        sata_dev_t *sata = fun_sata_dev(fun);
    118201        *num_blocks = sata->blocks;
    119202        return EOK;
    120203}
    121204
     205/** Get SATA device block size.
     206 *
     207 * @param fun        Device function handling the call.
     208 * @param block_size Return block size.
     209 *
     210 * @return EOK.
     211 *
     212 */
    122213static int ahci_get_block_size(ddf_fun_t *fun, size_t *block_size)
    123214{
    124         sata_dev_t *sata = (sata_dev_t *) fun->driver_data;
     215        sata_dev_t *sata = fun_sata_dev(fun);
    125216        *block_size = sata->block_size;
    126217        return EOK;
    127218}
    128219
     220/** Read data blocks into SATA device.
     221 *
     222 * @param fun      Device function handling the call.
     223 * @param blocknum Number of first block.
     224 * @param count    Number of blocks to read.
     225 * @param buf      Buffer for data.
     226 *
     227 * @return EOK if succeed, error code otherwise
     228 *
     229 */
    129230static int ahci_read_blocks(ddf_fun_t *fun, uint64_t blocknum,
    130231    size_t count, void *buf)
    131232{
    132         int rc = EOK;
    133         sata_dev_t *sata = (sata_dev_t *) fun->driver_data;
     233        sata_dev_t *sata = fun_sata_dev(fun);
    134234       
    135235        void *phys;
    136236        void *ibuf;
    137        
    138         dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
     237        int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
    139238            0, &phys, (void **) &ibuf);
     239        if (rc != EOK) {
     240                ddf_msg(LVL_ERROR, "Cannot allocate read buffer.");
     241                return rc;
     242        }
     243       
    140244        bzero(buf, sata->block_size);
    141245       
     
    157261}
    158262
     263/** Write data blocks into SATA device.
     264 *
     265 * @param fun      Device function handling the call.
     266 * @param blocknum Number of first block.
     267 * @param count    Number of blocks to write.
     268 * @param buf      Buffer with data.
     269 *
     270 * @return EOK if succeed, error code otherwise
     271 *
     272 */
    159273static int ahci_write_blocks(ddf_fun_t *fun, uint64_t blocknum,
    160274    size_t count, void *buf)
    161275{
    162         int rc = EOK;
    163         sata_dev_t *sata = (sata_dev_t *) fun->driver_data;
     276        sata_dev_t *sata = fun_sata_dev(fun);
    164277       
    165278        void *phys;
    166279        void *ibuf;
    167        
    168         dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
     280        int rc = dmamem_map_anonymous(sata->block_size, AS_AREA_READ | AS_AREA_WRITE,
    169281            0, &phys, (void **) &ibuf);
     282        if (rc != EOK) {
     283                ddf_msg(LVL_ERROR, "Cannot allocate write buffer.");
     284                return rc;
     285        }
    170286       
    171287        fibril_mutex_lock(&sata->lock);
     
    181297        fibril_mutex_unlock(&sata->lock);
    182298        dmamem_unmap_anonymous(ibuf);
     299       
    183300        return rc;
    184301}
     
    188305/*----------------------------------------------------------------------------*/
    189306
     307/** Wait for interrupt event.
     308 *
     309 * @param sata SATA device structure.
     310 *
     311 * @return Value of interrupt state register.
     312 *
     313 */
     314static ahci_port_is_t ahci_wait_event(sata_dev_t *sata)
     315{
     316        fibril_mutex_lock(&sata->event_lock);
     317       
     318        sata->event_pxis = 0;
     319        while (sata->event_pxis == 0)
     320                fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
     321       
     322        ahci_port_is_t pxis = sata->event_pxis;
     323       
     324        if (ahci_port_is_permanent_error(pxis))
     325                sata->is_invalid_device = true;
     326       
     327        fibril_mutex_unlock(&sata->event_lock);
     328       
     329        return pxis;
     330}
     331
     332/** Set AHCI registers for identifying SATA device.
     333 *
     334 * @param sata SATA device structure.
     335 * @param phys Physical address of working buffer.
     336 *
     337 */
    190338static void ahci_identify_device_cmd(sata_dev_t *sata, void *phys)
    191339{
    192         volatile std_command_frame_t *cmd =
    193             (std_command_frame_t *) sata->cmd_table;
    194        
    195         cmd->fis_type = 0x27;
    196         cmd->c = 0x80;
     340        volatile sata_std_command_frame_t *cmd =
     341            (sata_std_command_frame_t *) sata->cmd_table;
     342       
     343        cmd->fis_type = SATA_CMD_FIS_TYPE;
     344        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    197345        cmd->command = 0xec;
    198346        cmd->features = 0;
     
    212360        prdt->data_address_upper = HI(phys);
    213361        prdt->reserved1 = 0;
    214         prdt->dbc = 511;
     362        prdt->dbc = SATA_IDENTIFY_DEVICE_BUFFER_LENGTH - 1;
    215363        prdt->reserved2 = 0;
    216364        prdt->ioc = 0;
    217365       
    218366        sata->cmd_header->prdtl = 1;
    219         sata->cmd_header->flags = 0x402;
     367        sata->cmd_header->flags =
     368            AHCI_CMDHDR_FLAGS_CLEAR_BUSY_UPON_OK |
     369            AHCI_CMDHDR_FLAGS_2DWCMD;
    220370        sata->cmd_header->bytesprocessed = 0;
    221371       
     372        /* Run command. */
    222373        sata->port->pxsact |= 1;
    223374        sata->port->pxci |= 1;
    224375}
    225376
     377/** Set AHCI registers for identifying packet SATA device.
     378 *
     379 * @param sata SATA device structure.
     380 * @param phys Physical address of working buffer.
     381 *
     382 */
    226383static void ahci_identify_packet_device_cmd(sata_dev_t *sata, void *phys)
    227384{
    228         volatile std_command_frame_t *cmd =
    229             (std_command_frame_t *) sata->cmd_table;
    230        
    231         cmd->fis_type = 0x27;
    232         cmd->c = 0x80;
     385        volatile sata_std_command_frame_t *cmd =
     386            (sata_std_command_frame_t *) sata->cmd_table;
     387       
     388        cmd->fis_type = SATA_CMD_FIS_TYPE;
     389        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    233390        cmd->command = 0xa1;
    234391        cmd->features = 0;
     
    248405        prdt->data_address_upper = HI(phys);
    249406        prdt->reserved1 = 0;
    250         prdt->dbc = 511;
     407        prdt->dbc = SATA_IDENTIFY_DEVICE_BUFFER_LENGTH - 1;
    251408        prdt->reserved2 = 0;
    252409        prdt->ioc = 0;
    253410       
    254411        sata->cmd_header->prdtl = 1;
    255         sata->cmd_header->flags = 0x402;
     412        sata->cmd_header->flags =
     413            AHCI_CMDHDR_FLAGS_CLEAR_BUSY_UPON_OK |
     414            AHCI_CMDHDR_FLAGS_2DWCMD;
    256415        sata->cmd_header->bytesprocessed = 0;
    257416       
     417        /* Run command. */
    258418        sata->port->pxsact |= 1;
    259419        sata->port->pxci |= 1;
    260420}
    261421
     422/** Fill device identification in SATA device structure.
     423 *
     424 * @param sata SATA device structure.
     425 *
     426 * @return EOK if succeed, error code otherwise.
     427 *
     428 */
    262429static int ahci_identify_device(sata_dev_t *sata)
    263430{
    264         if (sata->invalid_device) {
     431        if (sata->is_invalid_device) {
    265432                ddf_msg(LVL_ERROR,
    266433                    "Identify command device on invalid device");
     
    269436       
    270437        void *phys;
    271         identify_data_t *idata;
    272        
    273         dmamem_map_anonymous(512, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
    274             (void **) &idata);
    275         bzero(idata, 512);
     438        sata_identify_data_t *idata;
     439        int rc = dmamem_map_anonymous(SATA_IDENTIFY_DEVICE_BUFFER_LENGTH,
     440            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
     441        if (rc != EOK) {
     442                ddf_msg(LVL_ERROR, "Cannot allocate buffer to identify device.");
     443                return rc;
     444        }
     445       
     446        bzero(idata, SATA_IDENTIFY_DEVICE_BUFFER_LENGTH);
    276447       
    277448        fibril_mutex_lock(&sata->lock);
    278449       
    279450        ahci_identify_device_cmd(sata, phys);
    280        
    281         fibril_mutex_lock(&sata->event_lock);
    282         fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    283         fibril_mutex_unlock(&sata->event_lock);
    284        
    285         ahci_port_is_t pxis = sata->shadow_pxis;
    286         sata->shadow_pxis.u32 &= ~pxis.u32;
    287        
    288         if (sata->invalid_device) {
     451        ahci_port_is_t pxis = ahci_wait_event(sata);
     452       
     453        if (sata->is_invalid_device) {
    289454                ddf_msg(LVL_ERROR,
    290455                    "Unrecoverable error during ata identify device");
     
    294459        if (ahci_port_is_tfes(pxis)) {
    295460                ahci_identify_packet_device_cmd(sata, phys);
     461                pxis = ahci_wait_event(sata);
    296462               
    297                 fibril_mutex_lock(&sata->event_lock);
    298                 fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    299                 fibril_mutex_unlock(&sata->event_lock);
    300                
    301                 pxis = sata->shadow_pxis;
    302                 sata->shadow_pxis.u32 &= ~pxis.u32;
    303                
    304                 if ((sata->invalid_device) || (ahci_port_is_error(pxis))) {
     463                if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    305464                        ddf_msg(LVL_ERROR,
    306465                            "Unrecoverable error during ata identify packet device");
     
    308467                }
    309468               
    310                 sata->packet_device = true;
    311         } else
    312                 sata->packet_device = false;
     469                sata->is_packet_device = true;
     470        }
    313471       
    314472        ahci_get_model_name(idata->model_name, sata->model);
     
    318476         * only NCQ FPDMA mode is supported.
    319477         */
    320         if ((idata->sata_cap & np_cap_ncq) == 0) {
     478        if ((idata->sata_cap & sata_np_cap_ncq) == 0) {
    321479                ddf_msg(LVL_ERROR, "%s: NCQ must be supported", sata->model);
    322480                goto error;
    323481        }
    324482       
    325         if (sata->packet_device) {
     483        uint16_t logsec = idata->physical_logic_sector_size;
     484        if ((logsec & 0xc000) == 0x4000) {
     485                /* Length of sector may be larger than 512 B */
     486                if (logsec & 0x0100) {
     487                        /* Size of sector is larger than 512 B */
     488                        ddf_msg(LVL_ERROR,
     489                            "%s: Sector length other than 512 B not supported",
     490                            sata->model);
     491                        goto error;
     492                }
     493               
     494                if ((logsec & 0x0200) && ((logsec & 0x000f) != 0)) {
     495                        /* Physical sectors per logical sector is greather than 1 */
     496                        ddf_msg(LVL_ERROR,
     497                            "%s: Sector length other than 512 B not supported",
     498                            sata->model);
     499                        goto error;
     500                }
     501        }
     502       
     503        if (sata->is_packet_device) {
    326504                /*
    327505                 * Due to QEMU limitation (as of 2012-06-22),
    328                  * only NCQ FPDMA mode supported - block size is 512 B,
    329                  * not 2048 B!
     506                 * only NCQ FPDMA mode supported - block size is
     507                 * 512 B, not 2048 B!
    330508                 */
    331                 sata->block_size = 512;
     509                sata->block_size = SATA_DEFAULT_SECTOR_SIZE;
    332510                sata->blocks = 0;
    333511        } else {
    334                 sata->block_size = 512;
     512                sata->block_size = SATA_DEFAULT_SECTOR_SIZE;
    335513               
    336                 if ((idata->caps & rd_cap_lba) == 0) {
     514                if ((idata->caps & sata_rd_cap_lba) == 0) {
    337515                        ddf_msg(LVL_ERROR, "%s: LBA for NCQ must be supported",
    338516                            sata->model);
    339517                        goto error;
    340                 } else if ((idata->cmd_set1 & cs1_addr48) == 0) {
     518                } else if ((idata->cmd_set1 & sata_cs1_addr48) == 0) {
    341519                        sata->blocks = (uint32_t) idata->total_lba28_0 |
    342520                            ((uint32_t) idata->total_lba28_1 << 16);
     
    351529       
    352530        uint8_t udma_mask = idata->udma & 0x007f;
     531        sata->highest_udma_mode = (uint8_t) -1;
    353532        if (udma_mask == 0) {
    354533                ddf_msg(LVL_ERROR,
     
    357536                goto error;
    358537        } else {
    359                 for (unsigned int i = 0; i < 7; i++) {
     538                for (uint8_t i = 0; i < 7; i++) {
    360539                        if (udma_mask & (1 << i))
    361540                                sata->highest_udma_mode = i;
     
    375554}
    376555
     556/** Set AHCI registers for setting SATA device transfer mode.
     557 *
     558 * @param sata SATA device structure.
     559 * @param phys Physical address of working buffer.
     560 * @param mode Required mode.
     561 *
     562 */
    377563static void ahci_set_mode_cmd(sata_dev_t *sata, void* phys, uint8_t mode)
    378564{
    379         volatile std_command_frame_t *cmd =
    380             (std_command_frame_t *) sata->cmd_table;
    381        
    382         cmd->fis_type = 0x27;
    383         cmd->c = 0x80;
     565        volatile sata_std_command_frame_t *cmd =
     566            (sata_std_command_frame_t *) sata->cmd_table;
     567       
     568        cmd->fis_type = SATA_CMD_FIS_TYPE;
     569        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    384570        cmd->command = 0xef;
    385571        cmd->features = 0x03;
     
    393579        cmd->reserved2 = 0;
    394580       
    395         volatile ahci_cmd_prdt_t* prdt =
     581        volatile ahci_cmd_prdt_t *prdt =
    396582            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    397583       
     
    399585        prdt->data_address_upper = HI(phys);
    400586        prdt->reserved1 = 0;
    401         prdt->dbc = 511;
     587        prdt->dbc = SATA_SET_FEATURE_BUFFER_LENGTH - 1;
    402588        prdt->reserved2 = 0;
    403589        prdt->ioc = 0;
    404590       
    405591        sata->cmd_header->prdtl = 1;
    406         sata->cmd_header->flags = 0x402;
     592        sata->cmd_header->flags =
     593            AHCI_CMDHDR_FLAGS_CLEAR_BUSY_UPON_OK |
     594            AHCI_CMDHDR_FLAGS_2DWCMD;
    407595        sata->cmd_header->bytesprocessed = 0;
    408596       
     597        /* Run command. */
    409598        sata->port->pxsact |= 1;
    410599        sata->port->pxci |= 1;
    411600}
    412601
     602/** Set highest ultra DMA mode supported by SATA device.
     603 *
     604 * @param sata SATA device structure.
     605 *
     606 * @return EOK if succeed, error code otherwise
     607 *
     608 */
    413609static int ahci_set_highest_ultra_dma_mode(sata_dev_t *sata)
    414610{
    415         if (sata->invalid_device) {
     611        if (sata->is_invalid_device) {
    416612                ddf_msg(LVL_ERROR,
    417613                    "%s: Setting highest UDMA mode on invalid device",
     
    420616        }
    421617       
     618        if (sata->highest_udma_mode == (uint8_t) -1) {
     619                ddf_msg(LVL_ERROR,
     620                    "%s: No AHCI UDMA support.", sata->model);
     621                return EINTR;
     622        }
     623       
     624        if (sata->highest_udma_mode > 6) {
     625                ddf_msg(LVL_ERROR,
     626                    "%s: Unknown AHCI UDMA mode.", sata->model);
     627                return EINTR;
     628        }
     629       
    422630        void *phys;
    423         identify_data_t *idata;
    424        
    425         dmamem_map_anonymous(512, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
    426             (void **) &idata);
    427         bzero(idata, 512);
     631        sata_identify_data_t *idata;
     632        int rc = dmamem_map_anonymous(SATA_SET_FEATURE_BUFFER_LENGTH,
     633            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, (void **) &idata);
     634        if (rc != EOK) {
     635                ddf_msg(LVL_ERROR, "Cannot allocate buffer for device set mode.");
     636                return rc;
     637        }
     638       
     639        bzero(idata, SATA_SET_FEATURE_BUFFER_LENGTH);
    428640       
    429641        fibril_mutex_lock(&sata->lock);
     
    431643        uint8_t mode = 0x40 | (sata->highest_udma_mode & 0x07);
    432644        ahci_set_mode_cmd(sata, phys, mode);
    433        
    434         fibril_mutex_lock(&sata->event_lock);
    435         fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    436         fibril_mutex_unlock(&sata->event_lock);
    437        
    438         ahci_port_is_t pxis = sata->shadow_pxis;
    439         sata->shadow_pxis.u32 &= ~pxis.u32;
    440        
    441         if (sata->invalid_device) {
     645        ahci_port_is_t pxis = ahci_wait_event(sata);
     646       
     647        if (sata->is_invalid_device) {
    442648                ddf_msg(LVL_ERROR,
    443649                    "%s: Unrecoverable error during set highest UDMA mode",
     
    464670}
    465671
     672/** Set AHCI registers for reading one sector from the SATA device using FPDMA.
     673 *
     674 * @param sata     SATA device structure.
     675 * @param phys     Physical address of buffer for sector data.
     676 * @param blocknum Block number to read.
     677 *
     678 */
    466679static void ahci_rb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
    467680{
    468         volatile ncq_command_frame_t *cmd =
    469             (ncq_command_frame_t *) sata->cmd_table;
    470        
    471         cmd->fis_type = 0x27;
    472         cmd->c = 0x80;
     681        volatile sata_ncq_command_frame_t *cmd =
     682            (sata_ncq_command_frame_t *) sata->cmd_table;
     683       
     684        cmd->fis_type = SATA_CMD_FIS_TYPE;
     685        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    473686        cmd->command = 0x60;
    474687        cmd->tag = 0;
     
    503716       
    504717        sata->cmd_header->prdtl = 1;
    505         sata->cmd_header->flags = 0x405;
     718        sata->cmd_header->flags =
     719            AHCI_CMDHDR_FLAGS_CLEAR_BUSY_UPON_OK |
     720            AHCI_CMDHDR_FLAGS_5DWCMD;
    506721        sata->cmd_header->bytesprocessed = 0;
    507722       
     
    510725}
    511726
     727/** Read one sector from the SATA device using FPDMA.
     728 *
     729 * @param sata     SATA device structure.
     730 * @param phys     Physical address of buffer for sector data.
     731 * @param blocknum Block number to read.
     732 *
     733 * @return EOK if succeed, error code otherwise
     734 *
     735 */
    512736static int ahci_rb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
    513737{
    514         if (sata->invalid_device) {
     738        if (sata->is_invalid_device) {
    515739                ddf_msg(LVL_ERROR,
    516740                    "%s: FPDMA read from invalid device", sata->model);
     
    519743       
    520744        ahci_rb_fpdma_cmd(sata, phys, blocknum);
    521        
    522         fibril_mutex_lock(&sata->event_lock);
    523         fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    524         fibril_mutex_unlock(&sata->event_lock);
    525        
    526         ahci_port_is_t pxis = sata->shadow_pxis;
    527         sata->shadow_pxis.u32 &= ~pxis.u32;
    528        
    529         if ((sata->invalid_device) || (ahci_port_is_error(pxis))) {
     745        ahci_port_is_t pxis = ahci_wait_event(sata);
     746       
     747        if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    530748                ddf_msg(LVL_ERROR,
    531749                    "%s: Unrecoverable error during FPDMA read", sata->model);
     
    536754}
    537755
     756/** Set AHCI registers for writing one sector to the SATA device, use FPDMA.
     757 *
     758 * @param sata     SATA device structure.
     759 * @param phys     Physical address of buffer with sector data.
     760 * @param blocknum Block number to write.
     761 *
     762 * @return EOK if succeed, error code otherwise
     763 *
     764 */
    538765static void ahci_wb_fpdma_cmd(sata_dev_t *sata, void *phys, uint64_t blocknum)
    539766{
    540         volatile ncq_command_frame_t *cmd =
    541             (ncq_command_frame_t *) sata->cmd_table;
    542        
    543         cmd->fis_type = 0x27;
    544         cmd->c = 0x80;
     767        volatile sata_ncq_command_frame_t *cmd =
     768            (sata_ncq_command_frame_t *) sata->cmd_table;
     769       
     770        cmd->fis_type = SATA_CMD_FIS_TYPE;
     771        cmd->c = SATA_CMD_FIS_COMMAND_INDICATOR;
    545772        cmd->command = 0x61;
    546773        cmd->tag = 0;
     
    564791        cmd->lba5 = (blocknum >> 40) & 0xff;
    565792       
    566         volatile ahci_cmd_prdt_t * prdt =
     793        volatile ahci_cmd_prdt_t *prdt =
    567794            (ahci_cmd_prdt_t *) (&sata->cmd_table[0x20]);
    568795       
     
    575802       
    576803        sata->cmd_header->prdtl = 1;
    577         sata->cmd_header->flags = 0x445;
     804        sata->cmd_header->flags =
     805            AHCI_CMDHDR_FLAGS_CLEAR_BUSY_UPON_OK |
     806            AHCI_CMDHDR_FLAGS_WRITE |
     807            AHCI_CMDHDR_FLAGS_5DWCMD;
    578808        sata->cmd_header->bytesprocessed = 0;
    579809       
     
    582812}
    583813
     814/** Write one sector into the SATA device, use FPDMA.
     815 *
     816 * @param sata     SATA device structure.
     817 * @param phys     Physical addres of buffer with sector data.
     818 * @param blocknum Block number to write.
     819 *
     820 * @return EOK if succeed, error code otherwise
     821 *
     822 */
    584823static int ahci_wb_fpdma(sata_dev_t *sata, void *phys, uint64_t blocknum)
    585824{
    586         if (sata->invalid_device) {
     825        if (sata->is_invalid_device) {
    587826                ddf_msg(LVL_ERROR,
    588827                    "%s: FPDMA write to invalid device", sata->model);
     
    591830       
    592831        ahci_wb_fpdma_cmd(sata, phys, blocknum);
    593        
    594         fibril_mutex_lock(&sata->event_lock);
    595         fibril_condvar_wait(&sata->event_condvar, &sata->event_lock);
    596         fibril_mutex_unlock(&sata->event_lock);
    597        
    598         ahci_port_is_t pxis = sata->shadow_pxis;
    599         sata->shadow_pxis.u32 &= ~pxis.u32;
    600        
    601         if ((sata->invalid_device) || (ahci_port_is_error(pxis))) {
     832        ahci_port_is_t pxis = ahci_wait_event(sata);
     833       
     834        if ((sata->is_invalid_device) || (ahci_port_is_error(pxis))) {
    602835                ddf_msg(LVL_ERROR,
    603836                    "%s: Unrecoverable error during FPDMA write", sata->model);
     
    609842
    610843/*----------------------------------------------------------------------------*/
    611 /*-- Interrupts and timer unified handling -----------------------------------*/
     844/*-- Interrupts handling -----------------------------------------------------*/
    612845/*----------------------------------------------------------------------------*/
    613846
     
    615848        {
    616849                .base = 0,
    617                 .size = 32,
     850                .size = 0,
    618851        }
    619852};
    620853
    621854static irq_cmd_t ahci_cmds[] = {
    622         {
    623                 /* Disable interrupt - interrupt is deasserted in qemu 1.0.1 */
    624                 .cmd = CMD_PIO_WRITE_32,
    625                 .addr = NULL,
    626                 .value = AHCI_GHC_GHC_AE
    627         },
    628         {
    629                 .cmd = CMD_PIO_READ_32,
    630                 .addr = NULL,
    631                 .dstarg = 1
    632         },
    633         {
    634                 /* Clear interrupt status register - for vbox and real hw */
    635                 .cmd = CMD_PIO_WRITE_A_32,
    636                 .addr = NULL,
    637                 .srcarg = 1
    638         },
    639         {
    640                 .cmd = CMD_ACCEPT
    641         }
     855        AHCI_PORT_CMDS(0),
     856        AHCI_PORT_CMDS(1),
     857        AHCI_PORT_CMDS(2),
     858        AHCI_PORT_CMDS(3),
     859        AHCI_PORT_CMDS(4),
     860        AHCI_PORT_CMDS(5),
     861        AHCI_PORT_CMDS(6),
     862        AHCI_PORT_CMDS(7),
     863        AHCI_PORT_CMDS(8),
     864        AHCI_PORT_CMDS(9),
     865        AHCI_PORT_CMDS(10),
     866        AHCI_PORT_CMDS(11),
     867        AHCI_PORT_CMDS(12),
     868        AHCI_PORT_CMDS(13),
     869        AHCI_PORT_CMDS(14),
     870        AHCI_PORT_CMDS(15),
     871        AHCI_PORT_CMDS(16),
     872        AHCI_PORT_CMDS(17),
     873        AHCI_PORT_CMDS(18),
     874        AHCI_PORT_CMDS(19),
     875        AHCI_PORT_CMDS(20),
     876        AHCI_PORT_CMDS(21),
     877        AHCI_PORT_CMDS(22),
     878        AHCI_PORT_CMDS(23),
     879        AHCI_PORT_CMDS(24),
     880        AHCI_PORT_CMDS(25),
     881        AHCI_PORT_CMDS(26),
     882        AHCI_PORT_CMDS(27),
     883        AHCI_PORT_CMDS(28),
     884        AHCI_PORT_CMDS(29),
     885        AHCI_PORT_CMDS(30),
     886        AHCI_PORT_CMDS(31)
    642887};
    643888
    644 /** Unified AHCI interrupt and timer interrupt handler.
    645  *
    646  * @param ahci     AHCI device.
    647  * @param is_timer Indicate timer interrupt.
    648  *
    649  */
    650 static void ahci_interrupt_or_timer(ahci_dev_t *ahci, bool is_timer)
    651 {
    652         /*
    653          * Get current value of hardware interrupt state register,
    654          * clear hardware register (write to clear behavior).
    655          */
    656         ahci_ghc_is_t is;
    657        
    658         is.u32 = ahci->memregs->ghc.is;
    659         ahci->memregs->ghc.is = is.u32;
    660         is.u32 = ahci->memregs->ghc.is;
    661        
    662         uint32_t port_event_flags = 0;
    663         uint32_t port_mask = 1;
    664         for (unsigned int i = 0; i < 32; i++) {
    665                 /*
    666                  * Get current value of hardware port interrupt state register,
    667                  * clear hardware register (write to clear behavior).
    668                  */
    669                 ahci_port_is_t pxis;
     889/** AHCI interrupt handler.
     890 *
     891 * @param dev   DDF device structure.
     892 * @param iid   The IPC call id.
     893 * @param icall The IPC call structure.
     894 *
     895 */
     896static void ahci_interrupt(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *icall)
     897{
     898        ahci_dev_t *ahci = dev_ahci_dev(dev);
     899        unsigned int port = IPC_GET_ARG1(*icall);
     900        ahci_port_is_t pxis = IPC_GET_ARG2(*icall);
     901       
     902        if (port >= AHCI_MAX_PORTS)
     903                return;
     904       
     905        sata_dev_t *sata = (sata_dev_t *) ahci->sata_devs[port];
     906        if (sata == NULL)
     907                return;
     908       
     909        /* Evaluate port event */
     910        if ((ahci_port_is_end_of_operation(pxis)) ||
     911            (ahci_port_is_error(pxis))) {
     912                fibril_mutex_lock(&sata->event_lock);
    670913               
    671                 pxis.u32 = ahci->memregs->ports[i].pxis;
    672                 ahci->memregs->ports[i].pxis = pxis.u32;
     914                sata->event_pxis = pxis;
     915                fibril_condvar_signal(&sata->event_condvar);
    673916               
    674                 sata_dev_t *sata = (sata_dev_t *) ahci->sata_devs[i];
    675                 if (sata != NULL) {
    676                         /* add value to shadow copy of port interrupt state register. */
    677                         sata->shadow_pxis.u32 |= pxis.u32;
    678                        
    679                         /* Evaluate port event. */
    680                         if ((ahci_port_is_end_of_operation(pxis)) ||
    681                             (ahci_port_is_error(pxis)))
    682                                 port_event_flags |= port_mask;
    683                        
    684                         if (ahci_port_is_permanent_error(pxis))
    685                                 sata->invalid_device = true;
    686                 }
    687                
    688                 port_mask <<= 1;
    689         }
    690        
    691         port_mask = 1;
    692         for (unsigned int i = 0; i < 32; i++) {
    693                 sata_dev_t *sata = (sata_dev_t *) ahci->sata_devs[i];
    694                 if ((port_event_flags & port_mask) && (sata != NULL)) {
    695                         fibril_mutex_lock(&sata->event_lock);
    696                         fibril_condvar_signal(&sata->event_condvar);
    697                         fibril_mutex_unlock(&sata->event_lock);
    698                 }
    699                
    700                 port_mask <<= 1;
    701         }
    702 }
    703 
    704 /** AHCI timer interrupt handler.
    705  *
    706  * @param arg Pointer to AHCI device.
    707  *
    708  */
    709 static void ahci_timer(void *arg)
    710 {
    711         ahci_dev_t *ahci = (ahci_dev_t *) arg;
    712        
    713         ahci_interrupt_or_timer(ahci, 1);
    714         fibril_timer_set(ahci->timer, AHCI_TIMER_TICKS, ahci_timer, ahci);
    715 }
    716 
    717 /** AHCI interrupt handler.
    718  *
    719  * @param dev Pointer to device driver handler.
    720  *
    721  */
    722 static void ahci_interrupt(ddf_dev_t *dev, ipc_callid_t iid, ipc_call_t *icall)
    723 {
    724         ahci_dev_t *ahci = (ahci_dev_t *) dev->driver_data;
    725        
    726         ahci_interrupt_or_timer(ahci, 0);
    727        
    728         /* Enable interrupt. */
    729         ahci->memregs->ghc.ghc |= 2;
     917                fibril_mutex_unlock(&sata->event_lock);
     918        }
    730919}
    731920
     
    734923/*----------------------------------------------------------------------------*/
    735924
    736 static sata_dev_t *ahci_sata_device_allocate(volatile ahci_port_t *port)
     925/** Allocate SATA device structure with buffers for hardware.
     926 *
     927 * @param port AHCI port structure
     928 *
     929 * @return SATA device structure if succeed, NULL otherwise.
     930 *
     931 */
     932static sata_dev_t *ahci_sata_allocate(ahci_dev_t *ahci, volatile ahci_port_t *port)
    737933{
    738934        size_t size = 4096;
    739         void* phys = NULL;
    740         void* virt_fb = NULL;
    741         void* virt_cmd = NULL;
    742         void* virt_table = NULL;
    743        
    744         sata_dev_t *sata = malloc(sizeof(sata_dev_t));
     935        void *phys = NULL;
     936        void *virt_fb = NULL;
     937        void *virt_cmd = NULL;
     938        void *virt_table = NULL;
     939        ddf_fun_t *fun;
     940       
     941        fun = ddf_fun_create(ahci->dev, fun_exposed, NULL);
     942       
     943        sata_dev_t *sata = ddf_fun_data_alloc(fun, sizeof(sata_dev_t));
    745944        if (sata == NULL)
    746945                return NULL;
    747946       
    748         bzero(sata, sizeof(sata_dev_t));
    749        
     947        sata->fun = fun;
    750948        sata->port = port;
    751949       
     
    763961        rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
    764962            &phys, &virt_cmd);
    765        
    766963        if (rc != EOK)
    767964                goto error_cmd;
     
    775972        rc = dmamem_map_anonymous(size, AS_AREA_READ | AS_AREA_WRITE, 0,
    776973            &phys, &virt_table);
    777        
    778974        if (rc != EOK)
    779975                goto error_table;
     
    793989        free(sata);
    794990        return NULL;
    795        
    796         /*
    797          * Deleting of pointers in memory hardware mapped register
    798          * unneccessary, hardware port is not in operational state.
    799          */
    800 }
    801 
    802 static int ahci_sata_device_create(ahci_dev_t *ahci, ddf_dev_t *dev,
     991}
     992
     993/** Initialize and start SATA hardware device.
     994 *
     995 * @param sata SATA device structure.
     996 *
     997 */
     998static void ahci_sata_hw_start(sata_dev_t *sata)
     999{
     1000        ahci_port_cmd_t pxcmd;
     1001       
     1002        pxcmd.u32 = sata->port->pxcmd;
     1003       
     1004        /* Frame receiver disabled. */
     1005        pxcmd.fre = 0;
     1006       
     1007        /* Disable process the command list. */
     1008        pxcmd.st = 0;
     1009       
     1010        sata->port->pxcmd = pxcmd.u32;
     1011       
     1012        /* Clear interrupt status. */
     1013        sata->port->pxis = 0xffffffff;
     1014       
     1015        /* Clear error status. */
     1016        sata->port->pxserr = 0xffffffff;
     1017       
     1018        /* Enable all interrupts. */
     1019        sata->port->pxie = 0xffffffff;
     1020       
     1021        /* Frame receiver enabled. */
     1022        pxcmd.fre = 1;
     1023       
     1024        /* Enable process the command list. */
     1025        pxcmd.st = 1;
     1026       
     1027        sata->port->pxcmd = pxcmd.u32;
     1028}
     1029
     1030/** Create and initialize connected SATA structure device
     1031 *
     1032 * @param ahci     AHCI device structure.
     1033 * @param dev      DDF device structure.
     1034 * @param port     AHCI port structure.
     1035 * @param port_num Number of AHCI port with existing SATA device.
     1036 *
     1037 * @return EOK if succeed, error code otherwise.
     1038 *
     1039 */
     1040static int ahci_sata_create(ahci_dev_t *ahci, ddf_dev_t *dev,
    8031041    volatile ahci_port_t *port, unsigned int port_num)
    8041042{
    8051043        ddf_fun_t *fun = NULL;
    806         sata_dev_t *sata = ahci_sata_device_allocate(port);
    807        
     1044        int rc;
     1045       
     1046        sata_dev_t *sata = ahci_sata_allocate(ahci, port);
    8081047        if (sata == NULL)
    8091048                return EINTR;
     
    8141053        ahci->sata_devs[port_num] = sata;
    8151054       
     1055        /* Initialize synchronization structures */
    8161056        fibril_mutex_initialize(&sata->lock);
    8171057        fibril_mutex_initialize(&sata->event_lock);
    8181058        fibril_condvar_initialize(&sata->event_condvar);
    8191059       
    820         /* Initialize SATA port operational registers. */
    821         sata->port->pxis = 0;
    822         sata->port->pxie = 0xffffffff;
    823         sata->port->pxserr = 0;
    824         sata->port->pxcmd |= 0x10;
    825         sata->port->pxcmd |= 0x01;
    826        
     1060        ahci_sata_hw_start(sata);
     1061       
     1062        /* Identify device. */
    8271063        if (ahci_identify_device(sata) != EOK)
    8281064                goto error;
    8291065       
     1066        /* Set required UDMA mode */
    8301067        if (ahci_set_highest_ultra_dma_mode(sata) != EOK)
    8311068                goto error;
    8321069       
    833         /* Add sata device to system. */
    834         char sata_dev_name[1024];
    835         snprintf(sata_dev_name, 1024, "ahci_%u", sata_devices_count);
     1070        /* Add device to the system */
     1071        char sata_dev_name[16];
     1072        snprintf(sata_dev_name, 16, "ahci_%u", sata_devices_count);
    8361073       
    8371074        fibril_mutex_lock(&sata_devices_count_lock);
     
    8391076        fibril_mutex_unlock(&sata_devices_count_lock);
    8401077       
    841         fun = ddf_fun_create(dev, fun_exposed, sata_dev_name);
    842         if (fun == NULL) {
    843                 ddf_msg(LVL_ERROR, "Failed creating function.");
     1078        rc= ddf_fun_set_name(sata->fun, sata_dev_name);
     1079        if (rc != EOK) {
     1080                ddf_msg(LVL_ERROR, "Failed setting function name.");
    8441081                goto error;
    8451082        }
    8461083       
    847         fun->ops = &ahci_ops;
    848         fun->driver_data = sata;
    849         int rc = ddf_fun_bind(fun);
     1084        ddf_fun_set_ops(fun, &ahci_ops);
     1085       
     1086        rc = ddf_fun_bind(fun);
    8501087        if (rc != EOK) {
    8511088                ddf_msg(LVL_ERROR, "Failed binding function.");
     
    8561093       
    8571094error:
    858         sata->invalid_device = true;
     1095        sata->is_invalid_device = true;
    8591096        if (fun != NULL)
    8601097                ddf_fun_destroy(fun);
     
    8631100}
    8641101
     1102/** Create and initialize all SATA structure devices for connected SATA drives.
     1103 *
     1104 * @param ahci AHCI device structure.
     1105 * @param dev  DDF device structure.
     1106 *
     1107 */
    8651108static void ahci_sata_devices_create(ahci_dev_t *ahci, ddf_dev_t *dev)
    8661109{
    867         for (unsigned int port_num = 0; port_num < 32; port_num++) {
     1110        for (unsigned int port_num = 0; port_num < AHCI_MAX_PORTS; port_num++) {
    8681111                /* Active ports only */
    8691112                if (!(ahci->memregs->ghc.pi & (1 << port_num)))
     
    8731116               
    8741117                /* Active devices only */
    875                 if ((port->pxssts & 0x0f) != 3)
     1118                ahci_port_ssts_t pxssts;
     1119                pxssts.u32 = port->pxssts;
     1120                if (pxssts.det != AHCI_PORT_SSTS_DET_ACTIVE)
    8761121                        continue;
    8771122               
    878                 ahci_sata_device_create(ahci, dev, port, port_num);
    879         }
    880 }
    881 
     1123                ahci_sata_create(ahci, dev, port, port_num);
     1124        }
     1125}
     1126
     1127/** Create AHCI device structure, intialize it and register interrupt routine.
     1128 *
     1129 * @param dev DDF device structure.
     1130 *
     1131 * @return AHCI device structure if succeed, NULL otherwise.
     1132 *
     1133 */
    8821134static ahci_dev_t *ahci_ahci_create(ddf_dev_t *dev)
    8831135{
    884         ahci_dev_t *ahci = malloc(sizeof(ahci_dev_t));
     1136        ahci_dev_t *ahci = ddf_dev_data_alloc(dev, sizeof(ahci_dev_t));
    8851137        if (!ahci)
    8861138                return NULL;
    8871139       
    888         bzero(ahci, sizeof(ahci_dev_t));
     1140        /* Connect to parent device */
     1141        ahci->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
     1142        if (ahci->parent_sess == NULL)
     1143                return NULL;
    8891144       
    8901145        ahci->dev = dev;
     
    8921147        hw_res_list_parsed_t hw_res_parsed;
    8931148        hw_res_list_parsed_init(&hw_res_parsed);
    894         if (hw_res_get_list_parsed(dev->parent_sess, &hw_res_parsed, 0) != EOK)
     1149        if (hw_res_get_list_parsed(ahci->parent_sess, &hw_res_parsed, 0) != EOK)
    8951150                goto error_get_res_parsed;
     1151       
     1152        /* Map AHCI registers. */
     1153        ahci->memregs = NULL;
     1154       
     1155        physmem_map((void *) (size_t) (hw_res_parsed.mem_ranges.ranges[0].address),
     1156            AHCI_MEMREGS_PAGES_COUNT, AS_AREA_READ | AS_AREA_WRITE,
     1157            (void **) &ahci->memregs);
     1158        if (ahci->memregs == NULL)
     1159                goto error_map_registers;
    8961160       
    8971161        /* Register interrupt handler */
    8981162        ahci_ranges[0].base = (size_t) hw_res_parsed.mem_ranges.ranges[0].address;
    899         ahci_ranges[0].size = sizeof(ahci_dev_t);
    900         ahci_cmds[0].addr =
    901             ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) + 1;
    902         ahci_cmds[1].addr =
    903             ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) + 2;
    904         ahci_cmds[2].addr = ahci_cmds[1].addr;
     1163        ahci_ranges[0].size = sizeof(ahci_memregs_t);
     1164       
     1165        for (unsigned int port = 0; port < AHCI_MAX_PORTS; port++) {
     1166                size_t base = port * 7;
     1167               
     1168                ahci_cmds[base].addr =
     1169                    ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) +
     1170                    AHCI_PORTS_REGISTERS_OFFSET + port * AHCI_PORT_REGISTERS_SIZE +
     1171                    AHCI_PORT_IS_REGISTER_OFFSET;
     1172                ahci_cmds[base + 2].addr = ahci_cmds[base].addr;
     1173               
     1174                ahci_cmds[base + 3].addr =
     1175                    ((uint32_t *) (size_t) hw_res_parsed.mem_ranges.ranges[0].address) +
     1176                    AHCI_GHC_IS_REGISTER_OFFSET;
     1177                ahci_cmds[base + 4].addr = ahci_cmds[base + 3].addr;
     1178        }
    9051179       
    9061180        irq_code_t ct;
    907         ct.cmdcount = 3;
     1181        ct.cmdcount = sizeof(ahci_cmds) / sizeof(irq_cmd_t);
    9081182        ct.cmds = ahci_cmds;
    909         ct.rangecount = 1;
     1183        ct.rangecount = sizeof(ahci_ranges) / sizeof(irq_pio_range_t);
    9101184        ct.ranges = ahci_ranges;
    9111185       
    9121186        int rc = register_interrupt_handler(dev, hw_res_parsed.irqs.irqs[0],
    9131187            ahci_interrupt, &ct);
    914        
    9151188        if (rc != EOK) {
    916                 ddf_msg(LVL_ERROR, "Failed register_interrupt_handler function.");
     1189                ddf_msg(LVL_ERROR, "Failed registering interrupt handler.");
    9171190                goto error_register_interrupt_handler;
    9181191        }
    9191192       
    920         if (ahci_pciintel_enable_interrupt(hw_res_parsed.irqs.irqs[0]) != EOK) {
     1193        rc = ahci_enable_interrupt(hw_res_parsed.irqs.irqs[0]);
     1194        if (rc != EOK) {
    9211195                ddf_msg(LVL_ERROR, "Failed enable interupt.");
    9221196                goto error_enable_interrupt;
    9231197        }
    9241198       
    925         /* Map AHCI register. */
    926         physmem_map((void *) (size_t) (hw_res_parsed.mem_ranges.ranges[0].address),
    927             8, AS_AREA_READ | AS_AREA_WRITE, (void **) &ahci->memregs);
    9281199        hw_res_list_parsed_clean(&hw_res_parsed);
    929        
    930         if (ahci->memregs == NULL)
    931                 goto error_map_registers;
    932        
    933         ahci->timer = fibril_timer_create();
    934        
    9351200        return ahci;
    9361201       
     1202error_enable_interrupt:
     1203        unregister_interrupt_handler(dev, hw_res_parsed.irqs.irqs[0]);
     1204       
     1205error_register_interrupt_handler:
     1206        // FIXME: unmap physical memory
     1207       
    9371208error_map_registers:
    938 error_enable_interrupt:
    939 error_register_interrupt_handler:
    9401209        hw_res_list_parsed_clean(&hw_res_parsed);
     1210       
    9411211error_get_res_parsed:
     1212        free(ahci);
    9421213        return NULL;
    9431214}
    9441215
    945 static void ahci_ahci_init(ahci_dev_t *ahci)
    946 {
    947         /* Enable interrupt and bus mastering */
    948         ahci_pcireg_cmd_t cmd;
    949        
    950         pci_config_space_read_16(ahci->dev->parent_sess, AHCI_PCI_CMD, &cmd.u16);
    951         cmd.id = 0;
    952         cmd.bme = 1;
    953         pci_config_space_write_16(ahci->dev->parent_sess, AHCI_PCI_CMD, cmd.u16);
    954        
    955         /* Set master latency timer */
    956         pci_config_space_write_8(ahci->dev->parent_sess, AHCI_PCI_MLT, 32);
    957        
    958         /* Disable command completion coalescing feature. */
     1216/** Initialize and start AHCI hardware device.
     1217 *
     1218 * @param ahci AHCI device.
     1219 *
     1220 */
     1221static void ahci_ahci_hw_start(ahci_dev_t *ahci)
     1222{
     1223        /* Disable command completion coalescing feature */
    9591224        ahci_ghc_ccc_ctl_t ccc;
     1225       
    9601226        ccc.u32 = ahci->memregs->ghc.ccc_ctl;
    9611227        ccc.en = 0;
    9621228        ahci->memregs->ghc.ccc_ctl = ccc.u32;
    9631229       
     1230        /* Set master latency timer. */
     1231        pci_config_space_write_8(ahci->parent_sess, AHCI_PCI_MLT, 32);
     1232       
     1233        /* Enable PCI interrupt and bus mastering */
     1234        ahci_pcireg_cmd_t cmd;
     1235       
     1236        pci_config_space_read_16(ahci->parent_sess, AHCI_PCI_CMD, &cmd.u16);
     1237        cmd.id = 0;
     1238        cmd.bme = 1;
     1239        pci_config_space_write_16(ahci->parent_sess, AHCI_PCI_CMD, cmd.u16);
     1240       
    9641241        /* Enable AHCI and interrupt. */
    965         ahci->memregs->ghc.ghc = AHCI_GHC_GHC_AE | AHCI_GHC_GHC_IE;
    966        
    967         /* Enable timer. */
    968         fibril_timer_set(ahci->timer, AHCI_TIMER_TICKS, ahci_timer, ahci);
    969 }
    970 
     1242        ahci->memregs->ghc.ghc = AHCI_GHC_GHC_AE | AHCI_GHC_GHC_IE;
     1243}
     1244
     1245/** AHCI device driver initialization
     1246 *
     1247 * Create and initialize all SATA structure devices for connected
     1248 * SATA drives.
     1249 *
     1250 * @param dev DDF device structure.
     1251 *
     1252 * @return EOK if succeed, error code otherwise.
     1253 *
     1254 */
    9711255static int ahci_dev_add(ddf_dev_t *dev)
    9721256{
    973         dev->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    974             dev->handle, IPC_FLAG_BLOCKING);
    975         if (dev->parent_sess == NULL)
    976                 return EINTR;
    977        
    9781257        ahci_dev_t *ahci = ahci_ahci_create(dev);
    9791258        if (ahci == NULL)
    980                 return EINTR;
    981        
    982         dev->driver_data = ahci;
    983         ahci_ahci_init(ahci);
     1259                goto error;
     1260       
     1261        /* Start AHCI hardware. */
     1262        ahci_ahci_hw_start(ahci);
     1263       
     1264        /* Create device structures for sata devices attached to AHCI. */
    9841265        ahci_sata_devices_create(ahci, dev);
    9851266       
    9861267        return EOK;
     1268       
     1269error:
     1270        return EINTR;
    9871271}
    9881272
     
    9911275/*----------------------------------------------------------------------------*/
    9921276
     1277/** Convert SATA model name
     1278 *
     1279 * Convert SATA model name from machine format returned by
     1280 * identify device command to human readable form.
     1281 *
     1282 * @param src Source buffer with device name in machine format.
     1283 * @param dst Buffer for human readable string, minimum size is 41 chars.
     1284 *
     1285 */
    9931286static void ahci_get_model_name(uint16_t *src, char *dst)
    9941287{
     
    10181311}
    10191312
    1020 static int ahci_pciintel_enable_interrupt(int irq)
     1313/** Enable interrupt using SERVICE_IRC.
     1314 *
     1315 * @param irq Requested irq number.
     1316 *
     1317 * @return EOK if succeed, error code otherwise.
     1318 *
     1319 */
     1320static int ahci_enable_interrupt(int irq)
    10211321{
    10221322        async_sess_t *irc_sess = NULL;
    10231323        irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_IRC, 0, 0);
    1024        
    10251324        if (!irc_sess)
    10261325                return EINTR;
     
    10411340{
    10421341        printf("%s: HelenOS AHCI device driver\n", NAME);
    1043         ddf_log_init(NAME, LVL_ERROR);
     1342        ddf_log_init(NAME);
    10441343        fibril_mutex_initialize(&sata_devices_count_lock);
    10451344        return ddf_driver_main(&ahci_driver);
Note: See TracChangeset for help on using the changeset viewer.