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