/** * ioctl.c - Generic IOCTL command processing * * Copyright (c) 2011 thi.guten Software Development * Copyright (c) 2011 Mensys B.V. * Copyright (c) 2013-2023 David Azarewicz * * Authors: Christian Mueller, Markus Thielen * * Parts copied from/inspired by the Linux AHCI driver; * those parts are (c) Linux AHCI/ATA maintainers * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "os2ahci.h" #include "atapi.h" #include "ata.h" #include "ioctl.h" #include #pragma pack(1) /* Memory area for IOCTLs which send IORBs downstream; currently only * OS2AHCI_IOCTL_PASSTHROUGH falls into this category, thus we're simply * reusing the IORB_ADAPTER_PASSTHRU structure for now. If this ever changes, * we'll need to define a union to cover all IORB types in question. */ #define CMDLEN sizeof(((OS2AHCI_PASSTHROUGH *) 0)->cmd) typedef struct { IORB_ADAPTER_PASSTHRU iorb; /* IORB */ SCSI_STATUS_BLOCK ssb; /* SCSI status block */ UCHAR cmd[CMDLEN]; /* copy of passthrough cmd * (need to fill ATA return * registers at interrupt time) */ UCHAR sense[ATAPI_SENSE_LEN]; /* sense buffer */ SCATGATENTRY sg_lst[AHCI_MAX_SG / 2]; /* scatter/gather list */ ULONG sg_cnt; /* number of S/G elements */ struct _KernVMLock_t lh; /* lock handle for KernVMLock() */ } IOCTL_CONTEXT; static USHORT do_smart(BYTE unit, BYTE sub_func, BYTE cnt, BYTE lba_l, void *buf); static int map_unit(BYTE unit, USHORT *a, USHORT *p, USHORT *d); extern IORBH FAR16DATA * (__far16 *Far16AdrOfIoctlWakeup16)(IORBH FAR16DATA*); /****************************************************************************** * Return device list to allow the ring 3 application to figure out which * adapter/port/device combinations are available. */ USHORT ioctl_get_devlist(REQPACKET *ioctl) { OS2AHCI_DEVLIST *devlst = (OS2AHCI_DEVLIST*)Far16ToFlat(ioctl->ioctl.pvData); USHORT maxcnt = 0; USHORT cnt = 0; USHORT a; USHORT p; USHORT d; if (KernCopyIn(&maxcnt, ioctl->ioctl.pvParm, sizeof(maxcnt))) { return(RPDONE | RPERR_PARAMETER); } /* fill-in device list */ for (a = 0; a < ad_info_cnt; a++) { AD_INFO *ai = ad_infos + a; for (p = 0; p <= ai->port_max; p++) { P_INFO *pi = ai->ports + p; for (d = 0; d <= pi->dev_max; d++) { if (pi->devs[d].present) { /* add this device to the device list */ if (cnt >= maxcnt) { /* not enough room in devlst */ goto ioctl_get_device_done; } devlst->devs[cnt].adapter = a; devlst->devs[cnt].port = p; devlst->devs[cnt].device = d; devlst->devs[cnt].type = pi->devs[d].dev_type; devlst->devs[cnt].ncq_max = pi->devs[d].ncq_max; if (pi->devs[d].lba48) devlst->devs[cnt].flags |= DF_LBA48; if (pi->devs[d].atapi) devlst->devs[cnt].flags |= DF_ATAPI; if (pi->devs[d].atapi_16) devlst->devs[cnt].flags |= DF_ATAPI_16; if (pi->devs[d].removable) devlst->devs[cnt].flags |= DF_REMOVABLE; cnt++; } } } } ioctl_get_device_done: devlst->cnt = cnt; return(RPDONE); } /****************************************************************************** * Adapter passthrough IOCTL. This IOCTL covers both ATA and ATAPI passthrough * requests. */ USHORT ioctl_passthrough(REQPACKET *ioctl) { OS2AHCI_PASSTHROUGH *req = (OS2AHCI_PASSTHROUGH *)Far16ToFlat(ioctl->ioctl.pvParm); char *sense_buf = (char *)Far16ToFlat(ioctl->ioctl.pvData); IOCTL_CONTEXT *ic; USHORT ret; USHORT a; USHORT p; USHORT d; /* Verify basic request parameters such as adapter/port/device, size of * DMA buffer (the S/G list can't have more than AHCI_MAX_SG / 2 entries), ... */ a = req->adapter; p = req->port; d = req->device; if (a >= ad_info_cnt || p > ad_infos[a].port_max || d > ad_infos[a].ports[p].dev_max || !ad_infos[a].ports[p].devs[d].present) { return(RPDONE | RPERR_UNIT); } if ((req->buflen + 4095) / 4096 + 1 > AHCI_MAX_SG / 2 || req->cmdlen < 6 || req->cmdlen > sizeof(req->cmd)) { return(RPDONE | RPERR_PARAMETER); } /* allocate IOCTL context data */ if ((ic = MemAlloc(sizeof(*ic))) == NULL) { return(RPDONE | RPERR_GENERAL); } memset(ic, 0x00, sizeof(*ic)); /* lock DMA transfer buffer into memory and construct S/G list */ if (req->buflen > 0) { if (KernVMLock(VMDHL_LONG | !((req->flags & PT_WRITE) ? VMDHL_WRITE : 0), req->buf, req->buflen, &ic->lh, (KernPageList_t*)&ic->sg_lst, &ic->sg_cnt) != 0) { /* couldn't lock buffer and/or produce a S/G list */ MemFree(ic); return(RPDONE | RPERR_PARAMETER); } } /* fill in adapter passthrough fields */ ic->iorb.iorbh.Length = sizeof(ic->iorb); ic->iorb.iorbh.UnitHandle = iorb_unit(a, p, d); ic->iorb.iorbh.CommandCode = IOCC_ADAPTER_PASSTHRU; ic->iorb.iorbh.CommandModifier = (req->flags & PT_ATAPI) ? IOCM_EXECUTE_CDB : IOCM_EXECUTE_ATA; ic->iorb.iorbh.RequestControl = IORB_ASYNC_POST; ic->iorb.iorbh.Timeout = req->timeout; ic->iorb.iorbh.f16NotifyAddress = Far16AdrOfIoctlWakeup16; ic->iorb.cSGList = ic->sg_cnt; ic->iorb.f16SGList = MemFar16Adr(ic->sg_lst); ic->iorb.ppSGLIST = MemPhysAdr(ic->sg_lst); memcpy(ic->cmd, req->cmd.cdb, sizeof(ic->cmd)); ic->iorb.ControllerCmdLen = req->cmdlen; ic->iorb.f16ControllerCmd = MemFar16Adr(ic->cmd); ic->iorb.Flags = (req->flags & PT_WRITE) ? 0 : PT_DIRECTION_IN; if (req->sense_len > 0) { /* initialize SCSI status block to allow getting sense data */ ic->iorb.iorbh.pStatusBlock = CastFar16ToULONG(MemFar16Adr(&ic->ssb)); ic->iorb.iorbh.StatusBlockLen = sizeof(ic->ssb); ic->ssb.f16SenseData = MemFar16Adr(ic->sense); ic->ssb.ReqSenseLen = sizeof(ic->sense); ic->iorb.iorbh.RequestControl |= IORB_REQ_STATUSBLOCK; } /* send IORB on its way */ add_entry(MemFar16Adr(&ic->iorb.iorbh)); /* Wait for IORB completion. */ //DAZ 20171206 spin_lock(drv_lock); while (!(ic->iorb.iorbh.Status & IORB_DONE)) { KernBlock(CastFar16ToULONG(MemFar16Adr(&ic->iorb.iorbh)), 30000, 0, NULL, NULL); } //DAZ 20171206 spin_unlock(drv_lock); ret = RPDONE; /* map IORB error codes to device driver error codes */ if (ic->iorb.iorbh.Status & IORB_ERROR) { ret |= RPERR; switch (ic->iorb.iorbh.ErrorCode) { case IOERR_UNIT_NOT_READY: ret |= RPERR_NOTREADY; break; case IOERR_MEDIA_CHANGED: ret |= RPERR_DISK; break; case IOERR_MEDIA: case IOERR_MEDIA_NOT_FORMATTED: ret |= RPERR_CRC; break; case IOERR_CMD_SYNTAX: case IOERR_CMD_NOT_SUPPORTED: ret |= RPERR_BADCOMMAND; break; case IOERR_MEDIA_WRITE_PROTECT: ret |= RPERR_PROTECT; break; case IOERR_CMD_ABORTED: ret |= RPERR_INTERRUPTED; break; case IOERR_RBA_ADDRESSING_ERROR: ret |= RPERR_SEEK; break; case IOERR_RBA_LIMIT: ret |= RPERR_SECTOR; break; case IOERR_CMD_SGLIST_BAD: ret |= RPERR_PARAMETER; break; case IOERR_DEVICE_NONSPECIFIC: case IOERR_ADAPTER_TIMEOUT: case IOERR_ADAPTER_DEVICEBUSCHECK: case IOERR_CMD_ADD_SOFTWARE_FAILURE: case IOERR_CMD_SW_RESOURCE: default: ret |= RPERR_GENERAL; break; } /* copy sense information, if there is any */ if ((ic->iorb.iorbh.Status & IORB_STATUSBLOCK_AVAIL) && (ic->ssb.Flags | STATUS_SENSEDATA_VALID)) { memcpy(sense_buf, ic->sense, min(ic->ssb.ReqSenseLen, req->sense_len)); } } else if ((req->flags & PT_ATAPI) == 0) { /* Copy ATA cmd back to IOCTL request (ATA commands are effectively * registers which are sometimes used to indicate return conditions, * e.g. when requesting the smart status) */ memcpy(&req->cmd.ata, ic->cmd, sizeof(req->cmd.ata)); } MemFree(ic); if (req->buflen > 0) KernVMUnlock(&ic->lh); return(ret); } /****************************************************************************** * Generic disk IOCTL handler; this IOCTL category has originally been defined * in IBM1S506; the code has been more or less copied from DANIS506. * * NOTE: Only a subset of the IOCTL calls are implemented in OS2AHCI at this * point, basically those calls required to get HDMON working. */ USHORT ioctl_gen_dsk(REQPACKET *ioctl) { DSKSP_CommandParameters *cp = (DSKSP_CommandParameters*)Far16ToFlat(ioctl->ioctl.pvParm); UnitInformationData *ui; OS2AHCI_PASSTHROUGH pt; REQPACKET tmp_ioctl; USHORT size = 0; USHORT ret; USHORT a; USHORT p; USHORT d; UCHAR unit; unit = cp->byPhysicalUnit; /* verify addressability of data buffer (depends on function code) */ switch (ioctl->ioctl.bFunction) { case DSKSP_GEN_GET_COUNTERS: size = sizeof(DeviceCountersData); break; case DSKSP_GET_UNIT_INFORMATION: size = sizeof(UnitInformationData); break; case DSKSP_GET_INQUIRY_DATA: size = ATA_ID_WORDS * sizeof(u16); break; } if (map_unit(unit, &a, &p, &d)) { return(RPDONE | RPERR | RPERR_UNIT); } /* execute generic disk request */ switch (ioctl->ioctl.bFunction) { case DSKSP_GEN_GET_COUNTERS: /* Not supported, yet; we would need dynamically allocated device * structures to cope with the memory requirements of the corresponding * statistics buffer. For the time being, we'll return an empty buffer. */ memset(Far16ToFlat(ioctl->ioctl.pvData), 0x00, sizeof(DeviceCountersData)); ret = RPDONE; break; case DSKSP_GET_UNIT_INFORMATION: /* get unit information; things like port addresses won't fit so we don't * even bother returning those. */ ui = (UnitInformationData*)Far16ToFlat(ioctl->ioctl.pvData); memset(ui, 0x00, sizeof(*ui)); ui->wRevisionNumber = 1; ui->wIRQ = ad_infos[a].irq; ui->wFlags = UIF_VALID; ui->wFlags |= UIF_RUNNING_BMDMA; ui->wFlags |= (unit & 0x0001) ? UIF_SLAVE : 0; ui->wFlags |= (ad_infos[a].ports[p].devs[d].atapi) ? UIF_ATAPI : 0; ui->wFlags |= UIF_SATA; ret = RPDONE; break; case DSKSP_GET_INQUIRY_DATA: /* return ATA ID buffer */ memset(&tmp_ioctl, 0x00, sizeof(tmp_ioctl)); tmp_ioctl.ioctl.bCategory = OS2AHCI_IOCTL_CATEGORY; tmp_ioctl.ioctl.bFunction = OS2AHCI_IOCTL_PASSTHROUGH; tmp_ioctl.ioctl.pvParm = FlatToFar16(&pt); memset(&pt, 0x00, sizeof(pt)); pt.adapter = a; pt.port = p; pt.device = d; pt.cmdlen = sizeof(pt.cmd.ata); pt.cmd.ata.cmd = (ad_infos[a].ports[p].devs[d].atapi) ? ATA_CMD_ID_ATAPI : ATA_CMD_ID_ATA; pt.buflen = size; pt.buf = Far16ToFlat(ioctl->ioctl.pvData); ret = gen_ioctl(&tmp_ioctl); break; default: ret = RPDONE | RPERR_BADCOMMAND; break; } return(ret); } /****************************************************************************** * SMART IOCTL handler; this IOCTL category has originally been defined in * IBM1S506; the code has been more or less copied from DANIS506. */ USHORT ioctl_smart(REQPACKET *ioctl) { DSKSP_CommandParameters *cp = (DSKSP_CommandParameters *)Far16ToFlat(ioctl->ioctl.pvParm); USHORT ret; UCHAR unit; UCHAR parm = 0; void *pData = NULL; unit = cp->byPhysicalUnit; if (ioctl->ioctl.pvData) { pData = (void*)Far16ToFlat(ioctl->ioctl.pvData); parm = *(UCHAR*)pData; } /* execute SMART request */ switch (ioctl->ioctl.bFunction) { case DSKSP_SMART_ONOFF: ret = do_smart(unit, (BYTE) ((parm) ? ATA_SMART_ENABLE : ATA_SMART_DISABLE), 0, 0, NULL); break; case DSKSP_SMART_AUTOSAVE_ONOFF: ret = do_smart(unit, ATA_SMART_AUTOSAVE, (BYTE) ((parm) ? (BYTE) 0xf1 : 0), 0, NULL); break; case DSKSP_SMART_AUTO_OFFLINE: ret = do_smart(unit, ATA_SMART_AUTO_OFFLINE, parm, 0, NULL); break; case DSKSP_SMART_EXEC_OFFLINE: ret = do_smart(unit, ATA_SMART_IMMEDIATE_OFFLINE, 0, parm, NULL); break; case DSKSP_SMART_SAVE: ret = do_smart(unit, ATA_SMART_SAVE, 0, 0, NULL); break; case DSKSP_SMART_GETSTATUS: ret = do_smart(unit, ATA_SMART_STATUS, 0, 0, pData); break; case DSKSP_SMART_GET_ATTRIBUTES: ret = do_smart(unit, ATA_SMART_READ_VALUES, 0, 0, pData); break; case DSKSP_SMART_GET_THRESHOLDS: ret = do_smart(unit, ATA_SMART_READ_THRESHOLDS, 0, 0, pData); break; case DSKSP_SMART_GET_LOG: ret = do_smart(unit, ATA_SMART_READ_LOG, 1, parm, pData); break; default: ret = RPDONE | RPERR_BADCOMMAND; } return(ret); } /****************************************************************************** * Perform SMART request. The code has been more or less copied from DANIS506. */ static USHORT do_smart(BYTE unit, BYTE sub_func, BYTE cnt, BYTE lba_l, void *buf) { OS2AHCI_PASSTHROUGH pt; REQPACKET ioctl; USHORT ret; USHORT a; USHORT p; USHORT d; if (map_unit(unit, &a, &p, &d)) { return(RPDONE | RPERR_UNIT); } /* Perform SMART request using the existing OS2AHCI_IOTCL_PASSTHROUGH IOCTL * interface which already takes care of allocating an IORB, s/g lists, etc. */ memset(&ioctl, 0x00, sizeof(ioctl)); ioctl.ioctl.bCategory = OS2AHCI_IOCTL_CATEGORY; ioctl.ioctl.bFunction = OS2AHCI_IOCTL_PASSTHROUGH; ioctl.ioctl.pvParm = FlatToFar16(&pt); memset(&pt, 0x00, sizeof(pt)); pt.adapter = a; pt.port = p; pt.device = d; pt.cmdlen = sizeof(pt.cmd.ata); pt.cmd.ata.features = sub_func; pt.cmd.ata.count = cnt; pt.cmd.ata.lba_l = (0xc24fL << 8) | lba_l; pt.cmd.ata.cmd = ATA_CMD_SMART; if (buf != NULL && sub_func != ATA_SMART_STATUS) { pt.buflen = 512; pt.buf = buf; } if (((ret = gen_ioctl(&ioctl)) & RPERR) == 0 && sub_func == ATA_SMART_STATUS) { /* ATA_SMART_STATUS doesn't transfer anything but instead relies on the * returned D2H FIS, mapped to the ATA CMD, to have a certain value * (0xf42c); the IOCTL result is expected to be returned as a ULONG in * the data buffer. */ if (((pt.cmd.ata.lba_l >> 8) & 0xffff) == 0xf42c) { *((ULONG *) buf) = 1; } else { *((ULONG *) buf) = 0; } } return(ret); } /****************************************************************************** * Map DSKSP unit number to corresponding adapter/port/device number. Units * are identified by an 8-bit adapter/device number with the lowest bit * selecting between master (0) and slave (1). This number is mapped to our * ATA/ATAPI units sequentially. */ static int map_unit(BYTE unit, USHORT *a, USHORT *p, USHORT *d) { USHORT _a; USHORT _p; USHORT _d; /* map unit to adapter/port/device */ for (_a = 0; _a < ad_info_cnt; _a++) { AD_INFO *ai = ad_infos + _a; for (_p = 0; _p <= ai->port_max; _p++) { P_INFO *pi = ai->ports + _p; for (_d = 0; _d <= pi->dev_max; _d++) { if (pi->devs[_d].present) { if (unit-- == 0) { /* found the device */ *a = _a; *p = _p; *d = _d; return(0); } } } } } /* unit not found */ return(-1); } /****************************************************************************** * IORB notification routine; used to wake up the sleeping application thread * when the IOCTL IORB is complete. */ IORBH *IoctlWakeup(ULONG ulArg) { KernWakeup(ulArg, 0, NULL, 0); return(NULL); }