device.h

Go to the documentation of this file.

#ifndef DEVICE_H
#define DEVICE_H

#include <glib.h>
#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>

#include "include/log.h" 
#define PADDR_EMPTY ((uint32_t)UINT32_MAX)

struct device_request;
struct device_operations;

#define DEVICE_PAGE_SIZE (8192)

enum { DEVICE_DEFAULT_REQUEST = 0,
};

enum { DEVICE_WRITE = 0 ,
       DEVICE_READ ,
       DEVICE_ERASE ,
};

enum { RAMDISK_MODULE = 0 ,
       BLUEDBM_MODULE ,
       ZONE_MODULE ,
};

#ifndef DEVICE_NR_BUS_BITS
#define DEVICE_NR_BUS_BITS (3)
#endif

#ifndef DEVICE_NR_CHIPS_BITS
#define DEVICE_NR_CHIPS_BITS (3)
#endif

#ifndef DEVICE_NR_PAGES_BITS
#define DEVICE_NR_PAGES_BITS (7)
#endif

#ifndef DEVICE_NR_BLOCKS_BITS
#define DEVICE_NR_BLOCKS_BITS (19)
#endif

#if 0
#pragma message("DEVICE_NR_BUS_BITS = " TOSTRING(DEVICE_NR_BUS_BITS))
#pragma message("DEVICE_NR_CHIPS_BITS = " TOSTRING(DEVICE_NR_CHIPS_BITS))
#pragma message("DEVICE_NR_PAGES_BITS = " TOSTRING(DEVICE_NR_PAGES_BITS))
#pragma message("DEVICE_NR_BLOCKS_BITS = " TOSTRING(DEVICE_NR_BLOCKS_BITS))
#endif

typedef void (*device_end_req_fn)(struct device_request *);

struct device_address {
    union {
        struct {
            uint32_t bus : DEVICE_NR_BUS_BITS;
            uint32_t chip : DEVICE_NR_CHIPS_BITS;
            uint32_t page : DEVICE_NR_PAGES_BITS;
            uint32_t block : DEVICE_NR_BLOCKS_BITS;
        } format;
        uint32_t lpn;
    };
};

struct device_request {
    unsigned int flag; 
    size_t data_len; 
    size_t sector; 
    struct device_address paddr; 
    void *data; 
    device_end_req_fn end_rq; 
    gint is_finish;

    pthread_mutex_t mutex;
    pthread_cond_t cond;

    void *rq_private; 
};

struct device_page {
    size_t size; 
};

struct device_block {
    struct device_page page;
    size_t nr_pages;
};

struct device_package {
    struct device_block block;
    size_t nr_blocks;
};

struct device_info {
    struct device_package package;
    size_t nr_bus; 
    size_t nr_chips; 
};

struct device {
    pthread_mutex_t mutex;
    const struct device_operations *d_op;
    struct device_info info;
    uint64_t *badseg_bitmap;
    void *d_private; 
    int (*d_submodule_exit)(struct device *);
};

struct device_operations {
    int (*open)(struct device *, const char *name, int flags);
    ssize_t (*write)(struct device *, struct device_request *);
    ssize_t (*read)(struct device *, struct device_request *);
    int (*erase)(struct device *, struct device_request *);
    int (*close)(struct device *);
};

struct device_request *device_alloc_request(uint64_t flags);
void device_free_request(struct device_request *);

int device_module_init(const uint64_t modnum, struct device **, uint64_t flags);
int device_module_exit(struct device *);

static inline size_t device_get_nr_segments(struct device *dev)
{
    struct device_info *info = &dev->info;
    struct device_package *package = &info->package;
    return package->nr_blocks;
}

static inline size_t device_get_blocks_per_segment(struct device *dev)
{
    struct device_info *info = &dev->info;
    return (info->nr_bus * info->nr_chips);
}

static inline size_t device_get_pages_per_segment(struct device *dev)
{
    struct device_info *info = &dev->info;
    struct device_package *package = &info->package;
    struct device_block *block = &package->block;

    return device_get_blocks_per_segment(dev) * block->nr_pages;
}

static inline size_t device_get_page_size(struct device *dev)
{
    struct device_info *info = &dev->info;
    struct device_package *package = &info->package;
    struct device_block *block = &package->block;
    struct device_page *page = &block->page;
    return page->size;
}

static inline size_t device_get_total_size(struct device *dev)
{
    size_t nr_segments = device_get_nr_segments(dev);
    size_t nr_pages_per_segment = device_get_pages_per_segment(dev);
    size_t page_size = device_get_page_size(dev);

    return nr_segments * nr_pages_per_segment * page_size;
}

static inline size_t device_get_total_pages(struct device *dev)
{
    return device_get_total_size(dev) / device_get_page_size(dev);
}

#endif