drivers/parport/probe.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   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>
  13 #include <linux/slab.h>
  14 #include <linux/uaccess.h>
  15
  16 static const struct {
  17         const char *token;
  18         const char *descr;
  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
  41         printk(KERN_INFO "%s", port->name);
  42
  43         if (device >= 0)
  44                 printk (" (addr %d)", device);
  45
  46         printk (": %s", classes[info->class].descr);
  47         if (info->class)
  48                 printk(", %s %s", info->mfr, info->model);
  49
  50         printk("\n");
  51 }
  52
  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) {
  61                 printk(KERN_WARNING "%s probe: memory squeeze\n", port->name);
  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")) {
  83                                 kfree(info->mfr);
  84                                 info->mfr = kstrdup(sep, GFP_KERNEL);
  85                         } else if (!strcmp(p, "MDL") || !strcmp(p, "MODEL")) {
  86                                 kfree(info->model);
  87                                 info->model = kstrdup(sep, GFP_KERNEL);
  88                         } else if (!strcmp(p, "CLS") || !strcmp(p, "CLASS")) {
  89                                 int i;
  90
  91                                 kfree(info->class_name);
  92                                 info->class_name = kstrdup(sep, GFP_KERNEL);
  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                                 }
 101                                 printk(KERN_WARNING "%s probe: warning, class '%s' not understood.\n", port->name, sep);
 102                                 info->class = PARPORT_CLASS_OTHER;
 103                         } else if (!strcmp(p, "CMD") ||
 104                                    !strcmp(p, "COMMAND SET")) {
 105                                 kfree(info->cmdset);
 106                                 info->cmdset = kstrdup(sep, GFP_KERNEL);
 107                                 /* if it speaks printer language, it's
 108                                    probably a printer */
 109                                 if (strstr(sep, "PJL") || strstr(sep, "PCL"))
 110                                         guessed_class = PARPORT_CLASS_PRINTER;
 111                         } else if (!strcmp(p, "DES") || !strcmp(p, "DESCRIPTION")) {
 112                                 kfree(info->description);
 113                                 info->description = kstrdup(sep, GFP_KERNEL);
 114                         }
 115                 }
 116         rock_on:
 117                 if (q)
 118                         p = q + 1;
 119                 else
 120                         p = NULL;
 121         }
 122
 123         /* If the device didn't tell us its class, maybe we have managed to
 124            guess one from the things it did say. */
 125         if (info->class == PARPORT_CLASS_UNSPEC)
 126                 info->class = guessed_class;
 127
 128         pretty_print (port, device);
 129
 130         kfree(txt);
 131 }
 132
 133 /* Read up to count-1 bytes of device id. Terminate buffer with
 134  * '\0'. Buffer begins with two Device ID length bytes as given by
 135  * device. */
 136 static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 137                                        size_t count)
 138 {
 139         unsigned char length[2];
 140         unsigned lelen, belen;
 141         size_t idlens[4];
 142         unsigned numidlens;
 143         unsigned current_idlen;
 144         ssize_t retval;
 145         size_t len;
 146
 147         /* First two bytes are MSB,LSB of inclusive length. */
 148         retval = parport_read (port, length, 2);
 149
 150         if (retval < 0)
 151                 return retval;
 152         if (retval != 2)
 153                 return -EIO;
 154
 155         if (count < 2)
 156                 return 0;
 157         memcpy(buffer, length, 2);
 158         len = 2;
 159
 160         /* Some devices wrongly send LE length, and some send it two
 161          * bytes short. Construct a sorted array of lengths to try. */
 162         belen = (length[0] << 8) + length[1];
 163         lelen = (length[1] << 8) + length[0];
 164         idlens[0] = min(belen, lelen);
 165         idlens[1] = idlens[0]+2;
 166         if (belen != lelen) {
 167                 int off = 2;
 168                 /* Don't try lengths of 0x100 and 0x200 as 1 and 2 */
 169                 if (idlens[0] <= 2)
 170                         off = 0;
 171                 idlens[off] = max(belen, lelen);
 172                 idlens[off+1] = idlens[off]+2;
 173                 numidlens = off+2;
 174         }
 175         else {
 176                 /* Some devices don't truly implement Device ID, but
 177                  * just return constant nibble forever. This catches
 178                  * also those cases. */
 179                 if (idlens[0] == 0 || idlens[0] > 0xFFF) {
 180                         printk (KERN_DEBUG "%s: reported broken Device ID"
 181                                 " length of %#zX bytes\n",
 182                                 port->name, idlens[0]);
 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) {
 204                                 printk (KERN_DEBUG "%s: Device ID was %zd bytes"
 205                                         " while device told it would be %d"
 206                                         " bytes\n",
 207                                         port->name, len, belen);
 208                         }
 209                         goto done;
 210                 }
 211
 212                 /* This might end reading the Device ID too
 213                  * soon. Hopefully the needed fields were already in
 214                  * the first 256 bytes or so that we must have read so
 215                  * far. */
 216                 if (buffer[len-1] == ';') {
 217                         printk (KERN_DEBUG "%s: Device ID reading stopped"
 218                                 " before device told data not available. "
 219                                 "Current idlen %u of %u, len bytes %02X %02X\n",
 220                                 port->name, current_idlen, numidlens,
 221                                 length[0], length[1]);
 222                         goto done;
 223                 }
 224         }
 225         if (current_idlen < numidlens) {
 226                 /* Buffer not large enough, read to end of buffer. */
 227                 size_t idlen, len2;
 228                 if (len+1 < count) {
 229                         retval = parport_read (port, buffer+len, count-len-1);
 230                         if (retval < 0)
 231                                 return retval;
 232                         len += retval;
 233                 }
 234                 /* Read the whole ID since some devices would not
 235                  * otherwise give back the Device ID from beginning
 236                  * next time when asked. */
 237                 idlen = idlens[current_idlen];
 238                 len2 = len;
 239                 while(len2 < idlen && retval > 0) {
 240                         char tmp[4];
 241                         retval = parport_read (port, tmp,
 242                                                min(sizeof tmp, idlen-len2));
 243                         if (retval < 0)
 244                                 return retval;
 245                         len2 += retval;
 246                 }
 247         }
 248         /* In addition, there are broken devices out there that don't
 249            even finish off with a semi-colon. We do not need to care
 250            about those at this time. */
 251  done:
 252         buffer[len] = '\0';
 253         return len;
 254 }
 255
 256 /* Get Std 1284 Device ID. */
 257 ssize_t parport_device_id (int devnum, char *buffer, size_t count)
 258 {
 259         ssize_t retval = -ENXIO;
 260         struct pardevice *dev = parport_open (devnum, "Device ID probe");
 261         if (!dev)
 262                 return -ENXIO;
 263
 264         parport_claim_or_block (dev);
 265
 266         /* Negotiate to compatibility mode, and then to device ID
 267          * mode. (This so that we start form beginning of device ID if
 268          * already in device ID mode.) */
 269         parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
 270         retval = parport_negotiate (dev->port,
 271                                     IEEE1284_MODE_NIBBLE | IEEE1284_DEVICEID);
 272
 273         if (!retval) {
 274                 retval = parport_read_device_id (dev->port, buffer, count);
 275                 parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
 276                 if (retval > 2)
 277                         parse_data (dev->port, dev->daisy, buffer+2);
 278         }
 279
 280         parport_release (dev);
 281         parport_close (dev);
 282         return retval;
 283 }