[mirror_ubuntu-jammy-kernel.git] / drivers / scsi / ps3rom.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * PS3 BD/DVD/CD-ROM Storage Driver
 *
 * Copyright (C) 2007 Sony Computer Entertainment Inc.
 * Copyright 2007 Sony Corp.
 */

#include <linux/cdrom.h>
#include <linux/highmem.h>
#include <linux/module.h>
#include <linux/slab.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_eh.h>

#include <asm/lv1call.h>
#include <asm/ps3stor.h>


#define DEVICE_NAME			"ps3rom"

#define BOUNCE_SIZE			(64*1024)

#define PS3ROM_MAX_SECTORS		(BOUNCE_SIZE >> 9)


struct ps3rom_private {
	struct ps3_storage_device *dev;
	struct scsi_cmnd *curr_cmd;
};


#define LV1_STORAGE_SEND_ATAPI_COMMAND	(1)

struct lv1_atapi_cmnd_block {
	u8	pkt[32];	/* packet command block           */
	u32	pktlen;		/* should be 12 for ATAPI 8020    */
	u32	blocks;
	u32	block_size;
	u32	proto;		/* transfer mode                  */
	u32	in_out;		/* transfer direction             */
	u64	buffer;		/* parameter except command block */
	u32	arglen;		/* length above                   */
};

enum lv1_atapi_proto {
	NON_DATA_PROTO     = 0,
	PIO_DATA_IN_PROTO  = 1,
	PIO_DATA_OUT_PROTO = 2,
	DMA_PROTO = 3
};

enum lv1_atapi_in_out {
	DIR_WRITE = 0,		/* memory -> device */
	DIR_READ = 1		/* device -> memory */
};


static int ps3rom_slave_configure(struct scsi_device *scsi_dev)
{
	struct ps3rom_private *priv = shost_priv(scsi_dev->host);
	struct ps3_storage_device *dev = priv->dev;

	dev_dbg(&dev->sbd.core, "%s:%u: id %u, lun %llu, channel %u\n", __func__,
		__LINE__, scsi_dev->id, scsi_dev->lun, scsi_dev->channel);

	/*
	 * ATAPI SFF8020 devices use MODE_SENSE_10,
	 * so we can prohibit MODE_SENSE_6
	 */
	scsi_dev->use_10_for_ms = 1;

	/* we don't support {READ,WRITE}_6 */
	scsi_dev->use_10_for_rw = 1;

	return 0;
}

static int ps3rom_atapi_request(struct ps3_storage_device *dev,
				struct scsi_cmnd *cmd)
{
	struct lv1_atapi_cmnd_block atapi_cmnd;
	unsigned char opcode = cmd->cmnd[0];
	int res;
	u64 lpar;

	dev_dbg(&dev->sbd.core, "%s:%u: send ATAPI command 0x%02x\n", __func__,
		__LINE__, opcode);

	memset(&atapi_cmnd, 0, sizeof(struct lv1_atapi_cmnd_block));
	memcpy(&atapi_cmnd.pkt, cmd->cmnd, 12);
	atapi_cmnd.pktlen = 12;
	atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */
	atapi_cmnd.blocks = atapi_cmnd.arglen = scsi_bufflen(cmd);
	atapi_cmnd.buffer = dev->bounce_lpar;

	switch (cmd->sc_data_direction) {
	case DMA_FROM_DEVICE:
		if (scsi_bufflen(cmd) >= CD_FRAMESIZE)
			atapi_cmnd.proto = DMA_PROTO;
		else
			atapi_cmnd.proto = PIO_DATA_IN_PROTO;
		atapi_cmnd.in_out = DIR_READ;
		break;

	case DMA_TO_DEVICE:
		if (scsi_bufflen(cmd) >= CD_FRAMESIZE)
			atapi_cmnd.proto = DMA_PROTO;
		else
			atapi_cmnd.proto = PIO_DATA_OUT_PROTO;
		atapi_cmnd.in_out = DIR_WRITE;
		scsi_sg_copy_to_buffer(cmd, dev->bounce_buf, dev->bounce_size);
		break;

	default:
		atapi_cmnd.proto = NON_DATA_PROTO;
		break;
	}

