Lines Matching refs:msb
147 static int msb_validate_used_block_bitmap(struct msb_data *msb)
155 for (i = 0; i < msb->zone_count; i++)
156 total_free_blocks += msb->free_block_count[i];
158 if (msb->block_count - bitmap_weight(msb->used_blocks_bitmap,
159 msb->block_count) == total_free_blocks)
163 msb->read_only = true;
168 static void msb_mark_block_used(struct msb_data *msb, int pba)
172 if (test_bit(pba, msb->used_blocks_bitmap)) {
175 msb->read_only = true;
179 if (msb_validate_used_block_bitmap(msb))
183 __set_bit(pba, msb->used_blocks_bitmap);
184 msb->free_block_count[zone]--;
188 static void msb_mark_block_unused(struct msb_data *msb, int pba)
192 if (!test_bit(pba, msb->used_blocks_bitmap)) {
194 msb->read_only = true;
198 if (msb_validate_used_block_bitmap(msb))
202 __clear_bit(pba, msb->used_blocks_bitmap);
203 msb->free_block_count[zone]++;
207 static void msb_invalidate_reg_window(struct msb_data *msb)
209 msb->reg_addr.w_offset = offsetof(struct ms_register, id);
210 msb->reg_addr.w_length = sizeof(struct ms_id_register);
211 msb->reg_addr.r_offset = offsetof(struct ms_register, id);
212 msb->reg_addr.r_length = sizeof(struct ms_id_register);
213 msb->addr_valid = false;
217 static int msb_run_state_machine(struct msb_data *msb, int (*state_func)
220 struct memstick_dev *card = msb->card;
222 WARN_ON(msb->state != -1);
223 msb->int_polling = false;
224 msb->state = 0;
225 msb->exit_error = 0;
233 WARN_ON(msb->state != -1);
234 return msb->exit_error;
238 static int msb_exit_state_machine(struct msb_data *msb, int error)
240 WARN_ON(msb->state == -1);
242 msb->state = -1;
243 msb->exit_error = error;
244 msb->card->next_request = h_msb_default_bad;
248 msb_invalidate_reg_window(msb);
250 complete(&msb->card->mrq_complete);
255 static int msb_read_int_reg(struct msb_data *msb, long timeout)
257 struct memstick_request *mrq = &msb->card->current_mrq;
259 WARN_ON(msb->state == -1);
261 if (!msb->int_polling) {
262 msb->int_timeout = jiffies +
264 msb->int_polling = true;
265 } else if (time_after(jiffies, msb->int_timeout)) {
270 if ((msb->caps & MEMSTICK_CAP_AUTO_GET_INT) &&
282 static int msb_read_regs(struct msb_data *msb, int offset, int len)
284 struct memstick_request *req = &msb->card->current_mrq;
286 if (msb->reg_addr.r_offset != offset ||
287 msb->reg_addr.r_length != len || !msb->addr_valid) {
289 msb->reg_addr.r_offset = offset;
290 msb->reg_addr.r_length = len;
291 msb->addr_valid = true;
294 &msb->reg_addr, sizeof(msb->reg_addr));
303 static int msb_write_regs(struct msb_data *msb, int offset, int len, void *buf)
305 struct memstick_request *req = &msb->card->current_mrq;
307 if (msb->reg_addr.w_offset != offset ||
308 msb->reg_addr.w_length != len || !msb->addr_valid) {
310 msb->reg_addr.w_offset = offset;
311 msb->reg_addr.w_length = len;
312 msb->addr_valid = true;
315 &msb->reg_addr, sizeof(msb->reg_addr));
332 * Writes output to msb->current_sg, takes sector address from msb->reg.param
338 struct msb_data *msb = memstick_get_drvdata(card);
345 return msb_exit_state_machine(msb, mrq->error);
348 switch (msb->state) {
354 if (!msb_write_regs(msb,
357 (unsigned char *)&msb->regs.param))
360 msb->state = MSB_RP_SEND_READ_COMMAND;
366 msb->state = MSB_RP_SEND_INT_REQ;
370 msb->state = MSB_RP_RECEIVE_INT_REQ_RESULT;
374 if (msb_read_int_reg(msb, -1))
380 msb->regs.status.interrupt = intreg;
383 return msb_exit_state_machine(msb, -EIO);
386 msb->state = MSB_RP_SEND_INT_REQ;
390 msb->int_polling = false;
391 msb->state = (intreg & MEMSTICK_INT_ERR) ?
397 if (!msb_read_regs(msb,
402 msb->state = MSB_RP_RECEIVE_STATUS_REG;
406 msb->regs.status = *(struct ms_status_register *)mrq->data;
407 msb->state = MSB_RP_SEND_OOB_READ;
411 if (!msb_read_regs(msb,
416 msb->state = MSB_RP_RECEIVE_OOB_READ;
420 msb->regs.extra_data =
422 msb->state = MSB_RP_SEND_READ_DATA;
427 if (msb->regs.param.cp == MEMSTICK_CP_EXTRA) {
428 msb->state = MSB_RP_RECEIVE_READ_DATA;
433 msb_sg_copy(msb->current_sg, sg, ARRAY_SIZE(sg),
434 msb->current_sg_offset,
435 msb->page_size);
438 msb->state = MSB_RP_RECEIVE_READ_DATA;
442 if (!(msb->regs.status.interrupt & MEMSTICK_INT_ERR)) {
443 msb->current_sg_offset += msb->page_size;
444 return msb_exit_state_machine(msb, 0);
447 if (msb->regs.status.status1 & MEMSTICK_UNCORR_ERROR) {
449 return msb_exit_state_machine(msb, -EBADMSG);
452 if (msb->regs.status.status1 & MEMSTICK_CORR_ERROR) {
454 msb->current_sg_offset += msb->page_size;
455 return msb_exit_state_machine(msb, -EUCLEAN);
458 return msb_exit_state_machine(msb, -EIO);
467 * Takes address from msb->regs.param.
469 * from msb->regs.extra
476 struct msb_data *msb = memstick_get_drvdata(card);
482 return msb_exit_state_machine(msb, mrq->error);
485 switch (msb->state) {
494 if (!msb_write_regs(msb,
497 &msb->regs.param))
500 msb->state = MSB_WB_SEND_WRITE_OOB;
504 if (!msb_write_regs(msb,
507 &msb->regs.extra_data))
509 msb->state = MSB_WB_SEND_WRITE_COMMAND;
516 msb->state = MSB_WB_SEND_INT_REQ;
520 msb->state = MSB_WB_RECEIVE_INT_REQ;
521 if (msb_read_int_reg(msb, -1))
527 msb->regs.status.interrupt = intreg;
531 return msb_exit_state_machine(msb, -EIO);
534 return msb_exit_state_machine(msb, -EBADMSG);
538 if (msb->current_page == msb->pages_in_block) {
540 return msb_exit_state_machine(msb, 0);
541 msb->state = MSB_WB_SEND_INT_REQ;
548 msb->state = MSB_WB_SEND_INT_REQ;
552 msb->int_polling = false;
553 msb->state = MSB_WB_SEND_WRITE_DATA;
559 if (msb_sg_copy(msb->current_sg, sg, ARRAY_SIZE(sg),
560 msb->current_sg_offset,
561 msb->page_size) < msb->page_size)
562 return msb_exit_state_machine(msb, -EIO);
566 msb->state = MSB_WB_RECEIVE_WRITE_CONFIRMATION;
570 msb->current_page++;
571 msb->current_sg_offset += msb->page_size;
572 msb->state = MSB_WB_SEND_INT_REQ;
588 struct msb_data *msb = memstick_get_drvdata(card);
594 return msb_exit_state_machine(msb, mrq->error);
597 switch (msb->state) {
601 if (!msb_write_regs(msb,
604 &msb->regs.param))
606 msb->state = MSB_SC_SEND_WRITE_OOB;
610 if (!msb->command_need_oob) {
611 msb->state = MSB_SC_SEND_COMMAND;
615 if (!msb_write_regs(msb,
618 &msb->regs.extra_data))
621 msb->state = MSB_SC_SEND_COMMAND;
625 memstick_init_req(mrq, MS_TPC_SET_CMD, &msb->command_value, 1);
626 msb->state = MSB_SC_SEND_INT_REQ;
630 msb->state = MSB_SC_RECEIVE_INT_REQ;
631 if (msb_read_int_reg(msb, -1))
639 return msb_exit_state_machine(msb, -EIO);
641 return msb_exit_state_machine(msb, -EBADMSG);
644 msb->state = MSB_SC_SEND_INT_REQ;
648 return msb_exit_state_machine(msb, 0);
659 struct msb_data *msb = memstick_get_drvdata(card);
663 return msb_exit_state_machine(msb, mrq->error);
665 switch (msb->state) {
669 msb->state = MSB_RS_CONFIRM;
672 return msb_exit_state_machine(msb, 0);
681 struct msb_data *msb = memstick_get_drvdata(card);
687 msb->regs.param.system &= ~MEMSTICK_SYS_PAM;
688 return msb_exit_state_machine(msb, mrq->error);
691 switch (msb->state) {
694 msb->regs.param.system |= MEMSTICK_SYS_PAM;
696 if (!msb_write_regs(msb,
699 (unsigned char *)&msb->regs.param))
702 msb->state = MSB_PS_SWICH_HOST;
711 msb->state = MSB_PS_CONFIRM;
715 return msb_exit_state_machine(msb, 0);
721 static int msb_switch_to_parallel(struct msb_data *msb);
724 static int msb_reset(struct msb_data *msb, bool full)
727 bool was_parallel = msb->regs.param.system & MEMSTICK_SYS_PAM;
728 struct memstick_dev *card = msb->card;
733 msb->regs.param.system = MEMSTICK_SYS_BAMD;
741 msb_invalidate_reg_window(msb);
753 msb->read_only = true;
758 error = msb_run_state_machine(msb, h_msb_reset);
761 msb->read_only = true;
767 msb_switch_to_parallel(msb);
772 static int msb_switch_to_parallel(struct msb_data *msb)
776 error = msb_run_state_machine(msb, h_msb_parallel_switch);
779 msb->regs.param.system &= ~MEMSTICK_SYS_PAM;
780 msb_reset(msb, true);
784 msb->caps |= MEMSTICK_CAP_AUTO_GET_INT;
789 static int msb_set_overwrite_flag(struct msb_data *msb,
792 if (msb->read_only)
795 msb->regs.param.block_address = cpu_to_be16(pba);
796 msb->regs.param.page_address = page;
797 msb->regs.param.cp = MEMSTICK_CP_OVERWRITE;
798 msb->regs.extra_data.overwrite_flag = flag;
799 msb->command_value = MS_CMD_BLOCK_WRITE;
800 msb->command_need_oob = true;
804 return msb_run_state_machine(msb, h_msb_send_command);
807 static int msb_mark_bad(struct msb_data *msb, int pba)
810 msb_reset(msb, true);
812 msb, pba, 0, 0xFF & ~MEMSTICK_OVERWRITE_BKST);
815 static int msb_mark_page_bad(struct msb_data *msb, int pba, int page)
818 msb_reset(msb, true);
819 return msb_set_overwrite_flag(msb,
824 static int msb_erase_block(struct msb_data *msb, u16 pba)
828 if (msb->read_only)
834 msb->regs.param.block_address = cpu_to_be16(pba);
835 msb->regs.param.page_address = 0;
836 msb->regs.param.cp = MEMSTICK_CP_BLOCK;
837 msb->command_value = MS_CMD_BLOCK_ERASE;
838 msb->command_need_oob = false;
841 error = msb_run_state_machine(msb, h_msb_send_command);
842 if (!error || msb_reset(msb, true))
848 msb_mark_bad(msb, pba);
852 msb_mark_block_unused(msb, pba);
853 __set_bit(pba, msb->erased_blocks_bitmap);
858 static int msb_read_page(struct msb_data *msb,
867 size_t len = msb->page_size;
901 if (pba >= msb->block_count) {
907 msb->regs.param.block_address = cpu_to_be16(pba);
908 msb->regs.param.page_address = page;
909 msb->regs.param.cp = MEMSTICK_CP_PAGE;
911 msb->current_sg = sg;
912 msb->current_sg_offset = offset;
913 error = msb_run_state_machine(msb, h_msb_read_page);
923 *extra = msb->regs.extra_data;
925 if (!error || msb_reset(msb, true))
935 if (msb->regs.extra_data.overwrite_flag &
937 msb_mark_page_bad(msb, pba, page);
948 static int msb_read_oob(struct msb_data *msb, u16 pba, u16 page,
954 msb->regs.param.block_address = cpu_to_be16(pba);
955 msb->regs.param.page_address = page;
956 msb->regs.param.cp = MEMSTICK_CP_EXTRA;
958 if (pba > msb->block_count) {
963 error = msb_run_state_machine(msb, h_msb_read_page);
964 *extra = msb->regs.extra_data;
976 static int msb_verify_block(struct msb_data *msb, u16 pba,
982 sg_init_one(&sg, msb->block_buffer, msb->block_size);
984 while (page < msb->pages_in_block) {
986 error = msb_read_page(msb, pba, page,
987 NULL, &sg, page * msb->page_size);
994 msb->block_buffer, msb->block_size))
1000 static int msb_write_block(struct msb_data *msb,
1005 BUG_ON(sg->length < msb->page_size);
1007 if (msb->read_only)
1016 if (pba >= msb->block_count || lba >= msb->logical_block_count) {
1027 if (pba == msb->boot_block_locations[0] ||
1028 pba == msb->boot_block_locations[1]) {
1035 if (msb->read_only)
1038 msb->regs.param.cp = MEMSTICK_CP_BLOCK;
1039 msb->regs.param.page_address = 0;
1040 msb->regs.param.block_address = cpu_to_be16(pba);
1042 msb->regs.extra_data.management_flag = 0xFF;
1043 msb->regs.extra_data.overwrite_flag = 0xF8;
1044 msb->regs.extra_data.logical_address = cpu_to_be16(lba);
1046 msb->current_sg = sg;
1047 msb->current_sg_offset = offset;
1048 msb->current_page = 0;
1050 error = msb_run_state_machine(msb, h_msb_write_block);
1060 !test_bit(pba, msb->erased_blocks_bitmap)))
1061 error = msb_verify_block(msb, pba, sg, offset);
1066 if (current_try > 1 || msb_reset(msb, true))
1070 error = msb_erase_block(msb, pba);
1080 static u16 msb_get_free_block(struct msb_data *msb, int zone)
1088 if (!msb->free_block_count[zone]) {
1090 msb->read_only = true;
1094 pos %= msb->free_block_count[zone];
1097 msb->free_block_count[zone], pos);
1099 pba = find_next_zero_bit(msb->used_blocks_bitmap,
1100 msb->block_count, pba);
1102 pba = find_next_zero_bit(msb->used_blocks_bitmap,
1103 msb->block_count, pba + 1);
1107 if (pba == msb->block_count || (msb_get_zone_from_pba(pba)) != zone) {
1109 msb->read_only = true;
1113 msb_mark_block_used(msb, pba);
1117 static int msb_update_block(struct msb_data *msb, u16 lba,
1123 pba = msb->lba_to_pba_table[lba];
1128 msb_set_overwrite_flag(msb, pba, 0,
1133 new_pba = msb_get_free_block(msb,
1143 error = msb_write_block(msb, new_pba, lba, sg, offset);
1145 msb_mark_bad(msb, new_pba);
1153 msb_erase_block(msb, pba);
1154 msb->lba_to_pba_table[lba] = new_pba;
1160 msb->read_only = true;
1192 static int msb_read_boot_blocks(struct msb_data *msb)
1199 msb->boot_block_locations[0] = MS_BLOCK_INVALID;
1200 msb->boot_block_locations[1] = MS_BLOCK_INVALID;
1201 msb->boot_block_count = 0;
1205 if (!msb->boot_page) {
1211 msb->boot_page = page;
1213 page = msb->boot_page;
1215 msb->block_count = MS_BLOCK_MAX_BOOT_ADDR;
1220 if (msb_read_page(msb, pba, 0, &extra, &sg, 0)) {
1237 msb->boot_block_locations[msb->boot_block_count] = pba;
1240 msb->boot_block_count++;
1242 if (msb->boot_block_count == 2)
1246 if (!msb->boot_block_count) {
1255 static int msb_read_bad_block_table(struct msb_data *msb, int block_nr)
1266 boot_block = &msb->boot_page[block_nr];
1267 pba = msb->boot_block_locations[block_nr];
1269 if (msb->boot_block_locations[block_nr] == MS_BLOCK_INVALID)
1278 page = data_offset / msb->page_size;
1279 page_offset = data_offset % msb->page_size;
1281 DIV_ROUND_UP(data_size + page_offset, msb->page_size) *
1282 msb->page_size;
1295 error = msb_read_page(msb, pba, page, NULL, &sg, offset);
1300 offset += msb->page_size;
1302 if (page == msb->pages_in_block) {
1314 if (bad_block >= msb->block_count) {
1320 if (test_bit(bad_block, msb->used_blocks_bitmap)) {
1327 msb_mark_block_used(msb, bad_block);
1334 static int msb_ftl_initialize(struct msb_data *msb)
1338 if (msb->ftl_initialized)
1341 msb->zone_count = msb->block_count / MS_BLOCKS_IN_ZONE;
1342 msb->logical_block_count = msb->zone_count * 496 - 2;
1344 msb->used_blocks_bitmap = bitmap_zalloc(msb->block_count, GFP_KERNEL);
1345 msb->erased_blocks_bitmap = bitmap_zalloc(msb->block_count, GFP_KERNEL);
1346 msb->lba_to_pba_table =
1347 kmalloc_array(msb->logical_block_count, sizeof(u16),
1350 if (!msb->used_blocks_bitmap || !msb->lba_to_pba_table ||
1351 !msb->erased_blocks_bitmap) {
1352 bitmap_free(msb->used_blocks_bitmap);
1353 bitmap_free(msb->erased_blocks_bitmap);
1354 kfree(msb->lba_to_pba_table);
1358 for (i = 0; i < msb->zone_count; i++)
1359 msb->free_block_count[i] = MS_BLOCKS_IN_ZONE;
1361 memset(msb->lba_to_pba_table, MS_BLOCK_INVALID,
1362 msb->logical_block_count * sizeof(u16));
1365 msb->zone_count, msb->logical_block_count);
1367 msb->ftl_initialized = true;
1371 static int msb_ftl_scan(struct msb_data *msb)
1377 u8 *overwrite_flags = kzalloc(msb->block_count, GFP_KERNEL);
1383 for (pba = 0; pba < msb->block_count; pba++) {
1385 if (pba == msb->boot_block_locations[0] ||
1386 pba == msb->boot_block_locations[1]) {
1388 msb_mark_block_used(msb, pba);
1392 if (test_bit(pba, msb->used_blocks_bitmap)) {
1398 error = msb_read_oob(msb, pba, 0, &extra);
1404 msb_mark_block_used(msb, pba);
1405 msb_erase_block(msb, pba);
1423 msb_mark_block_used(msb, pba);
1432 msb_mark_block_used(msb, pba);
1440 msb_mark_block_used(msb, pba);
1441 msb_erase_block(msb, pba);
1450 msb_mark_block_used(msb, pba);
1456 msb_erase_block(msb, pba);
1461 if (msb->lba_to_pba_table[lba] == MS_BLOCK_INVALID) {
1463 msb->lba_to_pba_table[lba] = pba;
1467 other_block = msb->lba_to_pba_table[lba];
1475 msb_erase_block(msb, other_block);
1476 msb->lba_to_pba_table[lba] = pba;
1483 msb_erase_block(msb, pba);
1490 msb_erase_block(msb, other_block);
1491 msb->lba_to_pba_table[lba] = pba;
1501 struct msb_data *msb = from_timer(msb, t, cache_flush_timer);
1503 msb->need_flush_cache = true;
1504 queue_work(msb->io_queue, &msb->io_work);
1508 static void msb_cache_discard(struct msb_data *msb)
1510 if (msb->cache_block_lba == MS_BLOCK_INVALID)
1513 del_timer_sync(&msb->cache_flush_timer);
1516 msb->cache_block_lba = MS_BLOCK_INVALID;
1517 bitmap_zero(&msb->valid_cache_bitmap, msb->pages_in_block);
1520 static int msb_cache_init(struct msb_data *msb)
1522 timer_setup(&msb->cache_flush_timer, msb_cache_flush_timer, 0);
1524 if (!msb->cache)
1525 msb->cache = kzalloc(msb->block_size, GFP_KERNEL);
1526 if (!msb->cache)
1529 msb_cache_discard(msb);
1533 static int msb_cache_flush(struct msb_data *msb)
1540 if (msb->read_only)
1543 if (msb->cache_block_lba == MS_BLOCK_INVALID)
1546 lba = msb->cache_block_lba;
1547 pba = msb->lba_to_pba_table[lba];
1550 pba, msb->cache_block_lba);
1552 sg_init_one(&sg, msb->cache , msb->block_size);
1555 for (page = 0; page < msb->pages_in_block; page++) {
1557 if (test_bit(page, &msb->valid_cache_bitmap))
1560 offset = page * msb->page_size;
1564 error = msb_read_page(msb, pba, page, &extra, &sg, offset);
1581 set_bit(page, &msb->valid_cache_bitmap);
1585 error = msb_update_block(msb, msb->cache_block_lba, &sg, 0);
1586 pba = msb->lba_to_pba_table[msb->cache_block_lba];
1590 for (page = 0; page < msb->pages_in_block; page++) {
1592 if (test_bit(page, &msb->valid_cache_bitmap))
1597 msb_set_overwrite_flag(msb,
1602 msb_cache_discard(msb);
1606 static int msb_cache_write(struct msb_data *msb, int lba,
1612 if (msb->read_only)
1615 if (msb->cache_block_lba == MS_BLOCK_INVALID ||
1616 lba != msb->cache_block_lba)
1621 if (msb->cache_block_lba != MS_BLOCK_INVALID &&
1622 lba != msb->cache_block_lba) {
1624 error = msb_cache_flush(msb);
1629 if (msb->cache_block_lba == MS_BLOCK_INVALID) {
1630 msb->cache_block_lba = lba;
1631 mod_timer(&msb->cache_flush_timer,
1638 msb_sg_copy(sg, sg_tmp, ARRAY_SIZE(sg_tmp), offset, msb->page_size);
1641 msb->cache + page * msb->page_size, msb->page_size);
1643 set_bit(page, &msb->valid_cache_bitmap);
1647 static int msb_cache_read(struct msb_data *msb, int lba,
1650 int pba = msb->lba_to_pba_table[lba];
1654 if (lba == msb->cache_block_lba &&
1655 test_bit(page, &msb->valid_cache_bitmap)) {
1662 offset, msb->page_size);
1664 msb->cache + msb->page_size * page,
1665 msb->page_size);
1670 error = msb_read_page(msb, pba, page, NULL, sg, offset);
1674 msb_cache_write(msb, lba, page, true, sg, offset);
1700 struct msb_data *msb = memstick_get_drvdata(card);
1705 msb->caps = 0;
1709 msb->read_only = true;
1711 msb->state = -1;
1712 error = msb_reset(msb, false);
1721 msb_switch_to_parallel(msb);
1723 msb->page_size = sizeof(struct ms_boot_page);
1726 error = msb_read_boot_blocks(msb);
1730 boot_block = &msb->boot_page[0];
1733 msb->block_count = boot_block->attr.number_of_blocks;
1734 msb->page_size = boot_block->attr.page_size;
1736 msb->pages_in_block = boot_block->attr.block_size * 2;
1737 msb->block_size = msb->page_size * msb->pages_in_block;
1739 if ((size_t)msb->page_size > PAGE_SIZE) {
1741 dbg("device page %d size isn't supported", msb->page_size);
1745 msb->block_buffer = kzalloc(msb->block_size, GFP_KERNEL);
1746 if (!msb->block_buffer)
1749 raw_size_in_megs = (msb->block_size * msb->block_count) >> 20;
1756 msb->geometry.cylinders = chs_table[i].cyl;
1757 msb->geometry.heads = chs_table[i].head;
1758 msb->geometry.sectors = chs_table[i].sec;
1763 msb->caps |= MEMSTICK_CAP_PAR4;
1766 msb->read_only = true;
1768 dbg("Total block count = %d", msb->block_count);
1769 dbg("Each block consists of %d pages", msb->pages_in_block);
1770 dbg("Page size = %d bytes", msb->page_size);
1771 dbg("Parallel mode supported: %d", !!(msb->caps & MEMSTICK_CAP_PAR4));
1772 dbg("Read only: %d", msb->read_only);
1776 if (host->caps & msb->caps & MEMSTICK_CAP_PAR4)
1777 msb_switch_to_parallel(msb);
1780 error = msb_cache_init(msb);
1784 error = msb_ftl_initialize(msb);
1790 error = msb_read_bad_block_table(msb, 0);
1794 error = msb_read_bad_block_table(msb, 1);
1801 error = msb_ftl_scan(msb);
1811 static int msb_do_write_request(struct msb_data *msb, int lba,
1819 if (page == 0 && len - offset >= msb->block_size) {
1821 if (msb->cache_block_lba == lba)
1822 msb_cache_discard(msb);
1825 error = msb_update_block(msb, lba, sg, offset);
1829 offset += msb->block_size;
1830 *sucessfuly_written += msb->block_size;
1835 error = msb_cache_write(msb, lba, page, false, sg, offset);
1839 offset += msb->page_size;
1840 *sucessfuly_written += msb->page_size;
1843 if (page == msb->pages_in_block) {
1851 static int msb_do_read_request(struct msb_data *msb, int lba,
1860 error = msb_cache_read(msb, lba, page, sg, offset);
1864 offset += msb->page_size;
1865 *sucessfuly_read += msb->page_size;
1868 if (page == msb->pages_in_block) {
1878 struct msb_data *msb = container_of(work, struct msb_data, io_work);
1881 struct scatterlist *sg = msb->prealloc_sg;
1887 spin_lock_irq(&msb->q_lock);
1889 if (msb->need_flush_cache) {
1890 msb->need_flush_cache = false;
1891 spin_unlock_irq(&msb->q_lock);
1892 msb_cache_flush(msb);
1896 req = msb->req;
1899 spin_unlock_irq(&msb->q_lock);
1903 spin_unlock_irq(&msb->q_lock);
1907 blk_rq_map_sg(msb->queue, req, sg);
1911 sector_div(lba, msb->page_size / 512);
1912 page = sector_div(lba, msb->pages_in_block);
1914 if (rq_data_dir(msb->req) == READ)
1915 error = msb_do_read_request(msb, lba, page, sg,
1918 error = msb_do_write_request(msb, lba, page, sg,
1923 spin_lock_irq(&msb->q_lock);
1924 msb->req = NULL;
1925 spin_unlock_irq(&msb->q_lock);
1928 if (error && msb->req) {
1933 spin_lock_irq(&msb->q_lock);
1934 msb->req = NULL;
1935 spin_unlock_irq(&msb->q_lock);
1938 if (msb->req)
1946 static void msb_data_clear(struct msb_data *msb)
1948 kfree(msb->boot_page);
1949 bitmap_free(msb->used_blocks_bitmap);
1950 bitmap_free(msb->erased_blocks_bitmap);
1951 kfree(msb->lba_to_pba_table);
1952 kfree(msb->cache);
1953 msb->card = NULL;
1959 struct msb_data *msb = bdev->bd_disk->private_data;
1960 *geo = msb->geometry;
1966 struct msb_data *msb = disk->private_data;
1969 idr_remove(&msb_disk_idr, msb->disk_id);
1972 kfree(msb);
1979 struct msb_data *msb = memstick_get_drvdata(card);
1984 spin_lock_irq(&msb->q_lock);
1986 if (msb->card_dead) {
1989 WARN_ON(!msb->io_queue_stopped);
1991 spin_unlock_irq(&msb->q_lock);
1996 if (msb->req) {
1997 spin_unlock_irq(&msb->q_lock);
2002 msb->req = req;
2004 if (!msb->io_queue_stopped)
2005 queue_work(msb->io_queue, &msb->io_work);
2007 spin_unlock_irq(&msb->q_lock);
2013 struct msb_data *msb = memstick_get_drvdata(card);
2015 return (msb->card_dead == 0);
2020 struct msb_data *msb = memstick_get_drvdata(card);
2025 blk_mq_stop_hw_queues(msb->queue);
2026 spin_lock_irqsave(&msb->q_lock, flags);
2027 msb->io_queue_stopped = true;
2028 spin_unlock_irqrestore(&msb->q_lock, flags);
2030 del_timer_sync(&msb->cache_flush_timer);
2031 flush_workqueue(msb->io_queue);
2033 spin_lock_irqsave(&msb->q_lock, flags);
2034 if (msb->req) {
2035 blk_mq_requeue_request(msb->req, false);
2036 msb->req = NULL;
2038 spin_unlock_irqrestore(&msb->q_lock, flags);
2043 struct msb_data *msb = memstick_get_drvdata(card);
2048 msb_invalidate_reg_window(msb);
2050 spin_lock_irqsave(&msb->q_lock, flags);
2051 if (!msb->io_queue_stopped || msb->card_dead) {
2052 spin_unlock_irqrestore(&msb->q_lock, flags);
2055 spin_unlock_irqrestore(&msb->q_lock, flags);
2058 msb->need_flush_cache = true;
2059 msb->io_queue_stopped = false;
2061 blk_mq_start_hw_queues(msb->queue);
2063 queue_work(msb->io_queue, &msb->io_work);
2080 struct msb_data *msb = memstick_get_drvdata(card);
2082 .logical_block_size = msb->page_size,
2085 .max_segment_size = MS_BLOCK_MAX_PAGES * msb->page_size,
2091 msb->disk_id = idr_alloc(&msb_disk_idr, card, 0, 256, GFP_KERNEL);
2094 if (msb->disk_id < 0)
2095 return msb->disk_id;
2097 rc = blk_mq_alloc_sq_tag_set(&msb->tag_set, &msb_mq_ops, 2,
2102 msb->disk = blk_mq_alloc_disk(&msb->tag_set, &lim, card);
2103 if (IS_ERR(msb->disk)) {
2104 rc = PTR_ERR(msb->disk);
2107 msb->queue = msb->disk->queue;
2109 sprintf(msb->disk->disk_name, "msblk%d", msb->disk_id);
2110 msb->disk->fops = &msb_bdops;
2111 msb->disk->private_data = msb;
2113 capacity = msb->pages_in_block * msb->logical_block_count;
2114 capacity *= (msb->page_size / 512);
2115 set_capacity(msb->disk, capacity);
2118 msb->io_queue = alloc_ordered_workqueue("ms_block", WQ_MEM_RECLAIM);
2119 if (!msb->io_queue) {
2124 INIT_WORK(&msb->io_work, msb_io_work);
2125 sg_init_table(msb->prealloc_sg, MS_BLOCK_MAX_SEGS+1);
2127 if (msb->read_only)
2128 set_disk_ro(msb->disk, 1);
2131 rc = device_add_disk(&card->dev, msb->disk, NULL);
2138 destroy_workqueue(msb->io_queue);
2140 put_disk(msb->disk);
2142 blk_mq_free_tag_set(&msb->tag_set);
2145 idr_remove(&msb_disk_idr, msb->disk_id);
2152 struct msb_data *msb;
2155 msb = kzalloc(sizeof(struct msb_data), GFP_KERNEL);
2156 if (!msb)
2158 memstick_set_drvdata(card, msb);
2159 msb->card = card;
2160 spin_lock_init(&msb->q_lock);
2175 msb_data_clear(msb);
2176 kfree(msb);
2182 struct msb_data *msb = memstick_get_drvdata(card);
2185 if (!msb->io_queue_stopped)
2191 spin_lock_irqsave(&msb->q_lock, flags);
2192 msb->card_dead = true;
2193 spin_unlock_irqrestore(&msb->q_lock, flags);
2194 blk_mq_start_hw_queues(msb->queue);
2197 del_gendisk(msb->disk);
2198 blk_mq_free_tag_set(&msb->tag_set);
2199 msb->queue = NULL;
2202 msb_data_clear(msb);
2205 put_disk(msb->disk);
2219 struct msb_data *msb = memstick_get_drvdata(card);
2224 msb->card_dead = true;
2236 sg_init_table(msb->prealloc_sg, MS_BLOCK_MAX_SEGS+1);
2241 if (msb->block_size != new_msb->block_size)
2244 if (memcmp(msb->boot_page, new_msb->boot_page,
2248 if (msb->logical_block_count != new_msb->logical_block_count ||
2249 memcmp(msb->lba_to_pba_table, new_msb->lba_to_pba_table,
2250 msb->logical_block_count))
2253 if (msb->block_count != new_msb->block_count ||
2254 !bitmap_equal(msb->used_blocks_bitmap, new_msb->used_blocks_bitmap,
2255 msb->block_count))
2263 msb->card_dead = card_dead;
2264 memstick_set_drvdata(card, msb);