static void i2c_parport_attach (struct parport *port) { struct i2c_par *adapter; adapter = kmalloc(sizeof(struct i2c_par), GFP_KERNEL); if (adapter == NULL) { printk(KERN_ERR "i2c-parport: Failed to kmalloc\n"); return; } memset(adapter, 0x00, sizeof(struct i2c_par)); pr_debug("i2c-parport: attaching to %s\n", port->name); adapter->pdev = parport_register_device(port, "i2c-parport", NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL); if (!adapter->pdev) { printk(KERN_ERR "i2c-parport: Unable to register with parport\n"); goto ERROR0; } /* Fill the rest of the structure */ adapter->adapter = parport_adapter; adapter->algo_data = parport_algo_data; if (!adapter_parm[type].getscl.val) adapter->algo_data.getscl = NULL; adapter->algo_data.data = port; adapter->adapter.algo_data = &adapter->algo_data; if (parport_claim_or_block(adapter->pdev) < 0) { printk(KERN_ERR "i2c-parport: Could not claim parallel port\n"); goto ERROR1; } /* Reset hardware to a sane state (SCL and SDA high) */ parport_setsda(port, 1); parport_setscl(port, 1); /* Other init if needed (power on...) */ if (adapter_parm[type].init.val) line_set(port, 1, &adapter_parm[type].init); parport_release(adapter->pdev); if (i2c_bit_add_bus(&adapter->adapter) < 0) { printk(KERN_ERR "i2c-parport: Unable to register with I2C\n"); goto ERROR1; } /* Add the new adapter to the list */ adapter->next = adapter_list; adapter_list = adapter; return; ERROR1: parport_unregister_device(adapter->pdev); ERROR0: kfree(adapter); }
static int __init lirc_parallel_init(void) { pport = parport_find_base(io); if (pport == NULL) { printk(KERN_NOTICE "%s: no port at %x found\n", LIRC_DRIVER_NAME, io); return -ENXIO; } ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME, pf, kf, irq_handler, 0, NULL); parport_put_port(pport); if (ppdevice == NULL) { printk(KERN_NOTICE "%s: parport_register_device() failed\n", LIRC_DRIVER_NAME); return -ENXIO; } if (parport_claim(ppdevice) != 0) goto skip_init; is_claimed = 1; out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP); #ifdef LIRC_TIMER if (debug) out(LIRC_PORT_DATA, tx_mask); timer = init_lirc_timer(); #if 0 /* continue even if device is offline */ if (timer == 0) { is_claimed = 0; parport_release(pport); parport_unregister_device(ppdevice); return -EIO; } #endif if (debug) out(LIRC_PORT_DATA, 0); #endif is_claimed = 0; parport_release(ppdevice); skip_init: driver.minor = lirc_register_driver(&driver); if (driver.minor < 0) { printk(KERN_NOTICE "%s: register_chrdev() failed\n", LIRC_DRIVER_NAME); parport_unregister_device(ppdevice); return -EIO; } printk(KERN_INFO "%s: installed using port 0x%04x irq %d\n", LIRC_DRIVER_NAME, io, irq); return 0; }
static int pcan_parport_register_device(struct parport *p, struct pcandev *dev) { dev->port.dng.pardev = parport_register_device(p, "pcan", NULL, NULL, pcan_parport_irq_handler, 0, (void *)dev); if (!dev->port.dng.pardev) { DPRINTK(KERN_DEBUG "found no parport device\n"); return -ENODEV; } return 0; }
/* --------------------------------------------------------------------- */ __initfunc(static int check_lpt(struct hfmodem_state *dev, unsigned int iobase)) { struct parport *pp = parport_enumerate(); while (pp && pp->base != iobase) pp = pp->next; if (!pp) return 0; if (!(dev->ptt_out.pardev = parport_register_device(pp, hfmodem_drvname, NULL, parptt_wakeup, NULL, PARPORT_DEV_EXCL, dev))) return 0; return 1; }
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 daisydev *p = topology; struct parport *port; struct pardevice *dev; int daisy; spin_lock(&topology_lock); while (p && p->devnum != devnum) p = p->next; if (!p) { spin_unlock(&topology_lock); return NULL; } daisy = p->daisy; port = parport_get_port(p->port); spin_unlock(&topology_lock); dev = parport_register_device (port, name, pf, kf, irqf, flags, handle); parport_put_port(port); if (!dev) return NULL; dev->daisy = daisy; /* Check that there really is a device to select. */ if (daisy >= 0) { int selected; parport_claim_or_block (dev); selected = port->daisy; parport_release (dev); if (selected != daisy) { /* No corresponding device. */ parport_unregister_device (dev); return NULL; } } return dev; }
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; }
struct pardevice *parport_open(int devnum, const char *name) { struct daisydev *p = topology; struct parport *port; struct pardevice *dev; int daisy; spin_lock(&topology_lock); while (p && p->devnum != devnum) p = p->next; if (!p) { spin_unlock(&topology_lock); return NULL; } daisy = p->daisy; port = parport_get_port(p->port); spin_unlock(&topology_lock); dev = parport_register_device(port, name, NULL, NULL, NULL, 0, NULL); parport_put_port(port); if (!dev) return NULL; dev->daisy = daisy; if (daisy >= 0) { int selected; parport_claim_or_block(dev); selected = port->daisy; parport_release(dev); if (selected != daisy) { parport_unregister_device(dev); return NULL; } } return dev; }
static void i2c_parport_attach (struct parport *port) { struct i2c_par *adapter = kmalloc(sizeof(struct i2c_par), GFP_KERNEL); if (!adapter) { printk(KERN_ERR "i2c-philips-par: Unable to malloc.\n"); return; } printk(KERN_DEBUG "i2c-philips-par.o: attaching to %s\n", port->name); adapter->pdev = parport_register_device(port, "i2c-philips-par", NULL, NULL, NULL, PARPORT_FLAG_EXCL, NULL); if (!adapter->pdev) { printk(KERN_ERR "i2c-philips-par: Unable to register with parport.\n"); return; } adapter->adapter = bit_lp_ops; adapter->adapter.algo_data = &adapter->bit_lp_data; adapter->bit_lp_data = type ? bit_lp_data2 : bit_lp_data; adapter->bit_lp_data.data = port; /* reset hardware to sane state */ parport_claim_or_block(adapter->pdev); adapter->bit_lp_data.setsda(port, 1); adapter->bit_lp_data.setscl(port, 1); parport_release(adapter->pdev); if (i2c_bit_add_bus(&adapter->adapter) < 0) { printk(KERN_ERR "i2c-philips-par: Unable to register with I2C.\n"); parport_unregister_device(adapter->pdev); kfree(adapter); return; /* No good */ } adapter->next = adapter_list; adapter_list = adapter; }
static int __init ks0108_init(void) { int result; int ret = -EINVAL; ks0108_parport = parport_find_base(ks0108_port); if (ks0108_parport == NULL) { printk(KERN_ERR KS0108_NAME ": ERROR: " "parport didn't find %i port\n", ks0108_port); goto none; } ks0108_pardevice = parport_register_device(ks0108_parport, KS0108_NAME, NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); if (ks0108_pardevice == NULL) { printk(KERN_ERR KS0108_NAME ": ERROR: " "parport didn't register new device\n"); goto none; } result = parport_claim(ks0108_pardevice); if (result != 0) { printk(KERN_ERR KS0108_NAME ": ERROR: " "can't claim %i parport, maybe in use\n", ks0108_port); ret = result; goto registered; } ks0108_inited = 1; return 0; registered: parport_unregister_device(ks0108_pardevice); none: return ret; }
static void spi_lm70llp_attach(struct parport *p) { struct pardevice *pd; struct spi_lm70llp *pp; struct spi_master *master; int status; if (lm70llp) { printk(KERN_WARNING "%s: spi_lm70llp instance already loaded. Aborting.\n", DRVNAME); return; } master = spi_alloc_master(p->physport->dev, sizeof *pp); if (!master) { status = -ENOMEM; goto out_fail; } pp = spi_master_get_devdata(master); master->bus_num = -1; master->num_chipselect = 1; pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = lm70_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = lm70_txrx; pp->bitbang.flags = SPI_3WIRE; pp->port = p; pd = parport_register_device(p, DRVNAME, NULL, NULL, NULL, PARPORT_FLAG_EXCL, pp); if (!pd) { status = -ENOMEM; goto out_free_master; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto out_parport_unreg; status = spi_bitbang_start(&pp->bitbang); if (status < 0) { printk(KERN_WARNING "%s: spi_bitbang_start failed with status %d\n", DRVNAME, status); goto out_off_and_release; } strcpy(pp->info.modalias, "lm70"); pp->info.max_speed_hz = 6 * 1000 * 1000; pp->info.chip_select = 0; pp->info.mode = SPI_3WIRE | SPI_MODE_0; parport_write_data(pp->port, lm70_INIT); pp->info.controller_data = pp; pp->spidev_lm70 = spi_new_device(pp->bitbang.master, &pp->info); if (pp->spidev_lm70) dev_dbg(&pp->spidev_lm70->dev, "spidev_lm70 at %s\n", dev_name(&pp->spidev_lm70->dev)); else { printk(KERN_WARNING "%s: spi_new_device failed\n", DRVNAME); status = -ENODEV; goto out_bitbang_stop; } pp->spidev_lm70->bits_per_word = 8; lm70llp = pp; return; out_bitbang_stop: spi_bitbang_stop(&pp->bitbang); out_off_and_release: parport_write_data(pp->port, 0); mdelay(10); parport_release(pp->pd); out_parport_unreg: parport_unregister_device(pd); out_free_master: (void) spi_master_put(master); out_fail: pr_info("%s: spi_lm70llp probe fail, status %d\n", DRVNAME, status); }
// Initialize camera device. Setup all internal flags, set a // default video mode, setup ccd-chip, register v4l device etc.. // Also used for 'probing' of hardware. // -1 on error static int w9966_init(struct w9966_dev* cam, struct parport* port) { if (cam->dev_state != 0) return -1; cam->pport = port; cam->brightness = 128; cam->contrast = 64; cam->color = 64; cam->hue = 0; // Select requested transfer mode switch(parmode) { default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp) case 0: if (port->modes & PARPORT_MODE_ECP) cam->ppmode = IEEE1284_MODE_ECP; /* else if (port->modes & PARPORT_MODE_EPP) cam->ppmode = IEEE1284_MODE_EPP;*/ else cam->ppmode = IEEE1284_MODE_ECPSWE; break; case 1: // hw- or sw-ecp if (port->modes & PARPORT_MODE_ECP) cam->ppmode = IEEE1284_MODE_ECP; else cam->ppmode = IEEE1284_MODE_ECPSWE; break; case 2: // hw- or sw-epp if (port->modes & PARPORT_MODE_EPP) cam->ppmode = IEEE1284_MODE_EPP; else cam->ppmode = IEEE1284_MODE_EPPSWE; break; } // Tell the parport driver that we exists cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL); if (cam->pdev == NULL) { DPRINTF("parport_register_device() failed\n"); return -1; } w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV); w9966_pdev_claim(cam); // Setup a default capture mode if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) { DPRINTF("w9966_setup() failed.\n"); return -1; } w9966_pdev_release(cam); // Fill in the video_device struct and register us to v4l memset(&cam->vdev, 0, sizeof(struct video_device)); strcpy(cam->vdev.name, W9966_DRIVERNAME); cam->vdev.type = VID_TYPE_CAPTURE | VID_TYPE_SCALES; cam->vdev.hardware = VID_HARDWARE_W9966; cam->vdev.open = &w9966_v4l_open; cam->vdev.close = &w9966_v4l_close; cam->vdev.read = &w9966_v4l_read; cam->vdev.ioctl = &w9966_v4l_ioctl; cam->vdev.priv = (void*)cam; cam->vdev.owner = THIS_MODULE; if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) == -1) return -1; w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV); cam->buffer = NULL; // All ok printk( "w9966cf: Found and initialized a webcam on %s.\n", cam->pport->name ); return 0; }
static int __init lirc_parallel_init(void) { int result; result = platform_driver_register(&lirc_parallel_driver); if (result) { pr_notice("platform_driver_register returned %d\n", result); return result; } lirc_parallel_dev = platform_device_alloc(LIRC_DRIVER_NAME, 0); if (!lirc_parallel_dev) { result = -ENOMEM; goto exit_driver_unregister; } result = platform_device_add(lirc_parallel_dev); if (result) goto exit_device_put; pport = parport_find_base(io); if (pport == NULL) { pr_notice("no port at %x found\n", io); result = -ENXIO; goto exit_device_put; } ppdevice = parport_register_device(pport, LIRC_DRIVER_NAME, pf, kf, lirc_lirc_irq_handler, 0, NULL); parport_put_port(pport); if (ppdevice == NULL) { pr_notice("parport_register_device() failed\n"); result = -ENXIO; goto exit_device_put; } if (parport_claim(ppdevice) != 0) goto skip_init; is_claimed = 1; out(LIRC_LP_CONTROL, LP_PSELECP|LP_PINITP); #ifdef LIRC_TIMER if (debug) out(LIRC_PORT_DATA, tx_mask); timer = init_lirc_timer(); #if 0 /* continue even if device is offline */ if (timer == 0) { is_claimed = 0; parport_release(pport); parport_unregister_device(ppdevice); result = -EIO; goto exit_device_put; } #endif if (debug) out(LIRC_PORT_DATA, 0); #endif is_claimed = 0; parport_release(ppdevice); skip_init: driver.dev = &lirc_parallel_dev->dev; driver.minor = lirc_register_driver(&driver); if (driver.minor < 0) { pr_notice("register_chrdev() failed\n"); parport_unregister_device(ppdevice); result = -EIO; goto exit_device_put; } pr_info("installed using port 0x%04x irq %d\n", io, irq); return 0; exit_device_put: platform_device_put(lirc_parallel_dev); exit_driver_unregister: platform_driver_unregister(&lirc_parallel_driver); return result; }
static void spi_lm70llp_attach(struct parport *p) { struct pardevice *pd; struct spi_lm70llp *pp; struct spi_master *master; int status; if (lm70llp) { printk(KERN_WARNING "%s: spi_lm70llp instance already loaded. Aborting.\n", DRVNAME); return; } /* TODO: this just _assumes_ a lm70 is there ... no probe; * the lm70 driver could verify it, reading the manf ID. */ master = spi_alloc_master(p->physport->dev, sizeof *pp); if (!master) { status = -ENOMEM; goto out_fail; } pp = spi_master_get_devdata(master); master->bus_num = -1; /* dynamic alloc of a bus number */ master->num_chipselect = 1; /* * SPI and bitbang hookup. */ pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = lm70_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = lm70_txrx; pp->bitbang.flags = SPI_3WIRE; /* * Parport hookup */ pp->port = p; pd = parport_register_device(p, DRVNAME, NULL, NULL, NULL, PARPORT_FLAG_EXCL, pp); if (!pd) { status = -ENOMEM; goto out_free_master; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto out_parport_unreg; /* * Start SPI ... */ status = spi_bitbang_start(&pp->bitbang); if (status < 0) { printk(KERN_WARNING "%s: spi_bitbang_start failed with status %d\n", DRVNAME, status); goto out_off_and_release; } /* * The modalias name MUST match the device_driver name * for the bus glue code to match and subsequently bind them. * We are binding to the generic drivers/hwmon/lm70.c device * driver. */ strcpy(pp->info.modalias, "lm70"); pp->info.max_speed_hz = 6 * 1000 * 1000; pp->info.chip_select = 0; pp->info.mode = SPI_3WIRE | SPI_MODE_0; /* power up the chip, and let the LM70 control SI/SO */ parport_write_data(pp->port, lm70_INIT); /* Enable access to our primary data structure via * the board info's (void *)controller_data. */ pp->info.controller_data = pp; pp->spidev_lm70 = spi_new_device(pp->bitbang.master, &pp->info); if (pp->spidev_lm70) dev_dbg(&pp->spidev_lm70->dev, "spidev_lm70 at %s\n", dev_name(&pp->spidev_lm70->dev)); else { printk(KERN_WARNING "%s: spi_new_device failed\n", DRVNAME); status = -ENODEV; goto out_bitbang_stop; } pp->spidev_lm70->bits_per_word = 8; lm70llp = pp; return; out_bitbang_stop: spi_bitbang_stop(&pp->bitbang); out_off_and_release: /* power down */ parport_write_data(pp->port, 0); mdelay(10); parport_release(pp->pd); out_parport_unreg: parport_unregister_device(pd); out_free_master: (void) spi_master_put(master); out_fail: pr_info("%s: spi_lm70llp probe fail, status %d\n", DRVNAME, status); }
/* Initialize camera device. Setup all internal flags, set a default video mode, setup ccd-chip, register v4l device etc.. Also used for 'probing' of hardware. -1 on error */ static int w9966_init(struct w9966 *cam, struct parport *port) { struct v4l2_device *v4l2_dev = &cam->v4l2_dev; if (cam->dev_state != 0) return -1; strlcpy(v4l2_dev->name, "w9966", sizeof(v4l2_dev->name)); if (v4l2_device_register(NULL, v4l2_dev) < 0) { v4l2_err(v4l2_dev, "Could not register v4l2_device\n"); return -1; } cam->pport = port; cam->brightness = 128; cam->contrast = 64; cam->color = 64; cam->hue = 0; /* Select requested transfer mode */ switch (parmode) { default: /* Auto-detect (priority: hw-ecp, hw-epp, sw-ecp) */ case 0: if (port->modes & PARPORT_MODE_ECP) cam->ppmode = IEEE1284_MODE_ECP; else if (port->modes & PARPORT_MODE_EPP) cam->ppmode = IEEE1284_MODE_EPP; else cam->ppmode = IEEE1284_MODE_ECP; break; case 1: /* hw- or sw-ecp */ cam->ppmode = IEEE1284_MODE_ECP; break; case 2: /* hw- or sw-epp */ cam->ppmode = IEEE1284_MODE_EPP; break; } /* Tell the parport driver that we exists */ cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL); if (cam->pdev == NULL) { DPRINTF("parport_register_device() failed\n"); return -1; } w9966_set_state(cam, W9966_STATE_PDEV, W9966_STATE_PDEV); w9966_pdev_claim(cam); /* Setup a default capture mode */ if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) { DPRINTF("w9966_setup() failed.\n"); return -1; } w9966_pdev_release(cam); /* Fill in the video_device struct and register us to v4l */ strlcpy(cam->vdev.name, W9966_DRIVERNAME, sizeof(cam->vdev.name)); cam->vdev.v4l2_dev = v4l2_dev; cam->vdev.fops = &w9966_fops; cam->vdev.ioctl_ops = &w9966_ioctl_ops; cam->vdev.release = video_device_release_empty; video_set_drvdata(&cam->vdev, cam); mutex_init(&cam->lock); if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) return -1; w9966_set_state(cam, W9966_STATE_VDEV, W9966_STATE_VDEV); /* All ok */ v4l2_info(v4l2_dev, "Found and initialized a webcam on %s.\n", cam->pport->name); return 0; }
static void butterfly_attach(struct parport *p) { struct pardevice *pd; int status; struct butterfly *pp; struct spi_master *master; struct device *dev = p->physport->dev; if (butterfly || !dev) return; /* REVISIT: this just _assumes_ a butterfly is there ... no probe, * and no way to be selective about what it binds to. */ master = spi_alloc_master(dev, sizeof *pp); if (!master) { status = -ENOMEM; goto done; } pp = spi_master_get_devdata(master); /* * SPI and bitbang hookup * * use default setup(), cleanup(), and transfer() methods; and * only bother implementing mode 0. Start it later. */ master->bus_num = 42; master->num_chipselect = 2; pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = butterfly_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0; /* * parport hookup */ pp->port = p; pd = parport_register_device(p, "spi_butterfly", NULL, NULL, NULL, 0 /* FLAGS */, pp); if (!pd) { status = -ENOMEM; goto clean0; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto clean1; /* * Butterfly reset, powerup, run firmware */ pr_debug("%s: powerup/reset Butterfly\n", p->name); /* nCS for dataflash (this bit is inverted on output) */ parport_frob_control(pp->port, spi_cs_bit, 0); /* stabilize power with chip in reset (nRESET), and * spi_sck_bit clear (CPOL=0) */ pp->lastbyte |= vcc_bits; parport_write_data(pp->port, pp->lastbyte); msleep(5); /* take it out of reset; assume long reset delay */ pp->lastbyte |= butterfly_nreset; parport_write_data(pp->port, pp->lastbyte); msleep(100); /* * Start SPI ... for now, hide that we're two physical busses. */ status = spi_bitbang_start(&pp->bitbang); if (status < 0) goto clean2; /* Bus 1 lets us talk to at45db041b (firmware disables AVR SPI), AVR * (firmware resets at45, acts as spi slave) or neither (we ignore * both, AVR uses AT45). Here we expect firmware for the first option. */ pp->info[0].max_speed_hz = 15 * 1000 * 1000; strcpy(pp->info[0].modalias, "mtd_dataflash"); pp->info[0].platform_data = &flash; pp->info[0].chip_select = 1; pp->info[0].controller_data = pp; pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]); if (pp->dataflash) pr_debug("%s: dataflash at %s\n", p->name, dev_name(&pp->dataflash->dev)); // dev_info(_what?_, ...) pr_info("%s: AVR Butterfly\n", p->name); butterfly = pp; return; clean2: /* turn off VCC */ parport_write_data(pp->port, 0); parport_release(pp->pd); clean1: parport_unregister_device(pd); clean0: (void) spi_master_put(pp->bitbang.master); done: pr_debug("%s: butterfly probe, fail %d\n", p->name, status); }
static void sm_output_open(struct sm_state *sm, const char *ifname) { enum uart u = c_uart_unknown; struct parport *pp = NULL; sm->hdrv.ptt_out.flags = 0; if (sm->hdrv.ptt_out.seriobase > 0 && sm->hdrv.ptt_out.seriobase <= 0x1000-SER_EXTENT && ((u = check_uart(sm->hdrv.ptt_out.seriobase))) != c_uart_unknown) { sm->hdrv.ptt_out.flags |= SP_SER; request_region(sm->hdrv.ptt_out.seriobase, SER_EXTENT, "sm ser ptt"); outb(0, UART_IER(sm->hdrv.ptt_out.seriobase)); /* 5 bits, 1 stop, no parity, no break, Div latch access */ outb(0x80, UART_LCR(sm->hdrv.ptt_out.seriobase)); outb(0, UART_DLM(sm->hdrv.ptt_out.seriobase)); outb(1, UART_DLL(sm->hdrv.ptt_out.seriobase)); /* as fast as possible */ /* LCR and MCR set by output_status */ } sm->pardev = NULL; if (sm->hdrv.ptt_out.pariobase > 0) { pp = parport_enumerate(); while (pp && pp->base != sm->hdrv.ptt_out.pariobase) pp = pp->next; if (!pp) printk(KERN_WARNING "%s: parport at address 0x%x not found\n", sm_drvname, sm->hdrv.ptt_out.pariobase); else if ((~pp->modes) & (PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT)) printk(KERN_WARNING "%s: parport at address 0x%x cannot be used\n", sm_drvname, sm->hdrv.ptt_out.pariobase); else { sm->pardev = parport_register_device(pp, ifname, NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL); if (!sm->pardev) { pp = NULL; printk(KERN_WARNING "%s: cannot register parport device (address 0x%x)\n", sm_drvname, sm->hdrv.ptt_out.pariobase); } else { if (parport_claim(sm->pardev)) { parport_unregister_device(sm->pardev); sm->pardev = NULL; printk(KERN_WARNING "%s: cannot claim parport at address 0x%x\n", sm_drvname, sm->hdrv.ptt_out.pariobase); } else sm->hdrv.ptt_out.flags |= SP_PAR; } } } if (sm->hdrv.ptt_out.midiiobase > 0 && sm->hdrv.ptt_out.midiiobase <= 0x1000-MIDI_EXTENT && check_midi(sm->hdrv.ptt_out.midiiobase)) { sm->hdrv.ptt_out.flags |= SP_MIDI; request_region(sm->hdrv.ptt_out.midiiobase, MIDI_EXTENT, "sm midi ptt"); } sm_output_status(sm); printk(KERN_INFO "%s: ptt output:", sm_drvname); if (sm->hdrv.ptt_out.flags & SP_SER) printk(" serial interface at 0x%x, uart %s", sm->hdrv.ptt_out.seriobase, uart_str[u]); if (sm->hdrv.ptt_out.flags & SP_PAR) printk(" parallel interface at 0x%x", sm->hdrv.ptt_out.pariobase); if (sm->hdrv.ptt_out.flags & SP_MIDI) printk(" mpu401 (midi) interface at 0x%x", sm->hdrv.ptt_out.midiiobase); if (!sm->hdrv.ptt_out.flags) printk(" none"); printk("\n"); }
static void butterfly_attach(struct parport *p) { struct pardevice *pd; int status; struct butterfly *pp; struct spi_master *master; struct platform_device *pdev; if (butterfly) return; /* REVISIT: this just _assumes_ a butterfly is there ... no probe, * and no way to be selective about what it binds to. */ /* FIXME where should master->cdev.dev come from? * e.g. /sys/bus/pnp0/00:0b, some PCI thing, etc * setting up a platform device like this is an ugly kluge... */ pdev = platform_device_register_simple("butterfly", -1, NULL, 0); master = spi_alloc_master(&pdev->dev, sizeof *pp); if (!master) { status = -ENOMEM; goto done; } pp = spi_master_get_devdata(master); /* * SPI and bitbang hookup * * use default setup(), cleanup(), and transfer() methods; and * only bother implementing mode 0. Start it later. */ master->bus_num = 42; master->num_chipselect = 2; pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = butterfly_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0; /* * parport hookup */ pp->port = p; pd = parport_register_device(p, "spi_butterfly", NULL, NULL, NULL, 0 /* FLAGS */, pp); if (!pd) { status = -ENOMEM; goto clean0; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto clean1; /* * Butterfly reset, powerup, run firmware */ pr_debug("%s: powerup/reset Butterfly\n", p->name); /* nCS for dataflash (this bit is inverted on output) */ parport_frob_control(pp->port, spi_cs_bit, 0); /* stabilize power with chip in reset (nRESET), and * both spi_sck_bit and usi_sck_bit clear (CPOL=0) */ pp->lastbyte |= vcc_bits; parport_write_data(pp->port, pp->lastbyte); msleep(5); /* take it out of reset; assume long reset delay */ pp->lastbyte |= butterfly_nreset; parport_write_data(pp->port, pp->lastbyte); msleep(100); /* * Start SPI ... for now, hide that we're two physical busses. */ status = spi_bitbang_start(&pp->bitbang); if (status < 0) goto clean2; /* Bus 1 lets us talk to at45db041b (firmware disables AVR) * or AVR (firmware resets at45, acts as spi slave) */ pp->info[0].max_speed_hz = 15 * 1000 * 1000; strcpy(pp->info[0].modalias, "mtd_dataflash"); pp->info[0].platform_data = &flash; pp->info[0].chip_select = 1; pp->info[0].controller_data = pp; pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]); if (pp->dataflash) pr_debug("%s: dataflash at %s\n", p->name, pp->dataflash->dev.bus_id); #ifdef HAVE_USI /* even more custom AVR firmware */ pp->info[1].max_speed_hz = 10 /* ?? */ * 1000 * 1000; strcpy(pp->info[1].modalias, "butterfly"); // pp->info[1].platform_data = ... TBD ... ; pp->info[1].chip_select = 2, pp->info[1].controller_data = pp; pp->butterfly = spi_new_device(pp->bitbang.master, &pp->info[1]); if (pp->butterfly) pr_debug("%s: butterfly at %s\n", p->name, pp->butterfly->dev.bus_id); /* FIXME setup ACK for the IRQ line ... */ #endif // dev_info(_what?_, ...) pr_info("%s: AVR Butterfly\n", p->name); butterfly = pp; return; clean2: /* turn off VCC */ parport_write_data(pp->port, 0); parport_release(pp->pd); clean1: parport_unregister_device(pd); clean0: (void) spi_master_put(pp->bitbang.master); done: platform_device_unregister(pdev); pr_debug("%s: butterfly probe, fail %d\n", p->name, status); }
static void butterfly_attach(struct parport *p) { struct pardevice *pd; int status; struct butterfly *pp; struct spi_master *master; struct device *dev = p->physport->dev; if (butterfly || !dev) return; master = spi_alloc_master(dev, sizeof *pp); if (!master) { status = -ENOMEM; goto done; } pp = spi_master_get_devdata(master); master->bus_num = 42; master->num_chipselect = 2; pp->bitbang.master = spi_master_get(master); pp->bitbang.chipselect = butterfly_chipselect; pp->bitbang.txrx_word[SPI_MODE_0] = butterfly_txrx_word_mode0; pp->port = p; pd = parport_register_device(p, "spi_butterfly", NULL, NULL, NULL, 0 , pp); if (!pd) { status = -ENOMEM; goto clean0; } pp->pd = pd; status = parport_claim(pd); if (status < 0) goto clean1; pr_debug("%s: powerup/reset Butterfly\n", p->name); parport_frob_control(pp->port, spi_cs_bit, 0); pp->lastbyte |= vcc_bits; parport_write_data(pp->port, pp->lastbyte); msleep(5); pp->lastbyte |= butterfly_nreset; parport_write_data(pp->port, pp->lastbyte); msleep(100); status = spi_bitbang_start(&pp->bitbang); if (status < 0) goto clean2; pp->info[0].max_speed_hz = 15 * 1000 * 1000; strcpy(pp->info[0].modalias, "mtd_dataflash"); pp->info[0].platform_data = &flash; pp->info[0].chip_select = 1; pp->info[0].controller_data = pp; pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]); if (pp->dataflash) pr_debug("%s: dataflash at %s\n", p->name, dev_name(&pp->dataflash->dev)); pr_info("%s: AVR Butterfly\n", p->name); butterfly = pp; return; clean2: parport_write_data(pp->port, 0); parport_release(pp->pd); clean1: parport_unregister_device(pd); clean0: (void) spi_master_put(pp->bitbang.master); done: pr_debug("%s: butterfly probe, fail %d\n", p->name, status); }
// Initialize camera device. Setup all internal flags, set a // default video mode, setup ccd-chip, register v4l device etc.. // Also used for 'probing' of hardware. // 1 on success, else 0 static int w9966_init(struct w9966_dev* cam, struct parport* port, int vidnr) { if (cam->dev_state != 0) return 0; cam->pport = port; cam->brightness = 128; cam->contrast = 64; cam->color = 64; cam->hue = 0; // Select requested transfer mode switch(parmode) { default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp) case 0: if (port->modes & PARPORT_MODE_ECP) cam->ppmode = IEEE1284_MODE_ECP; else if (port->modes & PARPORT_MODE_EPP) cam->ppmode = IEEE1284_MODE_EPP; else cam->ppmode = IEEE1284_MODE_ECPSWE; break; case 1: // hw- or sw-ecp if (port->modes & PARPORT_MODE_ECP) cam->ppmode = IEEE1284_MODE_ECP; else cam->ppmode = IEEE1284_MODE_ECPSWE; break; case 2: // hw- or sw-epp if (port->modes & PARPORT_MODE_EPP) cam->ppmode = IEEE1284_MODE_EPP; else cam->ppmode = IEEE1284_MODE_EPPSWE; break; case 3: // hw-ecp cam->ppmode = IEEE1284_MODE_ECP; break; } // Tell the parport driver that we exists cam->pdev = parport_register_device( port, W9966_DRIVERNAME, NULL, NULL, NULL, 0, NULL); if (cam->pdev == NULL) { DPRINTF("parport_register_device() failed.\n"); return 0; } w9966_flag_set(cam, W9966_STATE_PDEV); // Claim parport if (!w9966_pdev_claim(cam)) { DPRINTF("w9966_pdev_claim() failed.\n"); return 0; } // Perform initial w9966 setup if (!w9966_setup(cam)) { DPRINTF("w9966_setup() failed.\n"); return 0; } // Detect model if (!w9966_saa7111_init(cam)) { DPRINTF("w9966_saa7111_init() failed.\n"); return 0; } if (!w9966_lc99053_init(cam)) { DPRINTF("w9966_lc99053_init() failed.\n"); return 0; } if (!w9966_flag_test(cam, W9966_STATE_DETECTED)) { DPRINTF("Camera model not identified.\n"); return 0; } // Setup w9966 with a default capture mode (QCIF res.) if (!w9966_window(cam, 0, 0, 1023, 1023, 176, 144)) { DPRINTF("w9966_window() failed.\n"); return 0; } w9966_pdev_release(cam); // Fill in the video_device struct and register us to v4l memset(&cam->vdev, 0, sizeof(struct video_device)); strcpy(cam->vdev.name, W9966_DRIVERNAME); cam->vdev.type = VID_TYPE_CAPTURE | VID_TYPE_SCALES; cam->vdev.hardware = VID_HARDWARE_W9966; cam->vdev.open = &w9966_v4l_open; cam->vdev.close = &w9966_v4l_close; cam->vdev.read = &w9966_v4l_read; cam->vdev.ioctl = &w9966_v4l_ioctl; cam->vdev.priv = (void*)cam; cam->vdev.owner = THIS_MODULE; if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, vidnr) == -1) { DPRINTF("video_register_device() failed (minor: %d).\n", vidnr); return 0; } w9966_flag_set(cam, W9966_STATE_VDEV); // All ok printk("w9966: Found and initialized %s on %s.\n", cam->name, cam->pport->name); return 1; }