	lpar = ps3_mm_phys_to_lpar(__pa(&atapi_cmnd));
	res = lv1_storage_send_device_command(dev->sbd.dev_id,
					      LV1_STORAGE_SEND_ATAPI_COMMAND,
					      lpar, sizeof(atapi_cmnd),
					      atapi_cmnd.buffer,
					      atapi_cmnd.arglen, &dev->tag);
	if (res == LV1_DENIED_BY_POLICY) {
		dev_dbg(&dev->sbd.core,
			"%s:%u: ATAPI command 0x%02x denied by policy\n",
			__func__, __LINE__, opcode);
		return DID_ERROR << 16;
	}

	if (res) {
		dev_err(&dev->sbd.core,
			"%s:%u: ATAPI command 0x%02x failed %d\n", __func__,
			__LINE__, opcode, res);
		return DID_ERROR << 16;
	}

	return 0;
}

static inline unsigned int srb10_lba(const struct scsi_cmnd *cmd)
{
	return cmd->cmnd[2] << 24 | cmd->cmnd[3] << 16 | cmd->cmnd[4] << 8 |
	       cmd->cmnd[5];
}

static inline unsigned int srb10_len(const struct scsi_cmnd *cmd)
{
	return cmd->cmnd[7] << 8 | cmd->cmnd[8];
}

static int ps3rom_read_request(struct ps3_storage_device *dev,
			       struct scsi_cmnd *cmd, u32 start_sector,
			       u32 sectors)
{
	int res;

	dev_dbg(&dev->sbd.core, "%s:%u: read %u sectors starting at %u\n",
		__func__, __LINE__, sectors, start_sector);

	res = lv1_storage_read(dev->sbd.dev_id,
			       dev->regions[dev->region_idx].id, start_sector,
			       sectors, 0, dev->bounce_lpar, &dev->tag);
	if (res) {
		dev_err(&dev->sbd.core, "%s:%u: read failed %d\n", __func__,
			__LINE__, res);
		return DID_ERROR << 16;
	}

	return 0;
}

static int ps3rom_write_request(struct ps3_storage_device *dev,
				struct scsi_cmnd *cmd, u32 start_sector,
				u32 sectors)
{
	int res;

	dev_dbg(&dev->sbd.core, "%s:%u: write %u sectors starting at %u\n",
		__func__, __LINE__, sectors, start_sector);

	scsi_sg_copy_to_buffer(cmd, dev->bounce_buf, dev->bounce_size);

	res = lv1_storage_write(dev->sbd.dev_id,
				dev->regions[dev->region_idx].id, start_sector,
				sectors, 0, dev->bounce_lpar, &dev->tag);
	if (res) {
		dev_err(&dev->sbd.core, "%s:%u: write failed %d\n", __func__,
			__LINE__, res);
		return DID_ERROR << 16;
	}

	return 0;
}

static int ps3rom_queuecommand_lck(struct scsi_cmnd *cmd,
			       void (*done)(struct scsi_cmnd *))
{
	struct ps3rom_private *priv = shost_priv(cmd->device->host);
	struct ps3_storage_device *dev = priv->dev;
	unsigned char opcode;
	int res;

	priv->curr_cmd = cmd;
	cmd->scsi_done = done;

	opcode = cmd->cmnd[0];
	/*
	 * While we can submit READ/WRITE SCSI commands as ATAPI commands,
	 * it's recommended for various reasons (performance, error handling,
	 * ...) to use lv1_storage_{read,write}() instead
	 */
	switch (opcode) {
	case READ_10:
		res = ps3rom_read_request(dev, cmd, srb10_lba(cmd),
					  srb10_len(cmd));
		break;

	case WRITE_10:
		res = ps3rom_write_request(dev, cmd, srb10_lba(cmd),
					   srb10_len(cmd));
		break;

	default:
		res = ps3rom_atapi_request(dev, cmd);
		break;
	}

	if (res) {
		memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
		cmd->result = res;
		cmd->sense_buffer[0] = 0x70;
		cmd->sense_buffer[2] = ILLEGAL_REQUEST;
		priv->curr_cmd = NULL;
		cmd->scsi_done(cmd);
	}

	return 0;
}

