| /* |
| * IEEE 1284.3 Parallel port daisy chain and multiplexor code |
| * |
| * Copyright (C) 1999, 2000 Tim Waugh <tim@cyberelk.demon.co.uk> |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version |
| * 2 of the License, or (at your option) any later version. |
| * |
| * ??-12-1998: Initial implementation. |
| * 31-01-1999: Make port-cloning transparent. |
| * 13-02-1999: Move DeviceID technique from parport_probe. |
| * 13-03-1999: Get DeviceID from non-IEEE 1284.3 devices too. |
| * 22-02-2000: Count devices that are actually detected. |
| * |
| * Any part of this program may be used in documents licensed under |
| * the GNU Free Documentation License, Version 1.1 or any later version |
| * published by the Free Software Foundation. |
| */ |
| |
| #include <linux/parport.h> |
| #include <linux/delay.h> |
| #include <asm/uaccess.h> |
| |
| #define DEBUG /* undef me for production */ |
| |
| #ifdef DEBUG |
| #define DPRINTK(stuff...) printk (stuff) |
| #else |
| #define DPRINTK(stuff...) |
| #endif |
| |
| static struct daisydev { |
| struct daisydev *next; |
| struct parport *port; |
| int daisy; |
| int devnum; |
| } *topology = NULL; |
| |
| static int numdevs = 0; |
| |
| /* Forward-declaration of lower-level functions. */ |
| static int mux_present (struct parport *port); |
| static int num_mux_ports (struct parport *port); |
| static int select_port (struct parport *port); |
| static int assign_addrs (struct parport *port); |
| |
| /* Add a device to the discovered topology. */ |
| static void add_dev (int devnum, struct parport *port, int daisy) |
| { |
| struct daisydev *newdev; |
| newdev = kmalloc (sizeof (struct daisydev), GFP_KERNEL); |
| if (newdev) { |
| newdev->port = port; |
| newdev->daisy = daisy; |
| newdev->devnum = devnum; |
| newdev->next = topology; |
| if (!topology || topology->devnum >= devnum) |
| topology = newdev; |
| else { |
| struct daisydev *prev = topology; |
| while (prev->next && prev->next->devnum < devnum) |
| prev = prev->next; |
| newdev->next = prev->next; |
| prev->next = newdev; |
| } |
| } |
| } |
| |
| /* Clone a parport (actually, make an alias). */ |
| static struct parport *clone_parport (struct parport *real, int muxport) |
| { |
| struct parport *extra = parport_register_port (real->base, |
| real->irq, |
| real->dma, |
| real->ops); |
| if (extra) { |
| extra->portnum = real->portnum; |
| extra->physport = real; |
| extra->muxport = muxport; |
| } |
| |
| return extra; |
| } |
| |
| /* Discover the IEEE1284.3 topology on a port -- muxes and daisy chains. |
| * Return value is number of devices actually detected. */ |
| int parport_daisy_init (struct parport *port) |
| { |
| int detected = 0; |
| char *deviceid; |
| static const char *th[] = { /*0*/"th", "st", "nd", "rd", "th" }; |
| int num_ports; |
| int i; |
| |
| /* Because this is called before any other devices exist, |
| * we don't have to claim exclusive access. */ |
| |
| /* If mux present on normal port, need to create new |
| * parports for each extra port. */ |
| if (port->muxport < 0 && mux_present (port) && |
| /* don't be fooled: a mux must have 2 or 4 ports. */ |
| ((num_ports = num_mux_ports (port)) == 2 || num_ports == 4)) { |
| /* Leave original as port zero. */ |
| port->muxport = 0; |
| printk (KERN_INFO |
| "%s: 1st (default) port of %d-way multiplexor\n", |
| port->name, num_ports); |
| for (i = 1; i < num_ports; i++) { |
| /* Clone the port. */ |
| struct parport *extra = clone_parport (port, i); |
| if (!extra) { |
| if (signal_pending (current)) |
| break; |
| |
| schedule (); |
| continue; |
| } |
| |
| printk (KERN_INFO |
| "%s: %d%s port of %d-way multiplexor on %s\n", |
| extra->name, i + 1, th[i + 1], num_ports, |
| port->name); |
| |
| /* Analyse that port too. We won't recurse |
| forever because of the 'port->muxport < 0' |
| test above. */ |
| parport_announce_port (extra); |
| } |
| } |
| |
| if (port->muxport >= 0) |
| select_port (port); |
| |
| parport_daisy_deselect_all (port); |
| detected += assign_addrs (port); |
| |
| /* Count the potential legacy device at the end. */ |
| add_dev (numdevs++, port, -1); |
| |
| /* Find out the legacy device's IEEE 1284 device ID. */ |
| deviceid = kmalloc (1000, GFP_KERNEL); |
| if (deviceid) { |
| if (parport_device_id (numdevs - 1, deviceid, 1000) > 2) |
| detected++; |
| |
| kfree (deviceid); |
| } |
| |
| return detected; |
| } |
| |
| /* Forget about devices on a physical port. */ |
| void parport_daisy_fini (struct parport *port) |
| { |
| struct daisydev *dev, *prev = topology; |
| while (prev && prev->port == port) { |
| topology = topology->next; |
| kfree (prev); |
| prev = topology; |
| } |
| |
| while (prev) { |
| dev = prev->next; |
| if (dev && dev->port == port) { |
| prev->next = dev->next; |
| kfree (dev); |
| } |
| prev = prev->next; |
| } |
| |
| /* Gaps in the numbering could be handled better. How should |
| someone enumerate through all IEEE1284.3 devices in the |
| topology?. */ |
| if (!topology) numdevs = 0; |
| return; |
| } |
| |
| /** |
| * parport_open - find a device by canonical device number |
| * @devnum: canonical device number |
| * @name: name to associate with the device |
| * @pf: preemption callback |
| * @kf: kick callback |
| * @irqf: interrupt handler |
| * @flags: registration flags |
| * @handle: driver data |
| * |
| * This function is similar to parport_register_device(), except |
| * that it locates a device by its number rather than by the port |
| * it is attached to. See parport_find_device() and |
| * parport_find_class(). |
| * |
| * All parameters except for @devnum are the same as for |
| * parport_register_device(). The return value is the same as |
| * for parport_register_device(). |
| **/ |
| |
| struct pardevice *parport_open (int devnum, const char *name, |
| int (*pf) (void *), void (*kf) (void *), |
| void (*irqf) (int, void *, struct pt_regs *), |
| int flags, void *handle) |
| { |
| struct parport *port = parport_enumerate (); |
| struct pardevice *dev; |
| int portnum; |
| int muxnum; |
| int daisynum; |
| |
| if (parport_device_coords (devnum, &portnum, &muxnum, &daisynum)) |
| return NULL; |
| |
| while (port && ((port->portnum != portnum) || |
| (port->muxport != muxnum))) |
| port = port->next; |
| |
| if (!port) |
| /* No corresponding parport. */ |
| return NULL; |
| |
| dev = parport_register_device (port, name, pf, kf, |
| irqf, flags, handle); |
| if (dev) |
| dev->daisy = daisynum; |
| |
| /* Check that there really is a device to select. */ |
| if (daisynum >= 0) { |
| int selected; |
| parport_claim_or_block (dev); |
| selected = port->daisy; |
| parport_release (dev); |
| |
| if (selected != port->daisy) { |
| /* No corresponding device. */ |
| parport_unregister_device (dev); |
| return NULL; |
| } |
| } |
| |
| return dev; |
| } |
| |
| /** |
| * parport_close - close a device opened with parport_open() |
| * @dev: device to close |
| * |
| * This is to parport_open() as parport_unregister_device() is to |
| * parport_register_device(). |
| **/ |
| |
| void parport_close (struct pardevice *dev) |
| { |
| parport_unregister_device (dev); |
| } |
| |
| /** |
| * parport_device_num - convert device coordinates |
| * @parport: parallel port number |
| * @mux: multiplexor port number (-1 for no multiplexor) |
| * @daisy: daisy chain address (-1 for no daisy chain address) |
| * |
| * This tries to locate a device on the given parallel port, |
| * multiplexor port and daisy chain address, and returns its |
| * device number or -NXIO if no device with those coordinates |
| * exists. |
| **/ |
| |
| int parport_device_num (int parport, int mux, int daisy) |
| { |
| struct daisydev *dev = topology; |
| |
| while (dev && dev->port->portnum != parport && |
| dev->port->muxport != mux && dev->daisy != daisy) |
| dev = dev->next; |
| |
| if (!dev) |
| return -ENXIO; |
| |
| return dev->devnum; |
| } |
| |
| /** |
| * parport_device_coords - convert canonical device number |
| * @devnum: device number |
| * @parport: pointer to storage for parallel port number |
| * @mux: pointer to storage for multiplexor port number |
| * @daisy: pointer to storage for daisy chain address |
| * |
| * This function converts a device number into its coordinates in |
| * terms of which parallel port in the system it is attached to, |
| * which multiplexor port it is attached to if there is a |
| * multiplexor on that port, and which daisy chain address it has |
| * if it is in a daisy chain. |
| * |
| * The caller must allocate storage for @parport, @mux, and |
| * @daisy. |
| * |
| * If there is no device with the specified device number, -ENXIO |
| * is returned. Otherwise, the values pointed to by @parport, |
| * @mux, and @daisy are set to the coordinates of the device, |
| * with -1 for coordinates with no value. |
| * |
| * This function is not actually very useful, but this interface |
| * was suggested by IEEE 1284.3. |
| **/ |
| |
| int parport_device_coords (int devnum, int *parport, int *mux, int *daisy) |
| { |
| struct daisydev *dev = topology; |
| |
| while (dev && dev->devnum != devnum) |
| dev = dev->next; |
| |
| if (!dev) |
| return -ENXIO; |
| |
| if (parport) *parport = dev->port->portnum; |
| if (mux) *mux = dev->port->muxport; |
| if (daisy) *daisy = dev->daisy; |
| return 0; |
| } |
| |
| /* Send a daisy-chain-style CPP command packet. */ |
| static int cpp_daisy (struct parport *port, int cmd) |
| { |
| unsigned char s; |
| |
| parport_data_forward (port); |
| parport_write_data (port, 0xaa); udelay (2); |
| parport_write_data (port, 0x55); udelay (2); |
| parport_write_data (port, 0x00); udelay (2); |
| parport_write_data (port, 0xff); udelay (2); |
| s = parport_read_status (port) & (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR); |
| if (s != (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR)) { |
| DPRINTK (KERN_DEBUG "%s: cpp_daisy: aa5500ff(%02x)\n", |
| port->name, s); |
| return -ENXIO; |
| } |
| |
| parport_write_data (port, 0x87); udelay (2); |
| s = parport_read_status (port) & (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR); |
| if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) { |
| DPRINTK (KERN_DEBUG "%s: cpp_daisy: aa5500ff87(%02x)\n", |
| port->name, s); |
| return -ENXIO; |
| } |
| |
| parport_write_data (port, 0x78); udelay (2); |
| parport_write_data (port, cmd); udelay (2); |
| parport_frob_control (port, |
| PARPORT_CONTROL_STROBE, |
| PARPORT_CONTROL_STROBE); |
| udelay (1); |
| parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
| udelay (1); |
| s = parport_read_status (port); |
| parport_write_data (port, 0xff); udelay (2); |
| |
| return s; |
| } |
| |
| /* Send a mux-style CPP command packet. */ |
| static int cpp_mux (struct parport *port, int cmd) |
| { |
| unsigned char s; |
| int rc; |
| |
| parport_data_forward (port); |
| parport_write_data (port, 0xaa); udelay (2); |
| parport_write_data (port, 0x55); udelay (2); |
| parport_write_data (port, 0xf0); udelay (2); |
| parport_write_data (port, 0x0f); udelay (2); |
| parport_write_data (port, 0x52); udelay (2); |
| parport_write_data (port, 0xad); udelay (2); |
| parport_write_data (port, cmd); udelay (2); |
| |
| s = parport_read_status (port); |
| if (!(s & PARPORT_STATUS_ACK)) { |
| DPRINTK (KERN_DEBUG "%s: cpp_mux: aa55f00f52ad%02x(%02x)\n", |
| port->name, cmd, s); |
| return -EIO; |
| } |
| |
| rc = (((s & PARPORT_STATUS_SELECT ? 1 : 0) << 0) | |
| ((s & PARPORT_STATUS_PAPEROUT ? 1 : 0) << 1) | |
| ((s & PARPORT_STATUS_BUSY ? 0 : 1) << 2) | |
| ((s & PARPORT_STATUS_ERROR ? 0 : 1) << 3)); |
| |
| return rc; |
| } |
| |
| void parport_daisy_deselect_all (struct parport *port) |
| { |
| cpp_daisy (port, 0x30); |
| } |
| |
| int parport_daisy_select (struct parport *port, int daisy, int mode) |
| { |
| switch (mode) |
| { |
| // For these modes we should switch to EPP mode: |
| case IEEE1284_MODE_EPP: |
| case IEEE1284_MODE_EPPSL: |
| case IEEE1284_MODE_EPPSWE: |
| return (cpp_daisy (port, 0x20 + daisy) & |
| PARPORT_STATUS_ERROR); |
| |
| // For these modes we should switch to ECP mode: |
| case IEEE1284_MODE_ECP: |
| case IEEE1284_MODE_ECPRLE: |
| case IEEE1284_MODE_ECPSWE: |
| return (cpp_daisy (port, 0xd0 + daisy) & |
| PARPORT_STATUS_ERROR); |
| |
| // Nothing was told for BECP in Daisy chain specification. |
| // May be it's wise to use ECP? |
| case IEEE1284_MODE_BECP: |
| // Others use compat mode |
| case IEEE1284_MODE_NIBBLE: |
| case IEEE1284_MODE_BYTE: |
| case IEEE1284_MODE_COMPAT: |
| default: |
| return (cpp_daisy (port, 0xe0 + daisy) & |
| PARPORT_STATUS_ERROR); |
| } |
| } |
| |
| static int mux_present (struct parport *port) |
| { |
| return cpp_mux (port, 0x51) == 3; |
| } |
| |
| static int num_mux_ports (struct parport *port) |
| { |
| return cpp_mux (port, 0x58); |
| } |
| |
| static int select_port (struct parport *port) |
| { |
| int muxport = port->muxport; |
| return cpp_mux (port, 0x60 + muxport) == muxport; |
| } |
| |
| static int assign_addrs (struct parport *port) |
| { |
| unsigned char s, last_dev; |
| unsigned char daisy; |
| int thisdev = numdevs; |
| int detected; |
| char *deviceid; |
| |
| parport_data_forward (port); |
| parport_write_data (port, 0xaa); udelay (2); |
| parport_write_data (port, 0x55); udelay (2); |
| parport_write_data (port, 0x00); udelay (2); |
| parport_write_data (port, 0xff); udelay (2); |
| s = parport_read_status (port) & (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR); |
| if (s != (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR)) { |
| DPRINTK (KERN_DEBUG "%s: assign_addrs: aa5500ff(%02x)\n", |
| port->name, s); |
| return 0; |
| } |
| |
| parport_write_data (port, 0x87); udelay (2); |
| s = parport_read_status (port) & (PARPORT_STATUS_BUSY |
| | PARPORT_STATUS_PAPEROUT |
| | PARPORT_STATUS_SELECT |
| | PARPORT_STATUS_ERROR); |
| if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) { |
| DPRINTK (KERN_DEBUG "%s: assign_addrs: aa5500ff87(%02x)\n", |
| port->name, s); |
| return 0; |
| } |
| |
| parport_write_data (port, 0x78); udelay (2); |
| last_dev = 0; /* We've just been speaking to a device, so we |
| know there must be at least _one_ out there. */ |
| |
| for (daisy = 0; daisy < 4; daisy++) { |
| parport_write_data (port, daisy); |
| udelay (2); |
| parport_frob_control (port, |
| PARPORT_CONTROL_STROBE, |
| PARPORT_CONTROL_STROBE); |
| udelay (1); |
| parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
| udelay (1); |
| |
| if (last_dev) |
| /* No more devices. */ |
| break; |
| |
| last_dev = !(parport_read_status (port) |
| & PARPORT_STATUS_BUSY); |
| |
| add_dev (numdevs++, port, daisy); |
| } |
| |
| parport_write_data (port, 0xff); udelay (2); |
| detected = numdevs - thisdev; |
| DPRINTK (KERN_DEBUG "%s: Found %d daisy-chained devices\n", port->name, |
| detected); |
| |
| /* Ask the new devices to introduce themselves. */ |
| deviceid = kmalloc (1000, GFP_KERNEL); |
| if (!deviceid) return 0; |
| |
| for (daisy = 0; thisdev < numdevs; thisdev++, daisy++) |
| parport_device_id (thisdev, deviceid, 1000); |
| |
| kfree (deviceid); |
| return detected; |
| } |
| |
| /* Find a device with a particular manufacturer and model string, |
| starting from a given device number. Like the PCI equivalent, |
| 'from' itself is skipped. */ |
| |
| /** |
| * parport_find_device - find a specific device |
| * @mfg: required manufacturer string |
| * @mdl: required model string |
| * @from: previous device number found in search, or %NULL for |
| * new search |
| * |
| * This walks through the list of parallel port devices looking |
| * for a device whose 'MFG' string matches @mfg and whose 'MDL' |
| * string matches @mdl in their IEEE 1284 Device ID. |
| * |
| * When a device is found matching those requirements, its device |
| * number is returned; if there is no matching device, a negative |
| * value is returned. |
| * |
| * A new search it initiated by passing %NULL as the @from |
| * argument. If @from is not %NULL, the search continues from |
| * that device. |
| **/ |
| |
| int parport_find_device (const char *mfg, const char *mdl, int from) |
| { |
| struct daisydev *d = topology; /* sorted by devnum */ |
| |
| /* Find where to start. */ |
| while (d && d->devnum <= from) |
| d = d->next; |
| |
| /* Search. */ |
| while (d) { |
| struct parport_device_info *info; |
| info = &d->port->probe_info[1 + d->daisy]; |
| if ((!mfg || !strcmp (mfg, info->mfr)) && |
| (!mdl || !strcmp (mdl, info->model))) |
| break; |
| |
| d = d->next; |
| } |
| |
| if (d) |
| return d->devnum; |
| |
| return -1; |
| } |
| |
| /** |
| * parport_find_class - find a device in a specified class |
| * @cls: required class |
| * @from: previous device number found in search, or %NULL for |
| * new search |
| * |
| * This walks through the list of parallel port devices looking |
| * for a device whose 'CLS' string matches @cls in their IEEE |
| * 1284 Device ID. |
| * |
| * When a device is found matching those requirements, its device |
| * number is returned; if there is no matching device, a negative |
| * value is returned. |
| * |
| * A new search it initiated by passing %NULL as the @from |
| * argument. If @from is not %NULL, the search continues from |
| * that device. |
| **/ |
| |
| int parport_find_class (parport_device_class cls, int from) |
| { |
| struct daisydev *d = topology; /* sorted by devnum */ |
| |
| /* Find where to start. */ |
| while (d && d->devnum <= from) |
| d = d->next; |
| |
| /* Search. */ |
| while (d && d->port->probe_info[1 + d->daisy].class != cls) |
| d = d->next; |
| |
| if (d) |
| return d->devnum; |
| |
| return -1; |
| } |