vm: fix a null dereference on out-of-memory
[minix.git] / drivers / mmc / mmchost_dummy.c
blob3d560abae1d32564a0d779eb5fb0f07a74a9a4cb
1 /* kernel headers */
2 #include <minix/blockdriver.h>
4 /* usr headers */
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <stdarg.h>
8 #include <assert.h>
10 /* local headers */
11 #include "mmclog.h"
12 #include "mmchost.h"
13 #include "sdmmcreg.h"
16 * Define a structure to be used for logging
18 static struct mmclog log = {
19 .name = "mmc_host_memory",
20 .log_level = LEVEL_TRACE,
21 .log_func = default_log
24 /* This is currently a dummy driver using an in-memory structure */
25 #define DUMMY_SIZE_IN_BLOCKS 0xFFFu
26 #define DUMMY_BLOCK_SIZE 512
27 static char dummy_data[DUMMY_BLOCK_SIZE * DUMMY_SIZE_IN_BLOCKS];
29 static struct sd_card *
30 init_dummy_sdcard(struct sd_slot *slot)
32 int i;
33 struct sd_card *card;
35 assert(slot != NULL);
37 mmc_log_info(&log, "Using a dummy card \n");
39 card = &slot->card;
40 memset(card, 0, sizeof(struct sd_card));
41 card->slot = slot;
43 for (i = 0; i < MINOR_PER_DISK + PARTITONS_PER_DISK; i++) {
44 card->part[i].dv_base = 0;
45 card->part[i].dv_size = 0;
48 for (i = 0; i < PARTITONS_PER_DISK * SUBPARTITION_PER_PARTITION; i++) {
49 card->subpart[i].dv_base = 0;
50 card->subpart[i].dv_size = 0;
53 card->part[0].dv_base = 0;
54 card->part[0].dv_size = DUMMY_BLOCK_SIZE * DUMMY_SIZE_IN_BLOCKS;
55 return card;
58 int
59 dummy_host_init(struct mmc_host *host)
61 return 0;
64 void
65 dummy_set_log_level(int level)
67 if (level >= 0 && level <= 4) {
68 log.log_level = level;
72 int
73 dummy_host_set_instance(struct mmc_host *host, int instance)
75 mmc_log_info(&log, "Using instance number %d\n", instance);
76 if (instance != 0) {
77 return EIO;
79 return OK;
82 int
83 dummy_host_reset(struct mmc_host *host)
85 return 0;
88 int
89 dummy_card_detect(struct sd_slot *slot)
91 return 1;
94 struct sd_card *
95 dummy_card_initialize(struct sd_slot *slot)
97 slot->card.blk_size = DUMMY_BLOCK_SIZE;
98 slot->card.blk_count = DUMMY_SIZE_IN_BLOCKS;
99 slot->card.state = SD_MODE_DATA_TRANSFER_MODE;
101 memset(slot->card.part, 0, sizeof(slot->card.part));
102 memset(slot->card.subpart, 0, sizeof(slot->card.subpart));
103 slot->card.part[0].dv_base = 0;
104 slot->card.part[0].dv_size = DUMMY_BLOCK_SIZE * DUMMY_SIZE_IN_BLOCKS;
105 return &slot->card;
109 dummy_card_release(struct sd_card *card)
111 assert(card->open_ct == 1);
112 card->open_ct--;
113 card->state = SD_MODE_UNINITIALIZED;
114 /* TODO:Set card state */
115 return OK;
118 /* read count blocks into existing buf */
120 dummy_host_read(struct sd_card *card,
121 uint32_t blknr, uint32_t count, unsigned char *buf)
123 memcpy(buf, &dummy_data[blknr * DUMMY_BLOCK_SIZE],
124 count * DUMMY_BLOCK_SIZE);
125 return OK;
128 /* write count blocks */
130 dummy_host_write(struct sd_card *card,
131 uint32_t blknr, uint32_t count, unsigned char *buf)
133 memcpy(&dummy_data[blknr * DUMMY_BLOCK_SIZE], buf,
134 count * DUMMY_BLOCK_SIZE);
135 return OK;
138 void
139 host_initialize_host_structure_dummy(struct mmc_host *host)
141 /* Initialize the basic data structures host slots and cards */
142 int i;
144 host->host_set_instance = dummy_host_set_instance;
145 host->host_init = dummy_host_init;
146 host->set_log_level = dummy_set_log_level;
147 host->host_reset = dummy_host_reset;
148 host->card_detect = dummy_card_detect;
149 host->card_initialize = dummy_card_initialize;
150 host->card_release = dummy_card_release;
151 host->read = dummy_host_read;
152 host->write = dummy_host_write;
154 /* initialize data structures */
155 for (i = 0; i < sizeof(host->slot) / sizeof(host->slot[0]); i++) {
156 // @TODO set initial card and slot state
157 host->slot[i].host = host;
158 host->slot[i].card.slot = &host->slot[i];
160 init_dummy_sdcard(&host->slot[0]);