static DEF_SCSI_QCMD(ps3rom_queuecommand)

static int decode_lv1_status(u64 status, unsigned char *sense_key,
			     unsigned char *asc, unsigned char *ascq)
{
	if (((status >> 24) & 0xff) != SAM_STAT_CHECK_CONDITION)
		return -1;

	*sense_key = (status >> 16) & 0xff;
	*asc       = (status >>  8) & 0xff;
	*ascq      =  status        & 0xff;
	return 0;
}

static irqreturn_t ps3rom_interrupt(int irq, void *data)
{
	struct ps3_storage_device *dev = data;
	struct Scsi_Host *host;
	struct ps3rom_private *priv;
	struct scsi_cmnd *cmd;
	int res;
	u64 tag, status;
	unsigned char sense_key, asc, ascq;

	res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
	/*
	 * status = -1 may mean that ATAPI transport completed OK, but
	 * ATAPI command itself resulted CHECK CONDITION
	 * so, upper layer should issue REQUEST_SENSE to check the sense data
	 */

	if (tag != dev->tag)
		dev_err(&dev->sbd.core,
			"%s:%u: tag mismatch, got %llx, expected %llx\n",
			__func__, __LINE__, tag, dev->tag);

	if (res) {
		dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
			__func__, __LINE__, res, status);
		return IRQ_HANDLED;
	}

	host = ps3_system_bus_get_drvdata(&dev->sbd);
	priv = shost_priv(host);
	cmd = priv->curr_cmd;

	if (!status) {
		/* OK, completed */
		if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
			int len;

			len = scsi_sg_copy_from_buffer(cmd,
						       dev->bounce_buf,
						       dev->bounce_size);

			scsi_set_resid(cmd, scsi_bufflen(cmd) - len);
		}
		cmd->result = DID_OK << 16;
		goto done;
	}

	if (cmd->cmnd[0] == REQUEST_SENSE) {
		/* SCSI spec says request sense should never get error */
		dev_err(&dev->sbd.core, "%s:%u: end error without autosense\n",
			__func__, __LINE__);
		cmd->result = DID_ERROR << 16 | SAM_STAT_CHECK_CONDITION;
		goto done;
	}

	if (decode_lv1_status(status, &sense_key, &asc, &ascq)) {
		cmd->result = DID_ERROR << 16;
		goto done;
	}

	scsi_build_sense_buffer(0, cmd->sense_buffer, sense_key, asc, ascq);
	cmd->result = SAM_STAT_CHECK_CONDITION;

done:
	priv->curr_cmd = NULL;
	cmd->scsi_done(cmd);
	return IRQ_HANDLED;
}

static struct scsi_host_template ps3rom_host_template = {
	.name =			DEVICE_NAME,
	.slave_configure =	ps3rom_slave_configure,
	.queuecommand =		ps3rom_queuecommand,
	.can_queue =		1,
	.this_id =		7,
	.sg_tablesize =		SG_ALL,
	.emulated =             1,		/* only sg driver uses this */
	.max_sectors =		PS3ROM_MAX_SECTORS,
	.module =		THIS_MODULE,
};


