include/block/device.h

Go to the documentation of this file.

#ifndef BLOCK_DEVICE_H_INCLUDED
#define BLOCK_DEVICE_H_INCLUDED

#include <buffer.h>
#include <slist.h>
#include <types.h>
#include <status_codes.h>

typedef uint32_t block_addr_t;

typedef uint32_t block_len_t;

struct block_device;

struct block_request {
        struct slist    buf_list;
        void (*req_started)(struct block_device *bdev,
                        struct block_request *req);
        void (*req_done)(struct block_device *bdev, struct block_request *req);
        void (*buf_list_done)(struct block_device *bdev,
                        struct block_request *req, struct slist *buf_list);
        void (*req_submit)(struct block_device *bdev,
                        struct block_request *req);
        int (*req_submit_buf_list)(struct block_device *bdev,
                        struct block_request *req, struct slist *buf_list);
        void (*req_abort)(struct block_device *bdev,
                        struct block_request *req);
        void                    *context;
        enum status_code        status;
        block_len_t             bytes_xfered;
        struct block_device     *bdev;
};

enum block_device_flag {
        BDEV_UNIT_ATTENTION,    
        BDEV_PRESENT,           
        BDEV_WRITEABLE,         
};

enum block_operation {
        BLK_OP_READ,            
        BLK_OP_WRITE,           
};

struct block_device {
        uint32_t        nr_blocks;
#ifndef CONFIG_BLOCK_FIXED_BLOCK_SIZE

        uint16_t        block_size;
#endif

        uint8_t         flags;
        void (*prepare_req)(struct block_device *bdev,
                        struct block_request *req,
                        block_addr_t lba, block_len_t nr_blocks,
                        enum block_operation operation);
        struct block_request *(*alloc_req)(struct block_device *bdev);
        void (*free_req)(struct block_device *bdev, struct block_request *req);
        uint32_t (*get_dev_id)(struct block_device *bdev);
};

static inline uint16_t blkdev_get_block_size(struct block_device *bdev)
{
#ifdef CONFIG_BLOCK_FIXED_BLOCK_SIZE
        return CONFIG_BLOCK_FIXED_BLOCK_SIZE;
#else
        return bdev->block_size;
#endif
}

static inline void blkdev_set_block_size(struct block_device *bdev,
                uint16_t block_size)
{
#ifdef CONFIG_BLOCK_FIXED_BLOCK_SIZE
        assert(block_size == CONFIG_BLOCK_FIXED_BLOCK_SIZE);
#else
        bdev->block_size = block_size;
#endif
}

extern struct block_request *block_alloc_request(struct block_device *bdev);
extern void block_free_request(struct block_device *bdev,
                struct block_request *req);

static inline void block_prepare_req(struct block_device *bdev,
                struct block_request *req, block_addr_t lba,
                block_len_t nr_blocks, enum block_operation operation)
{
        assert(bdev == req->bdev);

        bdev->prepare_req(bdev, req, lba, nr_blocks, operation);
}

static inline void block_submit_req(struct block_device *bdev,
                struct block_request *req)
{
        assert(bdev == req->bdev);

        req->req_submit(bdev, req);
}

static inline void block_queue_req(struct block_device *bdev,
                struct block_request *req, block_addr_t lba,
                block_len_t nr_blocks, enum block_operation operation)
{
        block_prepare_req(bdev, req, lba, nr_blocks, operation);
        block_submit_req(bdev, req);
}

static inline void block_abort_req(struct block_device *bdev,
                struct block_request *req)
{
        /* FIXME */
}

static inline uint32_t block_get_dev_id(struct block_device *bdev)
{
        assert(bdev);
        assert(bdev->get_dev_id);

        return bdev->get_dev_id(bdev);
}

static inline int block_submit_buf_list(struct block_device *bdev,
                struct block_request *breq, struct slist *buf_list)
{
        assert(breq->bdev == bdev);
        assert(breq->req_submit_buf_list);

        return breq->req_submit_buf_list(bdev, breq, buf_list);
}

static inline block_len_t blk_req_get_blocks_xfered(struct block_device *bdev,
                struct block_request *breq)
{
        assert(bdev == breq->bdev);

        return breq->bytes_xfered / blkdev_get_block_size(bdev);
}

static inline block_len_t blk_req_get_bytes_xfered(struct block_device *bdev,
                struct block_request *breq)
{
        assert(bdev == breq->bdev);

        return breq->bytes_xfered;
}

static inline void blk_req_add_buffer(struct block_request *req,
                struct buffer *buf)
{
        slist_insert_tail(&req->buf_list, &buf->node);
}

static inline void blk_req_add_buffer_list(struct block_request *req,
                struct slist *list)
{
        slist_move_to_tail(&req->buf_list, list);
}


#endif /* BLOCK_DEVICE_H_INCLUDED */

---