linux/drivers/ide/ide-devsets.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2
   3#include <linux/kernel.h>
   4#include <linux/gfp.h>
   5#include <linux/ide.h>
   6
   7DEFINE_MUTEX(ide_setting_mtx);
   8
   9ide_devset_get(io_32bit, io_32bit);
  10
  11static int set_io_32bit(ide_drive_t *drive, int arg)
  12{
  13        if (drive->dev_flags & IDE_DFLAG_NO_IO_32BIT)
  14                return -EPERM;
  15
  16        if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
  17                return -EINVAL;
  18
  19        drive->io_32bit = arg;
  20
  21        return 0;
  22}
  23
  24ide_devset_get_flag(ksettings, IDE_DFLAG_KEEP_SETTINGS);
  25
  26static int set_ksettings(ide_drive_t *drive, int arg)
  27{
  28        if (arg < 0 || arg > 1)
  29                return -EINVAL;
  30
  31        if (arg)
  32                drive->dev_flags |= IDE_DFLAG_KEEP_SETTINGS;
  33        else
  34                drive->dev_flags &= ~IDE_DFLAG_KEEP_SETTINGS;
  35
  36        return 0;
  37}
  38
  39ide_devset_get_flag(using_dma, IDE_DFLAG_USING_DMA);
  40
  41static int set_using_dma(ide_drive_t *drive, int arg)
  42{
  43#ifdef CONFIG_BLK_DEV_IDEDMA
  44        int err = -EPERM;
  45
  46        if (arg < 0 || arg > 1)
  47                return -EINVAL;
  48
  49        if (ata_id_has_dma(drive->id) == 0)
  50                goto out;
  51
  52        if (drive->hwif->dma_ops == NULL)
  53                goto out;
  54
  55        err = 0;
  56
  57        if (arg) {
  58                if (ide_set_dma(drive))
  59                        err = -EIO;
  60        } else
  61                ide_dma_off(drive);
  62
  63out:
  64        return err;
  65#else
  66        if (arg < 0 || arg > 1)
  67                return -EINVAL;
  68
  69        return -EPERM;
  70#endif
  71}
  72
  73/*
  74 * handle HDIO_SET_PIO_MODE ioctl abusers here, eventually it will go away
  75 */
  76static int set_pio_mode_abuse(ide_hwif_t *hwif, u8 req_pio)
  77{
  78        switch (req_pio) {
  79        case 202:
  80        case 201:
  81        case 200:
  82        case 102:
  83        case 101:
  84        case 100:
  85                return (hwif->host_flags & IDE_HFLAG_ABUSE_DMA_MODES) ? 1 : 0;
  86        case 9:
  87        case 8:
  88                return (hwif->host_flags & IDE_HFLAG_ABUSE_PREFETCH) ? 1 : 0;
  89        case 7:
  90        case 6:
  91                return (hwif->host_flags & IDE_HFLAG_ABUSE_FAST_DEVSEL) ? 1 : 0;
  92        default:
  93                return 0;
  94        }
  95}
  96
  97static int set_pio_mode(ide_drive_t *drive, int arg)
  98{
  99        ide_hwif_t *hwif = drive->hwif;
 100        const struct ide_port_ops *port_ops = hwif->port_ops;
 101
 102        if (arg < 0 || arg > 255)
 103                return -EINVAL;
 104
 105        if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
 106            (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
 107                return -ENOSYS;
 108
 109        if (set_pio_mode_abuse(drive->hwif, arg)) {
 110                drive->pio_mode = arg + XFER_PIO_0;
 111
 112                if (arg == 8 || arg == 9) {
 113                        unsigned long flags;
 114
 115                        /* take lock for IDE_DFLAG_[NO_]UNMASK/[NO_]IO_32BIT */
 116                        spin_lock_irqsave(&hwif->lock, flags);
 117                        port_ops->set_pio_mode(hwif, drive);
 118                        spin_unlock_irqrestore(&hwif->lock, flags);
 119                } else
 120                        port_ops->set_pio_mode(hwif, drive);
 121        } else {
 122                int keep_dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
 123
 124                ide_set_pio(drive, arg);
 125
 126                if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) {
 127                        if (keep_dma)
 128                                ide_dma_on(drive);
 129                }
 130        }
 131
 132        return 0;
 133}
 134
 135ide_devset_get_flag(unmaskirq, IDE_DFLAG_UNMASK);
 136
 137static int set_unmaskirq(ide_drive_t *drive, int arg)
 138{
 139        if (drive->dev_flags & IDE_DFLAG_NO_UNMASK)
 140                return -EPERM;
 141
 142        if (arg < 0 || arg > 1)
 143                return -EINVAL;
 144
 145        if (arg)
 146                drive->dev_flags |= IDE_DFLAG_UNMASK;
 147        else
 148                drive->dev_flags &= ~IDE_DFLAG_UNMASK;
 149
 150        return 0;
 151}
 152
 153ide_ext_devset_rw_sync(io_32bit, io_32bit);
 154ide_ext_devset_rw_sync(keepsettings, ksettings);
 155ide_ext_devset_rw_sync(unmaskirq, unmaskirq);
 156ide_ext_devset_rw_sync(using_dma, using_dma);
 157__IDE_DEVSET(pio_mode, DS_SYNC, NULL, set_pio_mode);
 158
 159int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
 160                       int arg)
 161{
 162        struct request_queue *q = drive->queue;
 163        struct request *rq;
 164        int ret = 0;
 165
 166        if (!(setting->flags & DS_SYNC))
 167                return setting->set(drive, arg);
 168
 169        rq = blk_get_request(q, REQ_OP_DRV_IN, 0);
 170        ide_req(rq)->type = ATA_PRIV_MISC;
 171        scsi_req(rq)->cmd_len = 5;
 172        scsi_req(rq)->cmd[0] = REQ_DEVSET_EXEC;
 173        *(int *)&scsi_req(rq)->cmd[1] = arg;
 174        ide_req(rq)->special = setting->set;
 175
 176        blk_execute_rq(q, NULL, rq, 0);
 177        ret = scsi_req(rq)->result;
 178        blk_put_request(rq);
 179
 180        return ret;
 181}
 182
 183ide_startstop_t ide_do_devset(ide_drive_t *drive, struct request *rq)
 184{
 185        int err, (*setfunc)(ide_drive_t *, int) = ide_req(rq)->special;
 186
 187        err = setfunc(drive, *(int *)&scsi_req(rq)->cmd[1]);
 188        if (err)
 189                scsi_req(rq)->result = err;
 190        ide_complete_rq(drive, 0, blk_rq_bytes(rq));
 191        return ide_stopped;
 192}
 193