static int ps3rom_probe(struct ps3_system_bus_device *_dev)
{
	struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
	int error;
	struct Scsi_Host *host;
	struct ps3rom_private *priv;

	if (dev->blk_size != CD_FRAMESIZE) {
		dev_err(&dev->sbd.core,
			"%s:%u: cannot handle block size %llu\n", __func__,
			__LINE__, dev->blk_size);
		return -EINVAL;
	}

	dev->bounce_size = BOUNCE_SIZE;
	dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
	if (!dev->bounce_buf)
		return -ENOMEM;

	error = ps3stor_setup(dev, ps3rom_interrupt);
	if (error)
		goto fail_free_bounce;

	host = scsi_host_alloc(&ps3rom_host_template,
			       sizeof(struct ps3rom_private));
	if (!host) {
		dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed\n",
			__func__, __LINE__);
		error = -ENOMEM;
		goto fail_teardown;
	}

	priv = shost_priv(host);
	ps3_system_bus_set_drvdata(&dev->sbd, host);
	priv->dev = dev;

	/* One device/LUN per SCSI bus */
	host->max_id = 1;
	host->max_lun = 1;

	error = scsi_add_host(host, &dev->sbd.core);
	if (error) {
		dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed %d\n",
			__func__, __LINE__, error);
		error = -ENODEV;
		goto fail_host_put;
	}

	scsi_scan_host(host);
	return 0;

fail_host_put:
	scsi_host_put(host);
	ps3_system_bus_set_drvdata(&dev->sbd, NULL);
fail_teardown:
	ps3stor_teardown(dev);
fail_free_bounce:
	kfree(dev->bounce_buf);
	return error;
}

static int ps3rom_remove(struct ps3_system_bus_device *_dev)
{
	struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
	struct Scsi_Host *host = ps3_system_bus_get_drvdata(&dev->sbd);

	scsi_remove_host(host);
	ps3stor_teardown(dev);
	scsi_host_put(host);
	ps3_system_bus_set_drvdata(&dev->sbd, NULL);
	kfree(dev->bounce_buf);
	return 0;
}

static struct ps3_system_bus_driver ps3rom = {
	.match_id	= PS3_MATCH_ID_STOR_ROM,
	.core.name	= DEVICE_NAME,
	.core.owner	= THIS_MODULE,
	.probe		= ps3rom_probe,
	.remove		= ps3rom_remove
};


static int __init ps3rom_init(void)
{
	return ps3_system_bus_driver_register(&ps3rom);
}

static void __exit ps3rom_exit(void)
{
	ps3_system_bus_driver_unregister(&ps3rom);
}

module_init(ps3rom_init);
module_exit(ps3rom_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("PS3 BD/DVD/CD-ROM Storage Driver");
MODULE_AUTHOR("Sony Corporation");
MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_ROM);
Commit	Line	Data
935912c5	1	// SPDX-License-Identifier: GPL-2.0-only
9aea8cbf GU	2	/*
	3	* PS3 BD/DVD/CD-ROM Storage Driver
	4	*
	5	* Copyright (C) 2007 Sony Computer Entertainment Inc.
	6	* Copyright 2007 Sony Corp.
9aea8cbf GU	7	*/
	8
	9	#include <linux/cdrom.h>
	10	#include <linux/highmem.h>
acf3368f	11	#include <linux/module.h>
5a0e3ad6	12	#include <linux/slab.h>
9aea8cbf GU	13
	14	#include <scsi/scsi.h>
	15	#include <scsi/scsi_cmnd.h>
	16	#include <scsi/scsi_dbg.h>
	17	#include <scsi/scsi_device.h>
	18	#include <scsi/scsi_host.h>
53df8ba8	19	#include <scsi/scsi_eh.h>
9aea8cbf GU	20
	21	#include <asm/lv1call.h>
	22	#include <asm/ps3stor.h>
	23
	24
	25	#define DEVICE_NAME "ps3rom"
	26
	27	#define BOUNCE_SIZE (64*1024)
	28
