| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Maxim Levitsky | 10277 | 96.64% | 1 | 3.85% |
| Jens Axboe | 188 | 1.77% | 1 | 3.85% |
| Christoph Hellwig | 49 | 0.46% | 4 | 15.38% |
| Jiasheng Jiang | 27 | 0.25% | 1 | 3.85% |
| Kees Cook | 19 | 0.18% | 2 | 7.69% |
| Christophe Jaillet | 16 | 0.15% | 3 | 11.54% |
| Gustavo A. R. Silva | 12 | 0.11% | 1 | 3.85% |
| Colin Ian King | 12 | 0.11% | 4 | 15.38% |
| Luis R. Rodriguez | 10 | 0.09% | 1 | 3.85% |
| Shubhankar Kuranagatti | 7 | 0.07% | 1 | 3.85% |
| Dan J Williams | 6 | 0.06% | 1 | 3.85% |
| Arnd Bergmann | 4 | 0.04% | 2 | 7.69% |
| Thomas Gleixner | 2 | 0.02% | 1 | 3.85% |
| Hannes Reinecke | 2 | 0.02% | 1 | 3.85% |
| Andrew Morton | 2 | 0.02% | 1 | 3.85% |
| Neil Brown | 1 | 0.01% | 1 | 3.85% |
| Total | 10634 | 26 |
// SPDX-License-Identifier: GPL-2.0-only /* * ms_block.c - Sony MemoryStick (legacy) storage support * Copyright (C) 2013 Maxim Levitsky <maximlevitsky@gmail.com> * * Minor portions of the driver were copied from mspro_block.c which is * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com> */ #define DRIVER_NAME "ms_block" #define pr_fmt(fmt) DRIVER_NAME ": " fmt #include <linux/module.h> #include <linux/blk-mq.h> #include <linux/memstick.h> #include <linux/idr.h> #include <linux/hdreg.h> #include <linux/delay.h> #include <linux/slab.h> #include <linux/random.h> #include <linux/bitmap.h> #include <linux/scatterlist.h> #include <linux/jiffies.h> #include <linux/workqueue.h> #include <linux/mutex.h> #include "ms_block.h" static int debug; static int cache_flush_timeout = 1000; static bool verify_writes; /* * Copies section of 'sg_from' starting from offset 'offset' and with length * 'len' To another scatterlist of to_nents enties */ static size_t msb_sg_copy(struct scatterlist *sg_from, struct scatterlist *sg_to, int to_nents, size_t offset, size_t len) { size_t copied = 0; while (offset > 0) { if (offset >= sg_from->length) { if (sg_is_last(sg_from)) return 0; offset -= sg_from->length; sg_from = sg_next(sg_from); continue; } copied = min(len, sg_from->length - offset); sg_set_page(sg_to, sg_page(sg_from), copied, sg_from->offset + offset); len -= copied; offset = 0; if (sg_is_last(sg_from) || !len) goto out; sg_to = sg_next(sg_to); to_nents--; sg_from = sg_next(sg_from); } while (len > sg_from->length && to_nents--) { len -= sg_from->length; copied += sg_from->length; sg_set_page(sg_to, sg_page(sg_from), sg_from->length, sg_from->offset); if (sg_is_last(sg_from) || !len) goto out; sg_from = sg_next(sg_from); sg_to = sg_next(sg_to); } if (len && to_nents) { sg_set_page(sg_to, sg_page(sg_from), len, sg_from->offset); copied += len; } out: sg_mark_end(sg_to); return copied; } /* * Compares section of 'sg' starting from offset 'offset' and with length 'len' * to linear buffer of length 'len' at address 'buffer' * Returns 0 if equal and -1 otherwice */ static int msb_sg_compare_to_buffer(struct scatterlist *sg, size_t offset, u8 *buffer, size_t len) { int retval = 0, cmplen; struct sg_mapping_iter miter; sg_miter_start(&miter, sg, sg_nents(sg), SG_MITER_ATOMIC | SG_MITER_FROM_SG); while (sg_miter_next(&miter) && len > 0) { if (offset >= miter.length) { offset -= miter.length; continue; } cmplen = min(miter.length - offset, len); retval = memcmp(miter.addr + offset, buffer, cmplen) ? -1 : 0; if (retval) break; buffer += cmplen; len -= cmplen; offset = 0; } if (!retval && len) retval = -1; sg_miter_stop(&miter); return retval; } /* Get zone at which block with logical address 'lba' lives * Flash is broken into zones. * Each zone consists of 512 eraseblocks, out of which in first * zone 494 are used and 496 are for all following zones. * Therefore zone #0 hosts blocks 0-493, zone #1 blocks 494-988, etc... */ static int msb_get_zone_from_lba(int lba) { if (lba < 494) return 0; return ((lba - 494) / 496) + 1; } /* Get zone of physical block. Trivial */ static int msb_get_zone_from_pba(int pba) { return pba / MS_BLOCKS_IN_ZONE; } /* Debug test to validate free block counts */ static int msb_validate_used_block_bitmap(struct msb_data *msb) { int total_free_blocks = 0; int i; if (!debug) return 0; for (i = 0; i < msb->zone_count; i++) total_free_blocks += msb->free_block_count[i]; if (msb->block_count - bitmap_weight(msb->used_blocks_bitmap, msb->block_count) == total_free_blocks) return 0; pr_err("BUG: free block counts don't match the bitmap"); msb->read_only = true; return -EINVAL; } /* Mark physical block as used */ static void msb_mark_block_used(struct msb_data *msb, int pba) { int zone = msb_get_zone_from_pba(pba); if (test_bit(pba, msb->used_blocks_bitmap)) { pr_err( "BUG: attempt to mark already used pba %d as used", pba); msb->read_only = true; return; } if (msb_validate_used_block_bitmap(msb)) return; /* No races because all IO is single threaded */ __set_bit(pba, msb->used_blocks_bitmap); msb->free_block_count[zone]--; } /* Mark physical block as free */ static void msb_mark_block_unused(struct msb_data *msb, int pba) { int zone = msb_get_zone_from_pba(pba); if (!test_bit(pba, msb->used_blocks_bitmap)) { pr_err("BUG: attempt to mark already unused pba %d as unused" , pba); msb->read_only = true; return; } if (msb_validate_used_block_bitmap(msb)) return; /* No races because all IO is single threaded */ __clear_bit(pba, msb->used_blocks_bitmap); msb->free_block_count[zone]++; } /* Invalidate current register window */ static void msb_invalidate_reg_window(struct msb_data *msb) { msb->reg_addr.w_offset = offsetof(struct ms_register, id); msb->reg_addr.w_length = sizeof(struct ms_id_register); msb->reg_addr.r_offset = offsetof(struct ms_register, id); msb->reg_addr.r_length = sizeof(struct ms_id_register); msb->addr_valid = false; } /* Start a state machine */ static int msb_run_state_machine(struct msb_data *msb, int (*state_func) (struct memstick_dev *card, struct memstick_request **req)) { struct memstick_dev *card = msb->card; WARN_ON(msb->state != -1); msb->int_polling = false; msb->state = 0; msb->exit_error = 0; memset(&card->current_mrq, 0, sizeof(card->current_mrq)); card->next_request = state_func; memstick_new_req(card->host); wait_for_completion(&card->mrq_complete); WARN_ON(msb->state != -1); return msb->exit_error; } /* State machines call that to exit */ static int msb_exit_state_machine(struct msb_data *msb, int error) { WARN_ON(msb->state == -1); msb->state = -1; msb->exit_error = error; msb->card->next_request = h_msb_default_bad; /* Invalidate reg window on errors */ if (error) msb_invalidate_reg_window(msb); complete(&msb->card->mrq_complete); return -ENXIO; } /* read INT register */ static int msb_read_int_reg(struct msb_data *msb, long timeout) { struct memstick_request *mrq = &msb->card->current_mrq; WARN_ON(msb->state == -1); if (!msb->int_polling) { msb->int_timeout = jiffies + msecs_to_jiffies(timeout == -1 ? 500 : timeout); msb->int_polling = true; } else if (time_after(jiffies, msb->int_timeout)) { mrq->data[0] = MEMSTICK_INT_CMDNAK; return 0; } if ((msb->caps & MEMSTICK_CAP_AUTO_GET_INT) && mrq->need_card_int && !mrq->error) { mrq->data[0] = mrq->int_reg; mrq->need_card_int = false; return 0; } else { memstick_init_req(mrq, MS_TPC_GET_INT, NULL, 1); return 1; } } /* Read a register */ static int msb_read_regs(struct msb_data *msb, int offset, int len) { struct memstick_request *req = &msb->card->current_mrq; if (msb->reg_addr.r_offset != offset || msb->reg_addr.r_length != len || !msb->addr_valid) { msb->reg_addr.r_offset = offset; msb->reg_addr.r_length = len; msb->addr_valid = true; memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &msb->reg_addr, sizeof(msb->reg_addr)); return 0; } memstick_init_req(req, MS_TPC_READ_REG, NULL, len); return 1; } /* Write a card register */ static int msb_write_regs(struct msb_data *msb, int offset, int len, void *buf) { struct memstick_request *req = &msb->card->current_mrq; if (msb->reg_addr.w_offset != offset || msb->reg_addr.w_length != len || !msb->addr_valid) { msb->reg_addr.w_offset = offset; msb->reg_addr.w_length = len; msb->addr_valid = true; memstick_init_req(req, MS_TPC_SET_RW_REG_ADRS, &msb->reg_addr, sizeof(msb->reg_addr)); return 0; } memstick_init_req(req, MS_TPC_WRITE_REG, buf, len); return 1; } /* Handler for absence of IO */ static int h_msb_default_bad(struct memstick_dev *card, struct memstick_request **mrq) { return -ENXIO; } /* * This function is a handler for reads of one page from device. * Writes output to msb->current_sg, takes sector address from msb->reg.param * Can also be used to read extra data only. Set params accordintly. */ static int h_msb_read_page(struct memstick_dev *card, struct memstick_request **out_mrq) { struct msb_data *msb = memstick_get_drvdata(card); struct memstick_request *mrq = *out_mrq = &card->current_mrq; struct scatterlist sg[2]; u8 command, intreg; if (mrq->error) { dbg("read_page, unknown error"); return msb_exit_state_machine(msb, mrq->error); } again: switch (msb->state) { case MSB_RP_SEND_BLOCK_ADDRESS: /* msb_write_regs sometimes "fails" because it needs to update * the reg window, and thus it returns request for that. * Then we stay in this state and retry */ if (!msb_write_regs(msb, offsetof(struct ms_register, param), sizeof(struct ms_param_register), (unsigned char *)&msb->regs.param)) return 0; msb->state = MSB_RP_SEND_READ_COMMAND; return 0; case MSB_RP_SEND_READ_COMMAND: command = MS_CMD_BLOCK_READ; memstick_init_req(mrq, MS_TPC_SET_CMD, &command, 1); msb->state = MSB_RP_SEND_INT_REQ; return 0; case MSB_RP_SEND_INT_REQ: msb->state = MSB_RP_RECEIVE_INT_REQ_RESULT; /* If dont actually need to send the int read request (only in * serial mode), then just fall through */ if (msb_read_int_reg(msb, -1)) return 0; fallthrough; case MSB_RP_RECEIVE_INT_REQ_RESULT: intreg = mrq->data[0]; msb->regs.status.interrupt = intreg; if (intreg & MEMSTICK_INT_CMDNAK) return msb_exit_state_machine(msb, -EIO); if (!(intreg & MEMSTICK_INT_CED)) { msb->state = MSB_RP_SEND_INT_REQ; goto again; } msb->int_polling = false; msb->state = (intreg & MEMSTICK_INT_ERR) ? MSB_RP_SEND_READ_STATUS_REG : MSB_RP_SEND_OOB_READ; goto again; case MSB_RP_SEND_READ_STATUS_REG: /* read the status register to understand source of the INT_ERR */ if (!msb_read_regs(msb, offsetof(struct ms_register, status), sizeof(struct ms_status_register))) return 0; msb->state = MSB_RP_RECEIVE_STATUS_REG; return 0; case MSB_RP_RECEIVE_STATUS_REG: msb->regs.status = *(struct ms_status_register *)mrq->data; msb->state = MSB_RP_SEND_OOB_READ; fallthrough; case MSB_RP_SEND_OOB_READ: if (!msb_read_regs(msb, offsetof(struct ms_register, extra_data), sizeof(struct ms_extra_data_register))) return 0; msb->state = MSB_RP_RECEIVE_OOB_READ; return 0; case MSB_RP_RECEIVE_OOB_READ: msb->regs.extra_data = *(struct ms_extra_data_register *) mrq->data; msb->state = MSB_RP_SEND_READ_DATA; fallthrough; case MSB_RP_SEND_READ_DATA: /* Skip that state if we only read the oob */ if (msb->regs.param.cp == MEMSTICK_CP_EXTRA) { msb->state = MSB_RP_RECEIVE_READ_DATA; goto again; } sg_init_table(sg, ARRAY_SIZE(sg)); msb_sg_copy(msb->current_sg, sg, ARRAY_SIZE(sg), msb->current_sg_offset, msb->page_size); memstick_init_req_sg(mrq, MS_TPC_READ_LONG_DATA, sg); msb->state = MSB_RP_RECEIVE_READ_DATA; return 0; case MSB_RP_RECEIVE_READ_DATA: if (!(msb->regs.status.interrupt & MEMSTICK_INT_ERR)) { msb->current_sg_offset += msb->page_size; return msb_exit_state_machine(msb, 0); } if (msb->regs.status.status1 & MEMSTICK_UNCORR_ERROR) { dbg("read_page: uncorrectable error"); return msb_exit_state_machine(msb, -EBADMSG); } if (msb->regs.status.status1 & MEMSTICK_CORR_ERROR) { dbg("read_page: correctable error"); msb->current_sg_offset += msb->page_size; return msb_exit_state_machine(msb, -EUCLEAN); } else { dbg("read_page: INT error, but no status error bits"); return msb_exit_state_machine(msb, -EIO); } } BUG(); } /* * Handler of writes of exactly one block. * Takes address from msb->regs.param. * Writes same extra data to blocks, also taken * from msb->regs.extra * Returns -EBADMSG if write fails due to uncorrectable error, or -EIO if * device refuses to take the command or something else */ static int h_msb_write_block(struct memstick_dev *card, struct memstick_request **out_mrq) { struct msb_data *msb = memstick_get_drvdata(card); struct memstick_request *mrq = *out_mrq = &card->current_mrq; struct scatterlist sg[2]; u8 intreg, command; if (mrq->error) return msb_exit_state_machine(msb, mrq->error); again: switch (msb->state) { /* HACK: Jmicon handling of TPCs between 8 and * sizeof(memstick_request.data) is broken due to hardware * bug in PIO mode that is used for these TPCs * Therefore split the write */ case MSB_WB_SEND_WRITE_PARAMS: if (!msb_write_regs(msb, offsetof(struct ms_register, param), sizeof(struct ms_param_register), &msb->regs.param)) return 0; msb->state = MSB_WB_SEND_WRITE_OOB; return 0; case MSB_WB_SEND_WRITE_OOB: if (!msb_write_regs(msb, offsetof(struct ms_register, extra_data), sizeof(struct ms_extra_data_register), &msb->regs.extra_data)) return 0; msb->state = MSB_WB_SEND_WRITE_COMMAND; return 0; case MSB_WB_SEND_WRITE_COMMAND: command = MS_CMD_BLOCK_WRITE; memstick_init_req(mrq, MS_TPC_SET_CMD, &command, 1); msb->state = MSB_WB_SEND_INT_REQ; return 0; case MSB_WB_SEND_INT_REQ: msb->state = MSB_WB_RECEIVE_INT_REQ; if (msb_read_int_reg(msb, -1)) return 0; fallthrough; case MSB_WB_RECEIVE_INT_REQ: intreg = mrq->data[0]; msb->regs.status.interrupt = intreg; /* errors mean out of here, and fast... */ if (intreg & (MEMSTICK_INT_CMDNAK)) return msb_exit_state_machine(msb, -EIO); if (intreg & MEMSTICK_INT_ERR) return msb_exit_state_machine(msb, -EBADMSG); /* for last page we need to poll CED */ if (msb->current_page == msb->pages_in_block) { if (intreg & MEMSTICK_INT_CED) return msb_exit_state_machine(msb, 0); msb->state = MSB_WB_SEND_INT_REQ; goto again; } /* for non-last page we need BREQ before writing next chunk */ if (!(intreg & MEMSTICK_INT_BREQ)) { msb->state = MSB_WB_SEND_INT_REQ; goto again; } msb->int_polling = false; msb->state = MSB_WB_SEND_WRITE_DATA; fallthrough; case MSB_WB_SEND_WRITE_DATA: sg_init_table(sg, ARRAY_SIZE(sg)); if (msb_sg_copy(msb->current_sg, sg, ARRAY_SIZE(sg), msb->current_sg_offset, msb->page_size) < msb->page_size) return msb_exit_state_machine(msb, -EIO); memstick_init_req_sg(mrq, MS_TPC_WRITE_LONG_DATA, sg); mrq->need_card_int = 1; msb->state = MSB_WB_RECEIVE_WRITE_CONFIRMATION; return 0; case MSB_WB_RECEIVE_WRITE_CONFIRMATION: msb->current_page++; msb->current_sg_offset += msb->page_size; msb->state = MSB_WB_SEND_INT_REQ; goto again; default: BUG(); } return 0; } /* * This function is used to send simple IO requests to device that consist * of register write + command */ static int h_msb_send_command(struct memstick_dev *card, struct memstick_request **out_mrq) { struct msb_data *msb = memstick_get_drvdata(card); struct memstick_request *mrq = *out_mrq = &card->current_mrq; u8 intreg; if (mrq->error) { dbg("send_command: unknown error"); return msb_exit_state_machine(msb, mrq->error); } again: switch (msb->state) { /* HACK: see h_msb_write_block */ case MSB_SC_SEND_WRITE_PARAMS: /* write param register*/ if (!msb_write_regs(msb, offsetof(struct ms_register, param), sizeof(struct ms_param_register), &msb->regs.param)) return 0; msb->state = MSB_SC_SEND_WRITE_OOB; return 0; case MSB_SC_SEND_WRITE_OOB: if (!msb->command_need_oob) { msb->state = MSB_SC_SEND_COMMAND; goto again; } if (!msb_write_regs(msb, offsetof(struct ms_register, extra_data), sizeof(struct ms_extra_data_register), &msb->regs.extra_data)) return 0; msb->state = MSB_SC_SEND_COMMAND; return 0; case MSB_SC_SEND_COMMAND: memstick_init_req(mrq, MS_TPC_SET_CMD, &msb->command_value, 1); msb->state = MSB_SC_SEND_INT_REQ; return 0; case MSB_SC_SEND_INT_REQ: msb->state = MSB_SC_RECEIVE_INT_REQ; if (msb_read_int_reg(msb, -1)) return 0; fallthrough; case MSB_SC_RECEIVE_INT_REQ: intreg = mrq->data[0]; if (intreg & MEMSTICK_INT_CMDNAK) return msb_exit_state_machine(msb, -EIO); if (intreg & MEMSTICK_INT_ERR) return msb_exit_state_machine(msb, -EBADMSG); if (!(intreg & MEMSTICK_INT_CED)) { msb->state = MSB_SC_SEND_INT_REQ; goto again; } return msb_exit_state_machine(msb, 0); } BUG(); } /* Small handler for card reset */ static int h_msb_reset(struct memstick_dev *card, struct memstick_request **out_mrq) { u8 command = MS_CMD_RESET; struct msb_data *msb = memstick_get_drvdata(card); struct memstick_request *mrq = *out_mrq = &card->current_mrq; if (mrq->error) return msb_exit_state_machine(msb, mrq->error); switch (msb->state) { case MSB_RS_SEND: memstick_init_req(mrq, MS_TPC_SET_CMD, &command, 1); mrq->need_card_int = 0; msb->state = MSB_RS_CONFIRM; return 0; case MSB_RS_CONFIRM: return msb_exit_state_machine(msb, 0); } BUG(); } /* This handler is used to do serial->parallel switch */ static int h_msb_parallel_switch(struct memstick_dev *card, struct memstick_request **out_mrq) { struct msb_data *msb = memstick_get_drvdata(card); struct memstick_request *mrq = *out_mrq = &card->current_mrq; struct memstick_host *host = card->host; if (mrq->error) { dbg("parallel_switch: error"); msb->regs.param.system &= ~MEMSTICK_SYS_PAM; return msb_exit_state_machine(msb, mrq->error); } switch (msb->state) { case MSB_PS_SEND_SWITCH_COMMAND: /* Set the parallel interface on memstick side */ msb->regs.param.system |= MEMSTICK_SYS_PAM; if (!msb_write_regs(msb, offsetof(struct ms_register, param), 1, (unsigned char *)&msb->regs.param)) return 0; msb->state = MSB_PS_SWICH_HOST; return 0; case MSB_PS_SWICH_HOST: /* Set parallel interface on our side + send a dummy request * to see if card responds */ host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_PAR4); memstick_init_req(mrq, MS_TPC_GET_INT, NULL, 1); msb->state = MSB_PS_CONFIRM; return 0; case MSB_PS_CONFIRM: return msb_exit_state_machine(msb, 0); } BUG(); } static int msb_switch_to_parallel(struct msb_data *msb); /* Reset the card, to guard against hw errors beeing treated as bad blocks */ static int msb_reset(struct msb_data *msb, bool full) { bool was_parallel = msb->regs.param.system & MEMSTICK_SYS_PAM; struct memstick_dev *card = msb->card; struct memstick_host *host = card->host; int error; /* Reset the card */ msb->regs.param.system = MEMSTICK_SYS_BAMD; if (full) { error = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); if (error) goto out_error; msb_invalidate_reg_window(msb); error = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON); if (error) goto out_error; error = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL); if (error) { out_error: dbg("Failed to reset the host controller"); msb->read_only = true; return -EFAULT; } } error = msb_run_state_machine(msb, h_msb_reset); if (error) { dbg("Failed to reset the card"); msb->read_only = true; return -ENODEV; } /* Set parallel mode */ if (was_parallel) msb_switch_to_parallel(msb); return 0; } /* Attempts to switch interface to parallel mode */ static int msb_switch_to_parallel(struct msb_data *msb) { int error; error = msb_run_state_machine(msb, h_msb_parallel_switch); if (error) { pr_err("Switch to parallel failed"); msb->regs.param.system &= ~MEMSTICK_SYS_PAM; msb_reset(msb, true); return -EFAULT; } msb->caps |= MEMSTICK_CAP_AUTO_GET_INT; return 0; } /* Changes overwrite flag on a page */ static int msb_set_overwrite_flag(struct msb_data *msb, u16 pba, u8 page, u8 flag) { if (msb->read_only) return -EROFS; msb->regs.param.block_address = cpu_to_be16(pba); msb->regs.param.page_address = page; msb->regs.param.cp = MEMSTICK_CP_OVERWRITE; msb->regs.extra_data.overwrite_flag = flag; msb->command_value = MS_CMD_BLOCK_WRITE; msb->command_need_oob = true; dbg_verbose("changing overwrite flag to %02x for sector %d, page %d", flag, pba, page); return msb_run_state_machine(msb, h_msb_send_command); } static int msb_mark_bad(struct msb_data *msb, int pba) { pr_notice("marking pba %d as bad", pba); msb_reset(msb, true); return msb_set_overwrite_flag( msb, pba, 0, 0xFF & ~MEMSTICK_OVERWRITE_BKST); } static int msb_mark_page_bad(struct msb_data *msb, int pba, int page) { dbg("marking page %d of pba %d as bad", page, pba); msb_reset(msb, true); return msb_set_overwrite_flag(msb, pba, page, ~MEMSTICK_OVERWRITE_PGST0); } /* Erases one physical block */ static int msb_erase_block(struct msb_data *msb, u16 pba) { int error, try; if (msb->read_only) return -EROFS; dbg_verbose("erasing pba %d", pba); for (try = 1; try < 3; try++) { msb->regs.param.block_address = cpu_to_be16(pba); msb->regs.param.page_address = 0; msb->regs.param.cp = MEMSTICK_CP_BLOCK; msb->command_value = MS_CMD_BLOCK_ERASE; msb->command_need_oob = false; error = msb_run_state_machine(msb, h_msb_send_command); if (!error || msb_reset(msb, true)) break; } if (error) { pr_err("erase failed, marking pba %d as bad", pba); msb_mark_bad(msb, pba); } dbg_verbose("erase success, marking pba %d as unused", pba); msb_mark_block_unused(msb, pba); __set_bit(pba, msb->erased_blocks_bitmap); return error; } /* Reads one page from device */ static int msb_read_page(struct msb_data *msb, u16 pba, u8 page, struct ms_extra_data_register *extra, struct scatterlist *sg, int offset) { int try, error; if (pba == MS_BLOCK_INVALID) { unsigned long flags; struct sg_mapping_iter miter; size_t len = msb->page_size; dbg_verbose("read unmapped sector. returning 0xFF"); local_irq_save(flags); sg_miter_start(&miter, sg, sg_nents(sg), SG_MITER_ATOMIC | SG_MITER_TO_SG); while (sg_miter_next(&miter) && len > 0) { int chunklen; if (offset && offset >= miter.length) { offset -= miter.length; continue; } chunklen = min(miter.length - offset, len); memset(miter.addr + offset, 0xFF, chunklen); len -= chunklen; offset = 0; } sg_miter_stop(&miter); local_irq_restore(flags); if (offset) return -EFAULT; if (extra) memset(extra, 0xFF, sizeof(*extra)); return 0; } if (pba >= msb->block_count) { pr_err("BUG: attempt to read beyond the end of the card at pba %d", pba); return -EINVAL; } for (try = 1; try < 3; try++) { msb->regs.param.block_address = cpu_to_be16(pba); msb->regs.param.page_address = page; msb->regs.param.cp = MEMSTICK_CP_PAGE; msb->current_sg = sg; msb->current_sg_offset = offset; error = msb_run_state_machine(msb, h_msb_read_page); if (error == -EUCLEAN) { pr_notice("correctable error on pba %d, page %d", pba, page); error = 0; } if (!error && extra) *extra = msb->regs.extra_data; if (!error || msb_reset(msb, true)) break; } /* Mark bad pages */ if (error == -EBADMSG) { pr_err("uncorrectable error on read of pba %d, page %d", pba, page); if (msb->regs.extra_data.overwrite_flag & MEMSTICK_OVERWRITE_PGST0) msb_mark_page_bad(msb, pba, page); return -EBADMSG; } if (error) pr_err("read of pba %d, page %d failed with error %d", pba, page, error); return error; } /* Reads oob of page only */ static int msb_read_oob(struct msb_data *msb, u16 pba, u16 page, struct ms_extra_data_register *extra) { int error; BUG_ON(!extra); msb->regs.param.block_address = cpu_to_be16(pba); msb->regs.param.page_address = page; msb->regs.param.cp = MEMSTICK_CP_EXTRA; if (pba > msb->block_count) { pr_err("BUG: attempt to read beyond the end of card at pba %d", pba); return -EINVAL; } error = msb_run_state_machine(msb, h_msb_read_page); *extra = msb->regs.extra_data; if (error == -EUCLEAN) { pr_notice("correctable error on pba %d, page %d", pba, page); return 0; } return error; } /* Reads a block and compares it with data contained in scatterlist orig_sg */ static int msb_verify_block(struct msb_data *msb, u16 pba, struct scatterlist *orig_sg, int offset) { struct scatterlist sg; int page = 0, error; sg_init_one(&sg, msb->block_buffer, msb->block_size); while (page < msb->pages_in_block) { error = msb_read_page(msb, pba, page, NULL, &sg, page * msb->page_size); if (error) return error; page++; } if (msb_sg_compare_to_buffer(orig_sg, offset, msb->block_buffer, msb->block_size)) return -EIO; return 0; } /* Writes exectly one block + oob */ static int msb_write_block(struct msb_data *msb, u16 pba, u32 lba, struct scatterlist *sg, int offset) { int error, current_try = 1; BUG_ON(sg->length < msb->page_size); if (msb->read_only) return -EROFS; if (pba == MS_BLOCK_INVALID) { pr_err( "BUG: write: attempt to write MS_BLOCK_INVALID block"); return -EINVAL; } if (pba >= msb->block_count || lba >= msb->logical_block_count) { pr_err( "BUG: write: attempt to write beyond the end of device"); return -EINVAL; } if (msb_get_zone_from_lba(lba) != msb_get_zone_from_pba(pba)) { pr_err("BUG: write: lba zone mismatch"); return -EINVAL; } if (pba == msb->boot_block_locations[0] || pba == msb->boot_block_locations[1]) { pr_err("BUG: write: attempt to write to boot blocks!"); return -EINVAL; } while (1) { if (msb->read_only) return -EROFS; msb->regs.param.cp = MEMSTICK_CP_BLOCK; msb->regs.param.page_address = 0; msb->regs.param.block_address = cpu_to_be16(pba); msb->regs.extra_data.management_flag = 0xFF; msb->regs.extra_data.overwrite_flag = 0xF8; msb->regs.extra_data.logical_address = cpu_to_be16(lba); msb->current_sg = sg; msb->current_sg_offset = offset; msb->current_page = 0; error = msb_run_state_machine(msb, h_msb_write_block); /* Sector we just wrote to is assumed erased since its pba * was erased. If it wasn't erased, write will succeed * and will just clear the bits that were set in the block * thus test that what we have written, * matches what we expect. * We do trust the blocks that we erased */ if (!error && (verify_writes || !test_bit(pba, msb->erased_blocks_bitmap))) error = msb_verify_block(msb, pba, sg, offset); if (!error) break; if (current_try > 1 || msb_reset(msb, true)) break; pr_err("write failed, trying to erase the pba %d", pba); error = msb_erase_block(msb, pba); if (error) break; current_try++; } return error; } /* Finds a free block for write replacement */ static u16 msb_get_free_block(struct msb_data *msb, int zone) { u16 pos; int pba = zone * MS_BLOCKS_IN_ZONE; int i; get_random_bytes(&pos, sizeof(pos)); if (!msb->free_block_count[zone]) { pr_err("NO free blocks in the zone %d, to use for a write, (media is WORN out) switching to RO mode", zone); msb->read_only = true; return MS_BLOCK_INVALID; } pos %= msb->free_block_count[zone]; dbg_verbose("have %d choices for a free block, selected randomly: %d", msb->free_block_count[zone], pos); pba = find_next_zero_bit(msb->used_blocks_bitmap, msb->block_count, pba); for (i = 0; i < pos; ++i) pba = find_next_zero_bit(msb->used_blocks_bitmap, msb->block_count, pba + 1); dbg_verbose("result of the free blocks scan: pba %d", pba); if (pba == msb->block_count || (msb_get_zone_from_pba(pba)) != zone) { pr_err("BUG: can't get a free block"); msb->read_only = true; return MS_BLOCK_INVALID; } msb_mark_block_used(msb, pba); return pba; } static int msb_update_block(struct msb_data *msb, u16 lba, struct scatterlist *sg, int offset) { u16 pba, new_pba; int error, try; pba = msb->lba_to_pba_table[lba]; dbg_verbose("start of a block update at lba %d, pba %d", lba, pba); if (pba != MS_BLOCK_INVALID) { dbg_verbose("setting the update flag on the block"); msb_set_overwrite_flag(msb, pba, 0, 0xFF & ~MEMSTICK_OVERWRITE_UDST); } for (try = 0; try < 3; try++) { new_pba = msb_get_free_block(msb, msb_get_zone_from_lba(lba)); if (new_pba == MS_BLOCK_INVALID) { error = -EIO; goto out; } dbg_verbose("block update: writing updated block to the pba %d", new_pba); error = msb_write_block(msb, new_pba, lba, sg, offset); if (error == -EBADMSG) { msb_mark_bad(msb, new_pba); continue; } if (error) goto out; dbg_verbose("block update: erasing the old block"); msb_erase_block(msb, pba); msb->lba_to_pba_table[lba] = new_pba; return 0; } out: if (error) { pr_err("block update error after %d tries, switching to r/o mode", try); msb->read_only = true; } return error; } /* Converts endiannes in the boot block for easy use */ static void msb_fix_boot_page_endianness(struct ms_boot_page *p) { p->header.block_id = be16_to_cpu(p->header.block_id); p->header.format_reserved = be16_to_cpu(p->header.format_reserved); p->entry.disabled_block.start_addr = be32_to_cpu(p->entry.disabled_block.start_addr); p->entry.disabled_block.data_size = be32_to_cpu(p->entry.disabled_block.data_size); p->entry.cis_idi.start_addr = be32_to_cpu(p->entry.cis_idi.start_addr); p->entry.cis_idi.data_size = be32_to_cpu(p->entry.cis_idi.data_size); p->attr.block_size = be16_to_cpu(p->attr.block_size); p->attr.number_of_blocks = be16_to_cpu(p->attr.number_of_blocks); p->attr.number_of_effective_blocks = be16_to_cpu(p->attr.number_of_effective_blocks); p->attr.page_size = be16_to_cpu(p->attr.page_size); p->attr.memory_manufacturer_code = be16_to_cpu(p->attr.memory_manufacturer_code); p->attr.memory_device_code = be16_to_cpu(p->attr.memory_device_code); p->attr.implemented_capacity = be16_to_cpu(p->attr.implemented_capacity); p->attr.controller_number = be16_to_cpu(p->attr.controller_number); p->attr.controller_function = be16_to_cpu(p->attr.controller_function); } static int msb_read_boot_blocks(struct msb_data *msb) { int pba = 0; struct scatterlist sg; struct ms_extra_data_register extra; struct ms_boot_page *page; msb->boot_block_locations[0] = MS_BLOCK_INVALID; msb->boot_block_locations[1] = MS_BLOCK_INVALID; msb->boot_block_count = 0; dbg_verbose("Start of a scan for the boot blocks"); if (!msb->boot_page) { page = kmalloc_array(2, sizeof(struct ms_boot_page), GFP_KERNEL); if (!page) return -ENOMEM; msb->boot_page = page; } else page = msb->boot_page; msb->block_count = MS_BLOCK_MAX_BOOT_ADDR; for (pba = 0; pba < MS_BLOCK_MAX_BOOT_ADDR; pba++) { sg_init_one(&sg, page, sizeof(*page)); if (msb_read_page(msb, pba, 0, &extra, &sg, 0)) { dbg("boot scan: can't read pba %d", pba); continue; } if (extra.management_flag & MEMSTICK_MANAGEMENT_SYSFLG) { dbg("management flag doesn't indicate boot block %d", pba); continue; } if (be16_to_cpu(page->header.block_id) != MS_BLOCK_BOOT_ID) { dbg("the pba at %d doesn't contain boot block ID", pba); continue; } msb_fix_boot_page_endianness(page); msb->boot_block_locations[msb->boot_block_count] = pba; page++; msb->boot_block_count++; if (msb->boot_block_count == 2) break; } if (!msb->boot_block_count) { pr_err("media doesn't contain master page, aborting"); return -EIO; } dbg_verbose("End of scan for boot blocks"); return 0; } static int msb_read_bad_block_table(struct msb_data *msb, int block_nr) { struct ms_boot_page *boot_block; struct scatterlist sg; u16 *buffer = NULL; int offset = 0; int i, error = 0; int data_size, data_offset, page, page_offset, size_to_read; u16 pba; BUG_ON(block_nr > 1); boot_block = &msb->boot_page[block_nr]; pba = msb->boot_block_locations[block_nr]; if (msb->boot_block_locations[block_nr] == MS_BLOCK_INVALID) return -EINVAL; data_size = boot_block->entry.disabled_block.data_size; data_offset = sizeof(struct ms_boot_page) + boot_block->entry.disabled_block.start_addr; if (!data_size) return 0; page = data_offset / msb->page_size; page_offset = data_offset % msb->page_size; size_to_read = DIV_ROUND_UP(data_size + page_offset, msb->page_size) * msb->page_size; dbg("reading bad block of boot block at pba %d, offset %d len %d", pba, data_offset, data_size); buffer = kzalloc(size_to_read, GFP_KERNEL); if (!buffer) return -ENOMEM; /* Read the buffer */ sg_init_one(&sg, buffer, size_to_read); while (offset < size_to_read) { error = msb_read_page(msb, pba, page, NULL, &sg, offset); if (error) goto out; page++; offset += msb->page_size; if (page == msb->pages_in_block) { pr_err( "bad block table extends beyond the boot block"); break; } } /* Process the bad block table */ for (i = page_offset; i < data_size / sizeof(u16); i++) { u16 bad_block = be16_to_cpu(buffer[i]); if (bad_block >= msb->block_count) { dbg("bad block table contains invalid block %d", bad_block); continue; } if (test_bit(bad_block, msb->used_blocks_bitmap)) { dbg("duplicate bad block %d in the table", bad_block); continue; } dbg("block %d is marked as factory bad", bad_block); msb_mark_block_used(msb, bad_block); } out: kfree(buffer); return error; } static int msb_ftl_initialize(struct msb_data *msb) { int i; if (msb->ftl_initialized) return 0; msb->zone_count = msb->block_count / MS_BLOCKS_IN_ZONE; msb->logical_block_count = msb->zone_count * 496 - 2; msb->used_blocks_bitmap = bitmap_zalloc(msb->block_count, GFP_KERNEL); msb->erased_blocks_bitmap = bitmap_zalloc(msb->block_count, GFP_KERNEL); msb->lba_to_pba_table = kmalloc_array(msb->logical_block_count, sizeof(u16), GFP_KERNEL); if (!msb->used_blocks_bitmap || !msb->lba_to_pba_table || !msb->erased_blocks_bitmap) { bitmap_free(msb->used_blocks_bitmap); bitmap_free(msb->erased_blocks_bitmap); kfree(msb->lba_to_pba_table); return -ENOMEM; } for (i = 0; i < msb->zone_count; i++) msb->free_block_count[i] = MS_BLOCKS_IN_ZONE; memset(msb->lba_to_pba_table, MS_BLOCK_INVALID, msb->logical_block_count * sizeof(u16)); dbg("initial FTL tables created. Zone count = %d, Logical block count = %d", msb->zone_count, msb->logical_block_count); msb->ftl_initialized = true; return 0; } static int msb_ftl_scan(struct msb_data *msb) { u16 pba, lba, other_block; u8 overwrite_flag, management_flag, other_overwrite_flag; int error; struct ms_extra_data_register extra; u8 *overwrite_flags = kzalloc(msb->block_count, GFP_KERNEL); if (!overwrite_flags) return -ENOMEM; dbg("Start of media scanning"); for (pba = 0; pba < msb->block_count; pba++) { if (pba == msb->boot_block_locations[0] || pba == msb->boot_block_locations[1]) { dbg_verbose("pba %05d -> [boot block]", pba); msb_mark_block_used(msb, pba); continue; } if (test_bit(pba, msb->used_blocks_bitmap)) { dbg_verbose("pba %05d -> [factory bad]", pba); continue; } memset(&extra, 0, sizeof(extra)); error = msb_read_oob(msb, pba, 0, &extra); /* can't trust the page if we can't read the oob */ if (error == -EBADMSG) { pr_notice( "oob of pba %d damaged, will try to erase it", pba); msb_mark_block_used(msb, pba); msb_erase_block(msb, pba); continue; } else if (error) { pr_err("unknown error %d on read of oob of pba %d - aborting", error, pba); kfree(overwrite_flags); return error; } lba = be16_to_cpu(extra.logical_address); management_flag = extra.management_flag; overwrite_flag = extra.overwrite_flag; overwrite_flags[pba] = overwrite_flag; /* Skip bad blocks */ if (!(overwrite_flag & MEMSTICK_OVERWRITE_BKST)) { dbg("pba %05d -> [BAD]", pba); msb_mark_block_used(msb, pba); continue; } /* Skip system/drm blocks */ if ((management_flag & MEMSTICK_MANAGEMENT_FLAG_NORMAL) != MEMSTICK_MANAGEMENT_FLAG_NORMAL) { dbg("pba %05d -> [reserved management flag %02x]", pba, management_flag); msb_mark_block_used(msb, pba); continue; } /* Erase temporary tables */ if (!(management_flag & MEMSTICK_MANAGEMENT_ATFLG)) { dbg("pba %05d -> [temp table] - will erase", pba); msb_mark_block_used(msb, pba); msb_erase_block(msb, pba); continue; } if (lba == MS_BLOCK_INVALID) { dbg_verbose("pba %05d -> [free]", pba); continue; } msb_mark_block_used(msb, pba); /* Block has LBA not according to zoning*/ if (msb_get_zone_from_lba(lba) != msb_get_zone_from_pba(pba)) { pr_notice("pba %05d -> [bad lba %05d] - will erase", pba, lba); msb_erase_block(msb, pba); continue; } /* No collisions - great */ if (msb->lba_to_pba_table[lba] == MS_BLOCK_INVALID) { dbg_verbose("pba %05d -> [lba %05d]", pba, lba); msb->lba_to_pba_table[lba] = pba; continue; } other_block = msb->lba_to_pba_table[lba]; other_overwrite_flag = overwrite_flags[other_block]; pr_notice("Collision between pba %d and pba %d", pba, other_block); if (!(overwrite_flag & MEMSTICK_OVERWRITE_UDST)) { pr_notice("pba %d is marked as stable, use it", pba); msb_erase_block(msb, other_block); msb->lba_to_pba_table[lba] = pba; continue; } if (!(other_overwrite_flag & MEMSTICK_OVERWRITE_UDST)) { pr_notice("pba %d is marked as stable, use it", other_block); msb_erase_block(msb, pba); continue; } pr_notice("collision between blocks %d and %d, without stable flag set on both, erasing pba %d", pba, other_block, other_block); msb_erase_block(msb, other_block); msb->lba_to_pba_table[lba] = pba; } dbg("End of media scanning"); kfree(overwrite_flags); return 0; } static void msb_cache_flush_timer(struct timer_list *t) { struct msb_data *msb = from_timer(msb, t, cache_flush_timer); msb->need_flush_cache = true; queue_work(msb->io_queue, &msb->io_work); } static void msb_cache_discard(struct msb_data *msb) { if (msb->cache_block_lba == MS_BLOCK_INVALID) return; del_timer_sync(&msb->cache_flush_timer); dbg_verbose("Discarding the write cache"); msb->cache_block_lba = MS_BLOCK_INVALID; bitmap_zero(&msb->valid_cache_bitmap, msb->pages_in_block); } static int msb_cache_init(struct msb_data *msb) { timer_setup(&msb->cache_flush_timer, msb_cache_flush_timer, 0); if (!msb->cache) msb->cache = kzalloc(msb->block_size, GFP_KERNEL); if (!msb->cache) return -ENOMEM; msb_cache_discard(msb); return 0; } static int msb_cache_flush(struct msb_data *msb) { struct scatterlist sg; struct ms_extra_data_register extra; int page, offset, error; u16 pba, lba; if (msb->read_only) return -EROFS; if (msb->cache_block_lba == MS_BLOCK_INVALID) return 0; lba = msb->cache_block_lba; pba = msb->lba_to_pba_table[lba]; dbg_verbose("Flushing the write cache of pba %d (LBA %d)", pba, msb->cache_block_lba); sg_init_one(&sg, msb->cache , msb->block_size); /* Read all missing pages in cache */ for (page = 0; page < msb->pages_in_block; page++) { if (test_bit(page, &msb->valid_cache_bitmap)) continue; offset = page * msb->page_size; dbg_verbose("reading non-present sector %d of cache block %d", page, lba); error = msb_read_page(msb, pba, page, &extra, &sg, offset); /* Bad pages are copied with 00 page status */ if (error == -EBADMSG) { pr_err("read error on sector %d, contents probably damaged", page); continue; } if (error) return error; if ((extra.overwrite_flag & MEMSTICK_OV_PG_NORMAL) != MEMSTICK_OV_PG_NORMAL) { dbg("page %d is marked as bad", page); continue; } set_bit(page, &msb->valid_cache_bitmap); } /* Write the cache now */ error = msb_update_block(msb, msb->cache_block_lba, &sg, 0); pba = msb->lba_to_pba_table[msb->cache_block_lba]; /* Mark invalid pages */ if (!error) { for (page = 0; page < msb->pages_in_block; page++) { if (test_bit(page, &msb->valid_cache_bitmap)) continue; dbg("marking page %d as containing damaged data", page); msb_set_overwrite_flag(msb, pba , page, 0xFF & ~MEMSTICK_OV_PG_NORMAL); } } msb_cache_discard(msb); return error; } static int msb_cache_write(struct msb_data *msb, int lba, int page, bool add_to_cache_only, struct scatterlist *sg, int offset) { int error; struct scatterlist sg_tmp[10]; if (msb->read_only) return -EROFS; if (msb->cache_block_lba == MS_BLOCK_INVALID || lba != msb->cache_block_lba) if (add_to_cache_only) return 0; /* If we need to write different block */ if (msb->cache_block_lba != MS_BLOCK_INVALID && lba != msb->cache_block_lba) { dbg_verbose("first flush the cache"); error = msb_cache_flush(msb); if (error) return error; } if (msb->cache_block_lba == MS_BLOCK_INVALID) { msb->cache_block_lba = lba; mod_timer(&msb->cache_flush_timer, jiffies + msecs_to_jiffies(cache_flush_timeout)); } dbg_verbose("Write of LBA %d page %d to cache ", lba, page); sg_init_table(sg_tmp, ARRAY_SIZE(sg_tmp)); msb_sg_copy(sg, sg_tmp, ARRAY_SIZE(sg_tmp), offset, msb->page_size); sg_copy_to_buffer(sg_tmp, sg_nents(sg_tmp), msb->cache + page * msb->page_size, msb->page_size); set_bit(page, &msb->valid_cache_bitmap); return 0; } static int msb_cache_read(struct msb_data *msb, int lba, int page, struct scatterlist *sg, int offset) { int pba = msb->lba_to_pba_table[lba]; struct scatterlist sg_tmp[10]; int error = 0; if (lba == msb->cache_block_lba && test_bit(page, &msb->valid_cache_bitmap)) { dbg_verbose("Read of LBA %d (pba %d) sector %d from cache", lba, pba, page); sg_init_table(sg_tmp, ARRAY_SIZE(sg_tmp)); msb_sg_copy(sg, sg_tmp, ARRAY_SIZE(sg_tmp), offset, msb->page_size); sg_copy_from_buffer(sg_tmp, sg_nents(sg_tmp), msb->cache + msb->page_size * page, msb->page_size); } else { dbg_verbose("Read of LBA %d (pba %d) sector %d from device", lba, pba, page); error = msb_read_page(msb, pba, page, NULL, sg, offset); if (error) return error; msb_cache_write(msb, lba, page, true, sg, offset); } return error; } /* Emulated geometry table * This table content isn't that importaint, * One could put here different values, providing that they still * cover whole disk. * 64 MB entry is what windows reports for my 64M memstick */ static const struct chs_entry chs_table[] = { /* size sectors cylynders heads */ { 4, 16, 247, 2 }, { 8, 16, 495, 2 }, { 16, 16, 495, 4 }, { 32, 16, 991, 4 }, { 64, 16, 991, 8 }, {128, 16, 991, 16 }, { 0 } }; /* Load information about the card */ static int msb_init_card(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); struct memstick_host *host = card->host; struct ms_boot_page *boot_block; int error = 0, i, raw_size_in_megs; msb->caps = 0; if (card->id.class >= MEMSTICK_CLASS_ROM && card->id.class <= MEMSTICK_CLASS_ROM) msb->read_only = true; msb->state = -1; error = msb_reset(msb, false); if (error) return error; /* Due to a bug in Jmicron driver written by Alex Dubov, * its serial mode barely works, * so we switch to parallel mode right away */ if (host->caps & MEMSTICK_CAP_PAR4) msb_switch_to_parallel(msb); msb->page_size = sizeof(struct ms_boot_page); /* Read the boot page */ error = msb_read_boot_blocks(msb); if (error) return -EIO; boot_block = &msb->boot_page[0]; /* Save intersting attributes from boot page */ msb->block_count = boot_block->attr.number_of_blocks; msb->page_size = boot_block->attr.page_size; msb->pages_in_block = boot_block->attr.block_size * 2; msb->block_size = msb->page_size * msb->pages_in_block; if ((size_t)msb->page_size > PAGE_SIZE) { /* this isn't supported by linux at all, anyway*/ dbg("device page %d size isn't supported", msb->page_size); return -EINVAL; } msb->block_buffer = kzalloc(msb->block_size, GFP_KERNEL); if (!msb->block_buffer) return -ENOMEM; raw_size_in_megs = (msb->block_size * msb->block_count) >> 20; for (i = 0; chs_table[i].size; i++) { if (chs_table[i].size != raw_size_in_megs) continue; msb->geometry.cylinders = chs_table[i].cyl; msb->geometry.heads = chs_table[i].head; msb->geometry.sectors = chs_table[i].sec; break; } if (boot_block->attr.transfer_supporting == 1) msb->caps |= MEMSTICK_CAP_PAR4; if (boot_block->attr.device_type & 0x03) msb->read_only = true; dbg("Total block count = %d", msb->block_count); dbg("Each block consists of %d pages", msb->pages_in_block); dbg("Page size = %d bytes", msb->page_size); dbg("Parallel mode supported: %d", !!(msb->caps & MEMSTICK_CAP_PAR4)); dbg("Read only: %d", msb->read_only); #if 0 /* Now we can switch the interface */ if (host->caps & msb->caps & MEMSTICK_CAP_PAR4) msb_switch_to_parallel(msb); #endif error = msb_cache_init(msb); if (error) return error; error = msb_ftl_initialize(msb); if (error) return error; /* Read the bad block table */ error = msb_read_bad_block_table(msb, 0); if (error && error != -ENOMEM) { dbg("failed to read bad block table from primary boot block, trying from backup"); error = msb_read_bad_block_table(msb, 1); } if (error) return error; /* *drum roll* Scan the media */ error = msb_ftl_scan(msb); if (error) { pr_err("Scan of media failed"); return error; } return 0; } static int msb_do_write_request(struct msb_data *msb, int lba, int page, struct scatterlist *sg, size_t len, int *sucessfuly_written) { int error = 0; off_t offset = 0; *sucessfuly_written = 0; while (offset < len) { if (page == 0 && len - offset >= msb->block_size) { if (msb->cache_block_lba == lba) msb_cache_discard(msb); dbg_verbose("Writing whole lba %d", lba); error = msb_update_block(msb, lba, sg, offset); if (error) return error; offset += msb->block_size; *sucessfuly_written += msb->block_size; lba++; continue; } error = msb_cache_write(msb, lba, page, false, sg, offset); if (error) return error; offset += msb->page_size; *sucessfuly_written += msb->page_size; page++; if (page == msb->pages_in_block) { page = 0; lba++; } } return 0; } static int msb_do_read_request(struct msb_data *msb, int lba, int page, struct scatterlist *sg, int len, int *sucessfuly_read) { int error = 0; int offset = 0; *sucessfuly_read = 0; while (offset < len) { error = msb_cache_read(msb, lba, page, sg, offset); if (error) return error; offset += msb->page_size; *sucessfuly_read += msb->page_size; page++; if (page == msb->pages_in_block) { page = 0; lba++; } } return 0; } static void msb_io_work(struct work_struct *work) { struct msb_data *msb = container_of(work, struct msb_data, io_work); int page, error, len; sector_t lba; struct scatterlist *sg = msb->prealloc_sg; struct request *req; dbg_verbose("IO: work started"); while (1) { spin_lock_irq(&msb->q_lock); if (msb->need_flush_cache) { msb->need_flush_cache = false; spin_unlock_irq(&msb->q_lock); msb_cache_flush(msb); continue; } req = msb->req; if (!req) { dbg_verbose("IO: no more requests exiting"); spin_unlock_irq(&msb->q_lock); return; } spin_unlock_irq(&msb->q_lock); /* process the request */ dbg_verbose("IO: processing new request"); blk_rq_map_sg(msb->queue, req, sg); lba = blk_rq_pos(req); sector_div(lba, msb->page_size / 512); page = sector_div(lba, msb->pages_in_block); if (rq_data_dir(msb->req) == READ) error = msb_do_read_request(msb, lba, page, sg, blk_rq_bytes(req), &len); else error = msb_do_write_request(msb, lba, page, sg, blk_rq_bytes(req), &len); if (len && !blk_update_request(req, BLK_STS_OK, len)) { __blk_mq_end_request(req, BLK_STS_OK); spin_lock_irq(&msb->q_lock); msb->req = NULL; spin_unlock_irq(&msb->q_lock); } if (error && msb->req) { blk_status_t ret = errno_to_blk_status(error); dbg_verbose("IO: ending one sector of the request with error"); blk_mq_end_request(req, ret); spin_lock_irq(&msb->q_lock); msb->req = NULL; spin_unlock_irq(&msb->q_lock); } if (msb->req) dbg_verbose("IO: request still pending"); } } static DEFINE_IDR(msb_disk_idr); /*set of used disk numbers */ static DEFINE_MUTEX(msb_disk_lock); /* protects against races in open/release */ static void msb_data_clear(struct msb_data *msb) { kfree(msb->boot_page); bitmap_free(msb->used_blocks_bitmap); bitmap_free(msb->erased_blocks_bitmap); kfree(msb->lba_to_pba_table); kfree(msb->cache); msb->card = NULL; } static int msb_bd_getgeo(struct block_device *bdev, struct hd_geometry *geo) { struct msb_data *msb = bdev->bd_disk->private_data; *geo = msb->geometry; return 0; } static void msb_bd_free_disk(struct gendisk *disk) { struct msb_data *msb = disk->private_data; mutex_lock(&msb_disk_lock); idr_remove(&msb_disk_idr, msb->disk_id); mutex_unlock(&msb_disk_lock); kfree(msb); } static blk_status_t msb_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd) { struct memstick_dev *card = hctx->queue->queuedata; struct msb_data *msb = memstick_get_drvdata(card); struct request *req = bd->rq; dbg_verbose("Submit request"); spin_lock_irq(&msb->q_lock); if (msb->card_dead) { dbg("Refusing requests on removed card"); WARN_ON(!msb->io_queue_stopped); spin_unlock_irq(&msb->q_lock); blk_mq_start_request(req); return BLK_STS_IOERR; } if (msb->req) { spin_unlock_irq(&msb->q_lock); return BLK_STS_DEV_RESOURCE; } blk_mq_start_request(req); msb->req = req; if (!msb->io_queue_stopped) queue_work(msb->io_queue, &msb->io_work); spin_unlock_irq(&msb->q_lock); return BLK_STS_OK; } static int msb_check_card(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); return (msb->card_dead == 0); } static void msb_stop(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); unsigned long flags; dbg("Stopping all msblock IO"); blk_mq_stop_hw_queues(msb->queue); spin_lock_irqsave(&msb->q_lock, flags); msb->io_queue_stopped = true; spin_unlock_irqrestore(&msb->q_lock, flags); del_timer_sync(&msb->cache_flush_timer); flush_workqueue(msb->io_queue); spin_lock_irqsave(&msb->q_lock, flags); if (msb->req) { blk_mq_requeue_request(msb->req, false); msb->req = NULL; } spin_unlock_irqrestore(&msb->q_lock, flags); } static void msb_start(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); unsigned long flags; dbg("Resuming IO from msblock"); msb_invalidate_reg_window(msb); spin_lock_irqsave(&msb->q_lock, flags); if (!msb->io_queue_stopped || msb->card_dead) { spin_unlock_irqrestore(&msb->q_lock, flags); return; } spin_unlock_irqrestore(&msb->q_lock, flags); /* Kick cache flush anyway, its harmless */ msb->need_flush_cache = true; msb->io_queue_stopped = false; blk_mq_start_hw_queues(msb->queue); queue_work(msb->io_queue, &msb->io_work); } static const struct block_device_operations msb_bdops = { .owner = THIS_MODULE, .getgeo = msb_bd_getgeo, .free_disk = msb_bd_free_disk, }; static const struct blk_mq_ops msb_mq_ops = { .queue_rq = msb_queue_rq, }; /* Registers the block device */ static int msb_init_disk(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); int rc; unsigned long capacity; mutex_lock(&msb_disk_lock); msb->disk_id = idr_alloc(&msb_disk_idr, card, 0, 256, GFP_KERNEL); mutex_unlock(&msb_disk_lock); if (msb->disk_id < 0) return msb->disk_id; rc = blk_mq_alloc_sq_tag_set(&msb->tag_set, &msb_mq_ops, 2, BLK_MQ_F_SHOULD_MERGE); if (rc) goto out_release_id; msb->disk = blk_mq_alloc_disk(&msb->tag_set, card); if (IS_ERR(msb->disk)) { rc = PTR_ERR(msb->disk); goto out_free_tag_set; } msb->queue = msb->disk->queue; blk_queue_max_hw_sectors(msb->queue, MS_BLOCK_MAX_PAGES); blk_queue_max_segments(msb->queue, MS_BLOCK_MAX_SEGS); blk_queue_max_segment_size(msb->queue, MS_BLOCK_MAX_PAGES * msb->page_size); blk_queue_logical_block_size(msb->queue, msb->page_size); sprintf(msb->disk->disk_name, "msblk%d", msb->disk_id); msb->disk->fops = &msb_bdops; msb->disk->private_data = msb; capacity = msb->pages_in_block * msb->logical_block_count; capacity *= (msb->page_size / 512); set_capacity(msb->disk, capacity); dbg("Set total disk size to %lu sectors", capacity); msb->io_queue = alloc_ordered_workqueue("ms_block", WQ_MEM_RECLAIM); if (!msb->io_queue) { rc = -ENOMEM; goto out_cleanup_disk; } INIT_WORK(&msb->io_work, msb_io_work); sg_init_table(msb->prealloc_sg, MS_BLOCK_MAX_SEGS+1); if (msb->read_only) set_disk_ro(msb->disk, 1); msb_start(card); rc = device_add_disk(&card->dev, msb->disk, NULL); if (rc) goto out_destroy_workqueue; dbg("Disk added"); return 0; out_destroy_workqueue: destroy_workqueue(msb->io_queue); out_cleanup_disk: put_disk(msb->disk); out_free_tag_set: blk_mq_free_tag_set(&msb->tag_set); out_release_id: mutex_lock(&msb_disk_lock); idr_remove(&msb_disk_idr, msb->disk_id); mutex_unlock(&msb_disk_lock); return rc; } static int msb_probe(struct memstick_dev *card) { struct msb_data *msb; int rc = 0; msb = kzalloc(sizeof(struct msb_data), GFP_KERNEL); if (!msb) return -ENOMEM; memstick_set_drvdata(card, msb); msb->card = card; spin_lock_init(&msb->q_lock); rc = msb_init_card(card); if (rc) goto out_free; rc = msb_init_disk(card); if (!rc) { card->check = msb_check_card; card->stop = msb_stop; card->start = msb_start; return 0; } out_free: memstick_set_drvdata(card, NULL); msb_data_clear(msb); kfree(msb); return rc; } static void msb_remove(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); unsigned long flags; if (!msb->io_queue_stopped) msb_stop(card); dbg("Removing the disk device"); /* Take care of unhandled + new requests from now on */ spin_lock_irqsave(&msb->q_lock, flags); msb->card_dead = true; spin_unlock_irqrestore(&msb->q_lock, flags); blk_mq_start_hw_queues(msb->queue); /* Remove the disk */ del_gendisk(msb->disk); blk_mq_free_tag_set(&msb->tag_set); msb->queue = NULL; mutex_lock(&msb_disk_lock); msb_data_clear(msb); mutex_unlock(&msb_disk_lock); put_disk(msb->disk); memstick_set_drvdata(card, NULL); } #ifdef CONFIG_PM static int msb_suspend(struct memstick_dev *card, pm_message_t state) { msb_stop(card); return 0; } static int msb_resume(struct memstick_dev *card) { struct msb_data *msb = memstick_get_drvdata(card); struct msb_data *new_msb = NULL; bool card_dead = true; #ifndef CONFIG_MEMSTICK_UNSAFE_RESUME msb->card_dead = true; return 0; #endif mutex_lock(&card->host->lock); new_msb = kzalloc(sizeof(struct msb_data), GFP_KERNEL); if (!new_msb) goto out; new_msb->card = card; memstick_set_drvdata(card, new_msb); spin_lock_init(&new_msb->q_lock); sg_init_table(msb->prealloc_sg, MS_BLOCK_MAX_SEGS+1); if (msb_init_card(card)) goto out; if (msb->block_size != new_msb->block_size) goto out; if (memcmp(msb->boot_page, new_msb->boot_page, sizeof(struct ms_boot_page))) goto out; if (msb->logical_block_count != new_msb->logical_block_count || memcmp(msb->lba_to_pba_table, new_msb->lba_to_pba_table, msb->logical_block_count)) goto out; if (msb->block_count != new_msb->block_count || !bitmap_equal(msb->used_blocks_bitmap, new_msb->used_blocks_bitmap, msb->block_count)) goto out; card_dead = false; out: if (card_dead) dbg("Card was removed/replaced during suspend"); msb->card_dead = card_dead; memstick_set_drvdata(card, msb); if (new_msb) { msb_data_clear(new_msb); kfree(new_msb); } msb_start(card); mutex_unlock(&card->host->lock); return 0; } #else #define msb_suspend NULL #define msb_resume NULL #endif /* CONFIG_PM */ static struct memstick_device_id msb_id_tbl[] = { {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_LEGACY, MEMSTICK_CATEGORY_STORAGE, MEMSTICK_CLASS_FLASH}, {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_LEGACY, MEMSTICK_CATEGORY_STORAGE, MEMSTICK_CLASS_ROM}, {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_LEGACY, MEMSTICK_CATEGORY_STORAGE, MEMSTICK_CLASS_RO}, {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_LEGACY, MEMSTICK_CATEGORY_STORAGE, MEMSTICK_CLASS_WP}, {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_DUO, MEMSTICK_CATEGORY_STORAGE_DUO, MEMSTICK_CLASS_DUO}, {} }; MODULE_DEVICE_TABLE(memstick, msb_id_tbl); static struct memstick_driver msb_driver = { .driver = { .name = DRIVER_NAME, .owner = THIS_MODULE }, .id_table = msb_id_tbl, .probe = msb_probe, .remove = msb_remove, .suspend = msb_suspend, .resume = msb_resume }; static int __init msb_init(void) { int rc = memstick_register_driver(&msb_driver); if (rc) pr_err("failed to register memstick driver (error %d)\n", rc); return rc; } static void __exit msb_exit(void) { memstick_unregister_driver(&msb_driver); idr_destroy(&msb_disk_idr); } module_init(msb_init); module_exit(msb_exit); module_param(cache_flush_timeout, int, S_IRUGO); MODULE_PARM_DESC(cache_flush_timeout, "Cache flush timeout in msec (1000 default)"); module_param(debug, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(debug, "Debug level (0-2)"); module_param(verify_writes, bool, S_IRUGO); MODULE_PARM_DESC(verify_writes, "Read back and check all data that is written"); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Maxim Levitsky"); MODULE_DESCRIPTION("Sony MemoryStick block device driver");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1