[linux-block.git] / drivers / parport / probe.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Parallel port device probing code
 *
 * Authors:    Carsten Gross, carsten@sol.wohnheim.uni-ulm.de
 *             Philip Blundell <philb@gnu.org>
 */

#include <linux/module.h>
#include <linux/parport.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

static const struct {
	const char *token;
	const char *descr;
} classes[] = {
	{ "",            "Legacy device" },
	{ "PRINTER",     "Printer" },
	{ "MODEM",       "Modem" },
	{ "NET",         "Network device" },
	{ "HDC",       	 "Hard disk" },
	{ "PCMCIA",      "PCMCIA" },
	{ "MEDIA",       "Multimedia device" },
	{ "FDC",         "Floppy disk" },
	{ "PORTS",       "Ports" },
	{ "SCANNER",     "Scanner" },
	{ "DIGICAM",     "Digital camera" },
	{ "",            "Unknown device" },
	{ "",            "Unspecified" },
	{ "SCSIADAPTER", "SCSI adapter" },
	{ NULL,          NULL }
};

static void pretty_print(struct parport *port, int device)
{
	struct parport_device_info *info = &port->probe_info[device + 1];

	pr_info("%s", port->name);

	if (device >= 0)
		pr_cont(" (addr %d)", device);

	pr_cont(": %s", classes[info->class].descr);
	if (info->class)
		pr_cont(", %s %s", info->mfr, info->model);

	pr_cont("\n");
}

static void parse_data(struct parport *port, int device, char *str)
{
	char *txt = kmalloc(strlen(str)+1, GFP_KERNEL);
	char *p = txt, *q;
	int guessed_class = PARPORT_CLASS_UNSPEC;
	struct parport_device_info *info = &port->probe_info[device + 1];

	if (!txt) {
		pr_warn("%s probe: memory squeeze\n", port->name);
		return;
	}
	strcpy(txt, str);
	while (p) {
		char *sep;
		q = strchr(p, ';');
		if (q) *q = 0;
		sep = strchr(p, ':');
		if (sep) {
			char *u;
			*(sep++) = 0;
			/* Get rid of trailing blanks */
			u = sep + strlen (sep) - 1;
			while (u >= p && *u == ' ')
				*u-- = '\0';
			u = p;
			while (*u) {
				*u = toupper(*u);
				u++;
			}
			if (!strcmp(p, "MFG") || !strcmp(p, "MANUFACTURER")) {
				kfree(info->mfr);
				info->mfr = kstrdup(sep, GFP_KERNEL);
			} else if (!strcmp(p, "MDL") || !strcmp(p, "MODEL")) {
				kfree(info->model);
				info->model = kstrdup(sep, GFP_KERNEL);
			} else if (!strcmp(p, "CLS") || !strcmp(p, "CLASS")) {
				int i;

				kfree(info->class_name);
				info->class_name = kstrdup(sep, GFP_KERNEL);
				for (u = sep; *u; u++)
					*u = toupper(*u);
				for (i = 0; classes[i].token; i++) {
					if (!strcmp(classes[i].token, sep)) {
						info->class = i;
						goto rock_on;
					}
				}
				pr_warn("%s probe: warning, class '%s' not understood\n",
					port->name, sep);
				info->class = PARPORT_CLASS_OTHER;
			} else if (!strcmp(p, "CMD") ||
				   !strcmp(p, "COMMAND SET")) {
				kfree(info->cmdset);
				info->cmdset = kstrdup(sep, GFP_KERNEL);
				/* if it speaks printer language, it's
				   probably a printer */
				if (strstr(sep, "PJL") || strstr(sep, "PCL"))
					guessed_class = PARPORT_CLASS_PRINTER;
			} else if (!strcmp(p, "DES") || !strcmp(p, "DESCRIPTION")) {
				kfree(info->description);
				info->description = kstrdup(sep, GFP_KERNEL);
			}
		}
	rock_on:
		if (q)
			p = q + 1;
		else
			p = NULL;
	}

	/* If the device didn't tell us its class, maybe we have managed to
	   guess one from the things it did say. */
	if (info->class == PARPORT_CLASS_UNSPEC)
		info->class = guessed_class;

	pretty_print (port, device);

	kfree(txt);
}