51883b5e	29	#define PS3ROM_MAX_SECTORS (BOUNCE_SIZE >> 9)
9aea8cbf GU	30
	31
	32	struct ps3rom_private {
	33	struct ps3_storage_device *dev;
	34	struct scsi_cmnd *curr_cmd;
	35	};
	36
	37
	38	#define LV1_STORAGE_SEND_ATAPI_COMMAND (1)
	39
	40	struct lv1_atapi_cmnd_block {
	41	u8 pkt[32]; /* packet command block */
	42	u32 pktlen; /* should be 12 for ATAPI 8020 */
	43	u32 blocks;
	44	u32 block_size;
	45	u32 proto; /* transfer mode */
	46	u32 in_out; /* transfer direction */
	47	u64 buffer; /* parameter except command block */
	48	u32 arglen; /* length above */
	49	};
	50
	51	enum lv1_atapi_proto {
	52	NON_DATA_PROTO = 0,
	53	PIO_DATA_IN_PROTO = 1,
	54	PIO_DATA_OUT_PROTO = 2,
	55	DMA_PROTO = 3
	56	};
	57
	58	enum lv1_atapi_in_out {
	59	DIR_WRITE = 0, /* memory -> device */
	60	DIR_READ = 1 /* device -> memory */
	61	};
	62
	63
	64	static int ps3rom_slave_configure(struct scsi_device *scsi_dev)
	65	{
	66	struct ps3rom_private *priv = shost_priv(scsi_dev->host);
	67	struct ps3_storage_device *dev = priv->dev;
	68
9cb78c16	69	dev_dbg(&dev->sbd.core, "%s:%u: id %u, lun %llu, channel %u\n", __func__,
9aea8cbf GU	70	__LINE__, scsi_dev->id, scsi_dev->lun, scsi_dev->channel);
	71
	72	/*
	73	* ATAPI SFF8020 devices use MODE_SENSE_10,
	74	* so we can prohibit MODE_SENSE_6
	75	*/
	76	scsi_dev->use_10_for_ms = 1;
	77
	78	/* we don't support {READ,WRITE}_6 */
	79	scsi_dev->use_10_for_rw = 1;
	80
	81	return 0;
	82	}
	83
