Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b224a3e in mainline


Ignore:
Timestamp:
2012-08-15T23:55:32Z (8 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
master
Children:
681a985
Parents:
71b0d4d4 (diff), b8b742e (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.
Message:

Merge mainline changes

Files:
4 added
25 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.common

    r71b0d4d4 rb224a3e  
    108108        $(USPACE_PATH)/srv/fs/ext4fs/ext4fs \
    109109        $(USPACE_PATH)/srv/hid/remcons/remcons \
     110        $(USPACE_PATH)/srv/hid/isdv4_tablet/isdv4_tablet \
    110111        $(USPACE_PATH)/srv/net/ethip/ethip \
    111112        $(USPACE_PATH)/srv/net/inetsrv/inetsrv \
  • uspace/Makefile

    r71b0d4d4 rb224a3e  
    102102        srv/hid/console \
    103103        srv/hid/s3c24xx_ts \
     104        srv/hid/isdv4_tablet \
    104105        srv/hid/fb \
    105106        srv/hid/input \
  • uspace/app/edit/edit.c

    r71b0d4d4 rb224a3e  
    126126static int file_save_range(char const *fname, spt_t const *spos,
    127127    spt_t const *epos);
    128 static char *filename_prompt(char const *prompt, char const *init_value);
    129128static char *range_get_str(spt_t const *spos, spt_t const *epos);
     129
     130static char *prompt(char const *prompt, char const *init_value);
    130131
    131132static void pane_text_display(void);
     
    142143static void caret_move_word_left(void);
    143144static void caret_move_word_right(void);
     145static void caret_move_to_line(int row);
     146static void caret_go_to_line_ask(void);
    144147
    145148static bool selection_active(void);
     
    404407                caret_move_word_left();
    405408                break;
     409        case KC_L:
     410                caret_go_to_line_ask();
     411                break;
    406412        default:
    407413                break;
     
    520526        char *fname;
    521527       
    522         fname = filename_prompt("Save As", old_fname);
     528        fname = prompt("Save As", old_fname);
    523529        if (fname == NULL) {
    524530                status_display("Save cancelled.");
     
    535541}
    536542
    537 /** Ask for a file name. */
    538 static char *filename_prompt(char const *prompt, char const *init_value)
     543/** Ask for a string. */
     544static char *prompt(char const *prompt, char const *init_value)
    539545{
    540546        kbd_event_t ev;
     
    842848                /* Fill until the end of display area. */
    843849
    844                 if (str_length(row_buf) < (unsigned) scr_columns)
    845                         fill = scr_columns - str_length(row_buf);
     850                if ((unsigned)s_column - 1 < scr_columns)
     851                        fill = scr_columns - (s_column - 1);
    846852                else
    847853                        fill = 0;
     
    10771083        pane.rflags |= REDRAW_TEXT;
    10781084}
     1085
     1086/** Change the caret position to a beginning of a given line
     1087 */
     1088static void caret_move_to_line(int row)
     1089{
     1090        spt_t pt;
     1091        coord_t coord;
     1092        int num_rows;
     1093
     1094        tag_get_pt(&pane.caret_pos, &pt);
     1095        spt_get_coord(&pt, &coord);
     1096        coord.row = row;
     1097        coord.column = 1;
     1098
     1099        /* Clamp coordinates. */
     1100        if (coord.row < 1) coord.row = 1;
     1101        sheet_get_num_rows(&doc.sh, &num_rows);
     1102        if (coord.row > num_rows) coord.row = num_rows;
     1103
     1104        /*
     1105         * Select the point before the character at the designated
     1106         * coordinates. The character can be wider than one cell (e.g. tab).
     1107         */
     1108        sheet_get_cell_pt(&doc.sh, &coord, dir_before, &pt);
     1109        sheet_remove_tag(&doc.sh, &pane.caret_pos);
     1110        sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
     1111
     1112        /* Set the new value for @c ideal_column. */
     1113        spt_get_coord(&pt, &coord);
     1114        pane.ideal_column = coord.column;
     1115
     1116        caret_update();
     1117}
     1118
     1119/** Ask for line and go to it. */
     1120static void caret_go_to_line_ask(void)
     1121{
     1122        char *sline;
     1123       
     1124        sline = prompt("Go to line", "");
     1125        if (sline == NULL) {
     1126                status_display("Go to line cancelled.");
     1127                return;
     1128        }
     1129       
     1130        char *endptr;
     1131        int line = strtol(sline, &endptr, 10);
     1132        if (*endptr != '\0') {
     1133                status_display("Invalid number entered.");
     1134                return;
     1135        }
     1136       
     1137        caret_move_to_line(line);
     1138}
     1139
    10791140
    10801141/** Check for non-empty selection. */
  • uspace/app/sportdmp/sportdmp.c

    r71b0d4d4 rb224a3e  
    140140                ssize_t i;
    141141                for (i = 0; i < read; i++) {
    142                         if ((buf[i] >= 32) && (buf[i] < 128))
    143                                 putchar((wchar_t) buf[i]);
    144                         else
    145                                 putchar('.');
    146                         fflush(stdout);
     142                        printf("%02hhx ", buf[i]);
    147143                }
     144                fflush(stdout);
    148145        }
    149146       
  • uspace/drv/bus/usb/usbmast/main.c

    r71b0d4d4 rb224a3e  
    8282    void *arg);
    8383
    84 static int usbmast_bd_open(bd_srv_t *);
     84static int usbmast_bd_open(bd_srvs_t *, bd_srv_t *);
    8585static int usbmast_bd_close(bd_srv_t *);
    8686static int usbmast_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    100100static usbmast_fun_t *bd_srv_usbmast(bd_srv_t *bd)
    101101{
    102         return (usbmast_fun_t *)bd->arg;
     102        return (usbmast_fun_t *)bd->srvs->sarg;
    103103}
    104104
     
    240240        mfun->lun = lun;
    241241
    242         bd_srv_init(&mfun->bd);
    243         mfun->bd.ops = &usbmast_bd_ops;
    244         mfun->bd.arg = mfun;
     242        bd_srvs_init(&mfun->bds);
     243        mfun->bds.ops = &usbmast_bd_ops;
     244        mfun->bds.sarg = mfun;
    245245
    246246        /* Set up a connection handler. */
     
    311311
    312312        mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
    313         bd_conn(iid, icall, &mfun->bd);
     313        bd_conn(iid, icall, &mfun->bds);
    314314}
    315315
    316316/** Open device. */
    317 static int usbmast_bd_open(bd_srv_t *bd)
     317static int usbmast_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    318318{
    319319        return EOK;
  • uspace/drv/bus/usb/usbmast/usbmast.h

    r71b0d4d4 rb224a3e  
    6969        /** Block size in bytes */
    7070        size_t block_size;
    71         /** Block device server structure */
    72         bd_srv_t bd;
     71        /** Block device service structure */
     72        bd_srvs_t bds;
    7373} usbmast_fun_t;
    7474
  • uspace/drv/char/ns8250/cyclic_buffer.h

    r71b0d4d4 rb224a3e  
    3636#define CYCLIC_BUFFER_H_
    3737
    38 #define BUF_LEN 256
     38#define BUF_LEN 4096
    3939
    4040typedef struct cyclic_buffer {
  • uspace/drv/char/ns8250/ns8250.c

    r71b0d4d4 rb224a3e  
    8282/** Interrupt ID Register definition. */
    8383#define NS8250_IID_ACTIVE       (1 << 0)
     84#define NS8250_IID_CAUSE_MASK 0x0e
     85#define NS8250_IID_CAUSE_RXSTATUS 0x06
    8486
    8587/** FIFO Control Register definition. */
     
    179181        /** The fibril mutex for synchronizing the access to the device. */
    180182        fibril_mutex_t mutex;
     183        /** Indicates that some data has become available */
     184        fibril_condvar_t input_buffer_available;
    181185        /** True if device is removed. */
    182186        bool removed;
     
    238242{
    239243        ns8250_t *ns = NS8250(fun);
    240         int ret = EOK;
     244        int ret = 0;
     245       
     246        if (count == 0) return 0;
    241247       
    242248        fibril_mutex_lock(&ns->mutex);
     249        while (buf_is_empty(&ns->input_buffer))
     250                fibril_condvar_wait(&ns->input_buffer_available, &ns->mutex);
    243251        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
    244252                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
     
    460468{
    461469        /* Interrupt when data received. */
    462         pio_write_8(&regs->ier, NS8250_IER_RXREADY);
     470        pio_write_8(&regs->ier, NS8250_IER_RXREADY | NS8250_IER_RXSTATUS);
    463471        pio_write_8(&regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
    464472            | NS8250_MCR_OUT2);
     
    499507        async_exchange_end(exch);
    500508
     509        /* Read LSR to clear possible previous LSR interrupt */
     510        pio_read_8(&ns->regs->lsr);
     511
    501512        /* Enable interrupt on the serial port. */
    502513        ns8250_port_interrupts_enable(ns->regs);
     
    695706        /* 8 bits, no parity, two stop bits. */
    696707        ns8250_port_set_com_props(ns->regs, SERIAL_NO_PARITY, 8, 2);
    697         /* Enable FIFO, clear them, with 14-byte threshold. */
     708        /*
     709         * Enable FIFO, clear them, with 4-byte threshold for greater
     710         * reliability.
     711         */
    698712        pio_write_8(&ns->regs->iid, NS8250_FCR_FIFOENABLE
    699             | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET 
    700             | NS8250_FCR_RXTRIGGERLOW | NS8250_FCR_RXTRIGGERHI);
     713            | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET
     714            | NS8250_FCR_RXTRIGGERLOW);
    701715        /*
    702716         * RTS/DSR set (Request to Send and Data Terminal Ready lines enabled),
     
    731745        bool cont = true;
    732746       
     747        fibril_mutex_lock(&ns->mutex);
    733748        while (cont) {
    734                 fibril_mutex_lock(&ns->mutex);
    735                
    736749                cont = ns8250_received(regs);
    737750                if (cont) {
     
    739752                       
    740753                        if (ns->client_connected) {
     754                                bool buf_was_empty = buf_is_empty(&ns->input_buffer);
    741755                                if (!buf_push_back(&ns->input_buffer, val)) {
    742756                                        ddf_msg(LVL_WARN, "Buffer overflow on "
    743757                                            "%s.", ns->dev->name);
     758                                        break;
    744759                                } else {
    745760                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
    746761                                            "to the buffer of %s.",
    747762                                            val, ns->dev->name);
     763                                        if (buf_was_empty)
     764                                                fibril_condvar_broadcast(&ns->input_buffer_available);
    748765                                }
    749766                        }
    750767                }
    751                
    752                 fibril_mutex_unlock(&ns->mutex);
    753                 fibril_yield();
    754         }
     768        }
     769        fibril_mutex_unlock(&ns->mutex);
     770        fibril_yield();
    755771}
    756772
    757773/** The interrupt handler.
    758774 *
    759  * The serial port is initialized to interrupt when some data come, so the
    760  * interrupt is handled by reading the incomming data.
     775 * The serial port is initialized to interrupt when some data come or line
     776 * status register changes, so the interrupt is handled by reading the incoming
     777 * data and reading the line status register.
    761778 *
    762779 * @param dev           The serial port device.
     
    765782    ipc_call_t *icall)
    766783{
    767         ns8250_read_from_device(NS8250_FROM_DEV(dev));
     784        ns8250_t *ns = NS8250_FROM_DEV(dev);
     785
     786        uint8_t iir = pio_read_8(&ns->regs->iid);
     787        if ((iir & NS8250_IID_CAUSE_MASK) == NS8250_IID_CAUSE_RXSTATUS) {
     788                uint8_t lsr = pio_read_8(&ns->regs->lsr);
     789                if (lsr & NS8250_LSR_OE) {
     790                        ddf_msg(LVL_WARN, "Overrun error on %s", ns->dev->name);
     791                }
     792        }
     793       
     794        ns8250_read_from_device(ns);
    768795}
    769796
     
    811838       
    812839        fibril_mutex_initialize(&ns->mutex);
     840        fibril_condvar_initialize(&ns->input_buffer_available);
    813841        ns->dev = dev;
    814842       
     
    10531081static void ns8250_init(void)
    10541082{
    1055         ddf_log_init(NAME, LVL_ERROR);
     1083        ddf_log_init(NAME, LVL_WARN);
    10561084       
    10571085        ns8250_dev_ops.open = &ns8250_open;
  • uspace/lib/c/generic/bd_srv.c

    r71b0d4d4 rb224a3e  
    6767        }
    6868
    69         if (srv->ops->read_blocks == NULL) {
     69        if (srv->srvs->ops->read_blocks == NULL) {
    7070                async_answer_0(rcallid, ENOTSUP);
    7171                async_answer_0(callid, ENOTSUP);
     
    7373        }
    7474
    75         rc = srv->ops->read_blocks(srv, ba, cnt, buf, size);
     75        rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
    7676        if (rc != EOK) {
    7777                async_answer_0(rcallid, ENOMEM);
     
    109109        }
    110110
    111         if (srv->ops->read_toc == NULL) {
     111        if (srv->srvs->ops->read_toc == NULL) {
    112112                async_answer_0(rcallid, ENOTSUP);
    113113                async_answer_0(callid, ENOTSUP);
     
    115115        }
    116116
    117         rc = srv->ops->read_toc(srv, session, buf, size);
     117        rc = srv->srvs->ops->read_toc(srv, session, buf, size);
    118118        if (rc != EOK) {
    119119                async_answer_0(rcallid, ENOMEM);
     
    146146        }
    147147
    148         if (srv->ops->write_blocks == NULL) {
    149                 async_answer_0(callid, ENOTSUP);
    150                 return;
    151         }
    152 
    153         rc = srv->ops->write_blocks(srv, ba, cnt, data, size);
     148        if (srv->srvs->ops->write_blocks == NULL) {
     149                async_answer_0(callid, ENOTSUP);
     150                return;
     151        }
     152
     153        rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
    154154        free(data);
    155155        async_answer_0(callid, rc);
     
    162162        size_t block_size;
    163163
    164         if (srv->ops->get_block_size == NULL) {
    165                 async_answer_0(callid, ENOTSUP);
    166                 return;
    167         }
    168 
    169         rc = srv->ops->get_block_size(srv, &block_size);
     164        if (srv->srvs->ops->get_block_size == NULL) {
     165                async_answer_0(callid, ENOTSUP);
     166                return;
     167        }
     168
     169        rc = srv->srvs->ops->get_block_size(srv, &block_size);
    170170        async_answer_1(callid, rc, block_size);
    171171}
     
    177177        aoff64_t num_blocks;
    178178
    179         if (srv->ops->get_num_blocks == NULL) {
    180                 async_answer_0(callid, ENOTSUP);
    181                 return;
    182         }
    183 
    184         rc = srv->ops->get_num_blocks(srv, &num_blocks);
     179        if (srv->srvs->ops->get_num_blocks == NULL) {
     180                async_answer_0(callid, ENOTSUP);
     181                return;
     182        }
     183
     184        rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
    185185        async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
    186186}
    187187
    188 void bd_srv_init(bd_srv_t *srv)
    189 {
    190         fibril_mutex_initialize(&srv->lock);
    191         srv->connected = false;
    192         srv->ops = NULL;
    193         srv->arg = NULL;
    194         srv->client_sess = NULL;
    195 }
    196 
    197 int bd_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    198 {
    199         bd_srv_t *srv = (bd_srv_t *)arg;
    200         int rc;
    201 
    202         fibril_mutex_lock(&srv->lock);
    203         if (srv->connected) {
    204                 fibril_mutex_unlock(&srv->lock);
    205                 async_answer_0(iid, EBUSY);
    206                 return EBUSY;
    207         }
    208 
    209         srv->connected = true;
    210         fibril_mutex_unlock(&srv->lock);
     188static bd_srv_t *bd_srv_create(bd_srvs_t *srvs)
     189{
     190        bd_srv_t *srv;
     191
     192        srv = calloc(1, sizeof(srv));
     193        if (srv == NULL)
     194                return NULL;
     195
     196        srv->srvs = srvs;
     197        return srv;
     198}
     199
     200void bd_srvs_init(bd_srvs_t *srvs)
     201{
     202        srvs->ops = NULL;
     203        srvs->sarg = NULL;
     204}
     205
     206int bd_conn(ipc_callid_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
     207{
     208        bd_srv_t *srv;
     209        int rc;
    211210
    212211        /* Accept the connection */
    213212        async_answer_0(iid, EOK);
     213
     214        srv = bd_srv_create(srvs);
     215        if (srv == NULL)
     216                return ENOMEM;
    214217
    215218        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
     
    219222        srv->client_sess = sess;
    220223
    221         rc = srv->ops->open(srv);
     224        rc = srvs->ops->open(srvs, srv);
    222225        if (rc != EOK)
    223226                return rc;
     
    230233                if (!method) {
    231234                        /* The other side has hung up */
    232                         fibril_mutex_lock(&srv->lock);
    233                         srv->connected = false;
    234                         fibril_mutex_unlock(&srv->lock);
    235235                        async_answer_0(callid, EOK);
    236236                        break;
     
    258258        }
    259259
    260         return srv->ops->close(srv);
     260        rc = srvs->ops->close(srv);
     261        free(srv);
     262
     263        return rc;
    261264}
    262265
  • uspace/lib/c/include/bd_srv.h

    r71b0d4d4 rb224a3e  
    3636#define LIBC_BD_SRV_H_
    3737
     38#include <adt/list.h>
    3839#include <async.h>
    3940#include <fibril_synch.h>
     
    4344typedef struct bd_ops bd_ops_t;
    4445
     46/** Service setup (per sevice) */
    4547typedef struct {
    46         fibril_mutex_t lock;
    47         bool connected;
    4848        bd_ops_t *ops;
    49         void *arg;
     49        void *sarg;
     50} bd_srvs_t;
     51
     52/** Server structure (per client session) */
     53typedef struct {
     54        bd_srvs_t *srvs;
    5055        async_sess_t *client_sess;
     56        void *carg;
    5157} bd_srv_t;
    5258
    5359typedef struct bd_ops {
    54         int (*open)(bd_srv_t *);
     60        int (*open)(bd_srvs_t *, bd_srv_t *);
    5561        int (*close)(bd_srv_t *);
    5662        int (*read_blocks)(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    6167} bd_ops_t;
    6268
    63 extern void bd_srv_init(bd_srv_t *);
     69extern void bd_srvs_init(bd_srvs_t *);
    6470
    65 extern int bd_conn(ipc_callid_t, ipc_call_t *, void *);
     71extern int bd_conn(ipc_callid_t, ipc_call_t *, bd_srvs_t *);
    6672
    6773#endif
  • uspace/lib/c/include/ipc/input.h

    r71b0d4d4 rb224a3e  
    4646        INPUT_EVENT_KEY = IPC_FIRST_USER_METHOD,
    4747        INPUT_EVENT_MOVE,
     48        INPUT_EVENT_ABS_MOVE,
    4849        INPUT_EVENT_BUTTON
    4950} input_notif_t;
  • uspace/lib/c/include/ipc/mouseev.h

    r71b0d4d4 rb224a3e  
    4747typedef enum {
    4848        MOUSEEV_MOVE_EVENT = IPC_FIRST_USER_METHOD,
     49        MOUSEEV_ABS_MOVE_EVENT,
    4950        MOUSEEV_BUTTON_EVENT
    5051} mouseev_notif_t;
  • uspace/srv/bd/ata_bd/ata_bd.c

    r71b0d4d4 rb224a3e  
    104104static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    105105
    106 static int ata_bd_open(bd_srv_t *);
     106static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
    107107static int ata_bd_close(bd_srv_t *);
    108108static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
     
    114114static int ata_bd_get_num_blocks(bd_srv_t *, aoff64_t *);
    115115
    116 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
     116static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t cnt,
    117117    void *buf);
    118 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     118static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    119119    const void *buf);
    120120static int disk_init(disk_t *d, int disk_id);
    121 static int drive_identify(int drive_id, void *buf);
    122 static int identify_pkt_dev(int dev_idx, void *buf);
    123 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
     121static int drive_identify(disk_t *disk, void *buf);
     122static int identify_pkt_dev(disk_t *disk, void *buf);
     123static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    124124    void *obuf, size_t obuf_size);
    125 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
    126 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
     125static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size);
     126static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    127127    void *obuf, size_t obuf_size);
    128 static int ata_pcmd_read_toc(int dev_idx, uint8_t ses,
     128static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
    129129    void *obuf, size_t obuf_size);
    130130static void disk_print_summary(disk_t *d);
     
    146146static disk_t *bd_srv_disk(bd_srv_t *bd)
    147147{
    148         return (disk_t *)bd->arg;
     148        return (disk_t *)bd->srvs->sarg;
     149}
     150
     151static int disk_dev_idx(disk_t *disk)
     152{
     153        return (disk->disk_id & 1);
    149154}
    150155
     
    296301{
    297302        service_id_t dsid;
    298         int disk_id, i;
     303        int i;
     304        disk_t *disk;
    299305
    300306        /* Get the device service ID. */
     
    302308
    303309        /* Determine which disk device is the client connecting to. */
    304         disk_id = -1;
     310        disk = NULL;
    305311        for (i = 0; i < MAX_DISKS; i++)
    306312                if (ata_disk[i].service_id == dsid)
    307                         disk_id = i;
    308 
    309         if (disk_id < 0 || ata_disk[disk_id].present == false) {
     313                        disk = &ata_disk[i];
     314
     315        if (disk == NULL || disk->present == false) {
    310316                async_answer_0(iid, EINVAL);
    311317                return;
    312318        }
    313319
    314         bd_conn(iid, icall, &ata_disk[disk_id].bd);
     320        bd_conn(iid, icall, &disk->bds);
    315321}
    316322
     
    336342        fibril_mutex_initialize(&d->lock);
    337343
    338         bd_srv_init(&d->bd);
    339         d->bd.ops = &ata_bd_ops;
    340         d->bd.arg = d;
     344        bd_srvs_init(&d->bds);
     345        d->bds.ops = &ata_bd_ops;
     346        d->bds.sarg = d;
    341347
    342348        /* Try identify command. */
    343         rc = drive_identify(disk_id, &idata);
     349        rc = drive_identify(d, &idata);
    344350        if (rc == EOK) {
    345351                /* Success. It's a register (non-packet) device. */
     
    361367
    362368                if (bc == PDEV_SIGNATURE_BC) {
    363                         rc = identify_pkt_dev(disk_id, &idata);
     369                        rc = identify_pkt_dev(d, &idata);
    364370                        if (rc == EOK) {
    365371                                /* We have a packet device. */
     
    445451        if (d->dev_type == ata_pkt_dev) {
    446452                /* Send inquiry. */
    447                 rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
     453                rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
    448454                if (rc != EOK) {
    449455                        printf("Device inquiry failed.\n");
     
    467473}
    468474
    469 static int ata_bd_open(bd_srv_t *bd)
     475static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    470476{
    471477        return EOK;
     
    488494
    489495        while (cnt > 0) {
    490                 if (disk->dev_type == ata_reg_dev)
    491                         rc = ata_rcmd_read(disk->disk_id, ba, 1, buf);
    492                 else
    493                         rc = ata_pcmd_read_12(disk->disk_id, ba, 1, buf,
     496                if (disk->dev_type == ata_reg_dev) {
     497                        rc = ata_rcmd_read(disk, ba, 1, buf);
     498                } else {
     499                        rc = ata_pcmd_read_12(disk, ba, 1, buf,
    494500                            disk->block_size);
     501                }
    495502
    496503                if (rc != EOK)
     
    510517        disk_t *disk = bd_srv_disk(bd);
    511518
    512         return ata_pcmd_read_toc(disk->disk_id, session, buf, size);
     519        return ata_pcmd_read_toc(disk, session, buf, size);
    513520}
    514521
     
    527534
    528535        while (cnt > 0) {
    529                 rc = ata_rcmd_write(disk->disk_id, ba, 1, buf);
     536                rc = ata_rcmd_write(disk, ba, 1, buf);
    530537                if (rc != EOK)
    531538                        return rc;
     
    562569 * whether an ATA device is present and if so, to determine its parameters.
    563570 *
    564  * @param disk_id       Device ID, 0 or 1.
     571 * @param disk          Disk
    565572 * @param buf           Pointer to a 512-byte buffer.
    566573 *
     
    568575 *                      not present). EIO if device responds with error.
    569576 */
    570 static int drive_identify(int disk_id, void *buf)
     577static int drive_identify(disk_t *disk, void *buf)
    571578{
    572579        uint16_t data;
     
    575582        size_t i;
    576583
    577         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
     584        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    578585
    579586        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     
    621628 * whether an ATAPI device is present and if so, to determine its parameters.
    622629 *
    623  * @param dev_idx       Device index, 0 or 1.
     630 * @param disk          Disk
    624631 * @param buf           Pointer to a 512-byte buffer.
    625632 */
    626 static int identify_pkt_dev(int dev_idx, void *buf)
     633static int identify_pkt_dev(disk_t *disk, void *buf)
    627634{
    628635        uint16_t data;
     
    631638        size_t i;
    632639
    633         drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
     640        drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    634641
    635642        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     
    666673 * Only data-in commands are supported (e.g. inquiry, read).
    667674 *
    668  * @param dev_idx       Device index (0 or 1)
     675 * @param disk          Disk
    669676 * @param obuf          Buffer for storing data read from device
    670677 * @param obuf_size     Size of obuf in bytes
     
    672679 * @return EOK on success, EIO on error.
    673680 */
    674 static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
     681static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
    675682    void *obuf, size_t obuf_size)
    676683{
     
    678685        uint8_t status;
    679686        uint8_t drv_head;
    680         disk_t *d;
    681687        size_t data_size;
    682688        uint16_t val;
    683689
    684         d = &ata_disk[dev_idx];
    685         fibril_mutex_lock(&d->lock);
     690        fibril_mutex_lock(&disk->lock);
    686691
    687692        /* New value for Drive/Head register */
    688693        drv_head =
    689             ((dev_idx != 0) ? DHR_DRV : 0);
     694            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
    690695
    691696        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    692                 fibril_mutex_unlock(&d->lock);
     697                fibril_mutex_unlock(&disk->lock);
    693698                return EIO;
    694699        }
     
    697702
    698703        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    699                 fibril_mutex_unlock(&d->lock);
     704                fibril_mutex_unlock(&disk->lock);
    700705                return EIO;
    701706        }
     
    708713
    709714        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    710                 fibril_mutex_unlock(&d->lock);
     715                fibril_mutex_unlock(&disk->lock);
    711716                return EIO;
    712717        }
     
    717722
    718723        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    719                 fibril_mutex_unlock(&d->lock);
     724                fibril_mutex_unlock(&disk->lock);
    720725                return EIO;
    721726        }
    722727
    723728        if ((status & SR_DRQ) == 0) {
    724                 fibril_mutex_unlock(&d->lock);
     729                fibril_mutex_unlock(&disk->lock);
    725730                return EIO;
    726731        }
     
    733738        if (data_size > obuf_size) {
    734739                /* Output buffer is too small to store data. */
    735                 fibril_mutex_unlock(&d->lock);
     740                fibril_mutex_unlock(&disk->lock);
    736741                return EIO;
    737742        }
     
    744749
    745750        if (status & SR_ERR) {
    746                 fibril_mutex_unlock(&d->lock);
    747                 return EIO;
    748         }
    749 
    750         fibril_mutex_unlock(&d->lock);
     751                fibril_mutex_unlock(&disk->lock);
     752                return EIO;
     753        }
     754
     755        fibril_mutex_unlock(&disk->lock);
    751756
    752757        return EOK;
     
    755760/** Issue ATAPI Inquiry.
    756761 *
    757  * @param dev_idx       Device index (0 or 1)
     762 * @param disk          Disk
    758763 * @param obuf          Buffer for storing inquiry data read from device
    759764 * @param obuf_size     Size of obuf in bytes
     
    761766 * @return EOK on success, EIO on error.
    762767 */
    763 static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
     768static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size)
    764769{
    765770        ata_pcmd_inquiry_t cp;
     
    771776        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    772777
    773         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     778        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    774779        if (rc != EOK)
    775780                return rc;
     
    783788 * function will fail.
    784789 *
    785  * @param dev_idx       Device index (0 or 1)
     790 * @param disk          Disk
    786791 * @param ba            Starting block address
    787792 * @param cnt           Number of blocks to read
     
    791796 * @return EOK on success, EIO on error.
    792797 */
    793 static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
     798static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
    794799    void *obuf, size_t obuf_size)
    795800{
     
    806811        cp.nblocks = host2uint32_t_be(cnt);
    807812
    808         rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
     813        rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
    809814        if (rc != EOK)
    810815                return rc;
     
    823828 * function will fail.
    824829 *
    825  * @param dev_idx       Device index (0 or 1)
     830 * @param disk          Disk
    826831 * @param session       Starting session
    827832 * @param obuf          Buffer for storing inquiry data read from device
     
    830835 * @return EOK on success, EIO on error.
    831836 */
    832 static int ata_pcmd_read_toc(int dev_idx, uint8_t session, void *obuf,
     837static int ata_pcmd_read_toc(disk_t *disk, uint8_t session, void *obuf,
    833838    size_t obuf_size)
    834839{
     
    854859/** Read a physical from the device.
    855860 *
    856  * @param disk_id       Device index (0 or 1)
     861 * @param disk          Disk
    857862 * @param ba            Address the first block.
    858863 * @param cnt           Number of blocks to transfer.
     
    861866 * @return EOK on success, EIO on error.
    862867 */
    863 static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
     868static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t blk_cnt,
    864869    void *buf)
    865870{
     
    868873        uint8_t status;
    869874        uint8_t drv_head;
    870         disk_t *d;
    871875        block_coord_t bc;
    872876
    873         d = &ata_disk[disk_id];
    874        
    875877        /* Silence warning. */
    876878        memset(&bc, 0, sizeof(bc));
    877879
    878880        /* Compute block coordinates. */
    879         if (coord_calc(d, ba, &bc) != EOK)
     881        if (coord_calc(disk, ba, &bc) != EOK)
    880882                return EINVAL;
    881883
    882884        /* New value for Drive/Head register */
    883885        drv_head =
    884             ((disk_id != 0) ? DHR_DRV : 0) |
    885             ((d->amode != am_chs) ? DHR_LBA : 0) |
     886            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     887            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    886888            (bc.h & 0x0f);
    887889
    888         fibril_mutex_lock(&d->lock);
     890        fibril_mutex_lock(&disk->lock);
    889891
    890892        /* Program a Read Sectors operation. */
    891893
    892894        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    893                 fibril_mutex_unlock(&d->lock);
     895                fibril_mutex_unlock(&disk->lock);
    894896                return EIO;
    895897        }
     
    898900
    899901        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    900                 fibril_mutex_unlock(&d->lock);
     902                fibril_mutex_unlock(&disk->lock);
    901903                return EIO;
    902904        }
     
    905907        coord_sc_program(&bc, 1);
    906908
    907         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     909        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    908910            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    909911
    910912        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    911                 fibril_mutex_unlock(&d->lock);
     913                fibril_mutex_unlock(&disk->lock);
    912914                return EIO;
    913915        }
     
    916918                /* Read data from the device buffer. */
    917919
    918                 for (i = 0; i < ata_disk[disk_id].block_size / 2; i++) {
     920                for (i = 0; i < disk->block_size / 2; i++) {
    919921                        data = pio_read_16(&cmd->data_port);
    920922                        ((uint16_t *) buf)[i] = data;
     
    925927                return EIO;
    926928
    927         fibril_mutex_unlock(&d->lock);
     929        fibril_mutex_unlock(&disk->lock);
    928930        return EOK;
    929931}
     
    931933/** Write a physical block to the device.
    932934 *
    933  * @param disk_id       Device index (0 or 1)
     935 * @param disk          Disk
    934936 * @param ba            Address of the first block.
    935937 * @param cnt           Number of blocks to transfer.
     
    938940 * @return EOK on success, EIO on error.
    939941 */
    940 static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
     942static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
    941943    const void *buf)
    942944{
     
    944946        uint8_t status;
    945947        uint8_t drv_head;
    946         disk_t *d;
    947948        block_coord_t bc;
    948949
    949         d = &ata_disk[disk_id];
    950        
    951950        /* Silence warning. */
    952951        memset(&bc, 0, sizeof(bc));
    953952
    954953        /* Compute block coordinates. */
    955         if (coord_calc(d, ba, &bc) != EOK)
     954        if (coord_calc(disk, ba, &bc) != EOK)
    956955                return EINVAL;
    957956
    958957        /* New value for Drive/Head register */
    959958        drv_head =
    960             ((disk_id != 0) ? DHR_DRV : 0) |
    961             ((d->amode != am_chs) ? DHR_LBA : 0) |
     959            ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
     960            ((disk->amode != am_chs) ? DHR_LBA : 0) |
    962961            (bc.h & 0x0f);
    963962
    964         fibril_mutex_lock(&d->lock);
     963        fibril_mutex_lock(&disk->lock);
    965964
    966965        /* Program a Write Sectors operation. */
    967966
    968967        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    969                 fibril_mutex_unlock(&d->lock);
     968                fibril_mutex_unlock(&disk->lock);
    970969                return EIO;
    971970        }
     
    974973
    975974        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    976                 fibril_mutex_unlock(&d->lock);
     975                fibril_mutex_unlock(&disk->lock);
    977976                return EIO;
    978977        }
     
    981980        coord_sc_program(&bc, 1);
    982981
    983         pio_write_8(&cmd->command, d->amode == am_lba48 ?
     982        pio_write_8(&cmd->command, disk->amode == am_lba48 ?
    984983            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    985984
    986985        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    987                 fibril_mutex_unlock(&d->lock);
     986                fibril_mutex_unlock(&disk->lock);
    988987                return EIO;
    989988        }
     
    992991                /* Write data to the device buffer. */
    993992
    994                 for (i = 0; i < d->block_size / 2; i++) {
     993                for (i = 0; i < disk->block_size / 2; i++) {
    995994                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    996995                }
    997996        }
    998997
    999         fibril_mutex_unlock(&d->lock);
     998        fibril_mutex_unlock(&disk->lock);
    1000999
    10011000        if (status & SR_ERR)
  • uspace/srv/bd/ata_bd/ata_bd.h

    r71b0d4d4 rb224a3e  
    119119        service_id_t service_id;
    120120        int disk_id;
    121         bd_srv_t bd;
     121        bd_srvs_t bds;
    122122} disk_t;
    123123
  • uspace/srv/bd/file_bd/file_bd.c

    r71b0d4d4 rb224a3e  
    6262
    6363static service_id_t service_id;
    64 static bd_srv_t bd_srv;
     64static bd_srvs_t bd_srvs;
    6565static fibril_mutex_t dev_lock;
    6666
     
    6969static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    7070
    71 static int file_bd_open(bd_srv_t *);
     71static int file_bd_open(bd_srvs_t *, bd_srv_t *);
    7272static int file_bd_close(bd_srv_t *);
    7373static int file_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    154154static int file_bd_init(const char *fname)
    155155{
    156         bd_srv_init(&bd_srv);
    157         bd_srv.ops = &file_bd_ops;
     156        bd_srvs_init(&bd_srvs);
     157        bd_srvs.ops = &file_bd_ops;
    158158       
    159159        async_set_client_connection(file_bd_connection);
     
    188188static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    189189{
    190         bd_conn(iid, icall, &bd_srv);
     190        bd_conn(iid, icall, &bd_srvs);
    191191}
    192192
    193193/** Open device. */
    194 static int file_bd_open(bd_srv_t *bd)
     194static int file_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    195195{
    196196        return EOK;
  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r71b0d4d4 rb224a3e  
    8888/** GXE block device soft state */
    8989typedef struct {
    90         /** Block device server structure */
    91         bd_srv_t bd;
     90        /** Block device service structure */
     91        bd_srvs_t bds;
    9292        int disk_id;
    9393} gxe_bd_t;
     
    109109static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf);
    110110
    111 static int gxe_bd_open(bd_srv_t *);
     111static int gxe_bd_open(bd_srvs_t *, bd_srv_t *);
    112112static int gxe_bd_close(bd_srv_t *);
    113113static int gxe_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    127127static gxe_bd_t *bd_srv_gxe(bd_srv_t *bd)
    128128{
    129         return (gxe_bd_t *)bd->arg;
     129        return (gxe_bd_t *)bd->srvs->sarg;
    130130}
    131131
     
    166166                char name[16];
    167167               
    168                 bd_srv_init(&gxe_bd[i].bd);
    169                 gxe_bd[i].bd.ops = &gxe_bd_ops;
    170                 gxe_bd[i].bd.arg = (void *)&gxe_bd[i];
     168                bd_srvs_init(&gxe_bd[i].bds);
     169                gxe_bd[i].bds.ops = &gxe_bd_ops;
     170                gxe_bd[i].bds.sarg = (void *)&gxe_bd[i];
    171171               
    172172                snprintf(name, 16, "%s/disk%u", NAMESPACE, i);
     
    203203        }
    204204
    205         bd_conn(iid, icall, &gxe_bd[disk_id].bd);
     205        bd_conn(iid, icall, &gxe_bd[disk_id].bds);
    206206}
    207207
    208208/** Open device. */
    209 static int gxe_bd_open(bd_srv_t *bd)
     209static int gxe_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    210210{
    211211        return EOK;
  • uspace/srv/bd/part/guid_part/guid_part.c

    r71b0d4d4 rb224a3e  
    8383        /** Service representing the partition (outbound device) */
    8484        service_id_t dsid;
    85         /** Block device server structure */
    86         bd_srv_t bd;
     85        /** Block device service structure */
     86        bd_srvs_t bds;
    8787        /** Points to next partition structure. */
    8888        struct part *next;
     
    104104static int gpt_bsa_translate(part_t *p, aoff64_t ba, size_t cnt, aoff64_t *gba);
    105105
    106 static int gpt_bd_open(bd_srv_t *);
     106static int gpt_bd_open(bd_srvs_t *, bd_srv_t *);
    107107static int gpt_bd_close(bd_srv_t *);
    108108static int gpt_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    122122static part_t *bd_srv_part(bd_srv_t *bd)
    123123{
    124         return (part_t *)bd->arg;
     124        return (part_t *)bd->srvs->sarg;
    125125}
    126126
     
    325325        }
    326326
    327         bd_srv_init(&part->bd);
    328         part->bd.ops = &gpt_bd_ops;
    329         part->bd.arg = part;
     327        bd_srvs_init(&part->bds);
     328        part->bds.ops = &gpt_bd_ops;
     329        part->bds.sarg = part;
    330330
    331331        part->dsid = 0;
     
    357357        assert(part->present == true);
    358358
    359         bd_conn(iid, icall, &part->bd);
     359        bd_conn(iid, icall, &part->bds);
    360360}
    361361
    362362/** Open device. */
    363 static int gpt_bd_open(bd_srv_t *bd)
     363static int gpt_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    364364{
    365365        return EOK;
  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r71b0d4d4 rb224a3e  
    100100        /** Device representing the partition (outbound device) */
    101101        service_id_t dsid;
    102         /** Block device server structure */
    103         bd_srv_t bd;
     102        /** Block device service sturcture */
     103        bd_srvs_t bds;
    104104        /** Points to next partition structure. */
    105105        struct part *next;
     
    154154static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba);
    155155
    156 static int mbr_bd_open(bd_srv_t *);
     156static int mbr_bd_open(bd_srvs_t *, bd_srv_t *);
    157157static int mbr_bd_close(bd_srv_t *);
    158158static int mbr_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    172172static part_t *bd_srv_part(bd_srv_t *bd)
    173173{
    174         return (part_t *)bd->arg;
     174        return (part_t *)bd->srvs->sarg;
    175175}
    176176
     
    402402        part->present = (pte->ptype != PT_UNUSED) ? true : false;
    403403
    404         bd_srv_init(&part->bd);
    405         part->bd.ops = &mbr_bd_ops;
    406         part->bd.arg = part;
     404        bd_srvs_init(&part->bds);
     405        part->bds.ops = &mbr_bd_ops;
     406        part->bds.sarg = part;
    407407
    408408        part->dsid = 0;
     
    433433
    434434        assert(part->present == true);
    435         bd_conn(iid, icall, &part->bd);
     435        bd_conn(iid, icall, &part->bds);
    436436}
    437437
    438438/** Open device. */
    439 static int mbr_bd_open(bd_srv_t *bd)
     439static int mbr_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    440440{
    441441        return EOK;
  • uspace/srv/bd/rd/rd.c

    r71b0d4d4 rb224a3e  
    6868static const size_t block_size = 512;
    6969
    70 static int rd_open(bd_srv_t *);
     70static int rd_open(bd_srvs_t *, bd_srv_t *);
    7171static int rd_close(bd_srv_t *);
    7272static int rd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    9393};
    9494
    95 static bd_srv_t bd_srv;
     95static bd_srvs_t bd_srvs;
    9696
    9797static void rd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9898{
    99         bd_conn(iid, icall, &bd_srv);
     99        bd_conn(iid, icall, &bd_srvs);
    100100}
    101101
    102102/** Open device. */
    103 static int rd_open(bd_srv_t *bd)
     103static int rd_open(bd_srvs_t *bds, bd_srv_t *bd)
    104104{
    105105        return EOK;
     
    175175            (void *) addr_phys, size);
    176176       
    177         bd_srv_init(&bd_srv);
    178         bd_srv.ops = &rd_bd_ops;
     177        bd_srvs_init(&bd_srvs);
     178        bd_srvs.ops = &rd_bd_ops;
    179179       
    180180        async_set_client_connection(rd_client_conn);
  • uspace/srv/bd/sata_bd/sata_bd.c

    r71b0d4d4 rb224a3e  
    5757static int disk_count;
    5858
    59 static int sata_bd_open(bd_srv_t *);
     59static int sata_bd_open(bd_srvs_t *, bd_srv_t *);
    6060static int sata_bd_close(bd_srv_t *);
    6161static int sata_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    7575static sata_bd_dev_t *bd_srv_sata(bd_srv_t *bd)
    7676{
    77         return (sata_bd_dev_t *)bd->arg;
     77        return (sata_bd_dev_t *)bd->srvs->sarg;
    7878}
    7979
     
    104104                ahci_get_num_blocks(disk[disk_count].sess, &disk[disk_count].blocks);
    105105               
    106                 bd_srv_init(&disk[disk_count].bd);
    107                 disk[disk_count].bd.ops = &sata_bd_ops;
    108                 disk[disk_count].bd.arg = &disk[disk_count];
     106                bd_srvs_init(&disk[disk_count].bds);
     107                disk[disk_count].bds.ops = &sata_bd_ops;
     108                disk[disk_count].bds.sarg = &disk[disk_count];
    109109               
    110110                printf("Device %s - %s , blocks: %lu, block_size: %lu\n",
     
    183183        }
    184184
    185         bd_conn(iid, icall, &disk[disk_id].bd);
     185        bd_conn(iid, icall, &disk[disk_id].bds);
    186186}
    187187
    188188/** Open device. */
    189 static int sata_bd_open(bd_srv_t *bd)
     189static int sata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    190190{
    191191        return EOK;
  • uspace/srv/bd/sata_bd/sata_bd.h

    r71b0d4d4 rb224a3e  
    5858        size_t block_size;
    5959        /** Block device server structure */
    60         bd_srv_t bd;
     60        bd_srvs_t bds;
    6161} sata_bd_dev_t;
    6262
  • uspace/srv/hid/console/console.c

    r71b0d4d4 rb224a3e  
    383383       
    384384        fb_pointer_update(fb_sess, mouse.x, mouse.y, true);
     385}
     386
     387static void cons_mouse_abs_move(sysarg_t x, sysarg_t y,
     388    sysarg_t max_x, sysarg_t max_y)
     389{
     390        if (max_x && max_y) {
     391                mouse.x = limit(x * xres / max_x, 0, xres);
     392                mouse.y = limit(y * yres / max_y, 0, yres);
     393               
     394                fb_pointer_update(fb_sess, mouse.x, mouse.y, true);
     395        }
    385396}
    386397
     
    503514                        async_answer_0(callid, EOK);
    504515                        break;
     516                case INPUT_EVENT_ABS_MOVE:
     517                        cons_mouse_abs_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call),
     518                            IPC_GET_ARG3(call), IPC_GET_ARG4(call));
     519                        async_answer_0(callid, EOK);
     520                        break;
    505521                case INPUT_EVENT_BUTTON:
    506522                        /* Got pointer button press/release event */
  • uspace/srv/hid/input/generic/input.c

    r71b0d4d4 rb224a3e  
    189189        }
    190190        async_exchange_end(exch);
     191}
     192
     193/** Mouse pointer has moved in absolute mode. */
     194void mouse_push_event_abs_move(mouse_dev_t *mdev, unsigned int x, unsigned int y,
     195    unsigned int max_x, unsigned int max_y)
     196{
     197        if (max_x && max_y) {
     198                async_exch_t *exch = async_exchange_begin(client_sess);
     199                async_msg_4(exch, INPUT_EVENT_ABS_MOVE, x, y, max_x, max_y);
     200                async_exchange_end(exch);
     201        }
    191202}
    192203
  • uspace/srv/hid/input/include/mouse.h

    r71b0d4d4 rb224a3e  
    6363extern void mouse_push_data(mouse_dev_t *, sysarg_t);
    6464extern void mouse_push_event_move(mouse_dev_t *, int, int, int);
     65extern void mouse_push_event_abs_move(mouse_dev_t *, unsigned int, unsigned int,
     66    unsigned int, unsigned int);
    6567extern void mouse_push_event_button(mouse_dev_t *, int, int);
    6668
  • uspace/srv/hid/input/proto/mousedev.c

    r71b0d4d4 rb224a3e  
    9696                        retval = EOK;
    9797                        break;
     98                case MOUSEEV_ABS_MOVE_EVENT:
     99                        mouse_push_event_abs_move(mousedev->mouse_dev,
     100                                IPC_GET_ARG1(call), IPC_GET_ARG2(call),
     101                                IPC_GET_ARG3(call), IPC_GET_ARG4(call));
     102                        retval = EOK;
     103                        break;
    98104                case MOUSEEV_BUTTON_EVENT:
    99105                        mouse_push_event_button(mousedev->mouse_dev,
Note: See TracChangeset for help on using the changeset viewer.