[linux-block.git] / drivers / usb / storage / sierra_ms.c

// SPDX-License-Identifier: GPL-2.0
#include <scsi/scsi.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <linux/usb.h>
#include <linux/module.h>
#include <linux/slab.h>

#include "usb.h"
#include "transport.h"
#include "protocol.h"
#include "scsiglue.h"
#include "sierra_ms.h"
#include "debug.h"

#define SWIMS_USB_REQUEST_SetSwocMode	0x0B
#define SWIMS_USB_REQUEST_GetSwocInfo	0x0A
#define SWIMS_USB_INDEX_SetMode		0x0000
#define SWIMS_SET_MODE_Modem		0x0001

#define TRU_NORMAL 			0x01
#define TRU_FORCE_MS 			0x02
#define TRU_FORCE_MODEM 		0x03

static unsigned int swi_tru_install = 1;
module_param(swi_tru_install, uint, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(swi_tru_install, "TRU-Install mode (1=Full Logic (def),"
		 " 2=Force CD-Rom, 3=Force Modem)");

struct swoc_info {
	__u8 rev;
	__u8 reserved[8];
	__u16 LinuxSKU;
	__u16 LinuxVer;
	__u8 reserved2[47];
} __attribute__((__packed__));

static bool containsFullLinuxPackage(struct swoc_info *swocInfo)
{
	if ((swocInfo->LinuxSKU >= 0x2100 && swocInfo->LinuxSKU <= 0x2FFF) ||
	   (swocInfo->LinuxSKU >= 0x7100 && swocInfo->LinuxSKU <= 0x7FFF))
		return true;
	else
		return false;
}

static int sierra_set_ms_mode(struct usb_device *udev, __u16 eSWocMode)
{
	int result;
	dev_dbg(&udev->dev, "SWIMS: %s", "DEVICE MODE SWITCH\n");
	result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
			SWIMS_USB_REQUEST_SetSwocMode,	/* __u8 request      */
			USB_TYPE_VENDOR | USB_DIR_OUT,	/* __u8 request type */
			eSWocMode,			/* __u16 value       */
			0x0000,				/* __u16 index       */
			NULL,				/* void *data        */
			0,				/* __u16 size 	     */
			USB_CTRL_SET_TIMEOUT);		/* int timeout       */
	return result;
}


static int sierra_get_swoc_info(struct usb_device *udev,
				struct swoc_info *swocInfo)
{
	int result;

	dev_dbg(&udev->dev, "SWIMS: Attempting to get TRU-Install info\n");

	result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
			SWIMS_USB_REQUEST_GetSwocInfo,	/* __u8 request      */
			USB_TYPE_VENDOR | USB_DIR_IN,	/* __u8 request type */
			0,				/* __u16 value       */
			0,				/* __u16 index       */
			(void *) swocInfo,		/* void *data        */
			sizeof(struct swoc_info),	/* __u16 size 	     */
			USB_CTRL_SET_TIMEOUT);		/* int timeout 	     */

	swocInfo->LinuxSKU = le16_to_cpu(swocInfo->LinuxSKU);
	swocInfo->LinuxVer = le16_to_cpu(swocInfo->LinuxVer);
	return result;
}

static void debug_swoc(const struct device *dev, struct swoc_info *swocInfo)
{
	dev_dbg(dev, "SWIMS: SWoC Rev: %02d\n", swocInfo->rev);
	dev_dbg(dev, "SWIMS: Linux SKU: %04X\n", swocInfo->LinuxSKU);
	dev_dbg(dev, "SWIMS: Linux Version: %04X\n", swocInfo->LinuxVer);
}