/* Read up to count-1 bytes of device id. Terminate buffer with
 * '\0'. Buffer begins with two Device ID length bytes as given by
 * device. */
static ssize_t parport_read_device_id (struct parport *port, char *buffer,
				       size_t count)
{
	unsigned char length[2];
	unsigned lelen, belen;
	size_t idlens[4];
	unsigned numidlens;
	unsigned current_idlen;
	ssize_t retval;
	size_t len;

	/* First two bytes are MSB,LSB of inclusive length. */
	retval = parport_read (port, length, 2);

	if (retval < 0)
		return retval;
	if (retval != 2)
		return -EIO;

	if (count < 2)
		return 0;
	memcpy(buffer, length, 2);
	len = 2;

	/* Some devices wrongly send LE length, and some send it two
	 * bytes short. Construct a sorted array of lengths to try. */
	belen = (length[0] << 8) + length[1];
	lelen = (length[1] << 8) + length[0];
	idlens[0] = min(belen, lelen);
	idlens[1] = idlens[0]+2;
	if (belen != lelen) {
		int off = 2;
		/* Don't try lengths of 0x100 and 0x200 as 1 and 2 */
		if (idlens[0] <= 2)
			off = 0;
		idlens[off] = max(belen, lelen);
		idlens[off+1] = idlens[off]+2;
		numidlens = off+2;
	}
	else {
		/* Some devices don't truly implement Device ID, but
		 * just return constant nibble forever. This catches
		 * also those cases. */
		if (idlens[0] == 0 || idlens[0] > 0xFFF) {
			printk(KERN_DEBUG "%s: reported broken Device ID length of %#zX bytes\n",
			       port->name, idlens[0]);
			return -EIO;
		}
		numidlens = 2;
	}

	/* Try to respect the given ID length despite all the bugs in
	 * the ID length. Read according to shortest possible ID
	 * first. */
	for (current_idlen = 0; current_idlen < numidlens; ++current_idlen) {
		size_t idlen = idlens[current_idlen];
		if (idlen+1 >= count)
			break;

		retval = parport_read (port, buffer+len, idlen-len);

		if (retval < 0)
			return retval;
		len += retval;

		if (port->physport->ieee1284.phase != IEEE1284_PH_HBUSY_DAVAIL) {
			if (belen != len) {
				printk(KERN_DEBUG "%s: Device ID was %zd bytes while device told it would be %d bytes\n",
				       port->name, len, belen);
			}
			goto done;
		}

		/* This might end reading the Device ID too
		 * soon. Hopefully the needed fields were already in
		 * the first 256 bytes or so that we must have read so
		 * far. */
		if (buffer[len-1] == ';') {
			printk(KERN_DEBUG "%s: Device ID reading stopped before device told data not available. Current idlen %u of %u, len bytes %02X %02X\n",
			       port->name, current_idlen, numidlens,
			       length[0], length[1]);
			goto done;
		}
	}
	if (current_idlen < numidlens) {
		/* Buffer not large enough, read to end of buffer. */
		size_t idlen, len2;
		if (len+1 < count) {
			retval = parport_read (port, buffer+len, count-len-1);
			if (retval < 0)
				return retval;
			len += retval;
		}
		/* Read the whole ID since some devices would not
		 * otherwise give back the Device ID from beginning
		 * next time when asked. */
		idlen = idlens[current_idlen];
		len2 = len;
		while(len2 < idlen && retval > 0) {
			char tmp[4];
			retval = parport_read (port, tmp,
					       min(sizeof tmp, idlen-len2));
			if (retval < 0)
				return retval;
			len2 += retval;
		}
	}
	/* In addition, there are broken devices out there that don't
	   even finish off with a semi-colon. We do not need to care
	   about those at this time. */
 done:
	buffer[len] = '\0';
	return len;
}

