Linux-2.6.12-rc2
[linux-2.6.git] / drivers / parport / probe.c
1 /* $Id: parport_probe.c,v 1.1 1999/07/03 08:56:17 davem Exp $
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 struct {
15         char *token;
16         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 char *strdup(char *str)
52 {
53         int n = strlen(str)+1;
54         char *s = kmalloc(n, GFP_KERNEL);
55         if (!s) return NULL;
56         return strcpy(s, str);
57 }
58
59 static void parse_data(struct parport *port, int device, char *str)
60 {
61         char *txt = kmalloc(strlen(str)+1, GFP_KERNEL);
62         char *p = txt, *q;
63         int guessed_class = PARPORT_CLASS_UNSPEC;
64         struct parport_device_info *info = &port->probe_info[device + 1];
65
66         if (!txt) {
67                 printk(KERN_WARNING "%s probe: memory squeeze\n", port->name);
68                 return;
69         }
70         strcpy(txt, str);
71         while (p) {
72                 char *sep;
73                 q = strchr(p, ';');
74                 if (q) *q = 0;
75                 sep = strchr(p, ':');
76                 if (sep) {
77                         char *u;
78                         *(sep++) = 0;
79                         /* Get rid of trailing blanks */
80                         u = sep + strlen (sep) - 1;
81                         while (u >= p && *u == ' ')
82                                 *u-- = '\0';
83                         u = p;
84                         while (*u) {
85                                 *u = toupper(*u);
86                                 u++;
87                         }
88                         if (!strcmp(p, "MFG") || !strcmp(p, "MANUFACTURER")) {
89                                 if (info->mfr)
90                                         kfree (info->mfr);
91                                 info->mfr = strdup(sep);
92                         } else if (!strcmp(p, "MDL") || !strcmp(p, "MODEL")) {
93                                 if (info->model)
94                                         kfree (info->model);
95                                 info->model = strdup(sep);
96                         } else if (!strcmp(p, "CLS") || !strcmp(p, "CLASS")) {
97                                 int i;
98                                 if (info->class_name)
99                                         kfree (info->class_name);
100                                 info->class_name = strdup(sep);
101                                 for (u = sep; *u; u++)
102                                         *u = toupper(*u);
103                                 for (i = 0; classes[i].token; i++) {
104                                         if (!strcmp(classes[i].token, sep)) {
105                                                 info->class = i;
106                                                 goto rock_on;
107                                         }
108                                 }
109                                 printk(KERN_WARNING "%s probe: warning, class '%s' not understood.\n", port->name, sep);
110                                 info->class = PARPORT_CLASS_OTHER;
111                         } else if (!strcmp(p, "CMD") ||
112                                    !strcmp(p, "COMMAND SET")) {
113                                 if (info->cmdset)
114                                         kfree (info->cmdset);
115                                 info->cmdset = strdup(sep);
116                                 /* if it speaks printer language, it's
117                                    probably a printer */
118                                 if (strstr(sep, "PJL") || strstr(sep, "PCL"))
119                                         guessed_class = PARPORT_CLASS_PRINTER;
120                         } else if (!strcmp(p, "DES") || !strcmp(p, "DESCRIPTION")) {
121                                 if (info->description)
122                                         kfree (info->description);
123                                 info->description = strdup(sep);
124                         }
125                 }
126         rock_on:
127                 if (q) p = q+1; else p=NULL;
128         }
129
130         /* If the device didn't tell us its class, maybe we have managed to
131            guess one from the things it did say. */
132         if (info->class == PARPORT_CLASS_UNSPEC)
133                 info->class = guessed_class;
134
135         pretty_print (port, device);
136
137         kfree(txt);
138 }
139
140 /* Get Std 1284 Device ID. */
141 ssize_t parport_device_id (int devnum, char *buffer, size_t len)
142 {
143         ssize_t retval = -ENXIO;
144         struct pardevice *dev = parport_open (devnum, "Device ID probe",
145                                               NULL, NULL, NULL, 0, NULL);
146         if (!dev)
147                 return -ENXIO;
148
149         parport_claim_or_block (dev);
150
151         /* Negotiate to compatibility mode, and then to device ID mode.
152          * (This is in case we are already in device ID mode.) */
153         parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
154         retval = parport_negotiate (dev->port,
155                                     IEEE1284_MODE_NIBBLE | IEEE1284_DEVICEID);
156
157         if (!retval) {
158                 int idlen;
159                 unsigned char length[2];
160
161                 /* First two bytes are MSB,LSB of inclusive length. */
162                 retval = parport_read (dev->port, length, 2);
163
164                 if (retval != 2) goto end_id;
165
166                 idlen = (length[0] << 8) + length[1] - 2;
167                 /*
168                  * Check if the caller-allocated buffer is large enough
169                  * otherwise bail out or there will be an at least off by one.
170                  */
171                 if (idlen + 1 < len)
172                         len = idlen;
173                 else {
174                         retval = -EINVAL;
175                         goto out;
176                 }
177                 retval = parport_read (dev->port, buffer, len);
178
179                 if (retval != len)
180                         printk (KERN_DEBUG "%s: only read %Zd of %Zd ID bytes\n",
181                                 dev->port->name, retval,
182                                 len);
183
184                 /* Some printer manufacturers mistakenly believe that
185                    the length field is supposed to be _exclusive_.
186                    In addition, there are broken devices out there
187                    that don't even finish off with a semi-colon. */
188                 if (buffer[len - 1] != ';') {
189                         ssize_t diff;
190                         diff = parport_read (dev->port, buffer + len, 2);
191                         retval += diff;
192
193                         if (diff)
194                                 printk (KERN_DEBUG
195                                         "%s: device reported incorrect "
196                                         "length field (%d, should be %Zd)\n",
197                                         dev->port->name, idlen, retval);
198                         else {
199                                 /* One semi-colon short of a device ID. */
200                                 buffer[len++] = ';';
201                                 printk (KERN_DEBUG "%s: faking semi-colon\n",
202                                         dev->port->name);
203
204                                 /* If we get here, I don't think we
205                                    need to worry about the possible
206                                    standard violation of having read
207                                    more than we were told to.  The
208                                    device is non-compliant anyhow. */
209                         }
210                 }
211
212         end_id:
213                 buffer[len] = '\0';
214                 parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
215         }
216
217         if (retval > 2)
218                 parse_data (dev->port, dev->daisy, buffer);
219
220 out:
221         parport_release (dev);
222         parport_close (dev);
223         return retval;
224 }