]>
Commit | Line | Data |
---|---|---|
16216333 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
74ee1a75 AM |
2 | /* GD ROM driver for the SEGA Dreamcast |
3 | * copyright Adrian McMenamin, 2007 | |
4 | * With thanks to Marcus Comstedt and Nathan Keynes | |
5 | * for work in reversing PIO and DMA | |
74ee1a75 AM |
6 | */ |
7 | ||
e597cd09 JP |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9 | ||
74ee1a75 AM |
10 | #include <linux/init.h> |
11 | #include <linux/module.h> | |
12 | #include <linux/fs.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/list.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/dma-mapping.h> | |
17 | #include <linux/cdrom.h> | |
18 | #include <linux/genhd.h> | |
19 | #include <linux/bio.h> | |
ad5fc6bb | 20 | #include <linux/blk-mq.h> |
74ee1a75 AM |
21 | #include <linux/interrupt.h> |
22 | #include <linux/device.h> | |
2a48fc0a | 23 | #include <linux/mutex.h> |
74ee1a75 | 24 | #include <linux/wait.h> |
74ee1a75 AM |
25 | #include <linux/platform_device.h> |
26 | #include <scsi/scsi.h> | |
27 | #include <asm/io.h> | |
28 | #include <asm/dma.h> | |
29 | #include <asm/delay.h> | |
0764bff4 PM |
30 | #include <mach/dma.h> |
31 | #include <mach/sysasic.h> | |
74ee1a75 AM |
32 | |
33 | #define GDROM_DEV_NAME "gdrom" | |
34 | #define GD_SESSION_OFFSET 150 | |
35 | ||
36 | /* GD Rom commands */ | |
37 | #define GDROM_COM_SOFTRESET 0x08 | |
38 | #define GDROM_COM_EXECDIAG 0x90 | |
39 | #define GDROM_COM_PACKET 0xA0 | |
40 | #define GDROM_COM_IDDEV 0xA1 | |
41 | ||
42 | /* GD Rom registers */ | |
43 | #define GDROM_BASE_REG 0xA05F7000 | |
44 | #define GDROM_ALTSTATUS_REG (GDROM_BASE_REG + 0x18) | |
45 | #define GDROM_DATA_REG (GDROM_BASE_REG + 0x80) | |
46 | #define GDROM_ERROR_REG (GDROM_BASE_REG + 0x84) | |
47 | #define GDROM_INTSEC_REG (GDROM_BASE_REG + 0x88) | |
48 | #define GDROM_SECNUM_REG (GDROM_BASE_REG + 0x8C) | |
49 | #define GDROM_BCL_REG (GDROM_BASE_REG + 0x90) | |
50 | #define GDROM_BCH_REG (GDROM_BASE_REG + 0x94) | |
51 | #define GDROM_DSEL_REG (GDROM_BASE_REG + 0x98) | |
52 | #define GDROM_STATUSCOMMAND_REG (GDROM_BASE_REG + 0x9C) | |
53 | #define GDROM_RESET_REG (GDROM_BASE_REG + 0x4E4) | |
54 | ||
55 | #define GDROM_DMA_STARTADDR_REG (GDROM_BASE_REG + 0x404) | |
56 | #define GDROM_DMA_LENGTH_REG (GDROM_BASE_REG + 0x408) | |
57 | #define GDROM_DMA_DIRECTION_REG (GDROM_BASE_REG + 0x40C) | |
58 | #define GDROM_DMA_ENABLE_REG (GDROM_BASE_REG + 0x414) | |
59 | #define GDROM_DMA_STATUS_REG (GDROM_BASE_REG + 0x418) | |
60 | #define GDROM_DMA_WAIT_REG (GDROM_BASE_REG + 0x4A0) | |
61 | #define GDROM_DMA_ACCESS_CTRL_REG (GDROM_BASE_REG + 0x4B8) | |
62 | ||
63 | #define GDROM_HARD_SECTOR 2048 | |
64 | #define BLOCK_LAYER_SECTOR 512 | |
65 | #define GD_TO_BLK 4 | |
66 | ||
67 | #define GDROM_DEFAULT_TIMEOUT (HZ * 7) | |
68 | ||
2a48fc0a | 69 | static DEFINE_MUTEX(gdrom_mutex); |
74ee1a75 AM |
70 | static const struct { |
71 | int sense_key; | |
72 | const char * const text; | |
73 | } sense_texts[] = { | |
74 | {NO_SENSE, "OK"}, | |
75 | {RECOVERED_ERROR, "Recovered from error"}, | |
76 | {NOT_READY, "Device not ready"}, | |
77 | {MEDIUM_ERROR, "Disk not ready"}, | |
78 | {HARDWARE_ERROR, "Hardware error"}, | |
79 | {ILLEGAL_REQUEST, "Command has failed"}, | |
80 | {UNIT_ATTENTION, "Device needs attention - disk may have been changed"}, | |
81 | {DATA_PROTECT, "Data protection error"}, | |
82 | {ABORTED_COMMAND, "Command aborted"}, | |
83 | }; | |
84 | ||
85 | static struct platform_device *pd; | |
86 | static int gdrom_major; | |
87 | static DECLARE_WAIT_QUEUE_HEAD(command_queue); | |
88 | static DECLARE_WAIT_QUEUE_HEAD(request_queue); | |
89 | ||
74ee1a75 AM |
90 | struct gdromtoc { |
91 | unsigned int entry[99]; | |
92 | unsigned int first, last; | |
93 | unsigned int leadout; | |
94 | }; | |
95 | ||
96 | static struct gdrom_unit { | |
97 | struct gendisk *disk; | |
98 | struct cdrom_device_info *cd_info; | |
99 | int status; | |
100 | int pending; | |
101 | int transfer; | |
102 | char disk_type; | |
103 | struct gdromtoc *toc; | |
104 | struct request_queue *gdrom_rq; | |
ad5fc6bb | 105 | struct blk_mq_tag_set tag_set; |
74ee1a75 AM |
106 | } gd; |
107 | ||
108 | struct gdrom_id { | |
109 | char mid; | |
110 | char modid; | |
111 | char verid; | |
112 | char padA[13]; | |
113 | char mname[16]; | |
114 | char modname[16]; | |
115 | char firmver[16]; | |
116 | char padB[16]; | |
117 | }; | |
118 | ||
119 | static int gdrom_getsense(short *bufstring); | |
120 | static int gdrom_packetcommand(struct cdrom_device_info *cd_info, | |
121 | struct packet_command *command); | |
122 | static int gdrom_hardreset(struct cdrom_device_info *cd_info); | |
123 | ||
124 | static bool gdrom_is_busy(void) | |
125 | { | |
9eb79bb3 | 126 | return (__raw_readb(GDROM_ALTSTATUS_REG) & 0x80) != 0; |
74ee1a75 AM |
127 | } |
128 | ||
129 | static bool gdrom_data_request(void) | |
130 | { | |
9eb79bb3 | 131 | return (__raw_readb(GDROM_ALTSTATUS_REG) & 0x88) == 8; |
74ee1a75 AM |
132 | } |
133 | ||
134 | static bool gdrom_wait_clrbusy(void) | |
135 | { | |
136 | unsigned long timeout = jiffies + GDROM_DEFAULT_TIMEOUT; | |
9eb79bb3 | 137 | while ((__raw_readb(GDROM_ALTSTATUS_REG) & 0x80) && |
74ee1a75 AM |
138 | (time_before(jiffies, timeout))) |
139 | cpu_relax(); | |
140 | return time_before(jiffies, timeout + 1); | |
141 | } | |
142 | ||
143 | static bool gdrom_wait_busy_sleeps(void) | |
144 | { | |
145 | unsigned long timeout; | |
146 | /* Wait to get busy first */ | |
147 | timeout = jiffies + GDROM_DEFAULT_TIMEOUT; | |
148 | while (!gdrom_is_busy() && time_before(jiffies, timeout)) | |
149 | cpu_relax(); | |
150 | /* Now wait for busy to clear */ | |
151 | return gdrom_wait_clrbusy(); | |
152 | } | |
153 | ||
154 | static void gdrom_identifydevice(void *buf) | |
155 | { | |
156 | int c; | |
157 | short *data = buf; | |
158 | /* If the device won't clear it has probably | |
159 | * been hit by a serious failure - but we'll | |
160 | * try to return a sense key even so */ | |
161 | if (!gdrom_wait_clrbusy()) { | |
162 | gdrom_getsense(NULL); | |
163 | return; | |
164 | } | |
9eb79bb3 | 165 | __raw_writeb(GDROM_COM_IDDEV, GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
166 | if (!gdrom_wait_busy_sleeps()) { |
167 | gdrom_getsense(NULL); | |
168 | return; | |
169 | } | |
170 | /* now read in the data */ | |
171 | for (c = 0; c < 40; c++) | |
9eb79bb3 | 172 | data[c] = __raw_readw(GDROM_DATA_REG); |
74ee1a75 AM |
173 | } |
174 | ||
175 | static void gdrom_spicommand(void *spi_string, int buflen) | |
176 | { | |
177 | short *cmd = spi_string; | |
178 | unsigned long timeout; | |
179 | ||
180 | /* ensure IRQ_WAIT is set */ | |
9eb79bb3 | 181 | __raw_writeb(0x08, GDROM_ALTSTATUS_REG); |
74ee1a75 | 182 | /* specify how many bytes we expect back */ |
9eb79bb3 PM |
183 | __raw_writeb(buflen & 0xFF, GDROM_BCL_REG); |
184 | __raw_writeb((buflen >> 8) & 0xFF, GDROM_BCH_REG); | |
74ee1a75 | 185 | /* other parameters */ |
9eb79bb3 PM |
186 | __raw_writeb(0, GDROM_INTSEC_REG); |
187 | __raw_writeb(0, GDROM_SECNUM_REG); | |
188 | __raw_writeb(0, GDROM_ERROR_REG); | |
74ee1a75 AM |
189 | /* Wait until we can go */ |
190 | if (!gdrom_wait_clrbusy()) { | |
191 | gdrom_getsense(NULL); | |
192 | return; | |
193 | } | |
194 | timeout = jiffies + GDROM_DEFAULT_TIMEOUT; | |
9eb79bb3 | 195 | __raw_writeb(GDROM_COM_PACKET, GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
196 | while (!gdrom_data_request() && time_before(jiffies, timeout)) |
197 | cpu_relax(); | |
198 | if (!time_before(jiffies, timeout + 1)) { | |
199 | gdrom_getsense(NULL); | |
200 | return; | |
201 | } | |
54d5102f | 202 | outsw(GDROM_DATA_REG, cmd, 6); |
74ee1a75 AM |
203 | } |
204 | ||
205 | ||
206 | /* gdrom_command_executediagnostic: | |
207 | * Used to probe for presence of working GDROM | |
208 | * Restarts GDROM device and then applies standard ATA 3 | |
209 | * Execute Diagnostic Command: a return of '1' indicates device 0 | |
210 | * present and device 1 absent | |
211 | */ | |
212 | static char gdrom_execute_diagnostic(void) | |
213 | { | |
214 | gdrom_hardreset(gd.cd_info); | |
215 | if (!gdrom_wait_clrbusy()) | |
216 | return 0; | |
9eb79bb3 | 217 | __raw_writeb(GDROM_COM_EXECDIAG, GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
218 | if (!gdrom_wait_busy_sleeps()) |
219 | return 0; | |
9eb79bb3 | 220 | return __raw_readb(GDROM_ERROR_REG); |
74ee1a75 AM |
221 | } |
222 | ||
223 | /* | |
224 | * Prepare disk command | |
225 | * byte 0 = 0x70 | |
226 | * byte 1 = 0x1f | |
227 | */ | |
228 | static int gdrom_preparedisk_cmd(void) | |
229 | { | |
230 | struct packet_command *spin_command; | |
231 | spin_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL); | |
232 | if (!spin_command) | |
233 | return -ENOMEM; | |
234 | spin_command->cmd[0] = 0x70; | |
235 | spin_command->cmd[2] = 0x1f; | |
236 | spin_command->buflen = 0; | |
237 | gd.pending = 1; | |
238 | gdrom_packetcommand(gd.cd_info, spin_command); | |
239 | /* 60 second timeout */ | |
240 | wait_event_interruptible_timeout(command_queue, gd.pending == 0, | |
241 | GDROM_DEFAULT_TIMEOUT); | |
242 | gd.pending = 0; | |
243 | kfree(spin_command); | |
244 | if (gd.status & 0x01) { | |
245 | /* log an error */ | |
246 | gdrom_getsense(NULL); | |
247 | return -EIO; | |
248 | } | |
249 | return 0; | |
250 | } | |
251 | ||
252 | /* | |
253 | * Read TOC command | |
254 | * byte 0 = 0x14 | |
255 | * byte 1 = session | |
256 | * byte 3 = sizeof TOC >> 8 ie upper byte | |
257 | * byte 4 = sizeof TOC & 0xff ie lower byte | |
258 | */ | |
259 | static int gdrom_readtoc_cmd(struct gdromtoc *toc, int session) | |
260 | { | |
261 | int tocsize; | |
262 | struct packet_command *toc_command; | |
263 | int err = 0; | |
264 | ||
265 | toc_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL); | |
266 | if (!toc_command) | |
267 | return -ENOMEM; | |
268 | tocsize = sizeof(struct gdromtoc); | |
269 | toc_command->cmd[0] = 0x14; | |
270 | toc_command->cmd[1] = session; | |
271 | toc_command->cmd[3] = tocsize >> 8; | |
272 | toc_command->cmd[4] = tocsize & 0xff; | |
273 | toc_command->buflen = tocsize; | |
274 | if (gd.pending) { | |
275 | err = -EBUSY; | |
276 | goto cleanup_readtoc_final; | |
277 | } | |
278 | gd.pending = 1; | |
279 | gdrom_packetcommand(gd.cd_info, toc_command); | |
280 | wait_event_interruptible_timeout(command_queue, gd.pending == 0, | |
281 | GDROM_DEFAULT_TIMEOUT); | |
282 | if (gd.pending) { | |
283 | err = -EINVAL; | |
284 | goto cleanup_readtoc; | |
285 | } | |
54d5102f | 286 | insw(GDROM_DATA_REG, toc, tocsize/2); |
74ee1a75 AM |
287 | if (gd.status & 0x01) |
288 | err = -EINVAL; | |
289 | ||
290 | cleanup_readtoc: | |
291 | gd.pending = 0; | |
292 | cleanup_readtoc_final: | |
293 | kfree(toc_command); | |
294 | return err; | |
295 | } | |
296 | ||
297 | /* TOC helpers */ | |
298 | static int get_entry_lba(int track) | |
299 | { | |
300 | return (cpu_to_be32(track & 0xffffff00) - GD_SESSION_OFFSET); | |
301 | } | |
302 | ||
303 | static int get_entry_q_ctrl(int track) | |
304 | { | |
305 | return (track & 0x000000f0) >> 4; | |
306 | } | |
307 | ||
308 | static int get_entry_track(int track) | |
309 | { | |
310 | return (track & 0x0000ff00) >> 8; | |
311 | } | |
312 | ||
313 | static int gdrom_get_last_session(struct cdrom_device_info *cd_info, | |
314 | struct cdrom_multisession *ms_info) | |
315 | { | |
cdffab7a | 316 | int fentry, lentry, track, data, err; |
317 | ||
74ee1a75 AM |
318 | if (!gd.toc) |
319 | return -ENOMEM; | |
cdffab7a | 320 | |
74ee1a75 AM |
321 | /* Check if GD-ROM */ |
322 | err = gdrom_readtoc_cmd(gd.toc, 1); | |
323 | /* Not a GD-ROM so check if standard CD-ROM */ | |
324 | if (err) { | |
74ee1a75 AM |
325 | err = gdrom_readtoc_cmd(gd.toc, 0); |
326 | if (err) { | |
e597cd09 | 327 | pr_info("Could not get CD table of contents\n"); |
74ee1a75 AM |
328 | return -ENXIO; |
329 | } | |
330 | } | |
331 | ||
332 | fentry = get_entry_track(gd.toc->first); | |
333 | lentry = get_entry_track(gd.toc->last); | |
334 | /* Find the first data track */ | |
335 | track = get_entry_track(gd.toc->last); | |
336 | do { | |
337 | data = gd.toc->entry[track - 1]; | |
338 | if (get_entry_q_ctrl(data)) | |
339 | break; /* ie a real data track */ | |
340 | track--; | |
341 | } while (track >= fentry); | |
342 | ||
343 | if ((track > 100) || (track < get_entry_track(gd.toc->first))) { | |
e597cd09 | 344 | pr_info("No data on the last session of the CD\n"); |
74ee1a75 AM |
345 | gdrom_getsense(NULL); |
346 | return -ENXIO; | |
347 | } | |
348 | ||
349 | ms_info->addr_format = CDROM_LBA; | |
350 | ms_info->addr.lba = get_entry_lba(data); | |
351 | ms_info->xa_flag = 1; | |
352 | return 0; | |
353 | } | |
354 | ||
355 | static int gdrom_open(struct cdrom_device_info *cd_info, int purpose) | |
356 | { | |
357 | /* spin up the disk */ | |
358 | return gdrom_preparedisk_cmd(); | |
359 | } | |
360 | ||
361 | /* this function is required even if empty */ | |
362 | static void gdrom_release(struct cdrom_device_info *cd_info) | |
363 | { | |
364 | } | |
365 | ||
366 | static int gdrom_drivestatus(struct cdrom_device_info *cd_info, int ignore) | |
367 | { | |
368 | /* read the sense key */ | |
9eb79bb3 | 369 | char sense = __raw_readb(GDROM_ERROR_REG); |
74ee1a75 AM |
370 | sense &= 0xF0; |
371 | if (sense == 0) | |
372 | return CDS_DISC_OK; | |
373 | if (sense == 0x20) | |
374 | return CDS_DRIVE_NOT_READY; | |
375 | /* default */ | |
376 | return CDS_NO_INFO; | |
377 | } | |
378 | ||
1c27030b TH |
379 | static unsigned int gdrom_check_events(struct cdrom_device_info *cd_info, |
380 | unsigned int clearing, int ignore) | |
74ee1a75 AM |
381 | { |
382 | /* check the sense key */ | |
1c27030b TH |
383 | return (__raw_readb(GDROM_ERROR_REG) & 0xF0) == 0x60 ? |
384 | DISK_EVENT_MEDIA_CHANGE : 0; | |
74ee1a75 AM |
385 | } |
386 | ||
387 | /* reset the G1 bus */ | |
388 | static int gdrom_hardreset(struct cdrom_device_info *cd_info) | |
389 | { | |
390 | int count; | |
9eb79bb3 | 391 | __raw_writel(0x1fffff, GDROM_RESET_REG); |
74ee1a75 | 392 | for (count = 0xa0000000; count < 0xa0200000; count += 4) |
9eb79bb3 | 393 | __raw_readl(count); |
74ee1a75 AM |
394 | return 0; |
395 | } | |
396 | ||
397 | /* keep the function looking like the universal | |
398 | * CD Rom specification - returning int */ | |
399 | static int gdrom_packetcommand(struct cdrom_device_info *cd_info, | |
400 | struct packet_command *command) | |
401 | { | |
402 | gdrom_spicommand(&command->cmd, command->buflen); | |
403 | return 0; | |
404 | } | |
405 | ||
406 | /* Get Sense SPI command | |
407 | * From Marcus Comstedt | |
408 | * cmd = 0x13 | |
409 | * cmd + 4 = length of returned buffer | |
410 | * Returns 5 16 bit words | |
411 | */ | |
412 | static int gdrom_getsense(short *bufstring) | |
413 | { | |
414 | struct packet_command *sense_command; | |
415 | short sense[5]; | |
416 | int sense_key; | |
417 | int err = -EIO; | |
418 | ||
419 | sense_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL); | |
420 | if (!sense_command) | |
421 | return -ENOMEM; | |
422 | sense_command->cmd[0] = 0x13; | |
423 | sense_command->cmd[4] = 10; | |
424 | sense_command->buflen = 10; | |
425 | /* even if something is pending try to get | |
426 | * the sense key if possible */ | |
427 | if (gd.pending && !gdrom_wait_clrbusy()) { | |
428 | err = -EBUSY; | |
429 | goto cleanup_sense_final; | |
430 | } | |
431 | gd.pending = 1; | |
432 | gdrom_packetcommand(gd.cd_info, sense_command); | |
433 | wait_event_interruptible_timeout(command_queue, gd.pending == 0, | |
434 | GDROM_DEFAULT_TIMEOUT); | |
435 | if (gd.pending) | |
436 | goto cleanup_sense; | |
54d5102f | 437 | insw(GDROM_DATA_REG, &sense, sense_command->buflen/2); |
74ee1a75 | 438 | if (sense[1] & 40) { |
e597cd09 | 439 | pr_info("Drive not ready - command aborted\n"); |
74ee1a75 AM |
440 | goto cleanup_sense; |
441 | } | |
442 | sense_key = sense[1] & 0x0F; | |
443 | if (sense_key < ARRAY_SIZE(sense_texts)) | |
e597cd09 | 444 | pr_info("%s\n", sense_texts[sense_key].text); |
74ee1a75 | 445 | else |
e597cd09 | 446 | pr_err("Unknown sense key: %d\n", sense_key); |
74ee1a75 AM |
447 | if (bufstring) /* return addional sense data */ |
448 | memcpy(bufstring, &sense[4], 2); | |
449 | if (sense_key < 2) | |
450 | err = 0; | |
451 | ||
452 | cleanup_sense: | |
453 | gd.pending = 0; | |
454 | cleanup_sense_final: | |
455 | kfree(sense_command); | |
456 | return err; | |
457 | } | |
458 | ||
d15cad5d BP |
459 | static int gdrom_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd, |
460 | void *arg) | |
461 | { | |
462 | return -EINVAL; | |
463 | } | |
464 | ||
853fe1bf | 465 | static const struct cdrom_device_ops gdrom_ops = { |
74ee1a75 AM |
466 | .open = gdrom_open, |
467 | .release = gdrom_release, | |
468 | .drive_status = gdrom_drivestatus, | |
1c27030b | 469 | .check_events = gdrom_check_events, |
74ee1a75 AM |
470 | .get_last_session = gdrom_get_last_session, |
471 | .reset = gdrom_hardreset, | |
d15cad5d | 472 | .audio_ioctl = gdrom_audio_ioctl, |
853fe1bf | 473 | .generic_packet = cdrom_dummy_generic_packet, |
74ee1a75 AM |
474 | .capability = CDC_MULTI_SESSION | CDC_MEDIA_CHANGED | |
475 | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R, | |
74ee1a75 AM |
476 | }; |
477 | ||
8389feb4 | 478 | static int gdrom_bdops_open(struct block_device *bdev, fmode_t mode) |
74ee1a75 | 479 | { |
6e9624b8 | 480 | int ret; |
2bbea6e1 | 481 | |
faf04138 | 482 | bdev_check_media_change(bdev); |
2bbea6e1 | 483 | |
2a48fc0a | 484 | mutex_lock(&gdrom_mutex); |
6e9624b8 | 485 | ret = cdrom_open(gd.cd_info, bdev, mode); |
2a48fc0a | 486 | mutex_unlock(&gdrom_mutex); |
6e9624b8 | 487 | return ret; |
74ee1a75 AM |
488 | } |
489 | ||
db2a144b | 490 | static void gdrom_bdops_release(struct gendisk *disk, fmode_t mode) |
74ee1a75 | 491 | { |
2a48fc0a | 492 | mutex_lock(&gdrom_mutex); |
545727f3 | 493 | cdrom_release(gd.cd_info, mode); |
2a48fc0a | 494 | mutex_unlock(&gdrom_mutex); |
74ee1a75 AM |
495 | } |
496 | ||
1c27030b TH |
497 | static unsigned int gdrom_bdops_check_events(struct gendisk *disk, |
498 | unsigned int clearing) | |
74ee1a75 | 499 | { |
1c27030b | 500 | return cdrom_check_events(gd.cd_info, clearing); |
74ee1a75 AM |
501 | } |
502 | ||
8389feb4 | 503 | static int gdrom_bdops_ioctl(struct block_device *bdev, fmode_t mode, |
74ee1a75 AM |
504 | unsigned cmd, unsigned long arg) |
505 | { | |
8a6cfeb6 AB |
506 | int ret; |
507 | ||
2a48fc0a | 508 | mutex_lock(&gdrom_mutex); |
8a6cfeb6 | 509 | ret = cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg); |
2a48fc0a | 510 | mutex_unlock(&gdrom_mutex); |
8a6cfeb6 AB |
511 | |
512 | return ret; | |
74ee1a75 AM |
513 | } |
514 | ||
83d5cde4 | 515 | static const struct block_device_operations gdrom_bdops = { |
74ee1a75 | 516 | .owner = THIS_MODULE, |
8389feb4 AV |
517 | .open = gdrom_bdops_open, |
518 | .release = gdrom_bdops_release, | |
1c27030b | 519 | .check_events = gdrom_bdops_check_events, |
8a6cfeb6 | 520 | .ioctl = gdrom_bdops_ioctl, |
64cbfa96 | 521 | #ifdef CONFIG_COMPAT |
03264ddd | 522 | .compat_ioctl = blkdev_compat_ptr_ioctl, |
64cbfa96 | 523 | #endif |
74ee1a75 AM |
524 | }; |
525 | ||
526 | static irqreturn_t gdrom_command_interrupt(int irq, void *dev_id) | |
527 | { | |
9eb79bb3 | 528 | gd.status = __raw_readb(GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
529 | if (gd.pending != 1) |
530 | return IRQ_HANDLED; | |
531 | gd.pending = 0; | |
532 | wake_up_interruptible(&command_queue); | |
533 | return IRQ_HANDLED; | |
534 | } | |
535 | ||
536 | static irqreturn_t gdrom_dma_interrupt(int irq, void *dev_id) | |
537 | { | |
9eb79bb3 | 538 | gd.status = __raw_readb(GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
539 | if (gd.transfer != 1) |
540 | return IRQ_HANDLED; | |
541 | gd.transfer = 0; | |
542 | wake_up_interruptible(&request_queue); | |
543 | return IRQ_HANDLED; | |
544 | } | |
545 | ||
0fe763c5 | 546 | static int gdrom_set_interrupt_handlers(void) |
74ee1a75 AM |
547 | { |
548 | int err; | |
549 | ||
550 | err = request_irq(HW_EVENT_GDROM_CMD, gdrom_command_interrupt, | |
644ff181 | 551 | 0, "gdrom_command", &gd); |
74ee1a75 AM |
552 | if (err) |
553 | return err; | |
554 | err = request_irq(HW_EVENT_GDROM_DMA, gdrom_dma_interrupt, | |
644ff181 | 555 | 0, "gdrom_dma", &gd); |
74ee1a75 AM |
556 | if (err) |
557 | free_irq(HW_EVENT_GDROM_CMD, &gd); | |
558 | return err; | |
559 | } | |
560 | ||
561 | /* Implement DMA read using SPI command | |
562 | * 0 -> 0x30 | |
563 | * 1 -> mode | |
564 | * 2 -> block >> 16 | |
565 | * 3 -> block >> 8 | |
566 | * 4 -> block | |
567 | * 8 -> sectors >> 16 | |
568 | * 9 -> sectors >> 8 | |
569 | * 10 -> sectors | |
570 | */ | |
ad5fc6bb | 571 | static blk_status_t gdrom_readdisk_dma(struct request *req) |
74ee1a75 | 572 | { |
2a842aca CH |
573 | int block, block_cnt; |
574 | blk_status_t err; | |
74ee1a75 | 575 | struct packet_command *read_command; |
74ee1a75 AM |
576 | unsigned long timeout; |
577 | ||
74ee1a75 AM |
578 | read_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL); |
579 | if (!read_command) | |
ad5fc6bb JA |
580 | return BLK_STS_RESOURCE; |
581 | ||
74ee1a75 AM |
582 | read_command->cmd[0] = 0x30; |
583 | read_command->cmd[1] = 0x20; | |
ad5fc6bb JA |
584 | block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET; |
585 | block_cnt = blk_rq_sectors(req)/GD_TO_BLK; | |
586 | __raw_writel(virt_to_phys(bio_data(req->bio)), GDROM_DMA_STARTADDR_REG); | |
587 | __raw_writel(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG); | |
588 | __raw_writel(1, GDROM_DMA_DIRECTION_REG); | |
589 | __raw_writel(1, GDROM_DMA_ENABLE_REG); | |
590 | read_command->cmd[2] = (block >> 16) & 0xFF; | |
591 | read_command->cmd[3] = (block >> 8) & 0xFF; | |
592 | read_command->cmd[4] = block & 0xFF; | |
593 | read_command->cmd[8] = (block_cnt >> 16) & 0xFF; | |
594 | read_command->cmd[9] = (block_cnt >> 8) & 0xFF; | |
595 | read_command->cmd[10] = block_cnt & 0xFF; | |
596 | /* set for DMA */ | |
597 | __raw_writeb(1, GDROM_ERROR_REG); | |
598 | /* other registers */ | |
599 | __raw_writeb(0, GDROM_SECNUM_REG); | |
600 | __raw_writeb(0, GDROM_BCL_REG); | |
601 | __raw_writeb(0, GDROM_BCH_REG); | |
602 | __raw_writeb(0, GDROM_DSEL_REG); | |
603 | __raw_writeb(0, GDROM_INTSEC_REG); | |
604 | /* Wait for registers to reset after any previous activity */ | |
605 | timeout = jiffies + HZ / 2; | |
606 | while (gdrom_is_busy() && time_before(jiffies, timeout)) | |
607 | cpu_relax(); | |
608 | __raw_writeb(GDROM_COM_PACKET, GDROM_STATUSCOMMAND_REG); | |
609 | timeout = jiffies + HZ / 2; | |
610 | /* Wait for packet command to finish */ | |
611 | while (gdrom_is_busy() && time_before(jiffies, timeout)) | |
612 | cpu_relax(); | |
613 | gd.pending = 1; | |
614 | gd.transfer = 1; | |
615 | outsw(GDROM_DATA_REG, &read_command->cmd, 6); | |
616 | timeout = jiffies + HZ / 2; | |
617 | /* Wait for any pending DMA to finish */ | |
618 | while (__raw_readb(GDROM_DMA_STATUS_REG) && | |
619 | time_before(jiffies, timeout)) | |
620 | cpu_relax(); | |
621 | /* start transfer */ | |
622 | __raw_writeb(1, GDROM_DMA_STATUS_REG); | |
623 | wait_event_interruptible_timeout(request_queue, | |
624 | gd.transfer == 0, GDROM_DEFAULT_TIMEOUT); | |
625 | err = gd.transfer ? BLK_STS_IOERR : BLK_STS_OK; | |
626 | gd.transfer = 0; | |
627 | gd.pending = 0; | |
628 | ||
629 | blk_mq_end_request(req, err); | |
74ee1a75 | 630 | kfree(read_command); |
ad5fc6bb | 631 | return BLK_STS_OK; |
74ee1a75 AM |
632 | } |
633 | ||
ad5fc6bb JA |
634 | static blk_status_t gdrom_queue_rq(struct blk_mq_hw_ctx *hctx, |
635 | const struct blk_mq_queue_data *bd) | |
636 | { | |
637 | blk_mq_start_request(bd->rq); | |
638 | ||
639 | switch (req_op(bd->rq)) { | |
640 | case REQ_OP_READ: | |
641 | return gdrom_readdisk_dma(bd->rq); | |
642 | case REQ_OP_WRITE: | |
643 | pr_notice("Read only device - write request ignored\n"); | |
644 | return BLK_STS_IOERR; | |
645 | default: | |
646 | printk(KERN_DEBUG "gdrom: Non-fs request ignored\n"); | |
647 | return BLK_STS_IOERR; | |
74ee1a75 AM |
648 | } |
649 | } | |
650 | ||
651 | /* Print string identifying GD ROM device */ | |
0fe763c5 | 652 | static int gdrom_outputversion(void) |
74ee1a75 AM |
653 | { |
654 | struct gdrom_id *id; | |
655 | char *model_name, *manuf_name, *firmw_ver; | |
656 | int err = -ENOMEM; | |
657 | ||
658 | /* query device ID */ | |
659 | id = kzalloc(sizeof(struct gdrom_id), GFP_KERNEL); | |
660 | if (!id) | |
661 | return err; | |
662 | gdrom_identifydevice(id); | |
663 | model_name = kstrndup(id->modname, 16, GFP_KERNEL); | |
664 | if (!model_name) | |
665 | goto free_id; | |
666 | manuf_name = kstrndup(id->mname, 16, GFP_KERNEL); | |
667 | if (!manuf_name) | |
668 | goto free_model_name; | |
669 | firmw_ver = kstrndup(id->firmver, 16, GFP_KERNEL); | |
670 | if (!firmw_ver) | |
671 | goto free_manuf_name; | |
e597cd09 | 672 | pr_info("%s from %s with firmware %s\n", |
74ee1a75 AM |
673 | model_name, manuf_name, firmw_ver); |
674 | err = 0; | |
675 | kfree(firmw_ver); | |
676 | free_manuf_name: | |
677 | kfree(manuf_name); | |
678 | free_model_name: | |
679 | kfree(model_name); | |
680 | free_id: | |
681 | kfree(id); | |
682 | return err; | |
683 | } | |
684 | ||
685 | /* set the default mode for DMA transfer */ | |
0fe763c5 | 686 | static int gdrom_init_dma_mode(void) |
74ee1a75 | 687 | { |
9eb79bb3 PM |
688 | __raw_writeb(0x13, GDROM_ERROR_REG); |
689 | __raw_writeb(0x22, GDROM_INTSEC_REG); | |
74ee1a75 AM |
690 | if (!gdrom_wait_clrbusy()) |
691 | return -EBUSY; | |
9eb79bb3 | 692 | __raw_writeb(0xEF, GDROM_STATUSCOMMAND_REG); |
74ee1a75 AM |
693 | if (!gdrom_wait_busy_sleeps()) |
694 | return -EBUSY; | |
695 | /* Memory protection setting for GDROM DMA | |
696 | * Bits 31 - 16 security: 0x8843 | |
697 | * Bits 15 and 7 reserved (0) | |
698 | * Bits 14 - 8 start of transfer range in 1 MB blocks OR'ed with 0x80 | |
699 | * Bits 6 - 0 end of transfer range in 1 MB blocks OR'ed with 0x80 | |
700 | * (0x40 | 0x80) = start range at 0x0C000000 | |
701 | * (0x7F | 0x80) = end range at 0x0FFFFFFF */ | |
9eb79bb3 PM |
702 | __raw_writel(0x8843407F, GDROM_DMA_ACCESS_CTRL_REG); |
703 | __raw_writel(9, GDROM_DMA_WAIT_REG); /* DMA word setting */ | |
74ee1a75 AM |
704 | return 0; |
705 | } | |
706 | ||
0fe763c5 | 707 | static void probe_gdrom_setupcd(void) |
74ee1a75 AM |
708 | { |
709 | gd.cd_info->ops = &gdrom_ops; | |
710 | gd.cd_info->capacity = 1; | |
711 | strcpy(gd.cd_info->name, GDROM_DEV_NAME); | |
712 | gd.cd_info->mask = CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK| | |
713 | CDC_SELECT_DISC; | |
714 | } | |
715 | ||
0fe763c5 | 716 | static void probe_gdrom_setupdisk(void) |
74ee1a75 AM |
717 | { |
718 | gd.disk->major = gdrom_major; | |
719 | gd.disk->first_minor = 1; | |
720 | gd.disk->minors = 1; | |
721 | strcpy(gd.disk->disk_name, GDROM_DEV_NAME); | |
722 | } | |
723 | ||
0fe763c5 | 724 | static int probe_gdrom_setupqueue(void) |
74ee1a75 | 725 | { |
e1defc4f | 726 | blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR); |
74ee1a75 | 727 | /* using DMA so memory will need to be contiguous */ |
8a78362c | 728 | blk_queue_max_segments(gd.gdrom_rq, 1); |
74ee1a75 AM |
729 | /* set a large max size to get most from DMA */ |
730 | blk_queue_max_segment_size(gd.gdrom_rq, 0x40000); | |
731 | gd.disk->queue = gd.gdrom_rq; | |
732 | return gdrom_init_dma_mode(); | |
733 | } | |
734 | ||
ad5fc6bb JA |
735 | static const struct blk_mq_ops gdrom_mq_ops = { |
736 | .queue_rq = gdrom_queue_rq, | |
737 | }; | |
738 | ||
74ee1a75 AM |
739 | /* |
740 | * register this as a block device and as compliant with the | |
741 | * universal CD Rom driver interface | |
742 | */ | |
0fe763c5 | 743 | static int probe_gdrom(struct platform_device *devptr) |
74ee1a75 AM |
744 | { |
745 | int err; | |
746 | /* Start the device */ | |
747 | if (gdrom_execute_diagnostic() != 1) { | |
f8b48998 | 748 | pr_warn("ATA Probe for GDROM failed\n"); |
74ee1a75 AM |
749 | return -ENODEV; |
750 | } | |
751 | /* Print out firmware ID */ | |
752 | if (gdrom_outputversion()) | |
753 | return -ENOMEM; | |
754 | /* Register GDROM */ | |
755 | gdrom_major = register_blkdev(0, GDROM_DEV_NAME); | |
756 | if (gdrom_major <= 0) | |
757 | return gdrom_major; | |
e597cd09 | 758 | pr_info("Registered with major number %d\n", |
74ee1a75 AM |
759 | gdrom_major); |
760 | /* Specify basic properties of drive */ | |
761 | gd.cd_info = kzalloc(sizeof(struct cdrom_device_info), GFP_KERNEL); | |
762 | if (!gd.cd_info) { | |
763 | err = -ENOMEM; | |
764 | goto probe_fail_no_mem; | |
765 | } | |
766 | probe_gdrom_setupcd(); | |
767 | gd.disk = alloc_disk(1); | |
768 | if (!gd.disk) { | |
769 | err = -ENODEV; | |
770 | goto probe_fail_no_disk; | |
771 | } | |
772 | probe_gdrom_setupdisk(); | |
a711d91c | 773 | if (register_cdrom(gd.disk, gd.cd_info)) { |
74ee1a75 AM |
774 | err = -ENODEV; |
775 | goto probe_fail_cdrom_register; | |
776 | } | |
777 | gd.disk->fops = &gdrom_bdops; | |
773008f6 | 778 | gd.disk->events = DISK_EVENT_MEDIA_CHANGE; |
74ee1a75 AM |
779 | /* latch on to the interrupt */ |
780 | err = gdrom_set_interrupt_handlers(); | |
781 | if (err) | |
782 | goto probe_fail_cmdirq_register; | |
ad5fc6bb JA |
783 | |
784 | gd.gdrom_rq = blk_mq_init_sq_queue(&gd.tag_set, &gdrom_mq_ops, 1, | |
785 | BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING); | |
786 | if (IS_ERR(gd.gdrom_rq)) { | |
0a40a935 | 787 | err = PTR_ERR(gd.gdrom_rq); |
ad5fc6bb | 788 | gd.gdrom_rq = NULL; |
74ee1a75 | 789 | goto probe_fail_requestq; |
605cdf08 | 790 | } |
ad5fc6bb | 791 | |
8fc45044 | 792 | blk_queue_bounce_limit(gd.gdrom_rq, BLK_BOUNCE_HIGH); |
74ee1a75 AM |
793 | |
794 | err = probe_gdrom_setupqueue(); | |
795 | if (err) | |
796 | goto probe_fail_toc; | |
797 | ||
798 | gd.toc = kzalloc(sizeof(struct gdromtoc), GFP_KERNEL); | |
605cdf08 CJ |
799 | if (!gd.toc) { |
800 | err = -ENOMEM; | |
74ee1a75 | 801 | goto probe_fail_toc; |
605cdf08 | 802 | } |
74ee1a75 AM |
803 | add_disk(gd.disk); |
804 | return 0; | |
805 | ||
806 | probe_fail_toc: | |
807 | blk_cleanup_queue(gd.gdrom_rq); | |
ad5fc6bb | 808 | blk_mq_free_tag_set(&gd.tag_set); |
74ee1a75 AM |
809 | probe_fail_requestq: |
810 | free_irq(HW_EVENT_GDROM_DMA, &gd); | |
811 | free_irq(HW_EVENT_GDROM_CMD, &gd); | |
812 | probe_fail_cmdirq_register: | |
813 | probe_fail_cdrom_register: | |
814 | del_gendisk(gd.disk); | |
815 | probe_fail_no_disk: | |
816 | kfree(gd.cd_info); | |
31bd8fbb | 817 | probe_fail_no_mem: |
74ee1a75 AM |
818 | unregister_blkdev(gdrom_major, GDROM_DEV_NAME); |
819 | gdrom_major = 0; | |
f8b48998 | 820 | pr_warn("Probe failed - error is 0x%X\n", err); |
74ee1a75 AM |
821 | return err; |
822 | } | |
823 | ||
0fe763c5 | 824 | static int remove_gdrom(struct platform_device *devptr) |
74ee1a75 | 825 | { |
74ee1a75 | 826 | blk_cleanup_queue(gd.gdrom_rq); |
ad5fc6bb | 827 | blk_mq_free_tag_set(&gd.tag_set); |
74ee1a75 AM |
828 | free_irq(HW_EVENT_GDROM_CMD, &gd); |
829 | free_irq(HW_EVENT_GDROM_DMA, &gd); | |
830 | del_gendisk(gd.disk); | |
831 | if (gdrom_major) | |
832 | unregister_blkdev(gdrom_major, GDROM_DEV_NAME); | |
0a0c4114 AM |
833 | unregister_cdrom(gd.cd_info); |
834 | ||
835 | return 0; | |
74ee1a75 AM |
836 | } |
837 | ||
838 | static struct platform_driver gdrom_driver = { | |
839 | .probe = probe_gdrom, | |
0fe763c5 | 840 | .remove = remove_gdrom, |
74ee1a75 AM |
841 | .driver = { |
842 | .name = GDROM_DEV_NAME, | |
843 | }, | |
844 | }; | |
845 | ||
846 | static int __init init_gdrom(void) | |
847 | { | |
848 | int rc; | |
849 | gd.toc = NULL; | |
850 | rc = platform_driver_register(&gdrom_driver); | |
851 | if (rc) | |
852 | return rc; | |
853 | pd = platform_device_register_simple(GDROM_DEV_NAME, -1, NULL, 0); | |
854 | if (IS_ERR(pd)) { | |
855 | platform_driver_unregister(&gdrom_driver); | |
856 | return PTR_ERR(pd); | |
857 | } | |
858 | return 0; | |
859 | } | |
860 | ||
861 | static void __exit exit_gdrom(void) | |
862 | { | |
863 | platform_device_unregister(pd); | |
864 | platform_driver_unregister(&gdrom_driver); | |
865 | kfree(gd.toc); | |
093c4821 | 866 | kfree(gd.cd_info); |
74ee1a75 AM |
867 | } |
868 | ||
869 | module_init(init_gdrom); | |
870 | module_exit(exit_gdrom); | |
871 | MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>"); | |
872 | MODULE_DESCRIPTION("SEGA Dreamcast GD-ROM Driver"); | |
873 | MODULE_LICENSE("GPL"); |