static ssize_t show_truinst(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct swoc_info *swocInfo;
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *udev = interface_to_usbdev(intf);
	int result;
	if (swi_tru_install == TRU_FORCE_MS) {
		result = snprintf(buf, PAGE_SIZE, "Forced Mass Storage\n");
	} else {
		swocInfo = kmalloc(sizeof(struct swoc_info), GFP_KERNEL);
		if (!swocInfo) {
			snprintf(buf, PAGE_SIZE, "Error\n");
			return -ENOMEM;
		}
		result = sierra_get_swoc_info(udev, swocInfo);
		if (result < 0) {
			dev_dbg(dev, "SWIMS: failed SWoC query\n");
			kfree(swocInfo);
			snprintf(buf, PAGE_SIZE, "Error\n");
			return -EIO;
		}
		debug_swoc(dev, swocInfo);
		result = snprintf(buf, PAGE_SIZE,
			"REV=%02d SKU=%04X VER=%04X\n",
			swocInfo->rev,
			swocInfo->LinuxSKU,
			swocInfo->LinuxVer);
		kfree(swocInfo);
	}
	return result;
}
static DEVICE_ATTR(truinst, S_IRUGO, show_truinst, NULL);

int sierra_ms_init(struct us_data *us)
{
	int result, retries;
	struct swoc_info *swocInfo;
	struct usb_device *udev;
	struct Scsi_Host *sh;

	retries = 3;
	result = 0;
	udev = us->pusb_dev;

	sh = us_to_host(us);
	scsi_get_host_dev(sh);

	/* Force Modem mode */
	if (swi_tru_install == TRU_FORCE_MODEM) {
		usb_stor_dbg(us, "SWIMS: Forcing Modem Mode\n");
		result = sierra_set_ms_mode(udev, SWIMS_SET_MODE_Modem);
		if (result < 0)
			usb_stor_dbg(us, "SWIMS: Failed to switch to modem mode\n");
		return -EIO;
	}
	/* Force Mass Storage mode (keep CD-Rom) */
	else if (swi_tru_install == TRU_FORCE_MS) {
		usb_stor_dbg(us, "SWIMS: Forcing Mass Storage Mode\n");
		goto complete;
	}
	/* Normal TRU-Install Logic */
	else {
		usb_stor_dbg(us, "SWIMS: Normal SWoC Logic\n");

		swocInfo = kmalloc(sizeof(struct swoc_info),
				GFP_KERNEL);
		if (!swocInfo)
			return -ENOMEM;

		retries = 3;
		do {
			retries--;
			result = sierra_get_swoc_info(udev, swocInfo);
			if (result < 0) {
				usb_stor_dbg(us, "SWIMS: Failed SWoC query\n");
				schedule_timeout_uninterruptible(2*HZ);
			}
		} while (retries && result < 0);

		if (result < 0) {
			usb_stor_dbg(us, "SWIMS: Completely failed SWoC query\n");
			kfree(swocInfo);
			return -EIO;
		}

		debug_swoc(&us->pusb_dev->dev, swocInfo);

		/*
		 * If there is not Linux software on the TRU-Install device
		 * then switch to modem mode
		 */
		if (!containsFullLinuxPackage(swocInfo)) {
			usb_stor_dbg(us, "SWIMS: Switching to Modem Mode\n");
			result = sierra_set_ms_mode(udev,
				SWIMS_SET_MODE_Modem);
			if (result < 0)
				usb_stor_dbg(us, "SWIMS: Failed to switch modem\n");
			kfree(swocInfo);
			return -EIO;
		}
		kfree(swocInfo);
	}
complete:
	result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst);

	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
32fe5e39 KL	2	#include <scsi/scsi.h>
	3	#include <scsi/scsi_host.h>
	4	#include <scsi/scsi_cmnd.h>
	5	#include <scsi/scsi_device.h>
	6	#include <linux/usb.h>
