drivers/ide/ide-devsets.c

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