drivers/cdrom/gdrom.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* GD ROM driver for the SEGA Dreamcast
0003  * copyright Adrian McMenamin, 2007
0004  * With thanks to Marcus Comstedt and Nathan Keynes
0005  * for work in reversing PIO and DMA
0006  */
0007
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009
0010 #include <linux/init.h>
0011 #include <linux/module.h>
0012 #include <linux/fs.h>
0013 #include <linux/kernel.h>
0014 #include <linux/list.h>
0015 #include <linux/slab.h>
0016 #include <linux/dma-mapping.h>
0017 #include <linux/cdrom.h>
0018 #include <linux/bio.h>
0019 #include <linux/blk-mq.h>
0020 #include <linux/interrupt.h>
0021 #include <linux/device.h>
0022 #include <linux/mutex.h>
0023 #include <linux/wait.h>
0024 #include <linux/platform_device.h>
0025 #include <scsi/scsi.h>
0026 #include <asm/io.h>
0027 #include <asm/dma.h>
0028 #include <asm/delay.h>
0029 #include <mach/dma.h>
0030 #include <mach/sysasic.h>
0031
0032 #define GDROM_DEV_NAME "gdrom"
0033 #define GD_SESSION_OFFSET 150
0034
0035 /* GD Rom commands */
0036 #define GDROM_COM_SOFTRESET 0x08
0037 #define GDROM_COM_EXECDIAG 0x90
0038 #define GDROM_COM_PACKET 0xA0
0039 #define GDROM_COM_IDDEV 0xA1
0040
0041 /* GD Rom registers */
0042 #define GDROM_BASE_REG          0xA05F7000
0043 #define GDROM_ALTSTATUS_REG     (GDROM_BASE_REG + 0x18)
0044 #define GDROM_DATA_REG          (GDROM_BASE_REG + 0x80)
0045 #define GDROM_ERROR_REG     (GDROM_BASE_REG + 0x84)
0046 #define GDROM_INTSEC_REG        (GDROM_BASE_REG + 0x88)
0047 #define GDROM_SECNUM_REG        (GDROM_BASE_REG + 0x8C)
0048 #define GDROM_BCL_REG           (GDROM_BASE_REG + 0x90)
0049 #define GDROM_BCH_REG           (GDROM_BASE_REG + 0x94)
0050 #define GDROM_DSEL_REG          (GDROM_BASE_REG + 0x98)
0051 #define GDROM_STATUSCOMMAND_REG (GDROM_BASE_REG + 0x9C)
0052 #define GDROM_RESET_REG     (GDROM_BASE_REG + 0x4E4)
0053
0054 #define GDROM_DMA_STARTADDR_REG (GDROM_BASE_REG + 0x404)
0055 #define GDROM_DMA_LENGTH_REG        (GDROM_BASE_REG + 0x408)
0056 #define GDROM_DMA_DIRECTION_REG (GDROM_BASE_REG + 0x40C)
0057 #define GDROM_DMA_ENABLE_REG        (GDROM_BASE_REG + 0x414)
0058 #define GDROM_DMA_STATUS_REG        (GDROM_BASE_REG + 0x418)
0059 #define GDROM_DMA_WAIT_REG      (GDROM_BASE_REG + 0x4A0)
0060 #define GDROM_DMA_ACCESS_CTRL_REG   (GDROM_BASE_REG + 0x4B8)
0061
0062 #define GDROM_HARD_SECTOR   2048
0063 #define BLOCK_LAYER_SECTOR  512
0064 #define GD_TO_BLK       4
0065
0066 #define GDROM_DEFAULT_TIMEOUT   (HZ * 7)
0067
0068 static DEFINE_MUTEX(gdrom_mutex);
0069 static const struct {
0070     int sense_key;
0071     const char * const text;
0072 } sense_texts[] = {
0073     {NO_SENSE, "OK"},
0074     {RECOVERED_ERROR, "Recovered from error"},
0075     {NOT_READY, "Device not ready"},
0076     {MEDIUM_ERROR, "Disk not ready"},
0077     {HARDWARE_ERROR, "Hardware error"},
0078     {ILLEGAL_REQUEST, "Command has failed"},
0079     {UNIT_ATTENTION, "Device needs attention - disk may have been changed"},
0080     {DATA_PROTECT, "Data protection error"},
0081     {ABORTED_COMMAND, "Command aborted"},
0082 };
0083
0084 static struct platform_device *pd;
0085 static int gdrom_major;
0086 static DECLARE_WAIT_QUEUE_HEAD(command_queue);
0087 static DECLARE_WAIT_QUEUE_HEAD(request_queue);
0088
0089 struct gdromtoc {
0090     unsigned int entry[99];
0091     unsigned int first, last;
0092     unsigned int leadout;
0093 };
0094
0095 static struct gdrom_unit {
0096     struct gendisk *disk;
0097     struct cdrom_device_info *cd_info;
0098     int status;
0099     int pending;
0100     int transfer;
0101     char disk_type;
0102     struct gdromtoc *toc;
0103     struct request_queue *gdrom_rq;
0104     struct blk_mq_tag_set tag_set;
0105 } gd;
0106
0107 struct gdrom_id {
0108     char mid;
0109     char modid;
0110     char verid;
0111     char padA[13];
0112     char mname[16];
0113     char modname[16];
0114     char firmver[16];
0115     char padB[16];
0116 };
0117
0118 static int gdrom_getsense(short *bufstring);
0119 static int gdrom_packetcommand(struct cdrom_device_info *cd_info,
0120     struct packet_command *command);
0121 static int gdrom_hardreset(struct cdrom_device_info *cd_info);
0122
0123 static bool gdrom_is_busy(void)
0124 {
0125     return (__raw_readb(GDROM_ALTSTATUS_REG) & 0x80) != 0;
0126 }
0127
0128 static bool gdrom_data_request(void)
0129 {
0130     return (__raw_readb(GDROM_ALTSTATUS_REG) & 0x88) == 8;
0131 }
0132
0133 static bool gdrom_wait_clrbusy(void)
0134 {
0135     unsigned long timeout = jiffies + GDROM_DEFAULT_TIMEOUT;
0136     while ((__raw_readb(GDROM_ALTSTATUS_REG) & 0x80) &&
0137         (time_before(jiffies, timeout)))
0138         cpu_relax();
0139     return time_before(jiffies, timeout + 1);
0140 }
0141
0142 static bool gdrom_wait_busy_sleeps(void)
0143 {
0144     unsigned long timeout;
0145     /* Wait to get busy first */
0146     timeout = jiffies + GDROM_DEFAULT_TIMEOUT;
0147     while (!gdrom_is_busy() && time_before(jiffies, timeout))
0148         cpu_relax();
0149     /* Now wait for busy to clear */
0150     return gdrom_wait_clrbusy();
0151 }
0152
0153 static void gdrom_identifydevice(void *buf)
0154 {
0155     int c;
0156     short *data = buf;
0157     /* If the device won't clear it has probably
0158     * been hit by a serious failure - but we'll
0159     * try to return a sense key even so */
0160     if (!gdrom_wait_clrbusy()) {
0161         gdrom_getsense(NULL);
0162         return;
0163     }
0164     __raw_writeb(GDROM_COM_IDDEV, GDROM_STATUSCOMMAND_REG);
0165     if (!gdrom_wait_busy_sleeps()) {
0166         gdrom_getsense(NULL);
0167         return;
0168     }
0169     /* now read in the data */
0170     for (c = 0; c < 40; c++)
0171         data[c] = __raw_readw(GDROM_DATA_REG);
0172 }
0173
0174 static void gdrom_spicommand(void *spi_string, int buflen)
0175 {
0176     short *cmd = spi_string;
0177     unsigned long timeout;
0178
0179     /* ensure IRQ_WAIT is set */
0180     __raw_writeb(0x08, GDROM_ALTSTATUS_REG);
0181     /* specify how many bytes we expect back */
0182     __raw_writeb(buflen & 0xFF, GDROM_BCL_REG);
0183     __raw_writeb((buflen >> 8) & 0xFF, GDROM_BCH_REG);
0184     /* other parameters */
0185     __raw_writeb(0, GDROM_INTSEC_REG);
0186     __raw_writeb(0, GDROM_SECNUM_REG);
0187     __raw_writeb(0, GDROM_ERROR_REG);
0188     /* Wait until we can go */
0189     if (!gdrom_wait_clrbusy()) {
0190         gdrom_getsense(NULL);
0191         return;
0192     }
0193     timeout = jiffies + GDROM_DEFAULT_TIMEOUT;
0194     __raw_writeb(GDROM_COM_PACKET, GDROM_STATUSCOMMAND_REG);
0195     while (!gdrom_data_request() && time_before(jiffies, timeout))
0196         cpu_relax();
0197     if (!time_before(jiffies, timeout + 1)) {
0198         gdrom_getsense(NULL);
0199         return;
0200     }
0201     outsw(GDROM_DATA_REG, cmd, 6);
0202 }
0203
0204
0205 /* gdrom_command_executediagnostic:
0206  * Used to probe for presence of working GDROM
0207  * Restarts GDROM device and then applies standard ATA 3
0208  * Execute Diagnostic Command: a return of '1' indicates device 0
0209  * present and device 1 absent
0210  */
0211 static char gdrom_execute_diagnostic(void)
0212 {
0213     gdrom_hardreset(gd.cd_info);
0214     if (!gdrom_wait_clrbusy())
0215         return 0;
0216     __raw_writeb(GDROM_COM_EXECDIAG, GDROM_STATUSCOMMAND_REG);
0217     if (!gdrom_wait_busy_sleeps())
0218         return 0;
0219     return __raw_readb(GDROM_ERROR_REG);
0220 }
0221
0222 /*
0223  * Prepare disk command
0224  * byte 0 = 0x70
0225  * byte 1 = 0x1f
0226  */
0227 static int gdrom_preparedisk_cmd(void)
0228 {
0229     struct packet_command *spin_command;
0230     spin_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL);
0231     if (!spin_command)
0232         return -ENOMEM;
0233     spin_command->cmd[0] = 0x70;
0234     spin_command->cmd[2] = 0x1f;
0235     spin_command->buflen = 0;
0236     gd.pending = 1;
0237     gdrom_packetcommand(gd.cd_info, spin_command);
0238     /* 60 second timeout */
0239     wait_event_interruptible_timeout(command_queue, gd.pending == 0,
0240         GDROM_DEFAULT_TIMEOUT);
0241     gd.pending = 0;
0242     kfree(spin_command);
0243     if (gd.status & 0x01) {
0244         /* log an error */
0245         gdrom_getsense(NULL);
0246         return -EIO;
0247     }
0248     return 0;
0249 }
0250
0251 /*
0252  * Read TOC command
0253  * byte 0 = 0x14
0254  * byte 1 = session
0255  * byte 3 = sizeof TOC >> 8  ie upper byte
0256  * byte 4 = sizeof TOC & 0xff ie lower byte
0257  */
0258 static int gdrom_readtoc_cmd(struct gdromtoc *toc, int session)
0259 {
0260     int tocsize;
0261     struct packet_command *toc_command;
0262     int err = 0;
0263
0264     toc_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL);
0265     if (!toc_command)
0266         return -ENOMEM;
0267     tocsize = sizeof(struct gdromtoc);
0268     toc_command->cmd[0] = 0x14;
0269     toc_command->cmd[1] = session;
0270     toc_command->cmd[3] = tocsize >> 8;
0271     toc_command->cmd[4] = tocsize & 0xff;
0272     toc_command->buflen = tocsize;
0273     if (gd.pending) {
0274         err = -EBUSY;
0275         goto cleanup_readtoc_final;
0276     }
0277     gd.pending = 1;
0278     gdrom_packetcommand(gd.cd_info, toc_command);
0279     wait_event_interruptible_timeout(command_queue, gd.pending == 0,
0280         GDROM_DEFAULT_TIMEOUT);
0281     if (gd.pending) {
0282         err = -EINVAL;
0283         goto cleanup_readtoc;
0284     }
0285     insw(GDROM_DATA_REG, toc, tocsize/2);
0286     if (gd.status & 0x01)
0287         err = -EINVAL;
0288
0289 cleanup_readtoc:
0290     gd.pending = 0;
0291 cleanup_readtoc_final:
0292     kfree(toc_command);
0293     return err;
0294 }
0295
0296 /* TOC helpers */
0297 static int get_entry_lba(int track)
0298 {
0299     return (cpu_to_be32(track & 0xffffff00) - GD_SESSION_OFFSET);
0300 }
0301
0302 static int get_entry_q_ctrl(int track)
0303 {
0304     return (track & 0x000000f0) >> 4;
0305 }
0306
0307 static int get_entry_track(int track)
0308 {
0309     return (track & 0x0000ff00) >> 8;
0310 }
0311
0312 static int gdrom_get_last_session(struct cdrom_device_info *cd_info,
0313     struct cdrom_multisession *ms_info)
0314 {
0315     int fentry, lentry, track, data, err;
0316
0317     if (!gd.toc)
0318         return -ENOMEM;
0319
0320     /* Check if GD-ROM */
0321     err = gdrom_readtoc_cmd(gd.toc, 1);
0322     /* Not a GD-ROM so check if standard CD-ROM */
0323     if (err) {
0324         err = gdrom_readtoc_cmd(gd.toc, 0);
0325         if (err) {
0326             pr_info("Could not get CD table of contents\n");
0327             return -ENXIO;
0328         }
0329     }
0330
0331     fentry = get_entry_track(gd.toc->first);
0332     lentry = get_entry_track(gd.toc->last);
0333     /* Find the first data track */
0334     track = get_entry_track(gd.toc->last);
0335     do {
0336         data = gd.toc->entry[track - 1];
0337         if (get_entry_q_ctrl(data))
0338             break;  /* ie a real data track */
0339         track--;
0340     } while (track >= fentry);
0341
0342     if ((track > 100) || (track < get_entry_track(gd.toc->first))) {
0343         pr_info("No data on the last session of the CD\n");
0344         gdrom_getsense(NULL);
0345         return -ENXIO;
0346     }
0347
0348     ms_info->addr_format = CDROM_LBA;
0349     ms_info->addr.lba = get_entry_lba(data);
0350     ms_info->xa_flag = 1;
0351     return 0;
0352 }
0353
0354 static int gdrom_open(struct cdrom_device_info *cd_info, int purpose)
0355 {
0356     /* spin up the disk */
0357     return gdrom_preparedisk_cmd();
0358 }
0359
0360 /* this function is required even if empty */
0361 static void gdrom_release(struct cdrom_device_info *cd_info)
0362 {
0363 }
0364
0365 static int gdrom_drivestatus(struct cdrom_device_info *cd_info, int ignore)
0366 {
0367     /* read the sense key */
0368     char sense = __raw_readb(GDROM_ERROR_REG);
0369     sense &= 0xF0;
0370     if (sense == 0)
0371         return CDS_DISC_OK;
0372     if (sense == 0x20)
0373         return CDS_DRIVE_NOT_READY;
0374     /* default */
0375     return CDS_NO_INFO;
0376 }
0377
0378 static unsigned int gdrom_check_events(struct cdrom_device_info *cd_info,
0379                        unsigned int clearing, int ignore)
0380 {
0381     /* check the sense key */
0382     return (__raw_readb(GDROM_ERROR_REG) & 0xF0) == 0x60 ?
0383         DISK_EVENT_MEDIA_CHANGE : 0;
0384 }
0385
0386 /* reset the G1 bus */
0387 static int gdrom_hardreset(struct cdrom_device_info *cd_info)
0388 {
0389     int count;
0390     __raw_writel(0x1fffff, GDROM_RESET_REG);
0391     for (count = 0xa0000000; count < 0xa0200000; count += 4)
0392         __raw_readl(count);
0393     return 0;
0394 }
0395
0396 /* keep the function looking like the universal
0397  * CD Rom specification  - returning int */
0398 static int gdrom_packetcommand(struct cdrom_device_info *cd_info,
0399     struct packet_command *command)
0400 {
0401     gdrom_spicommand(&command->cmd, command->buflen);
0402     return 0;
0403 }
0404
0405 /* Get Sense SPI command
0406  * From Marcus Comstedt
0407  * cmd = 0x13
0408  * cmd + 4 = length of returned buffer
0409  * Returns 5 16 bit words
0410  */
0411 static int gdrom_getsense(short *bufstring)
0412 {
0413     struct packet_command *sense_command;
0414     short sense[5];
0415     int sense_key;
0416     int err = -EIO;
0417
0418     sense_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL);
0419     if (!sense_command)
0420         return -ENOMEM;
0421     sense_command->cmd[0] = 0x13;
0422     sense_command->cmd[4] = 10;
0423     sense_command->buflen = 10;
0424     /* even if something is pending try to get
0425     * the sense key if possible */
0426     if (gd.pending && !gdrom_wait_clrbusy()) {
0427         err = -EBUSY;
0428         goto cleanup_sense_final;
0429     }
0430     gd.pending = 1;
0431     gdrom_packetcommand(gd.cd_info, sense_command);
0432     wait_event_interruptible_timeout(command_queue, gd.pending == 0,
0433         GDROM_DEFAULT_TIMEOUT);
0434     if (gd.pending)
0435         goto cleanup_sense;
0436     insw(GDROM_DATA_REG, &sense, sense_command->buflen/2);
0437     if (sense[1] & 40) {
0438         pr_info("Drive not ready - command aborted\n");
0439         goto cleanup_sense;
0440     }
0441     sense_key = sense[1] & 0x0F;
0442     if (sense_key < ARRAY_SIZE(sense_texts))
0443         pr_info("%s\n", sense_texts[sense_key].text);
0444     else
0445         pr_err("Unknown sense key: %d\n", sense_key);
0446     if (bufstring) /* return addional sense data */
0447         memcpy(bufstring, &sense[4], 2);
0448     if (sense_key < 2)
0449         err = 0;
0450
0451 cleanup_sense:
0452     gd.pending = 0;
0453 cleanup_sense_final:
0454     kfree(sense_command);
0455     return err;
0456 }
0457
0458 static int gdrom_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
0459                  void *arg)
0460 {
0461     return -EINVAL;
0462 }
0463
0464 static const struct cdrom_device_ops gdrom_ops = {
0465     .open           = gdrom_open,
0466     .release        = gdrom_release,
0467     .drive_status       = gdrom_drivestatus,
0468     .check_events       = gdrom_check_events,
0469     .get_last_session   = gdrom_get_last_session,
0470     .reset          = gdrom_hardreset,
0471     .audio_ioctl        = gdrom_audio_ioctl,
0472     .generic_packet     = cdrom_dummy_generic_packet,
0473     .capability     = CDC_MULTI_SESSION | CDC_MEDIA_CHANGED |
0474                   CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R,
0475 };
0476
0477 static int gdrom_bdops_open(struct block_device *bdev, fmode_t mode)
0478 {
0479     int ret;
0480
0481     bdev_check_media_change(bdev);
0482
0483     mutex_lock(&gdrom_mutex);
0484     ret = cdrom_open(gd.cd_info, bdev, mode);
0485     mutex_unlock(&gdrom_mutex);
0486     return ret;
0487 }
0488
0489 static void gdrom_bdops_release(struct gendisk *disk, fmode_t mode)
0490 {
0491     mutex_lock(&gdrom_mutex);
0492     cdrom_release(gd.cd_info, mode);
0493     mutex_unlock(&gdrom_mutex);
0494 }
0495
0496 static unsigned int gdrom_bdops_check_events(struct gendisk *disk,
0497                          unsigned int clearing)
0498 {
0499     return cdrom_check_events(gd.cd_info, clearing);
0500 }
0501
0502 static int gdrom_bdops_ioctl(struct block_device *bdev, fmode_t mode,
0503     unsigned cmd, unsigned long arg)
0504 {
0505     int ret;
0506
0507     mutex_lock(&gdrom_mutex);
0508     ret = cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg);
0509     mutex_unlock(&gdrom_mutex);
0510
0511     return ret;
0512 }
0513
0514 static const struct block_device_operations gdrom_bdops = {
0515     .owner          = THIS_MODULE,
0516     .open           = gdrom_bdops_open,
0517     .release        = gdrom_bdops_release,
0518     .check_events       = gdrom_bdops_check_events,
0519     .ioctl          = gdrom_bdops_ioctl,
0520 #ifdef CONFIG_COMPAT
0521     .compat_ioctl       = blkdev_compat_ptr_ioctl,
0522 #endif
0523 };
0524
0525 static irqreturn_t gdrom_command_interrupt(int irq, void *dev_id)
0526 {
0527     gd.status = __raw_readb(GDROM_STATUSCOMMAND_REG);
0528     if (gd.pending != 1)
0529         return IRQ_HANDLED;
0530     gd.pending = 0;
0531     wake_up_interruptible(&command_queue);
0532     return IRQ_HANDLED;
0533 }
0534
0535 static irqreturn_t gdrom_dma_interrupt(int irq, void *dev_id)
0536 {
0537     gd.status = __raw_readb(GDROM_STATUSCOMMAND_REG);
0538     if (gd.transfer != 1)
0539         return IRQ_HANDLED;
0540     gd.transfer = 0;
0541     wake_up_interruptible(&request_queue);
0542     return IRQ_HANDLED;
0543 }
0544
0545 static int gdrom_set_interrupt_handlers(void)
0546 {
0547     int err;
0548
0549     err = request_irq(HW_EVENT_GDROM_CMD, gdrom_command_interrupt,
0550         0, "gdrom_command", &gd);
0551     if (err)
0552         return err;
0553     err = request_irq(HW_EVENT_GDROM_DMA, gdrom_dma_interrupt,
0554         0, "gdrom_dma", &gd);
0555     if (err)
0556         free_irq(HW_EVENT_GDROM_CMD, &gd);
0557     return err;
0558 }
0559
0560 /* Implement DMA read using SPI command
0561  * 0 -> 0x30
0562  * 1 -> mode
0563  * 2 -> block >> 16
0564  * 3 -> block >> 8
0565  * 4 -> block
0566  * 8 -> sectors >> 16
0567  * 9 -> sectors >> 8
0568  * 10 -> sectors
0569  */
0570 static blk_status_t gdrom_readdisk_dma(struct request *req)
0571 {
0572     int block, block_cnt;
0573     blk_status_t err;
0574     struct packet_command *read_command;
0575     unsigned long timeout;
0576
0577     read_command = kzalloc(sizeof(struct packet_command), GFP_KERNEL);
0578     if (!read_command)
0579         return BLK_STS_RESOURCE;
0580
0581     read_command->cmd[0] = 0x30;
0582     read_command->cmd[1] = 0x20;
0583     block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET;
0584     block_cnt = blk_rq_sectors(req)/GD_TO_BLK;
0585     __raw_writel(page_to_phys(bio_page(req->bio)) + bio_offset(req->bio),
0586             GDROM_DMA_STARTADDR_REG);
0587     __raw_writel(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG);
0588     __raw_writel(1, GDROM_DMA_DIRECTION_REG);
0589     __raw_writel(1, GDROM_DMA_ENABLE_REG);
0590     read_command->cmd[2] = (block >> 16) & 0xFF;
0591     read_command->cmd[3] = (block >> 8) & 0xFF;
0592     read_command->cmd[4] = block & 0xFF;
0593     read_command->cmd[8] = (block_cnt >> 16) & 0xFF;
0594     read_command->cmd[9] = (block_cnt >> 8) & 0xFF;
0595     read_command->cmd[10] = block_cnt & 0xFF;
0596     /* set for DMA */
0597     __raw_writeb(1, GDROM_ERROR_REG);
0598     /* other registers */
0599     __raw_writeb(0, GDROM_SECNUM_REG);
0600     __raw_writeb(0, GDROM_BCL_REG);
0601     __raw_writeb(0, GDROM_BCH_REG);
0602     __raw_writeb(0, GDROM_DSEL_REG);
0603     __raw_writeb(0, GDROM_INTSEC_REG);
0604     /* Wait for registers to reset after any previous activity */
0605     timeout = jiffies + HZ / 2;
0606     while (gdrom_is_busy() && time_before(jiffies, timeout))
0607         cpu_relax();
0608     __raw_writeb(GDROM_COM_PACKET, GDROM_STATUSCOMMAND_REG);
0609     timeout = jiffies + HZ / 2;
0610     /* Wait for packet command to finish */
0611     while (gdrom_is_busy() && time_before(jiffies, timeout))
0612         cpu_relax();
0613     gd.pending = 1;
0614     gd.transfer = 1;
0615     outsw(GDROM_DATA_REG, &read_command->cmd, 6);
0616     timeout = jiffies + HZ / 2;
0617     /* Wait for any pending DMA to finish */
0618     while (__raw_readb(GDROM_DMA_STATUS_REG) &&
0619         time_before(jiffies, timeout))
0620         cpu_relax();
0621     /* start transfer */
0622     __raw_writeb(1, GDROM_DMA_STATUS_REG);
0623     wait_event_interruptible_timeout(request_queue,
0624         gd.transfer == 0, GDROM_DEFAULT_TIMEOUT);
0625     err = gd.transfer ? BLK_STS_IOERR : BLK_STS_OK;
0626     gd.transfer = 0;
0627     gd.pending = 0;
0628
0629     blk_mq_end_request(req, err);
0630     kfree(read_command);
0631     return BLK_STS_OK;
0632 }
0633
0634 static blk_status_t gdrom_queue_rq(struct blk_mq_hw_ctx *hctx,
0635                    const struct blk_mq_queue_data *bd)
0636 {
0637     blk_mq_start_request(bd->rq);
0638
0639     switch (req_op(bd->rq)) {
0640     case REQ_OP_READ:
0641         return gdrom_readdisk_dma(bd->rq);
0642     case REQ_OP_WRITE:
0643         pr_notice("Read only device - write request ignored\n");
0644         return BLK_STS_IOERR;
0645     default:
0646         printk(KERN_DEBUG "gdrom: Non-fs request ignored\n");
0647         return BLK_STS_IOERR;
0648     }
0649 }
0650
0651 /* Print string identifying GD ROM device */
0652 static int gdrom_outputversion(void)
0653 {
0654     struct gdrom_id *id;
0655     char *model_name, *manuf_name, *firmw_ver;
0656     int err = -ENOMEM;
0657
0658     /* query device ID */
0659     id = kzalloc(sizeof(struct gdrom_id), GFP_KERNEL);
0660     if (!id)
0661         return err;
0662     gdrom_identifydevice(id);
0663     model_name = kstrndup(id->modname, 16, GFP_KERNEL);
0664     if (!model_name)
0665         goto free_id;
0666     manuf_name = kstrndup(id->mname, 16, GFP_KERNEL);
0667     if (!manuf_name)
0668         goto free_model_name;
0669     firmw_ver = kstrndup(id->firmver, 16, GFP_KERNEL);
0670     if (!firmw_ver)
0671         goto free_manuf_name;
0672     pr_info("%s from %s with firmware %s\n",
0673         model_name, manuf_name, firmw_ver);
0674     err = 0;
0675     kfree(firmw_ver);
0676 free_manuf_name:
0677     kfree(manuf_name);
0678 free_model_name:
0679     kfree(model_name);
0680 free_id:
0681     kfree(id);
0682     return err;
0683 }
0684
0685 /* set the default mode for DMA transfer */
0686 static int gdrom_init_dma_mode(void)
0687 {
0688     __raw_writeb(0x13, GDROM_ERROR_REG);
0689     __raw_writeb(0x22, GDROM_INTSEC_REG);
0690     if (!gdrom_wait_clrbusy())
0691         return -EBUSY;
0692     __raw_writeb(0xEF, GDROM_STATUSCOMMAND_REG);
0693     if (!gdrom_wait_busy_sleeps())
0694         return -EBUSY;
0695     /* Memory protection setting for GDROM DMA
0696     * Bits 31 - 16 security: 0x8843
0697     * Bits 15 and 7 reserved (0)
0698     * Bits 14 - 8 start of transfer range in 1 MB blocks OR'ed with 0x80
0699     * Bits 6 - 0 end of transfer range in 1 MB blocks OR'ed with 0x80
0700     * (0x40 | 0x80) = start range at 0x0C000000
0701     * (0x7F | 0x80) = end range at 0x0FFFFFFF */
0702     __raw_writel(0x8843407F, GDROM_DMA_ACCESS_CTRL_REG);
0703     __raw_writel(9, GDROM_DMA_WAIT_REG); /* DMA word setting */
0704     return 0;
0705 }
0706
0707 static void probe_gdrom_setupcd(void)
0708 {
0709     gd.cd_info->ops = &gdrom_ops;
0710     gd.cd_info->capacity = 1;
0711     strcpy(gd.cd_info->name, GDROM_DEV_NAME);
0712     gd.cd_info->mask = CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK|
0713         CDC_SELECT_DISC;
0714 }
0715
0716 static void probe_gdrom_setupdisk(void)
0717 {
0718     gd.disk->major = gdrom_major;
0719     gd.disk->first_minor = 1;
0720     gd.disk->minors = 1;
0721     gd.disk->flags |= GENHD_FL_NO_PART;
0722     strcpy(gd.disk->disk_name, GDROM_DEV_NAME);
0723 }
0724
0725 static int probe_gdrom_setupqueue(void)
0726 {
0727     blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
0728     /* using DMA so memory will need to be contiguous */
0729     blk_queue_max_segments(gd.gdrom_rq, 1);
0730     /* set a large max size to get most from DMA */
0731     blk_queue_max_segment_size(gd.gdrom_rq, 0x40000);
0732     gd.disk->queue = gd.gdrom_rq;
0733     return gdrom_init_dma_mode();
0734 }
0735
0736 static const struct blk_mq_ops gdrom_mq_ops = {
0737     .queue_rq   = gdrom_queue_rq,
0738 };
0739
0740 /*
0741  * register this as a block device and as compliant with the
0742  * universal CD Rom driver interface
0743  */
0744 static int probe_gdrom(struct platform_device *devptr)
0745 {
0746     int err;
0747
0748     /*
0749      * Ensure our "one" device is initialized properly in case of previous
0750      * usages of it
0751      */
0752     memset(&gd, 0, sizeof(gd));
0753
0754     /* Start the device */
0755     if (gdrom_execute_diagnostic() != 1) {
0756         pr_warn("ATA Probe for GDROM failed\n");
0757         return -ENODEV;
0758     }
0759     /* Print out firmware ID */
0760     if (gdrom_outputversion())
0761         return -ENOMEM;
0762     /* Register GDROM */
0763     gdrom_major = register_blkdev(0, GDROM_DEV_NAME);
0764     if (gdrom_major <= 0)
0765         return gdrom_major;
0766     pr_info("Registered with major number %d\n",
0767         gdrom_major);
0768     /* Specify basic properties of drive */
0769     gd.cd_info = kzalloc(sizeof(struct cdrom_device_info), GFP_KERNEL);
0770     if (!gd.cd_info) {
0771         err = -ENOMEM;
0772         goto probe_fail_no_mem;
0773     }
0774     probe_gdrom_setupcd();
0775
0776     err = blk_mq_alloc_sq_tag_set(&gd.tag_set, &gdrom_mq_ops, 1,
0777                 BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING);
0778     if (err)
0779         goto probe_fail_free_cd_info;
0780
0781     gd.disk = blk_mq_alloc_disk(&gd.tag_set, NULL);
0782     if (IS_ERR(gd.disk)) {
0783         err = PTR_ERR(gd.disk);
0784         goto probe_fail_free_tag_set;
0785     }
0786     gd.gdrom_rq = gd.disk->queue;
0787     probe_gdrom_setupdisk();
0788     if (register_cdrom(gd.disk, gd.cd_info)) {
0789         err = -ENODEV;
0790         goto probe_fail_cleanup_disk;
0791     }
0792     gd.disk->fops = &gdrom_bdops;
0793     gd.disk->events = DISK_EVENT_MEDIA_CHANGE;
0794     /* latch on to the interrupt */
0795     err = gdrom_set_interrupt_handlers();
0796     if (err)
0797         goto probe_fail_cleanup_disk;
0798
0799     err = probe_gdrom_setupqueue();
0800     if (err)
0801         goto probe_fail_free_irqs;
0802
0803     gd.toc = kzalloc(sizeof(struct gdromtoc), GFP_KERNEL);
0804     if (!gd.toc) {
0805         err = -ENOMEM;
0806         goto probe_fail_free_irqs;
0807     }
0808     err = add_disk(gd.disk);
0809     if (err)
0810         goto probe_fail_add_disk;
0811
0812     return 0;
0813
0814 probe_fail_add_disk:
0815     kfree(gd.toc);
0816 probe_fail_free_irqs:
0817     free_irq(HW_EVENT_GDROM_DMA, &gd);
0818     free_irq(HW_EVENT_GDROM_CMD, &gd);
0819 probe_fail_cleanup_disk:
0820     put_disk(gd.disk);
0821 probe_fail_free_tag_set:
0822     blk_mq_free_tag_set(&gd.tag_set);
0823 probe_fail_free_cd_info:
0824     kfree(gd.cd_info);
0825 probe_fail_no_mem:
0826     unregister_blkdev(gdrom_major, GDROM_DEV_NAME);
0827     gdrom_major = 0;
0828     pr_warn("Probe failed - error is 0x%X\n", err);
0829     return err;
0830 }
0831
0832 static int remove_gdrom(struct platform_device *devptr)
0833 {
0834     blk_mq_free_tag_set(&gd.tag_set);
0835     free_irq(HW_EVENT_GDROM_CMD, &gd);
0836     free_irq(HW_EVENT_GDROM_DMA, &gd);
0837     del_gendisk(gd.disk);
0838     if (gdrom_major)
0839         unregister_blkdev(gdrom_major, GDROM_DEV_NAME);
0840     unregister_cdrom(gd.cd_info);
0841     kfree(gd.cd_info);
0842     kfree(gd.toc);
0843
0844     return 0;
0845 }
0846
0847 static struct platform_driver gdrom_driver = {
0848     .probe = probe_gdrom,
0849     .remove = remove_gdrom,
0850     .driver = {
0851             .name = GDROM_DEV_NAME,
0852     },
0853 };
0854
0855 static int __init init_gdrom(void)
0856 {
0857     int rc;
0858
0859     rc = platform_driver_register(&gdrom_driver);
0860     if (rc)
0861         return rc;
0862     pd = platform_device_register_simple(GDROM_DEV_NAME, -1, NULL, 0);
0863     if (IS_ERR(pd)) {
0864         platform_driver_unregister(&gdrom_driver);
0865         return PTR_ERR(pd);
0866     }
0867     return 0;
0868 }
0869
0870 static void __exit exit_gdrom(void)
0871 {
0872     platform_device_unregister(pd);
0873     platform_driver_unregister(&gdrom_driver);
0874 }
0875
0876 module_init(init_gdrom);
0877 module_exit(exit_gdrom);
0878 MODULE_AUTHOR("Adrian McMenamin <adrian@mcmen.demon.co.uk>");
0879 MODULE_DESCRIPTION("SEGA Dreamcast GD-ROM Driver");
0880 MODULE_LICENSE("GPL");