9aea8cbf GU	84	static int ps3rom_atapi_request(struct ps3_storage_device *dev,
	85	struct scsi_cmnd *cmd)
	86	{
	87	struct lv1_atapi_cmnd_block atapi_cmnd;
	88	unsigned char opcode = cmd->cmnd[0];
	89	int res;
	90	u64 lpar;
	91
	92	dev_dbg(&dev->sbd.core, "%s:%u: send ATAPI command 0x%02x\n", __func__,
	93	__LINE__, opcode);
	94
	95	memset(&atapi_cmnd, 0, sizeof(struct lv1_atapi_cmnd_block));
	96	memcpy(&atapi_cmnd.pkt, cmd->cmnd, 12);
	97	atapi_cmnd.pktlen = 12;
	98	atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */
35814740	99	atapi_cmnd.blocks = atapi_cmnd.arglen = scsi_bufflen(cmd);
9aea8cbf GU	100	atapi_cmnd.buffer = dev->bounce_lpar;
	101
	102	switch (cmd->sc_data_direction) {
	103	case DMA_FROM_DEVICE:
35814740	104	if (scsi_bufflen(cmd) >= CD_FRAMESIZE)
9aea8cbf GU	105	atapi_cmnd.proto = DMA_PROTO;
	106	else
	107	atapi_cmnd.proto = PIO_DATA_IN_PROTO;
	108	atapi_cmnd.in_out = DIR_READ;
	109	break;
	110
	111	case DMA_TO_DEVICE:
35814740	112	if (scsi_bufflen(cmd) >= CD_FRAMESIZE)
9aea8cbf GU	113	atapi_cmnd.proto = DMA_PROTO;
	114	else
	115	atapi_cmnd.proto = PIO_DATA_OUT_PROTO;
	116	atapi_cmnd.in_out = DIR_WRITE;
944cf8b4	117	scsi_sg_copy_to_buffer(cmd, dev->bounce_buf, dev->bounce_size);
9aea8cbf GU	118	break;
	119
	120	default:
	121	atapi_cmnd.proto = NON_DATA_PROTO;
	122	break;
	123	}
	124
	125	lpar = ps3_mm_phys_to_lpar(__pa(&atapi_cmnd));
	126	res = lv1_storage_send_device_command(dev->sbd.dev_id,
	127	LV1_STORAGE_SEND_ATAPI_COMMAND,
	128	lpar, sizeof(atapi_cmnd),
	129	atapi_cmnd.buffer,
	130	atapi_cmnd.arglen, &dev->tag);
	131	if (res == LV1_DENIED_BY_POLICY) {
	132	dev_dbg(&dev->sbd.core,
	133	"%s:%u: ATAPI command 0x%02x denied by policy\n",
	134	__func__, __LINE__, opcode);
	135	return DID_ERROR << 16;
	136	}
	137
	138	if (res) {
	139	dev_err(&dev->sbd.core,
	140	"%s:%u: ATAPI command 0x%02x failed %d\n", __func__,
	141	__LINE__, opcode, res);
	142	return DID_ERROR << 16;
	143	}
	144
	145	return 0;
	146	}
	147
	148	static inline unsigned int srb10_lba(const struct scsi_cmnd *cmd)
	149	{
	150	return cmd->cmnd[2] << 24 \| cmd->cmnd[3] << 16 \| cmd->cmnd[4] << 8 \|
	151	cmd->cmnd[5];
	152	}
	153
	154	static inline unsigned int srb10_len(const struct scsi_cmnd *cmd)
	155	{
	156	return cmd->cmnd[7] << 8 \| cmd->cmnd[8];
	157	}
	158
	159	static int ps3rom_read_request(struct ps3_storage_device *dev,
	160	struct scsi_cmnd *cmd, u32 start_sector,
	161	u32 sectors)
	162	{
	163	int res;
	164
	165	dev_dbg(&dev->sbd.core, "%s:%u: read %u sectors starting at %u\n",
	166	__func__, __LINE__, sectors, start_sector);
	167
	168	res = lv1_storage_read(dev->sbd.dev_id,
	169	dev->regions[dev->region_idx].id, start_sector,
	170	sectors, 0, dev->bounce_lpar, &dev->tag);
	171	if (res) {
	172	dev_err(&dev->sbd.core, "%s:%u: read failed %d\n", __func__,
	173	__LINE__, res);
	174	return DID_ERROR << 16;
	175	}
	176
	177	return 0;
	178	}
	179
	180	static int ps3rom_write_request(struct ps3_storage_device *dev,
	181	struct scsi_cmnd *cmd, u32 start_sector,
182	u32 sectors)
183	{
184	int res;
185
186	dev_dbg(&dev->sbd.core, "%s:%u: write %u sectors starting at %u\n",
187	__func__, __LINE__, sectors, start_sector);
188
944cf8b4	189	scsi_sg_copy_to_buffer(cmd, dev->bounce_buf, dev->bounce_size);
9aea8cbf GU	190
	191	res = lv1_storage_write(dev->sbd.dev_id,
	192	dev->regions[dev->region_idx].id, start_sector,
	193	sectors, 0, dev->bounce_lpar, &dev->tag);
	194	if (res) {
	195	dev_err(&dev->sbd.core, "%s:%u: write failed %d\n", __func__,
	196	__LINE__, res);
	197	return DID_ERROR << 16;
	198	}
	199
	200	return 0;
	201	}
	202
f281233d	203	static int ps3rom_queuecommand_lck(struct scsi_cmnd *cmd,
9aea8cbf GU	204	void (done)(struct scsi_cmnd ))
	205	{
	206	struct ps3rom_private *priv = shost_priv(cmd->device->host);
	207	struct ps3_storage_device *dev = priv->dev;
	208	unsigned char opcode;
	209	int res;
	210
9aea8cbf GU	211	priv->curr_cmd = cmd;
	212	cmd->scsi_done = done;
	213
	214	opcode = cmd->cmnd[0];
	215	/*
	216	* While we can submit READ/WRITE SCSI commands as ATAPI commands,
	217	* it's recommended for various reasons (performance, error handling,
	218	* ...) to use lv1_storage_{read,write}() instead
	219	*/
	220	switch (opcode) {
	221	case READ_10:
	222	res = ps3rom_read_request(dev, cmd, srb10_lba(cmd),
	223	srb10_len(cmd));
	224	break;
	225
	226	case WRITE_10:
	227	res = ps3rom_write_request(dev, cmd, srb10_lba(cmd),
	228	srb10_len(cmd));
	229	break;
	230
	231	default:
	232	res = ps3rom_atapi_request(dev, cmd);
	233	break;
	234	}
	235
	236	if (res) {
	237	memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
	238	cmd->result = res;
	239	cmd->sense_buffer[0] = 0x70;
	240	cmd->sense_buffer[2] = ILLEGAL_REQUEST;
	241	priv->curr_cmd = NULL;
	242	cmd->scsi_done(cmd);
	243	}
	244
	245	return 0;
	246	}
	247