6eb0de82	7	#include <linux/module.h>
5a0e3ad6	8	#include <linux/slab.h>
32fe5e39 KL	9
	10	#include "usb.h"
	11	#include "transport.h"
	12	#include "protocol.h"
	13	#include "scsiglue.h"
	14	#include "sierra_ms.h"
	15	#include "debug.h"
	16
	17	#define SWIMS_USB_REQUEST_SetSwocMode 0x0B
	18	#define SWIMS_USB_REQUEST_GetSwocInfo 0x0A
	19	#define SWIMS_USB_INDEX_SetMode 0x0000
	20	#define SWIMS_SET_MODE_Modem 0x0001
	21
	22	#define TRU_NORMAL 0x01
	23	#define TRU_FORCE_MS 0x02
	24	#define TRU_FORCE_MODEM 0x03
	25
	26	static unsigned int swi_tru_install = 1;
	27	module_param(swi_tru_install, uint, S_IRUGO \| S_IWUSR);
	28	MODULE_PARM_DESC(swi_tru_install, "TRU-Install mode (1=Full Logic (def),"
	29	" 2=Force CD-Rom, 3=Force Modem)");
	30
	31	struct swoc_info {
	32	__u8 rev;
	33	__u8 reserved[8];
	34	__u16 LinuxSKU;
	35	__u16 LinuxVer;
	36	__u8 reserved2[47];
	37	} __attribute__((__packed__));
	38
	39	static bool containsFullLinuxPackage(struct swoc_info *swocInfo)
	40	{
	41	if ((swocInfo->LinuxSKU >= 0x2100 && swocInfo->LinuxSKU <= 0x2FFF) \|\|
	42	(swocInfo->LinuxSKU >= 0x7100 && swocInfo->LinuxSKU <= 0x7FFF))
	43	return true;
	44	else
	45	return false;
	46	}
	47
	48	static int sierra_set_ms_mode(struct usb_device *udev, __u16 eSWocMode)
	49	{
	50	int result;
191648d0	51	dev_dbg(&udev->dev, "SWIMS: %s", "DEVICE MODE SWITCH\n");
32fe5e39 KL	52	result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
	53	SWIMS_USB_REQUEST_SetSwocMode, /* __u8 request */
	54	USB_TYPE_VENDOR \| USB_DIR_OUT, /* __u8 request type */
	55	eSWocMode, /* __u16 value */
	56	0x0000, /* __u16 index */
	57	NULL, /* void data /
	58	0, /* __u16 size */
	59	USB_CTRL_SET_TIMEOUT); /* int timeout */
	60	return result;
	61	}
	62
	63
	64	static int sierra_get_swoc_info(struct usb_device *udev,
	65	struct swoc_info *swocInfo)
	66	{
	67	int result;
	68
191648d0	69	dev_dbg(&udev->dev, "SWIMS: Attempting to get TRU-Install info\n");
32fe5e39 KL	70
	71	result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
	72	SWIMS_USB_REQUEST_GetSwocInfo, /* __u8 request */
	73	USB_TYPE_VENDOR \| USB_DIR_IN, /* __u8 request type */
	74	0, /* __u16 value */
	75	0, /* __u16 index */
	76	(void ) swocInfo, / void data /
	77	sizeof(struct swoc_info), /* __u16 size */
	78	USB_CTRL_SET_TIMEOUT); /* int timeout */
	79
	80	swocInfo->LinuxSKU = le16_to_cpu(swocInfo->LinuxSKU);
	81	swocInfo->LinuxVer = le16_to_cpu(swocInfo->LinuxVer);
	82	return result;
	83	}
	84
191648d0	85	static void debug_swoc(const struct device dev, struct swoc_info swocInfo)
32fe5e39	86	{
191648d0 JP	87	dev_dbg(dev, "SWIMS: SWoC Rev: %02d\n", swocInfo->rev);
	88	dev_dbg(dev, "SWIMS: Linux SKU: %04X\n", swocInfo->LinuxSKU);
	89	dev_dbg(dev, "SWIMS: Linux Version: %04X\n", swocInfo->LinuxVer);
32fe5e39 KL	90	}
	91
	92
	93	static ssize_t show_truinst(struct device dev, struct device_attribute attr,
	94	char *buf)
	95	{
	96	struct swoc_info *swocInfo;
	97	struct usb_interface *intf = to_usb_interface(dev);
	98	struct usb_device *udev = interface_to_usbdev(intf);
	99	int result;
	100	if (swi_tru_install == TRU_FORCE_MS) {
	101	result = snprintf(buf, PAGE_SIZE, "Forced Mass Storage\n");
	102	} else {
	103	swocInfo = kmalloc(sizeof(struct swoc_info), GFP_KERNEL);
	104	if (!swocInfo) {
32fe5e39 KL	105	snprintf(buf, PAGE_SIZE, "Error\n");
	106	return -ENOMEM;
	107	}
	108	result = sierra_get_swoc_info(udev, swocInfo);
	109	if (result < 0) {
191648d0	110	dev_dbg(dev, "SWIMS: failed SWoC query\n");
32fe5e39 KL	111	kfree(swocInfo);
	112	snprintf(buf, PAGE_SIZE, "Error\n");
	113	return -EIO;
	114	}
191648d0	115	debug_swoc(dev, swocInfo);
32fe5e39 KL	116	result = snprintf(buf, PAGE_SIZE,
	117	"REV=%02d SKU=%04X VER=%04X\n",
	118	swocInfo->rev,
	119	swocInfo->LinuxSKU,
	120	swocInfo->LinuxVer);
	121	kfree(swocInfo);
	122	}
	123	return result;
	124	}
