1 /* 2 * Copyright 2017 Rockchip Electronics Co., Ltd 3 * Frank Wang <frank.wang@rock-chips.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <rockusb.h> 9 10 #define ROCKUSB_INTERFACE_CLASS 0xff 11 #define ROCKUSB_INTERFACE_SUB_CLASS 0x06 12 #define ROCKUSB_INTERFACE_PROTOCOL 0x05 13 14 static struct usb_interface_descriptor rkusb_intf_desc = { 15 .bLength = USB_DT_INTERFACE_SIZE, 16 .bDescriptorType = USB_DT_INTERFACE, 17 .bInterfaceNumber = 0x00, 18 .bAlternateSetting = 0x00, 19 .bNumEndpoints = 0x02, 20 .bInterfaceClass = ROCKUSB_INTERFACE_CLASS, 21 .bInterfaceSubClass = ROCKUSB_INTERFACE_SUB_CLASS, 22 .bInterfaceProtocol = ROCKUSB_INTERFACE_PROTOCOL, 23 }; 24 25 static struct usb_descriptor_header *rkusb_fs_function[] = { 26 (struct usb_descriptor_header *)&rkusb_intf_desc, 27 (struct usb_descriptor_header *)&fsg_fs_bulk_in_desc, 28 (struct usb_descriptor_header *)&fsg_fs_bulk_out_desc, 29 NULL, 30 }; 31 32 static struct usb_descriptor_header *rkusb_hs_function[] = { 33 (struct usb_descriptor_header *)&rkusb_intf_desc, 34 (struct usb_descriptor_header *)&fsg_hs_bulk_in_desc, 35 (struct usb_descriptor_header *)&fsg_hs_bulk_out_desc, 36 NULL, 37 }; 38 39 struct rk_flash_info { 40 u32 flash_size; 41 u16 block_size; 42 u8 page_size; 43 u8 ecc_bits; 44 u8 access_time; 45 u8 manufacturer; 46 u8 flash_mask; 47 } __packed; 48 49 int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name) 50 { 51 if (IS_RKUSB_UMS_DNL(name)) { 52 /* Fix to Rockchip VID and PID */ 53 dev->idVendor = __constant_cpu_to_le16(0x2207); 54 dev->idProduct = __constant_cpu_to_le16(CONFIG_ROCKUSB_G_DNL_PID); 55 56 /* Enumerate as a loader device */ 57 dev->bcdUSB = cpu_to_le16(0x0201); 58 } 59 60 return 0; 61 } 62 63 __maybe_unused 64 static inline void dump_cbw(struct fsg_bulk_cb_wrap *cbw) 65 { 66 assert(!cbw); 67 68 debug("%s:\n", __func__); 69 debug("Signature %x\n", cbw->Signature); 70 debug("Tag %x\n", cbw->Tag); 71 debug("DataTransferLength %x\n", cbw->DataTransferLength); 72 debug("Flags %x\n", cbw->Flags); 73 debug("LUN %x\n", cbw->Lun); 74 debug("Length %x\n", cbw->Length); 75 debug("OptionCode %x\n", cbw->CDB[0]); 76 debug("SubCode %x\n", cbw->CDB[1]); 77 debug("SectorAddr %x\n", get_unaligned_be32(&cbw->CDB[2])); 78 debug("BlkSectors %x\n\n", get_unaligned_be16(&cbw->CDB[7])); 79 } 80 81 static int rkusb_check_lun(struct fsg_common *common) 82 { 83 struct fsg_lun *curlun; 84 85 /* Check the LUN */ 86 if (common->lun >= 0 && common->lun < common->nluns) { 87 curlun = &common->luns[common->lun]; 88 if (common->cmnd[0] != SC_REQUEST_SENSE) { 89 curlun->sense_data = SS_NO_SENSE; 90 curlun->info_valid = 0; 91 } 92 } else { 93 curlun = NULL; 94 common->bad_lun_okay = 0; 95 96 /* 97 * INQUIRY and REQUEST SENSE commands are explicitly allowed 98 * to use unsupported LUNs; all others may not. 99 */ 100 if (common->cmnd[0] != SC_INQUIRY && 101 common->cmnd[0] != SC_REQUEST_SENSE) { 102 debug("unsupported LUN %d\n", common->lun); 103 return -EINVAL; 104 } 105 } 106 107 return 0; 108 } 109 110 static void __do_reset(struct usb_ep *ep, struct usb_request *req) 111 { 112 do_reset(NULL, 0, 0, NULL); 113 } 114 115 static int rkusb_do_reset(struct fsg_common *common, 116 struct fsg_buffhd *bh) 117 { 118 common->data_size_from_cmnd = common->cmnd[4]; 119 common->residue = 0; 120 bh->inreq->complete = __do_reset; 121 bh->state = BUF_STATE_EMPTY; 122 123 return 0; 124 } 125 126 static int rkusb_do_test_unit_ready(struct fsg_common *common, 127 struct fsg_buffhd *bh) 128 { 129 common->residue = 0x06 << 24; /* Max block xfer support from host */ 130 common->data_dir = DATA_DIR_NONE; 131 bh->state = BUF_STATE_EMPTY; 132 133 return 0; 134 } 135 136 static int rkusb_do_read_flash_id(struct fsg_common *common, 137 struct fsg_buffhd *bh) 138 { 139 u8 *buf = (u8 *)bh->buf; 140 u32 len = common->data_size; 141 142 memcpy((void *)&buf[0], "EMMC ", 5); 143 144 /* Set data xfer size */ 145 common->residue = common->data_size_from_cmnd = len; 146 147 return len; 148 } 149 150 static int rkusb_do_test_bad_block(struct fsg_common *common, 151 struct fsg_buffhd *bh) 152 { 153 u8 *buf = (u8 *)bh->buf; 154 u32 len = common->data_size; 155 156 memset((void *)&buf[0], 0, len); 157 158 /* Set data xfer size */ 159 common->residue = common->data_size_from_cmnd = len; 160 161 return len; 162 } 163 164 static int rkusb_do_read_flash_info(struct fsg_common *common, 165 struct fsg_buffhd *bh) 166 { 167 u8 *buf = (u8 *)bh->buf; 168 u32 len = common->data_size; 169 struct rk_flash_info finfo = { 170 .block_size = 1024, 171 .ecc_bits = 0, 172 .page_size = 4, 173 .access_time = 40, 174 .manufacturer = 0, 175 .flash_mask = 0 176 }; 177 178 finfo.flash_size = (u32)ums[common->lun].block_dev.lba; 179 if (finfo.flash_size) 180 finfo.flash_mask = 1; 181 182 memset((void *)&buf[0], 0, len); 183 memcpy((void *)&buf[0], (void *)&finfo, len); 184 185 /* Set data xfer size */ 186 common->residue = common->data_size_from_cmnd = len; 187 188 return len; 189 } 190 191 static int rkusb_do_lba_erase(struct fsg_common *common, 192 struct fsg_buffhd *bh) 193 { 194 struct fsg_lun *curlun = &common->luns[common->lun]; 195 u32 lba, amount; 196 loff_t file_offset; 197 int rc; 198 199 lba = get_unaligned_be32(&common->cmnd[2]); 200 if (lba >= curlun->num_sectors) { 201 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 202 rc = -EINVAL; 203 goto out; 204 } 205 206 file_offset = ((loff_t) lba) << 9; 207 amount = get_unaligned_be16(&common->cmnd[7]) << 9; 208 if (unlikely(amount == 0)) { 209 curlun->sense_data = SS_INVALID_FIELD_IN_CDB; 210 rc = -EIO; 211 goto out; 212 } 213 214 /* Perform the erase */ 215 rc = ums[common->lun].erase_sector(&ums[common->lun], 216 file_offset / SECTOR_SIZE, 217 amount / SECTOR_SIZE); 218 if (!rc) { 219 curlun->sense_data = SS_MEDIUM_NOT_PRESENT; 220 rc = -EIO; 221 } 222 223 out: 224 common->data_dir = DATA_DIR_NONE; 225 bh->state = BUF_STATE_EMPTY; 226 227 return rc; 228 } 229 230 static int rkusb_do_read_capacity(struct fsg_common *common, 231 struct fsg_buffhd *bh) 232 { 233 u8 *buf = (u8 *)bh->buf; 234 u32 len = common->data_size; 235 enum if_type type = ums[common->lun].block_dev.if_type; 236 237 /* 238 * bit[0]: Direct LBA, 0: Disabled; 239 * bit[1]: Vendor Storage API, 0: default; 240 * bit[2]: First 4M Access, 0: Disabled; 241 * bit[3:63}: Reserved. 242 */ 243 memset((void *)&buf[0], 0, len); 244 buf[0] = (type == IF_TYPE_MMC) ? (BIT(2) | BIT(0)) : BIT(0); 245 246 /* Set data xfer size */ 247 common->residue = common->data_size_from_cmnd = len; 248 249 return len; 250 } 251 252 static int rkusb_cmd_process(struct fsg_common *common, 253 struct fsg_buffhd *bh, int *reply) 254 { 255 struct usb_request *req = bh->outreq; 256 struct fsg_bulk_cb_wrap *cbw = req->buf; 257 int rc; 258 259 dump_cbw(cbw); 260 261 if (rkusb_check_lun(common)) { 262 *reply = -EINVAL; 263 return RKUSB_RC_ERROR; 264 } 265 266 switch (common->cmnd[0]) { 267 case RKUSB_TEST_UNIT_READY: 268 *reply = rkusb_do_test_unit_ready(common, bh); 269 rc = RKUSB_RC_FINISHED; 270 break; 271 272 case RKUSB_READ_FLASH_ID: 273 *reply = rkusb_do_read_flash_id(common, bh); 274 rc = RKUSB_RC_FINISHED; 275 break; 276 277 case RKUSB_TEST_BAD_BLOCK: 278 *reply = rkusb_do_test_bad_block(common, bh); 279 rc = RKUSB_RC_FINISHED; 280 break; 281 282 case RKUSB_LBA_READ_10: 283 common->cmnd[0] = SC_READ_10; 284 common->cmnd[1] = 0; /* Not support */ 285 rc = RKUSB_RC_CONTINUE; 286 break; 287 288 case RKUSB_LBA_WRITE_10: 289 common->cmnd[0] = SC_WRITE_10; 290 common->cmnd[1] = 0; /* Not support */ 291 rc = RKUSB_RC_CONTINUE; 292 break; 293 294 case RKUSB_READ_FLASH_INFO: 295 *reply = rkusb_do_read_flash_info(common, bh); 296 rc = RKUSB_RC_FINISHED; 297 break; 298 299 case RKUSB_LBA_ERASE: 300 *reply = rkusb_do_lba_erase(common, bh); 301 rc = RKUSB_RC_FINISHED; 302 break; 303 304 case RKUSB_READ_CAPACITY: 305 *reply = rkusb_do_read_capacity(common, bh); 306 rc = RKUSB_RC_FINISHED; 307 break; 308 309 case RKUSB_RESET: 310 *reply = rkusb_do_reset(common, bh); 311 rc = RKUSB_RC_FINISHED; 312 break; 313 314 case RKUSB_SET_DEVICE_ID: 315 case RKUSB_READ_10: 316 case RKUSB_WRITE_10: 317 case RKUSB_ERASE_10: 318 case RKUSB_WRITE_SPARE: 319 case RKUSB_READ_SPARE: 320 case RKUSB_ERASE_10_FORCE: 321 case RKUSB_GET_VERSION: 322 case RKUSB_ERASE_SYS_DISK: 323 case RKUSB_SDRAM_READ_10: 324 case RKUSB_SDRAM_WRITE_10: 325 case RKUSB_SDRAM_EXECUTE: 326 case RKUSB_GET_CHIP_VER: 327 case RKUSB_LOW_FORMAT: 328 case RKUSB_SET_RESET_FLAG: 329 case RKUSB_SPI_READ_10: 330 case RKUSB_SPI_WRITE_10: 331 case RKUSB_SESSION: 332 /* Fall through */ 333 default: 334 rc = RKUSB_RC_UNKNOWN_CMND; 335 break; 336 } 337 338 return rc; 339 } 340 341 DECLARE_GADGET_BIND_CALLBACK(rkusb_ums_dnl, fsg_add); 342