Changes in / [b224a3e:71b0d4d4] in mainline


Ignore:
Files:
4 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rb224a3e r71b0d4d4  
    108108        $(USPACE_PATH)/srv/fs/ext4fs/ext4fs \
    109109        $(USPACE_PATH)/srv/hid/remcons/remcons \
    110         $(USPACE_PATH)/srv/hid/isdv4_tablet/isdv4_tablet \
    111110        $(USPACE_PATH)/srv/net/ethip/ethip \
    112111        $(USPACE_PATH)/srv/net/inetsrv/inetsrv \

  • uspace/Makefile

    rb224a3e r71b0d4d4  
    102102        srv/hid/console \
    103103        srv/hid/s3c24xx_ts \
    104         srv/hid/isdv4_tablet \
    105104        srv/hid/fb \
    106105        srv/hid/input \

  • uspace/app/edit/edit.c

    rb224a3e r71b0d4d4  
    126126static int file_save_range(char const *fname, spt_t const *spos,
    127127    spt_t const *epos);
     128static char *filename_prompt(char const *prompt, char const *init_value);
    128129static char *range_get_str(spt_t const *spos, spt_t const *epos);
    129 
    130 static char *prompt(char const *prompt, char const *init_value);
    131130
    132131static void pane_text_display(void);
    … …  
    143142static void caret_move_word_left(void);
    144143static void caret_move_word_right(void);
    145 static void caret_move_to_line(int row);
    146 static void caret_go_to_line_ask(void);
    147144
    148145static bool selection_active(void);
    … …  
    407404                caret_move_word_left();
    408405                break;
    409         case KC_L:
    410                 caret_go_to_line_ask();
    411                 break;
    412406        default:
    413407                break;
    … …  
    526520        char *fname;
    527521       
    528         fname = prompt("Save As", old_fname);
     522        fname = filename_prompt("Save As", old_fname);
    529523        if (fname == NULL) {
    530524                status_display("Save cancelled.");
    … …  
    541535}
    542536
    543 /** Ask for a string. */
    544 static char *prompt(char const *prompt, char const *init_value)
     537/** Ask for a file name. */
     538static char *filename_prompt(char const *prompt, char const *init_value)
    545539{
    546540        kbd_event_t ev;
    … …  
    848842                /* Fill until the end of display area. */
    849843
    850                 if ((unsigned)s_column - 1 < scr_columns)
    851                         fill = scr_columns - (s_column - 1);
     844                if (str_length(row_buf) < (unsigned) scr_columns)
     845                        fill = scr_columns - str_length(row_buf);
    852846                else
    853847                        fill = 0;
    … …  
    10831077        pane.rflags |= REDRAW_TEXT;
    10841078}
    1085 
    1086 /** Change the caret position to a beginning of a given line
    1087  */
    1088 static 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. */
    1120 static 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 
    11401079
    11411080/** Check for non-empty selection. */

  • uspace/app/sportdmp/sportdmp.c

    rb224a3e r71b0d4d4  
    140140                ssize_t i;
    141141                for (i = 0; i < read; i++) {
    142                         printf("%02hhx ", buf[i]);
     142                        if ((buf[i] >= 32) && (buf[i] < 128))
     143                                putchar((wchar_t) buf[i]);
     144                        else
     145                                putchar('.');
     146                        fflush(stdout);
    143147                }
    144                 fflush(stdout);
    145148        }
    146149       

  • uspace/drv/bus/usb/usbmast/main.c

    rb224a3e r71b0d4d4  
    8282    void *arg);
    8383
    84 static int usbmast_bd_open(bd_srvs_t *, bd_srv_t *);
     84static int usbmast_bd_open(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->srvs->sarg;
     102        return (usbmast_fun_t *)bd->arg;
    103103}
    104104
    … …  
    240240        mfun->lun = lun;
    241241
    242         bd_srvs_init(&mfun->bds);
    243         mfun->bds.ops = &usbmast_bd_ops;
    244         mfun->bds.sarg = mfun;
     242        bd_srv_init(&mfun->bd);
     243        mfun->bd.ops = &usbmast_bd_ops;
     244        mfun->bd.arg = 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->bds);
     313        bd_conn(iid, icall, &mfun->bd);
    314314}
    315315
    316316/** Open device. */
    317 static int usbmast_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     317static int usbmast_bd_open(bd_srv_t *bd)
    318318{
    319319        return EOK;

  • uspace/drv/bus/usb/usbmast/usbmast.h

    rb224a3e r71b0d4d4  
    6969        /** Block size in bytes */
    7070        size_t block_size;
    71         /** Block device service structure */
    72         bd_srvs_t bds;
     71        /** Block device server structure */
     72        bd_srv_t bd;
    7373} usbmast_fun_t;
    7474

  • uspace/drv/char/ns8250/cyclic_buffer.h

    rb224a3e r71b0d4d4  
    3636#define CYCLIC_BUFFER_H_
    3737
    38 #define BUF_LEN 4096
     38#define BUF_LEN 256
    3939
    4040typedef struct cyclic_buffer {

  • uspace/drv/char/ns8250/ns8250.c

    rb224a3e r71b0d4d4  
    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
    8684
    8785/** FIFO Control Register definition. */
    … …  
    181179        /** The fibril mutex for synchronizing the access to the device. */
    182180        fibril_mutex_t mutex;
    183         /** Indicates that some data has become available */
    184         fibril_condvar_t input_buffer_available;
    185181        /** True if device is removed. */
    186182        bool removed;
    … …  
    242238{
    243239        ns8250_t *ns = NS8250(fun);
    244         int ret = 0;
    245        
    246         if (count == 0) return 0;
     240        int ret = EOK;
    247241       
    248242        fibril_mutex_lock(&ns->mutex);
    249         while (buf_is_empty(&ns->input_buffer))
    250                 fibril_condvar_wait(&ns->input_buffer_available, &ns->mutex);
    251243        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
    252244                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
    … …  
    468460{
    469461        /* Interrupt when data received. */
    470         pio_write_8(&regs->ier, NS8250_IER_RXREADY | NS8250_IER_RXSTATUS);
     462        pio_write_8(&regs->ier, NS8250_IER_RXREADY);
    471463        pio_write_8(&regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
    472464            | NS8250_MCR_OUT2);
    … …  
    507499        async_exchange_end(exch);
    508500
    509         /* Read LSR to clear possible previous LSR interrupt */
    510         pio_read_8(&ns->regs->lsr);
    511 
    512501        /* Enable interrupt on the serial port. */
    513502        ns8250_port_interrupts_enable(ns->regs);
    … …  
    706695        /* 8 bits, no parity, two stop bits. */
    707696        ns8250_port_set_com_props(ns->regs, SERIAL_NO_PARITY, 8, 2);
    708         /*
    709          * Enable FIFO, clear them, with 4-byte threshold for greater
    710          * reliability.
    711          */
     697        /* Enable FIFO, clear them, with 14-byte threshold. */
    712698        pio_write_8(&ns->regs->iid, NS8250_FCR_FIFOENABLE
    713             | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET
    714             | NS8250_FCR_RXTRIGGERLOW);
     699            | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET 
     700            | NS8250_FCR_RXTRIGGERLOW | NS8250_FCR_RXTRIGGERHI);
    715701        /*
    716702         * RTS/DSR set (Request to Send and Data Terminal Ready lines enabled),
    … …  
    745731        bool cont = true;
    746732       
    747         fibril_mutex_lock(&ns->mutex);
    748733        while (cont) {
     734                fibril_mutex_lock(&ns->mutex);
     735               
    749736                cont = ns8250_received(regs);
    750737                if (cont) {
    … …  
    752739                       
    753740                        if (ns->client_connected) {
    754                                 bool buf_was_empty = buf_is_empty(&ns->input_buffer);
    755741                                if (!buf_push_back(&ns->input_buffer, val)) {
    756742                                        ddf_msg(LVL_WARN, "Buffer overflow on "
    757743                                            "%s.", ns->dev->name);
    758                                         break;
    759744                                } else {
    760745                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
    761746                                            "to the buffer of %s.",
    762747                                            val, ns->dev->name);
    763                                         if (buf_was_empty)
    764                                                 fibril_condvar_broadcast(&ns->input_buffer_available);
    765748                                }
    766749                        }
    767750                }
    768         }
    769         fibril_mutex_unlock(&ns->mutex);
    770         fibril_yield();
     751               
     752                fibril_mutex_unlock(&ns->mutex);
     753                fibril_yield();
     754        }
    771755}
    772756
    773757/** The interrupt handler.
    774758 *
    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.
     759 * The serial port is initialized to interrupt when some data come, so the
     760 * interrupt is handled by reading the incomming data.
    778761 *
    779762 * @param dev           The serial port device.
    … …  
    782765    ipc_call_t *icall)
    783766{
    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);
     767        ns8250_read_from_device(NS8250_FROM_DEV(dev));
    795768}
    796769
    … …  
    838811       
    839812        fibril_mutex_initialize(&ns->mutex);
    840         fibril_condvar_initialize(&ns->input_buffer_available);
    841813        ns->dev = dev;
    842814       
    … …  
    10811053static void ns8250_init(void)
    10821054{
    1083         ddf_log_init(NAME, LVL_WARN);
     1055        ddf_log_init(NAME, LVL_ERROR);
    10841056       
    10851057        ns8250_dev_ops.open = &ns8250_open;

  • uspace/lib/c/generic/bd_srv.c

    rb224a3e r71b0d4d4  
    6767        }
    6868
    69         if (srv->srvs->ops->read_blocks == NULL) {
     69        if (srv->ops->read_blocks == NULL) {
    7070                async_answer_0(rcallid, ENOTSUP);
    7171                async_answer_0(callid, ENOTSUP);
    … …  
    7373        }
    7474
    75         rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
     75        rc = srv->ops->read_blocks(srv, ba, cnt, buf, size);
    7676        if (rc != EOK) {
    7777                async_answer_0(rcallid, ENOMEM);
    … …  
    109109        }
    110110
    111         if (srv->srvs->ops->read_toc == NULL) {
     111        if (srv->ops->read_toc == NULL) {
    112112                async_answer_0(rcallid, ENOTSUP);
    113113                async_answer_0(callid, ENOTSUP);
    … …  
    115115        }
    116116
    117         rc = srv->srvs->ops->read_toc(srv, session, buf, size);
     117        rc = srv->ops->read_toc(srv, session, buf, size);
    118118        if (rc != EOK) {
    119119                async_answer_0(rcallid, ENOMEM);
    … …  
    146146        }
    147147
    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);
     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);
    154154        free(data);
    155155        async_answer_0(callid, rc);
    … …  
    162162        size_t block_size;
    163163
    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);
     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);
    170170        async_answer_1(callid, rc, block_size);
    171171}
    … …  
    177177        aoff64_t num_blocks;
    178178
    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);
     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);
    185185        async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
    186186}
    187187
    188 static 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 
    200 void bd_srvs_init(bd_srvs_t *srvs)
    201 {
    202         srvs->ops = NULL;
    203         srvs->sarg = NULL;
    204 }
    205 
    206 int bd_conn(ipc_callid_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
    207 {
    208         bd_srv_t *srv;
    209         int rc;
     188void 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
     197int 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);
    210211
    211212        /* Accept the connection */
    212213        async_answer_0(iid, EOK);
    213 
    214         srv = bd_srv_create(srvs);
    215         if (srv == NULL)
    216                 return ENOMEM;
    217214
    218215        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    … …  
    222219        srv->client_sess = sess;
    223220
    224         rc = srvs->ops->open(srvs, srv);
     221        rc = srv->ops->open(srv);
    225222        if (rc != EOK)
    226223                return rc;
    … …  
    233230                if (!method) {
    234231                        /* 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         rc = srvs->ops->close(srv);
    261         free(srv);
    262 
    263         return rc;
     260        return srv->ops->close(srv);
    264261}
    265262

  • uspace/lib/c/include/bd_srv.h

    rb224a3e r71b0d4d4  
    3636#define LIBC_BD_SRV_H_
    3737
    38 #include <adt/list.h>
    3938#include <async.h>
    4039#include <fibril_synch.h>
    … …  
    4443typedef struct bd_ops bd_ops_t;
    4544
    46 /** Service setup (per sevice) */
    4745typedef struct {
     46        fibril_mutex_t lock;
     47        bool connected;
    4848        bd_ops_t *ops;
    49         void *sarg;
    50 } bd_srvs_t;
    51 
    52 /** Server structure (per client session) */
    53 typedef struct {
    54         bd_srvs_t *srvs;
     49        void *arg;
    5550        async_sess_t *client_sess;
    56         void *carg;
    5751} bd_srv_t;
    5852
    5953typedef struct bd_ops {
    60         int (*open)(bd_srvs_t *, bd_srv_t *);
     54        int (*open)(bd_srv_t *);
    6155        int (*close)(bd_srv_t *);
    6256        int (*read_blocks)(bd_srv_t *, aoff64_t, size_t, void *, size_t);
    … …  
    6761} bd_ops_t;
    6862
    69 extern void bd_srvs_init(bd_srvs_t *);
     63extern void bd_srv_init(bd_srv_t *);
    7064
    71 extern int bd_conn(ipc_callid_t, ipc_call_t *, bd_srvs_t *);
     65extern int bd_conn(ipc_callid_t, ipc_call_t *, void *);
    7266
    7367#endif

  • uspace/lib/c/include/ipc/input.h

    rb224a3e r71b0d4d4  
    4646        INPUT_EVENT_KEY = IPC_FIRST_USER_METHOD,
    4747        INPUT_EVENT_MOVE,
    48         INPUT_EVENT_ABS_MOVE,
    4948        INPUT_EVENT_BUTTON
    5049} input_notif_t;

  • uspace/lib/c/include/ipc/mouseev.h

    rb224a3e r71b0d4d4  
    4747typedef enum {
    4848        MOUSEEV_MOVE_EVENT = IPC_FIRST_USER_METHOD,
    49         MOUSEEV_ABS_MOVE_EVENT,
    5049        MOUSEEV_BUTTON_EVENT
    5150} mouseev_notif_t;

  • uspace/srv/bd/ata_bd/ata_bd.c

    rb224a3e r71b0d4d4  
    104104static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    105105
    106 static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
     106static int ata_bd_open(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(disk_t *disk, uint64_t ba, size_t cnt,
     116static int ata_rcmd_read(int disk_id, uint64_t ba, size_t cnt,
    117117    void *buf);
    118 static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
     118static int ata_rcmd_write(int disk_id, 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(disk_t *disk, void *buf);
    122 static int identify_pkt_dev(disk_t *disk, void *buf);
    123 static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
     121static int drive_identify(int drive_id, void *buf);
     122static int identify_pkt_dev(int dev_idx, void *buf);
     123static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    124124    void *obuf, size_t obuf_size);
    125 static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size);
    126 static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
     125static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size);
     126static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    127127    void *obuf, size_t obuf_size);
    128 static int ata_pcmd_read_toc(disk_t *disk, uint8_t ses,
     128static int ata_pcmd_read_toc(int dev_idx, 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->srvs->sarg;
    149 }
    150 
    151 static int disk_dev_idx(disk_t *disk)
    152 {
    153         return (disk->disk_id & 1);
     148        return (disk_t *)bd->arg;
    154149}
    155150
    … …  
    301296{
    302297        service_id_t dsid;
    303         int i;
    304         disk_t *disk;
     298        int disk_id, i;
    305299
    306300        /* Get the device service ID. */
    … …  
    308302
    309303        /* Determine which disk device is the client connecting to. */
    310         disk = NULL;
     304        disk_id = -1;
    311305        for (i = 0; i < MAX_DISKS; i++)
    312306                if (ata_disk[i].service_id == dsid)
    313                         disk = &ata_disk[i];
    314 
    315         if (disk == NULL || disk->present == false) {
     307                        disk_id = i;
     308
     309        if (disk_id < 0 || ata_disk[disk_id].present == false) {
    316310                async_answer_0(iid, EINVAL);
    317311                return;
    318312        }
    319313
    320         bd_conn(iid, icall, &disk->bds);
     314        bd_conn(iid, icall, &ata_disk[disk_id].bd);
    321315}
    322316
    … …  
    342336        fibril_mutex_initialize(&d->lock);
    343337
    344         bd_srvs_init(&d->bds);
    345         d->bds.ops = &ata_bd_ops;
    346         d->bds.sarg = d;
     338        bd_srv_init(&d->bd);
     339        d->bd.ops = &ata_bd_ops;
     340        d->bd.arg = d;
    347341
    348342        /* Try identify command. */
    349         rc = drive_identify(d, &idata);
     343        rc = drive_identify(disk_id, &idata);
    350344        if (rc == EOK) {
    351345                /* Success. It's a register (non-packet) device. */
    … …  
    367361
    368362                if (bc == PDEV_SIGNATURE_BC) {
    369                         rc = identify_pkt_dev(d, &idata);
     363                        rc = identify_pkt_dev(disk_id, &idata);
    370364                        if (rc == EOK) {
    371365                                /* We have a packet device. */
    … …  
    451445        if (d->dev_type == ata_pkt_dev) {
    452446                /* Send inquiry. */
    453                 rc = ata_pcmd_inquiry(d, &inq_data, sizeof(inq_data));
     447                rc = ata_pcmd_inquiry(0, &inq_data, sizeof(inq_data));
    454448                if (rc != EOK) {
    455449                        printf("Device inquiry failed.\n");
    … …  
    473467}
    474468
    475 static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     469static int ata_bd_open(bd_srv_t *bd)
    476470{
    477471        return EOK;
    … …  
    494488
    495489        while (cnt > 0) {
    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,
     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,
    500494                            disk->block_size);
    501                 }
    502495
    503496                if (rc != EOK)
    … …  
    517510        disk_t *disk = bd_srv_disk(bd);
    518511
    519         return ata_pcmd_read_toc(disk, session, buf, size);
     512        return ata_pcmd_read_toc(disk->disk_id, session, buf, size);
    520513}
    521514
    … …  
    534527
    535528        while (cnt > 0) {
    536                 rc = ata_rcmd_write(disk, ba, 1, buf);
     529                rc = ata_rcmd_write(disk->disk_id, ba, 1, buf);
    537530                if (rc != EOK)
    538531                        return rc;
    … …  
    569562 * whether an ATA device is present and if so, to determine its parameters.
    570563 *
    571  * @param disk          Disk
     564 * @param disk_id       Device ID, 0 or 1.
    572565 * @param buf           Pointer to a 512-byte buffer.
    573566 *
    … …  
    575568 *                      not present). EIO if device responds with error.
    576569 */
    577 static int drive_identify(disk_t *disk, void *buf)
     570static int drive_identify(int disk_id, void *buf)
    578571{
    579572        uint16_t data;
    … …  
    582575        size_t i;
    583576
    584         drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     577        drv_head = ((disk_id != 0) ? DHR_DRV : 0);
    585578
    586579        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    628621 * whether an ATAPI device is present and if so, to determine its parameters.
    629622 *
    630  * @param disk          Disk
     623 * @param dev_idx       Device index, 0 or 1.
    631624 * @param buf           Pointer to a 512-byte buffer.
    632625 */
    633 static int identify_pkt_dev(disk_t *disk, void *buf)
     626static int identify_pkt_dev(int dev_idx, void *buf)
    634627{
    635628        uint16_t data;
    … …  
    638631        size_t i;
    639632
    640         drv_head = ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     633        drv_head = ((dev_idx != 0) ? DHR_DRV : 0);
    641634
    642635        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    … …  
    673666 * Only data-in commands are supported (e.g. inquiry, read).
    674667 *
    675  * @param disk          Disk
     668 * @param dev_idx       Device index (0 or 1)
    676669 * @param obuf          Buffer for storing data read from device
    677670 * @param obuf_size     Size of obuf in bytes
    … …  
    679672 * @return EOK on success, EIO on error.
    680673 */
    681 static int ata_cmd_packet(disk_t *disk, const void *cpkt, size_t cpkt_size,
     674static int ata_cmd_packet(int dev_idx, const void *cpkt, size_t cpkt_size,
    682675    void *obuf, size_t obuf_size)
    683676{
    … …  
    685678        uint8_t status;
    686679        uint8_t drv_head;
     680        disk_t *d;
    687681        size_t data_size;
    688682        uint16_t val;
    689683
    690         fibril_mutex_lock(&disk->lock);
     684        d = &ata_disk[dev_idx];
     685        fibril_mutex_lock(&d->lock);
    691686
    692687        /* New value for Drive/Head register */
    693688        drv_head =
    694             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0);
     689            ((dev_idx != 0) ? DHR_DRV : 0);
    695690
    696691        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK) {
    697                 fibril_mutex_unlock(&disk->lock);
     692                fibril_mutex_unlock(&d->lock);
    698693                return EIO;
    699694        }
    … …  
    702697
    703698        if (wait_status(0, ~(SR_BSY|SR_DRQ), NULL, TIMEOUT_BSY) != EOK) {
    704                 fibril_mutex_unlock(&disk->lock);
     699                fibril_mutex_unlock(&d->lock);
    705700                return EIO;
    706701        }
    … …  
    713708
    714709        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    715                 fibril_mutex_unlock(&disk->lock);
     710                fibril_mutex_unlock(&d->lock);
    716711                return EIO;
    717712        }
    … …  
    722717
    723718        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    724                 fibril_mutex_unlock(&disk->lock);
     719                fibril_mutex_unlock(&d->lock);
    725720                return EIO;
    726721        }
    727722
    728723        if ((status & SR_DRQ) == 0) {
    729                 fibril_mutex_unlock(&disk->lock);
     724                fibril_mutex_unlock(&d->lock);
    730725                return EIO;
    731726        }
    … …  
    738733        if (data_size > obuf_size) {
    739734                /* Output buffer is too small to store data. */
    740                 fibril_mutex_unlock(&disk->lock);
     735                fibril_mutex_unlock(&d->lock);
    741736                return EIO;
    742737        }
    … …  
    749744
    750745        if (status & SR_ERR) {
    751                 fibril_mutex_unlock(&disk->lock);
    752                 return EIO;
    753         }
    754 
    755         fibril_mutex_unlock(&disk->lock);
     746                fibril_mutex_unlock(&d->lock);
     747                return EIO;
     748        }
     749
     750        fibril_mutex_unlock(&d->lock);
    756751
    757752        return EOK;
    … …  
    760755/** Issue ATAPI Inquiry.
    761756 *
    762  * @param disk          Disk
     757 * @param dev_idx       Device index (0 or 1)
    763758 * @param obuf          Buffer for storing inquiry data read from device
    764759 * @param obuf_size     Size of obuf in bytes
    … …  
    766761 * @return EOK on success, EIO on error.
    767762 */
    768 static int ata_pcmd_inquiry(disk_t *disk, void *obuf, size_t obuf_size)
     763static int ata_pcmd_inquiry(int dev_idx, void *obuf, size_t obuf_size)
    769764{
    770765        ata_pcmd_inquiry_t cp;
    … …  
    776771        cp.alloc_len = min(obuf_size, 0xff); /* Allocation length */
    777772
    778         rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
     773        rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    779774        if (rc != EOK)
    780775                return rc;
    … …  
    788783 * function will fail.
    789784 *
    790  * @param disk          Disk
     785 * @param dev_idx       Device index (0 or 1)
    791786 * @param ba            Starting block address
    792787 * @param cnt           Number of blocks to read
    … …  
    796791 * @return EOK on success, EIO on error.
    797792 */
    798 static int ata_pcmd_read_12(disk_t *disk, uint64_t ba, size_t cnt,
     793static int ata_pcmd_read_12(int dev_idx, uint64_t ba, size_t cnt,
    799794    void *obuf, size_t obuf_size)
    800795{
    … …  
    811806        cp.nblocks = host2uint32_t_be(cnt);
    812807
    813         rc = ata_cmd_packet(disk, &cp, sizeof(cp), obuf, obuf_size);
     808        rc = ata_cmd_packet(0, &cp, sizeof(cp), obuf, obuf_size);
    814809        if (rc != EOK)
    815810                return rc;
    … …  
    828823 * function will fail.
    829824 *
    830  * @param disk          Disk
     825 * @param dev_idx       Device index (0 or 1)
    831826 * @param session       Starting session
    832827 * @param obuf          Buffer for storing inquiry data read from device
    … …  
    835830 * @return EOK on success, EIO on error.
    836831 */
    837 static int ata_pcmd_read_toc(disk_t *disk, uint8_t session, void *obuf,
     832static int ata_pcmd_read_toc(int dev_idx, uint8_t session, void *obuf,
    838833    size_t obuf_size)
    839834{
    … …  
    859854/** Read a physical from the device.
    860855 *
    861  * @param disk          Disk
     856 * @param disk_id       Device index (0 or 1)
    862857 * @param ba            Address the first block.
    863858 * @param cnt           Number of blocks to transfer.
    … …  
    866861 * @return EOK on success, EIO on error.
    867862 */
    868 static int ata_rcmd_read(disk_t *disk, uint64_t ba, size_t blk_cnt,
     863static int ata_rcmd_read(int disk_id, uint64_t ba, size_t blk_cnt,
    869864    void *buf)
    870865{
    … …  
    873868        uint8_t status;
    874869        uint8_t drv_head;
     870        disk_t *d;
    875871        block_coord_t bc;
    876872
     873        d = &ata_disk[disk_id];
     874       
    877875        /* Silence warning. */
    878876        memset(&bc, 0, sizeof(bc));
    879877
    880878        /* Compute block coordinates. */
    881         if (coord_calc(disk, ba, &bc) != EOK)
     879        if (coord_calc(d, ba, &bc) != EOK)
    882880                return EINVAL;
    883881
    884882        /* New value for Drive/Head register */
    885883        drv_head =
    886             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
    887             ((disk->amode != am_chs) ? DHR_LBA : 0) |
     884            ((disk_id != 0) ? DHR_DRV : 0) |
     885            ((d->amode != am_chs) ? DHR_LBA : 0) |
    888886            (bc.h & 0x0f);
    889887
    890         fibril_mutex_lock(&disk->lock);
     888        fibril_mutex_lock(&d->lock);
    891889
    892890        /* Program a Read Sectors operation. */
    893891
    894892        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    895                 fibril_mutex_unlock(&disk->lock);
     893                fibril_mutex_unlock(&d->lock);
    896894                return EIO;
    897895        }
    … …  
    900898
    901899        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    902                 fibril_mutex_unlock(&disk->lock);
     900                fibril_mutex_unlock(&d->lock);
    903901                return EIO;
    904902        }
    … …  
    907905        coord_sc_program(&bc, 1);
    908906
    909         pio_write_8(&cmd->command, disk->amode == am_lba48 ?
     907        pio_write_8(&cmd->command, d->amode == am_lba48 ?
    910908            CMD_READ_SECTORS_EXT : CMD_READ_SECTORS);
    911909
    912910        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    913                 fibril_mutex_unlock(&disk->lock);
     911                fibril_mutex_unlock(&d->lock);
    914912                return EIO;
    915913        }
    … …  
    918916                /* Read data from the device buffer. */
    919917
    920                 for (i = 0; i < disk->block_size / 2; i++) {
     918                for (i = 0; i < ata_disk[disk_id].block_size / 2; i++) {
    921919                        data = pio_read_16(&cmd->data_port);
    922920                        ((uint16_t *) buf)[i] = data;
    … …  
    927925                return EIO;
    928926
    929         fibril_mutex_unlock(&disk->lock);
     927        fibril_mutex_unlock(&d->lock);
    930928        return EOK;
    931929}
    … …  
    933931/** Write a physical block to the device.
    934932 *
    935  * @param disk          Disk
     933 * @param disk_id       Device index (0 or 1)
    936934 * @param ba            Address of the first block.
    937935 * @param cnt           Number of blocks to transfer.
    … …  
    940938 * @return EOK on success, EIO on error.
    941939 */
    942 static int ata_rcmd_write(disk_t *disk, uint64_t ba, size_t cnt,
     940static int ata_rcmd_write(int disk_id, uint64_t ba, size_t cnt,
    943941    const void *buf)
    944942{
    … …  
    946944        uint8_t status;
    947945        uint8_t drv_head;
     946        disk_t *d;
    948947        block_coord_t bc;
    949948
     949        d = &ata_disk[disk_id];
     950       
    950951        /* Silence warning. */
    951952        memset(&bc, 0, sizeof(bc));
    952953
    953954        /* Compute block coordinates. */
    954         if (coord_calc(disk, ba, &bc) != EOK)
     955        if (coord_calc(d, ba, &bc) != EOK)
    955956                return EINVAL;
    956957
    957958        /* New value for Drive/Head register */
    958959        drv_head =
    959             ((disk_dev_idx(disk) != 0) ? DHR_DRV : 0) |
    960             ((disk->amode != am_chs) ? DHR_LBA : 0) |
     960            ((disk_id != 0) ? DHR_DRV : 0) |
     961            ((d->amode != am_chs) ? DHR_LBA : 0) |
    961962            (bc.h & 0x0f);
    962963
    963         fibril_mutex_lock(&disk->lock);
     964        fibril_mutex_lock(&d->lock);
    964965
    965966        /* Program a Write Sectors operation. */
    966967
    967968        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    968                 fibril_mutex_unlock(&disk->lock);
     969                fibril_mutex_unlock(&d->lock);
    969970                return EIO;
    970971        }
    … …  
    973974
    974975        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    975                 fibril_mutex_unlock(&disk->lock);
     976                fibril_mutex_unlock(&d->lock);
    976977                return EIO;
    977978        }
    … …  
    980981        coord_sc_program(&bc, 1);
    981982
    982         pio_write_8(&cmd->command, disk->amode == am_lba48 ?
     983        pio_write_8(&cmd->command, d->amode == am_lba48 ?
    983984            CMD_WRITE_SECTORS_EXT : CMD_WRITE_SECTORS);
    984985
    985986        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    986                 fibril_mutex_unlock(&disk->lock);
     987                fibril_mutex_unlock(&d->lock);
    987988                return EIO;
    988989        }
    … …  
    991992                /* Write data to the device buffer. */
    992993
    993                 for (i = 0; i < disk->block_size / 2; i++) {
     994                for (i = 0; i < d->block_size / 2; i++) {
    994995                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    995996                }
    996997        }
    997998
    998         fibril_mutex_unlock(&disk->lock);
     999        fibril_mutex_unlock(&d->lock);
    9991000
    10001001        if (status & SR_ERR)

  • uspace/srv/bd/ata_bd/ata_bd.h

    rb224a3e r71b0d4d4  
    119119        service_id_t service_id;
    120120        int disk_id;
    121         bd_srvs_t bds;
     121        bd_srv_t bd;
    122122} disk_t;
    123123

  • uspace/srv/bd/file_bd/file_bd.c

    rb224a3e r71b0d4d4  
    6262
    6363static service_id_t service_id;
    64 static bd_srvs_t bd_srvs;
     64static bd_srv_t bd_srv;
    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_srvs_t *, bd_srv_t *);
     71static int file_bd_open(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_srvs_init(&bd_srvs);
    157         bd_srvs.ops = &file_bd_ops;
     156        bd_srv_init(&bd_srv);
     157        bd_srv.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_srvs);
     190        bd_conn(iid, icall, &bd_srv);
    191191}
    192192
    193193/** Open device. */
    194 static int file_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     194static int file_bd_open(bd_srv_t *bd)
    195195{
    196196        return EOK;

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    rb224a3e r71b0d4d4  
    8888/** GXE block device soft state */
    8989typedef struct {
    90         /** Block device service structure */
    91         bd_srvs_t bds;
     90        /** Block device server structure */
     91        bd_srv_t bd;
    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_srvs_t *, bd_srv_t *);
     111static int gxe_bd_open(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->srvs->sarg;
     129        return (gxe_bd_t *)bd->arg;
    130130}
    131131
    … …  
    166166                char name[16];
    167167               
    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];
     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];
    171171               
    172172                snprintf(name, 16, "%s/disk%u", NAMESPACE, i);
    … …  
    203203        }
    204204
    205         bd_conn(iid, icall, &gxe_bd[disk_id].bds);
     205        bd_conn(iid, icall, &gxe_bd[disk_id].bd);
    206206}
    207207
    208208/** Open device. */
    209 static int gxe_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     209static int gxe_bd_open(bd_srv_t *bd)
    210210{
    211211        return EOK;

  • uspace/srv/bd/part/guid_part/guid_part.c

    rb224a3e r71b0d4d4  
    8383        /** Service representing the partition (outbound device) */
    8484        service_id_t dsid;
    85         /** Block device service structure */
    86         bd_srvs_t bds;
     85        /** Block device server structure */
     86        bd_srv_t bd;
    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_srvs_t *, bd_srv_t *);
     106static int gpt_bd_open(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->srvs->sarg;
     124        return (part_t *)bd->arg;
    125125}
    126126
    … …  
    325325        }
    326326
    327         bd_srvs_init(&part->bds);
    328         part->bds.ops = &gpt_bd_ops;
    329         part->bds.sarg = part;
     327        bd_srv_init(&part->bd);
     328        part->bd.ops = &gpt_bd_ops;
     329        part->bd.arg = part;
    330330
    331331        part->dsid = 0;
    … …  
    357357        assert(part->present == true);
    358358
    359         bd_conn(iid, icall, &part->bds);
     359        bd_conn(iid, icall, &part->bd);
    360360}
    361361
    362362/** Open device. */
    363 static int gpt_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     363static int gpt_bd_open(bd_srv_t *bd)
    364364{
    365365        return EOK;

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    rb224a3e r71b0d4d4  
    100100        /** Device representing the partition (outbound device) */
    101101        service_id_t dsid;
    102         /** Block device service sturcture */
    103         bd_srvs_t bds;
     102        /** Block device server structure */
     103        bd_srv_t bd;
    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_srvs_t *, bd_srv_t *);
     156static int mbr_bd_open(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->srvs->sarg;
     174        return (part_t *)bd->arg;
    175175}
    176176
    … …  
    402402        part->present = (pte->ptype != PT_UNUSED) ? true : false;
    403403
    404         bd_srvs_init(&part->bds);
    405         part->bds.ops = &mbr_bd_ops;
    406         part->bds.sarg = part;
     404        bd_srv_init(&part->bd);
     405        part->bd.ops = &mbr_bd_ops;
     406        part->bd.arg = part;
    407407
    408408        part->dsid = 0;
    … …  
    433433
    434434        assert(part->present == true);
    435         bd_conn(iid, icall, &part->bds);
     435        bd_conn(iid, icall, &part->bd);
    436436}
    437437
    438438/** Open device. */
    439 static int mbr_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     439static int mbr_bd_open(bd_srv_t *bd)
    440440{
    441441        return EOK;

  • uspace/srv/bd/rd/rd.c

    rb224a3e r71b0d4d4  
    6868static const size_t block_size = 512;
    6969
    70 static int rd_open(bd_srvs_t *, bd_srv_t *);
     70static int rd_open(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_srvs_t bd_srvs;
     95static bd_srv_t bd_srv;
    9696
    9797static void rd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9898{
    99         bd_conn(iid, icall, &bd_srvs);
     99        bd_conn(iid, icall, &bd_srv);
    100100}
    101101
    102102/** Open device. */
    103 static int rd_open(bd_srvs_t *bds, bd_srv_t *bd)
     103static int rd_open(bd_srv_t *bd)
    104104{
    105105        return EOK;
    … …  
    175175            (void *) addr_phys, size);
    176176       
    177         bd_srvs_init(&bd_srvs);
    178         bd_srvs.ops = &rd_bd_ops;
     177        bd_srv_init(&bd_srv);
     178        bd_srv.ops = &rd_bd_ops;
    179179       
    180180        async_set_client_connection(rd_client_conn);

  • uspace/srv/bd/sata_bd/sata_bd.c

    rb224a3e r71b0d4d4  
    5757static int disk_count;
    5858
    59 static int sata_bd_open(bd_srvs_t *, bd_srv_t *);
     59static int sata_bd_open(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->srvs->sarg;
     77        return (sata_bd_dev_t *)bd->arg;
    7878}
    7979
    … …  
    104104                ahci_get_num_blocks(disk[disk_count].sess, &disk[disk_count].blocks);
    105105               
    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];
     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];
    109109               
    110110                printf("Device %s - %s , blocks: %lu, block_size: %lu\n",
    … …  
    183183        }
    184184
    185         bd_conn(iid, icall, &disk[disk_id].bds);
     185        bd_conn(iid, icall, &disk[disk_id].bd);
    186186}
    187187
    188188/** Open device. */
    189 static int sata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
     189static int sata_bd_open(bd_srv_t *bd)
    190190{
    191191        return EOK;

  • uspace/srv/bd/sata_bd/sata_bd.h

    rb224a3e r71b0d4d4  
    5858        size_t block_size;
    5959        /** Block device server structure */
    60         bd_srvs_t bds;
     60        bd_srv_t bd;
    6161} sata_bd_dev_t;
    6262

  • uspace/srv/hid/console/console.c

    rb224a3e r71b0d4d4  
    383383       
    384384        fb_pointer_update(fb_sess, mouse.x, mouse.y, true);
    385 }
    386 
    387 static 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         }
    396385}
    397386
    … …  
    514503                        async_answer_0(callid, EOK);
    515504                        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;
    521505                case INPUT_EVENT_BUTTON:
    522506                        /* Got pointer button press/release event */

  • uspace/srv/hid/input/generic/input.c

    rb224a3e r71b0d4d4  
    191191}
    192192
    193 /** Mouse pointer has moved in absolute mode. */
    194 void 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         }
    202 }
    203 
    204193/** Mouse button has been pressed. */
    205194void mouse_push_event_button(mouse_dev_t *mdev, int bnum, int press)

  • uspace/srv/hid/input/include/mouse.h

    rb224a3e r71b0d4d4  
    6363extern void mouse_push_data(mouse_dev_t *, sysarg_t);
    6464extern void mouse_push_event_move(mouse_dev_t *, int, int, int);
    65 extern void mouse_push_event_abs_move(mouse_dev_t *, unsigned int, unsigned int,
    66     unsigned int, unsigned int);
    6765extern void mouse_push_event_button(mouse_dev_t *, int, int);
    6866

  • uspace/srv/hid/input/proto/mousedev.c

    rb224a3e r71b0d4d4  
    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;
    10498                case MOUSEEV_BUTTON_EVENT:
    10599                        mouse_push_event_button(mousedev->mouse_dev,
Note: See TracChangeset for help on using the changeset viewer.