d9624e75	125	static DEVICE_ATTR(truinst, S_IRUGO, show_truinst, NULL);
32fe5e39 KL	126
	127	int sierra_ms_init(struct us_data *us)
	128	{
	129	int result, retries;
32fe5e39 KL	130	struct swoc_info *swocInfo;
	131	struct usb_device *udev;
	132	struct Scsi_Host *sh;
32fe5e39	133
32fe5e39 KL	134	retries = 3;
	135	result = 0;
	136	udev = us->pusb_dev;
	137
	138	sh = us_to_host(us);
0220a3f0	139	scsi_get_host_dev(sh);
32fe5e39	140
32fe5e39 KL	141	/* Force Modem mode */
32fe5e39 KL	142	if (swi_tru_install == TRU_FORCE_MODEM) {
191648d0	143	usb_stor_dbg(us, "SWIMS: Forcing Modem Mode\n");
32fe5e39 KL	144	result = sierra_set_ms_mode(udev, SWIMS_SET_MODE_Modem);
32fe5e39 KL	145	if (result < 0)
191648d0	146	usb_stor_dbg(us, "SWIMS: Failed to switch to modem mode\n");
32fe5e39 KL	147	return -EIO;
	148	}
	149	/* Force Mass Storage mode (keep CD-Rom) */
	150	else if (swi_tru_install == TRU_FORCE_MS) {
191648d0	151	usb_stor_dbg(us, "SWIMS: Forcing Mass Storage Mode\n");
32fe5e39 KL	152	goto complete;
	153	}
	154	/* Normal TRU-Install Logic */
	155	else {
191648d0	156	usb_stor_dbg(us, "SWIMS: Normal SWoC Logic\n");
32fe5e39 KL	157
	158	swocInfo = kmalloc(sizeof(struct swoc_info),
	159	GFP_KERNEL);
191648d0	160	if (!swocInfo)
32fe5e39	161	return -ENOMEM;
32fe5e39 KL	162
	163	retries = 3;
	164	do {
	165	retries--;
	166	result = sierra_get_swoc_info(udev, swocInfo);
	167	if (result < 0) {
191648d0	168	usb_stor_dbg(us, "SWIMS: Failed SWoC query\n");
32fe5e39 KL	169	schedule_timeout_uninterruptible(2*HZ);
	170	}
	171	} while (retries && result < 0);
	172
	173	if (result < 0) {
191648d0	174	usb_stor_dbg(us, "SWIMS: Completely failed SWoC query\n");
32fe5e39 KL	175	kfree(swocInfo);
	176	return -EIO;
	177	}
	178
191648d0	179	debug_swoc(&us->pusb_dev->dev, swocInfo);
32fe5e39	180
f0183a33 FB	181	/*
f0183a33 FB	182	* If there is not Linux software on the TRU-Install device
32fe5e39 KL	183	* then switch to modem mode
	184	*/
	185	if (!containsFullLinuxPackage(swocInfo)) {
191648d0	186	usb_stor_dbg(us, "SWIMS: Switching to Modem Mode\n");
32fe5e39 KL	187	result = sierra_set_ms_mode(udev,
	188	SWIMS_SET_MODE_Modem);
	189	if (result < 0)
191648d0	190	usb_stor_dbg(us, "SWIMS: Failed to switch modem\n");
32fe5e39 KL	191	kfree(swocInfo);
	192	return -EIO;
	193	}
	194	kfree(swocInfo);
	195	}
	196	complete:
	197	result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst);
	198
be475d90	199	return 0;
32fe5e39 KL	200	}
32fe5e39 KL	201