f281233d JG	248	static DEF_SCSI_QCMD(ps3rom_queuecommand)
f281233d JG	249
9aea8cbf GU	250	static int decode_lv1_status(u64 status, unsigned char *sense_key,
	251	unsigned char asc, unsigned char ascq)
	252	{
	253	if (((status >> 24) & 0xff) != SAM_STAT_CHECK_CONDITION)
	254	return -1;
	255
	256	*sense_key = (status >> 16) & 0xff;
	257	*asc = (status >> 8) & 0xff;
	258	*ascq = status & 0xff;
	259	return 0;
	260	}
	261
	262	static irqreturn_t ps3rom_interrupt(int irq, void *data)
	263	{
	264	struct ps3_storage_device *dev = data;
	265	struct Scsi_Host *host;
	266	struct ps3rom_private *priv;
	267	struct scsi_cmnd *cmd;
	268	int res;
	269	u64 tag, status;
	270	unsigned char sense_key, asc, ascq;
	271
	272	res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
	273	/*
	274	* status = -1 may mean that ATAPI transport completed OK, but
	275	* ATAPI command itself resulted CHECK CONDITION
	276	* so, upper layer should issue REQUEST_SENSE to check the sense data
	277	*/
	278
	279	if (tag != dev->tag)
	280	dev_err(&dev->sbd.core,
7ad489e3	281	"%s:%u: tag mismatch, got %llx, expected %llx\n",
9aea8cbf GU	282	__func__, __LINE__, tag, dev->tag);
	283
	284	if (res) {
7ad489e3	285	dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
9aea8cbf GU	286	__func__, __LINE__, res, status);
	287	return IRQ_HANDLED;
	288	}
	289
c4b512bc	290	host = ps3_system_bus_get_drvdata(&dev->sbd);
9aea8cbf GU	291	priv = shost_priv(host);
	292	cmd = priv->curr_cmd;
	293
	294	if (!status) {
	295	/* OK, completed */
	296	if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
944cf8b4 FT	297	int len;
	298
	299	len = scsi_sg_copy_from_buffer(cmd,
	300	dev->bounce_buf,
	301	dev->bounce_size);
	302
	303	scsi_set_resid(cmd, scsi_bufflen(cmd) - len);
9aea8cbf GU	304	}
	305	cmd->result = DID_OK << 16;
	306	goto done;
	307	}
	308
	309	if (cmd->cmnd[0] == REQUEST_SENSE) {
	310	/* SCSI spec says request sense should never get error */
	311	dev_err(&dev->sbd.core, "%s:%u: end error without autosense\n",
	312	__func__, __LINE__);
	313	cmd->result = DID_ERROR << 16 \| SAM_STAT_CHECK_CONDITION;
	314	goto done;
	315	}
	316
	317	if (decode_lv1_status(status, &sense_key, &asc, &ascq)) {
	318	cmd->result = DID_ERROR << 16;
	319	goto done;
	320	}
	321
53df8ba8	322	scsi_build_sense_buffer(0, cmd->sense_buffer, sense_key, asc, ascq);
9aea8cbf GU	323	cmd->result = SAM_STAT_CHECK_CONDITION;
	324
	325	done:
	326	priv->curr_cmd = NULL;
	327	cmd->scsi_done(cmd);
	328	return IRQ_HANDLED;
	329	}
	330
	331	static struct scsi_host_template ps3rom_host_template = {
	332	.name = DEVICE_NAME,
	333	.slave_configure = ps3rom_slave_configure,
	334	.queuecommand = ps3rom_queuecommand,
	335	.can_queue = 1,
	336	.this_id = 7,
	337	.sg_tablesize = SG_ALL,
9aea8cbf GU	338	.emulated = 1, /* only sg driver uses this */
9aea8cbf GU	339	.max_sectors = PS3ROM_MAX_SECTORS,
9aea8cbf GU	340	.module = THIS_MODULE,
	341	};
	342
	343
