projects/linux·blob v5.4 · refs

192 lines · 3.9 KiB

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}