/* Get Std 1284 Device ID. */
ssize_t parport_device_id (int devnum, char *buffer, size_t count)
{
	ssize_t retval = -ENXIO;
	struct pardevice *dev = parport_open(devnum, daisy_dev_name);
	if (!dev)
		return -ENXIO;

	parport_claim_or_block (dev);

	/* Negotiate to compatibility mode, and then to device ID
	 * mode. (This so that we start form beginning of device ID if
	 * already in device ID mode.) */
	parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
	retval = parport_negotiate (dev->port,
				    IEEE1284_MODE_NIBBLE | IEEE1284_DEVICEID);

	if (!retval) {
		retval = parport_read_device_id (dev->port, buffer, count);
		parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
		if (retval > 2)
			parse_data (dev->port, dev->daisy, buffer+2);
	}

	parport_release (dev);
	parport_close (dev);
	return retval;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
612de10d	2	/*
1da177e4 LT	3	* Parallel port device probing code
	4	*
	5	* Authors: Carsten Gross, carsten@sol.wohnheim.uni-ulm.de
	6	* Philip Blundell <philb@gnu.org>
	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/parport.h>
	11	#include <linux/ctype.h>
	12	#include <linux/string.h>
5a0e3ad6	13	#include <linux/slab.h>
7c0f6ba6	14	#include <linux/uaccess.h>
1da177e4	15
a6767b7c MK	16	static const struct {
	17	const char *token;
	18	const char *descr;
1da177e4 LT	19	} classes[] = {
	20	{ "", "Legacy device" },
	21	{ "PRINTER", "Printer" },
	22	{ "MODEM", "Modem" },
	23	{ "NET", "Network device" },
	24	{ "HDC", "Hard disk" },
	25	{ "PCMCIA", "PCMCIA" },
	26	{ "MEDIA", "Multimedia device" },
	27	{ "FDC", "Floppy disk" },
	28	{ "PORTS", "Ports" },
	29	{ "SCANNER", "Scanner" },
	30	{ "DIGICAM", "Digital camera" },
	31	{ "", "Unknown device" },
	32	{ "", "Unspecified" },
	33	{ "SCSIADAPTER", "SCSI adapter" },
	34	{ NULL, NULL }
	35	};
	36
	37	static void pretty_print(struct parport *port, int device)
	38	{
	39	struct parport_device_info *info = &port->probe_info[device + 1];
	40
decf26f6	41	pr_info("%s", port->name);
1da177e4 LT	42
1da177e4 LT	43	if (device >= 0)
aa3d6e7c	44	pr_cont(" (addr %d)", device);
1da177e4	45
aa3d6e7c	46	pr_cont(": %s", classes[info->class].descr);
1da177e4	47	if (info->class)
aa3d6e7c	48	pr_cont(", %s %s", info->mfr, info->model);
1da177e4	49
aa3d6e7c	50	pr_cont("\n");
1da177e4 LT	51	}
1da177e4 LT	52
1da177e4 LT	53	static void parse_data(struct parport port, int device, char str)
	54	{
	55	char *txt = kmalloc(strlen(str)+1, GFP_KERNEL);
	56	char p = txt, q;
	57	int guessed_class = PARPORT_CLASS_UNSPEC;
	58	struct parport_device_info *info = &port->probe_info[device + 1];
	59
	60	if (!txt) {
decf26f6	61	pr_warn("%s probe: memory squeeze\n", port->name);
1da177e4 LT	62	return;
	63	}
	64	strcpy(txt, str);
	65	while (p) {
	66	char *sep;
	67	q = strchr(p, ';');
	68	if (q) *q = 0;
	69	sep = strchr(p, ':');
	70	if (sep) {
	71	char *u;
	72	*(sep++) = 0;
	73	/* Get rid of trailing blanks */
	74	u = sep + strlen (sep) - 1;
	75	while (u >= p && *u == ' ')
	76	*u-- = '\0';
	77	u = p;
	78	while (*u) {
	79	u = toupper(u);
	80	u++;
	81	}
	82	if (!strcmp(p, "MFG") \|\| !strcmp(p, "MANUFACTURER")) {
6044ec88	83	kfree(info->mfr);
543537bd	84	info->mfr = kstrdup(sep, GFP_KERNEL);
1da177e4	85	} else if (!strcmp(p, "MDL") \|\| !strcmp(p, "MODEL")) {
6044ec88	86	kfree(info->model);
543537bd	87	info->model = kstrdup(sep, GFP_KERNEL);
1da177e4 LT	88	} else if (!strcmp(p, "CLS") \|\| !strcmp(p, "CLASS")) {
1da177e4 LT	89	int i;
6044ec88 JJ	90
6044ec88 JJ	91	kfree(info->class_name);
543537bd	92	info->class_name = kstrdup(sep, GFP_KERNEL);
1da177e4 LT	93	for (u = sep; *u; u++)
	94	u = toupper(u);
	95	for (i = 0; classes[i].token; i++) {
	96	if (!strcmp(classes[i].token, sep)) {
	97	info->class = i;
	98	goto rock_on;
	99	}
	100	}
decf26f6 JP	101	pr_warn("%s probe: warning, class '%s' not understood\n",
decf26f6 JP	102	port->name, sep);
1da177e4 LT	103	info->class = PARPORT_CLASS_OTHER;
	104	} else if (!strcmp(p, "CMD") \|\|
	105	!strcmp(p, "COMMAND SET")) {
6044ec88	106	kfree(info->cmdset);
543537bd	107	info->cmdset = kstrdup(sep, GFP_KERNEL);
1da177e4 LT	108	/* if it speaks printer language, it's
	109	probably a printer */
	110	if (strstr(sep, "PJL") \|\| strstr(sep, "PCL"))
	111	guessed_class = PARPORT_CLASS_PRINTER;
	112	} else if (!strcmp(p, "DES") \|\| !strcmp(p, "DESCRIPTION")) {
6044ec88	113	kfree(info->description);
543537bd	114	info->description = kstrdup(sep, GFP_KERNEL);
1da177e4 LT	115	}
	116	}
	117	rock_on:
6044ec88 JJ	118	if (q)
	119	p = q + 1;
	120	else
	121	p = NULL;
1da177e4 LT	122	}
	123
	124	/* If the device didn't tell us its class, maybe we have managed to
	125	guess one from the things it did say. */
	126	if (info->class == PARPORT_CLASS_UNSPEC)
	127	info->class = guessed_class;
	128
	129	pretty_print (port, device);
	130
	131	kfree(txt);
	132	}
	133
c6606290 MK	134	/* Read up to count-1 bytes of device id. Terminate buffer with
	135	* '\0'. Buffer begins with two Device ID length bytes as given by
	136	* device. */
	137	static ssize_t parport_read_device_id (struct parport port, char buffer,
	138	size_t count)
	139	{
	140	unsigned char length[2];
	141	unsigned lelen, belen;
	142	size_t idlens[4];
	143	unsigned numidlens;
	144	unsigned current_idlen;
	145	ssize_t retval;
	146	size_t len;
	147
	148	/* First two bytes are MSB,LSB of inclusive length. */
	149	retval = parport_read (port, length, 2);
	150
	151	if (retval < 0)
	152	return retval;
	153	if (retval != 2)
	154	return -EIO;
	155
	156	if (count < 2)
	157	return 0;
	158	memcpy(buffer, length, 2);
	159	len = 2;
	160
	161	/* Some devices wrongly send LE length, and some send it two
	162	* bytes short. Construct a sorted array of lengths to try. */
	163	belen = (length[0] << 8) + length[1];
	164	lelen = (length[1] << 8) + length[0];
	165	idlens[0] = min(belen, lelen);
	166	idlens[1] = idlens[0]+2;
	167	if (belen != lelen) {
	168	int off = 2;
efad798b	169	/* Don't try lengths of 0x100 and 0x200 as 1 and 2 */
c6606290 MK	170	if (idlens[0] <= 2)
	171	off = 0;
	172	idlens[off] = max(belen, lelen);
	173	idlens[off+1] = idlens[off]+2;
	174	numidlens = off+2;
	175	}
	176	else {
	177	/* Some devices don't truly implement Device ID, but
	178	* just return constant nibble forever. This catches
	179	* also those cases. */
	180	if (idlens[0] == 0 \|\| idlens[0] > 0xFFF) {
aa3d6e7c JP	181	printk(KERN_DEBUG "%s: reported broken Device ID length of %#zX bytes\n",
aa3d6e7c JP	182	port->name, idlens[0]);
c6606290 MK	183	return -EIO;
	184	}
	185	numidlens = 2;
	186	}
	187
	188	/* Try to respect the given ID length despite all the bugs in
	189	* the ID length. Read according to shortest possible ID
	190	* first. */
	191	for (current_idlen = 0; current_idlen < numidlens; ++current_idlen) {
	192	size_t idlen = idlens[current_idlen];
	193	if (idlen+1 >= count)
	194	break;
	195
	196	retval = parport_read (port, buffer+len, idlen-len);
	197
	198	if (retval < 0)
	199	return retval;
	200	len += retval;
	201
	202	if (port->physport->ieee1284.phase != IEEE1284_PH_HBUSY_DAVAIL) {
	203	if (belen != len) {
aa3d6e7c JP	204	printk(KERN_DEBUG "%s: Device ID was %zd bytes while device told it would be %d bytes\n",
aa3d6e7c JP	205	port->name, len, belen);
c6606290 MK	206	}
	207	goto done;
	208	}
	209
	210	/* This might end reading the Device ID too
	211	* soon. Hopefully the needed fields were already in
	212	* the first 256 bytes or so that we must have read so
	213	* far. */
	214	if (buffer[len-1] == ';') {
aa3d6e7c JP	215	printk(KERN_DEBUG "%s: Device ID reading stopped before device told data not available. Current idlen %u of %u, len bytes %02X %02X\n",
	216	port->name, current_idlen, numidlens,
	217	length[0], length[1]);
c6606290 MK	218	goto done;
	219	}
	220	}
	221	if (current_idlen < numidlens) {
	222	/* Buffer not large enough, read to end of buffer. */
	223	size_t idlen, len2;
	224	if (len+1 < count) {
	225	retval = parport_read (port, buffer+len, count-len-1);
	226	if (retval < 0)
	227	return retval;
	228	len += retval;
	229	}
	230	/* Read the whole ID since some devices would not
	231	* otherwise give back the Device ID from beginning
	232	* next time when asked. */
	233	idlen = idlens[current_idlen];
	234	len2 = len;
	235	while(len2 < idlen && retval > 0) {
	236	char tmp[4];
	237	retval = parport_read (port, tmp,
	238	min(sizeof tmp, idlen-len2));
	239	if (retval < 0)
	240	return retval;
	241	len2 += retval;
	242	}
	243	}
	244	/* In addition, there are broken devices out there that don't
	245	even finish off with a semi-colon. We do not need to care
	246	about those at this time. */
	247	done:
	248	buffer[len] = '\0';
	249	return len;
	250	}
	251
1da177e4	252	/* Get Std 1284 Device ID. */
c6606290	253	ssize_t parport_device_id (int devnum, char *buffer, size_t count)
1da177e4 LT	254	{
1da177e4 LT	255	ssize_t retval = -ENXIO;
c059d579	256	struct pardevice *dev = parport_open(devnum, daisy_dev_name);
1da177e4 LT	257	if (!dev)
	258	return -ENXIO;
	259
	260	parport_claim_or_block (dev);
	261
c6606290 MK	262	/* Negotiate to compatibility mode, and then to device ID
	263	* mode. (This so that we start form beginning of device ID if
	264	* already in device ID mode.) */
1da177e4 LT	265	parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
	266	retval = parport_negotiate (dev->port,
	267	IEEE1284_MODE_NIBBLE \| IEEE1284_DEVICEID);
	268
	269	if (!retval) {
c6606290	270	retval = parport_read_device_id (dev->port, buffer, count);
1da177e4	271	parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
c6606290 MK	272	if (retval > 2)
c6606290 MK	273	parse_data (dev->port, dev->daisy, buffer+2);
1da177e4 LT	274	}
1da177e4 LT	275
1da177e4 LT	276	parport_release (dev);
	277	parport_close (dev);
	278	return retval;
	279	}