6f039790	344	static int ps3rom_probe(struct ps3_system_bus_device *_dev)
9aea8cbf GU	345	{
	346	struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
	347	int error;
	348	struct Scsi_Host *host;
	349	struct ps3rom_private *priv;
	350
	351	if (dev->blk_size != CD_FRAMESIZE) {
	352	dev_err(&dev->sbd.core,
7ad489e3	353	"%s:%u: cannot handle block size %llu\n", __func__,
9aea8cbf GU	354	__LINE__, dev->blk_size);
	355	return -EINVAL;
	356	}
	357
	358	dev->bounce_size = BOUNCE_SIZE;
	359	dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
	360	if (!dev->bounce_buf)
	361	return -ENOMEM;
	362
	363	error = ps3stor_setup(dev, ps3rom_interrupt);
	364	if (error)
	365	goto fail_free_bounce;
	366
	367	host = scsi_host_alloc(&ps3rom_host_template,
	368	sizeof(struct ps3rom_private));
	369	if (!host) {
	370	dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed\n",
	371	__func__, __LINE__);
af222097	372	error = -ENOMEM;
9aea8cbf GU	373	goto fail_teardown;
	374	}
	375
	376	priv = shost_priv(host);
c4b512bc	377	ps3_system_bus_set_drvdata(&dev->sbd, host);
9aea8cbf GU	378	priv->dev = dev;
	379
	380	/* One device/LUN per SCSI bus */
	381	host->max_id = 1;
	382	host->max_lun = 1;
	383
	384	error = scsi_add_host(host, &dev->sbd.core);
	385	if (error) {
	386	dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed %d\n",
	387	__func__, __LINE__, error);
	388	error = -ENODEV;
	389	goto fail_host_put;
	390	}
	391
	392	scsi_scan_host(host);
	393	return 0;
	394
	395	fail_host_put:
	396	scsi_host_put(host);
c4b512bc	397	ps3_system_bus_set_drvdata(&dev->sbd, NULL);
9aea8cbf GU	398	fail_teardown:
	399	ps3stor_teardown(dev);
	400	fail_free_bounce:
	401	kfree(dev->bounce_buf);
	402	return error;
	403	}
	404
	405	static int ps3rom_remove(struct ps3_system_bus_device *_dev)
	406	{
	407	struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
c4b512bc	408	struct Scsi_Host *host = ps3_system_bus_get_drvdata(&dev->sbd);
9aea8cbf GU	409
	410	scsi_remove_host(host);
	411	ps3stor_teardown(dev);
	412	scsi_host_put(host);
c4b512bc	413	ps3_system_bus_set_drvdata(&dev->sbd, NULL);
9aea8cbf GU	414	kfree(dev->bounce_buf);
	415	return 0;
	416	}
	417
	418	static struct ps3_system_bus_driver ps3rom = {
	419	.match_id = PS3_MATCH_ID_STOR_ROM,
	420	.core.name = DEVICE_NAME,
	421	.core.owner = THIS_MODULE,
	422	.probe = ps3rom_probe,
	423	.remove = ps3rom_remove
	424	};
	425
	426
	427	static int __init ps3rom_init(void)
	428	{
	429	return ps3_system_bus_driver_register(&ps3rom);
	430	}
	431
	432	static void __exit ps3rom_exit(void)
	433	{
	434	ps3_system_bus_driver_unregister(&ps3rom);
	435	}
	436
	437	module_init(ps3rom_init);
	438	module_exit(ps3rom_exit);
	439
	440	MODULE_LICENSE("GPL");
	441	MODULE_DESCRIPTION("PS3 BD/DVD/CD-ROM Storage Driver");
	442	MODULE_AUTHOR("Sony Corporation");
	443	MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_ROM);