static void gf_write(struct map_info *map, map_word d1, unsigned long ofs) { struct async_state *state = gf_map_info_to_state(map); uint16_t d; gf_set_gpios(state, ofs); d = d1.x[0]; writew(d, map->virt + (ofs % state->win_size)); }
static void gf_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); gf_set_gpios(state, to); BUG_ON(!((to + len) % state->win_size <= (to + len))); memcpy_toio(map->virt + (to % state->win_size), from, len); }
static void gf_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); gf_set_gpios(state, from); BUG_ON(!((from + len) % state->win_size <= (from + len))); memcpy_fromio(to, map->virt + (from % state->win_size), len); }
static map_word gf_read(struct map_info *map, unsigned long ofs) { struct async_state *state = gf_map_info_to_state(map); uint16_t word; map_word test; gf_set_gpios(state, ofs); word = readw(map->virt + (ofs % state->win_size)); test.x[0] = word; return test; }
/** * gf_copy_from() - copy a chunk of data from the flash * @map: MTD map state * @to: memory to copy to * @from: flash offset to copy from * @len: how much to copy * * We rely on the MTD layer to chunk up copies such that a single request here * will not cross a window size. This allows us to only wiggle the GPIOs once * before falling back to a normal memcpy. Reading the higher layer code shows * that this is indeed the case, but add a BUG_ON() to future proof. */ static void gf_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); gf_set_gpios(state, from); /* BUG if operation crosses the win_size */ BUG_ON(!((from + len) % state->win_size <= (from + len))); /* operation does not cross the win_size, so one shot it */ memcpy_fromio(to, map->virt + (from % state->win_size), len); }
/** * gf_copy_to() - copy a chunk of data to the flash * @map: MTD map state * @to: flash offset to copy to * @from: memory to copy from * @len: how much to copy * * See gf_copy_from() caveat. */ static void gf_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); gf_set_gpios(state, to); /* BUG if operation crosses the win_size */ BUG_ON(!((to + len) % state->win_size <= (to + len))); /* operation does not cross the win_size, so one shot it */ memcpy_toio(map->virt + (to % state->win_size), from, len); }
/** * gf_copy_from() - copy a chunk of data from the flash * @map: MTD map state * @to: memory to copy to * @from: flash offset to copy from * @len: how much to copy * * The "from" region may straddle more than one window, so toggle the GPIOs for * each window region before reading its data. */ static void gf_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); int this_len; while (len) { if ((from % state->win_size) + len > state->win_size) this_len = state->win_size - (from % state->win_size); else this_len = len; gf_set_gpios(state, from); memcpy_fromio(to, map->virt + (from % state->win_size), this_len); len -= this_len; from += this_len; to += this_len; } }
/** * gf_copy_to() - copy a chunk of data to the flash * @map: MTD map state * @to: flash offset to copy to * @from: memory to copy from * @len: how much to copy * * See gf_copy_from() caveat. */ static void gf_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) { struct async_state *state = gf_map_info_to_state(map); int this_len; while (len) { if ((to % state->win_size) + len > state->win_size) this_len = state->win_size - (to % state->win_size); else this_len = len; gf_set_gpios(state, to); memcpy_toio(map->virt + (to % state->win_size), from, len); len -= this_len; to += this_len; from += this_len; } }