| /* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <debug.h> |
| #include <reg.h> |
| #include <ufs_hw.h> |
| #include <utp.h> |
| #include <upiu.h> |
| #include <uic.h> |
| #include <ucs.h> |
| #include <dme.h> |
| #include <qgic.h> |
| #include <string.h> |
| #include <platform/iomap.h> |
| #include <platform/irqs.h> |
| #include <kernel/mutex.h> |
| |
| static int ufs_dev_init(struct ufs_dev *dev) |
| { |
| /* Init the mutexes. */ |
| mutex_init(&(dev->uic_data.uic_mutex)); |
| mutex_init(&(dev->utrd_data.bitmap_mutex)); |
| mutex_init(&(dev->utmrd_data.bitmap_mutex)); |
| |
| /* Initialize wait lists. */ |
| list_initialize(&(dev->utrd_data.list_head.list_node)); |
| list_initialize(&(dev->utmrd_data.list_head.list_node)); |
| |
| /* Initialize the bitmaps. */ |
| dev->utrd_data.bitmap = 0; |
| dev->utmrd_data.bitmap = 0; |
| |
| /* Initialize task ids. */ |
| dev->utrd_data.task_id = 0; |
| dev->utmrd_data.task_id = 0; |
| |
| /* Allocate memory for lists. */ |
| dev->utrd_data.list_base_addr = ufs_alloc_trans_req_list(); |
| dev->utmrd_data.list_base_addr = ufs_alloc_task_mgmt_req_list(); |
| |
| if (!dev->utrd_data.list_base_addr || !dev->utmrd_data.list_base_addr) |
| return -UFS_FAILURE; |
| |
| return UFS_SUCCESS; |
| } |
| |
| static void ufs_setup_req_lists(struct ufs_dev *dev) |
| { |
| uint32_t val; |
| |
| writel(dev->utmrd_data.list_base_addr, UFS_UTMRLBA(dev->base)); |
| writel(dev->utmrd_data.list_base_addr << 32, UFS_UTMRLBAU(dev->base)); |
| |
| writel(dev->utrd_data.list_base_addr, UFS_UTRLBA(dev->base)); |
| writel(dev->utrd_data.list_base_addr << 32, UFS_UTRLBAU(dev->base)); |
| |
| writel(1, UFS_UTMRLRSR(dev->base)); |
| writel(1, UFS_UTRLRSR(dev->base)); |
| |
| /* Enable the required irqs. */ |
| val = UFS_IE_UEE | UFS_IE_UCCE ; |
| ufs_irq_enable(dev, val); |
| // Change UFS_IRQ to level based |
| qgic_change_interrupt_cfg(UFS_IRQ, INTERRUPT_LVL_N_TO_N); |
| } |
| |
| static void ufs_rpmb_init(struct ufs_dev *dev) |
| { |
| int ret = 0; |
| |
| // calculate the size of rpmb partition in sectors |
| ret = dme_read_unit_desc(dev, UFS_WLUN_RPMB); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dme_read_unit_desc failed for RPMB Partition\n"); |
| return; |
| } |
| |
| // gets the number of rpmb frames allowed in a single UPIU commands |
| ret = dme_read_geo_desc(dev, UFS_WLUN_RPMB); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dme_read_geo_desc failed for RPMB Partition\n"); |
| return; |
| } |
| #ifdef DEBUG_UFS |
| dprintf(INFO, "RPMB: Logical Block Count: 0x%x\n", dev->rpmb_num_blocks); |
| dprintf(INFO, "RPMB: RPMB Read Write Size: 0x%x\n", dev->rpmb_rw_size); |
| #endif |
| } |
| |
| int ufs_read(struct ufs_dev* dev, uint64_t start_lba, addr_t buffer, uint32_t num_blocks) |
| { |
| struct scsi_rdwr_req req; |
| int ret; |
| |
| req.data_buffer_base = buffer; |
| req.lun = dev->current_lun; |
| req.num_blocks = num_blocks; |
| req.start_lba = start_lba / dev->block_size; |
| |
| ret = ucs_do_scsi_read(dev, &req); |
| if (ret) |
| { |
| dprintf(CRITICAL, "UFS read failed.\n"); |
| ufs_dump_hc_registers(dev); |
| } |
| |
| return ret; |
| } |
| |
| int ufs_write(struct ufs_dev* dev, uint64_t start_lba, addr_t buffer, uint32_t num_blocks) |
| { |
| struct scsi_rdwr_req req; |
| int ret; |
| |
| req.data_buffer_base = buffer; |
| req.lun = dev->current_lun; |
| req.num_blocks = num_blocks; |
| req.start_lba = start_lba / dev->block_size; |
| |
| ret = ucs_do_scsi_write(dev, &req); |
| if (ret) |
| { |
| dprintf(CRITICAL, "UFS write failed.\n"); |
| ufs_dump_hc_registers(dev); |
| } |
| |
| return ret; |
| } |
| |
| int ufs_erase(struct ufs_dev* dev, uint64_t start_lba, uint32_t num_blocks) |
| { |
| struct scsi_unmap_req req; |
| int ret; |
| |
| req.lun = dev->current_lun; |
| req.start_lba = start_lba / dev->block_size; |
| req.num_blocks = num_blocks; |
| |
| ret = ucs_do_scsi_unmap(dev, &req); |
| if(ret) |
| { |
| dprintf(CRITICAL, "UFS erase failed \n"); |
| } |
| |
| return ret; |
| } |
| |
| uint64_t ufs_get_dev_capacity(struct ufs_dev* dev) |
| { |
| uint64_t capacity; |
| uint8_t lun = dev->current_lun; |
| |
| capacity = dev->lun_cfg[lun].logical_blk_cnt * dev->block_size; |
| |
| return capacity; |
| } |
| |
| uint32_t ufs_get_erase_blk_size(struct ufs_dev* dev) |
| { |
| uint32_t erase_blk_size; |
| uint8_t lun = dev->current_lun; |
| |
| erase_blk_size = dev->lun_cfg[lun].erase_blk_size; |
| |
| return erase_blk_size; |
| } |
| |
| uint32_t ufs_get_serial_num(struct ufs_dev* dev) |
| { |
| int ret; |
| |
| ret = dme_read_device_desc(dev); |
| if (ret) |
| { |
| dprintf(CRITICAL, "UFS get serial number failed.\n"); |
| ufs_dump_hc_registers(dev); |
| } |
| |
| return dev->serial_num; |
| } |
| |
| uint32_t ufs_get_page_size(struct ufs_dev* dev) |
| { |
| return dev->block_size; |
| } |
| |
| uint8_t ufs_get_num_of_luns(struct ufs_dev* dev) |
| { |
| return dev->num_lus; |
| } |
| |
| int ufs_init(struct ufs_dev *dev) |
| { |
| uint32_t ret = UFS_SUCCESS; |
| uint64_t cap; |
| uint8_t lun = 0; |
| |
| dev->block_size = 4096; |
| |
| /* Init dev struct. */ |
| ret = ufs_dev_init(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dev_init failed\n"); |
| goto ufs_init_err; |
| } |
| |
| /* Perform Data link init. */ |
| ret = uic_init(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS uic_init failed\n"); |
| goto ufs_init_err; |
| } |
| |
| /* Setup request lists. */ |
| ufs_setup_req_lists(dev); |
| |
| /* Send NOP to check if device UTP layer is ready. */ |
| ret = dme_send_nop_query(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dme_send_nop_query failed\n"); |
| goto ufs_init_err; |
| } |
| |
| ret = dme_set_fdeviceinit(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dme_set_fdeviceinit failed\n"); |
| goto ufs_init_err; |
| } |
| |
| ret = ucs_scsi_send_inquiry(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS ucs_scsi_send_inquiry failed\n"); |
| goto ufs_init_err; |
| } |
| |
| ret = dme_read_device_desc(dev); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "dme_read_dev_desc read failed\n"); |
| goto ufs_init_err; |
| } |
| |
| |
| for(lun=0; lun < dev->num_lus; lun++) |
| { |
| ret = dme_read_unit_desc(dev, lun); |
| if (ret != UFS_SUCCESS) |
| { |
| dprintf(CRITICAL, "UFS dme_read_unit_desc failed\n"); |
| goto ufs_init_err; |
| } |
| } |
| |
| dprintf(CRITICAL,"UFS init success\n"); |
| |
| ufs_init_err: |
| |
| if(ret != UFS_SUCCESS) |
| { |
| ufs_dump_hc_registers(dev); |
| } |
| |
| return ret; |
| } |
| |
| void ufs_dump_is_register(struct ufs_dev *dev) |
| { |
| uint32_t base = dev->base; |
| dprintf(CRITICAL,"UFS_IS 0x%x\n",readl(UFS_IS(base))); |
| } |
| |
| void ufs_dump_hc_registers(struct ufs_dev *dev) |
| { |
| uint32_t base = dev->base; |
| |
| dprintf(CRITICAL,"------Host controller register dump ---------\n"); |
| dprintf(CRITICAL,"UFS_UECPA 0x%x\n",readl(UFS_UECPA(base))); |
| dprintf(CRITICAL,"UFS_UECDL 0x%x\n",readl(UFS_UECDL(base))); |
| dprintf(CRITICAL,"UFS_UECN 0x%x\n", readl(UFS_UECN(base))); |
| dprintf(CRITICAL,"UFS_UECT 0x%x\n",readl(UFS_UECT(base))); |
| dprintf(CRITICAL,"UFS_UECDME 0x%x\n",readl(UFS_UECDME(base))); |
| dprintf(CRITICAL,"UFS_HCS 0x%x\n", readl(UFS_HCS(base))); |
| dprintf(CRITICAL,"-----------End--------------------------------\n"); |
| } |