*
********************************************************************/
-#include <linux/config.h>
#include <linux/module.h>
#define DRIVER_NAME "vlsi_ir"
* 3: external 40MHz XCLK (HP OB-800)
*/
-MODULE_PARM(clksrc, "i");
-MODULE_PARM_DESC(clksrc, "clock input source selection");
static int clksrc = 0; /* default is 0(auto) */
+module_param(clksrc, int, 0);
+MODULE_PARM_DESC(clksrc, "clock input source selection");
/* ringsize: size of the tx and rx descriptor rings
* independent for tx and rx
* there should be no gain when using rings larger than 8
*/
-MODULE_PARM(ringsize, "1-2i");
-MODULE_PARM_DESC(ringsize, "TX, RX ring descriptor size");
static int ringsize[] = {8,8}; /* default is tx=8 / rx=8 */
+module_param_array(ringsize, int, NULL, 0);
+MODULE_PARM_DESC(ringsize, "TX, RX ring descriptor size");
/* sirpulse: tuning of the SIR pulse width within IrPHY 1.3 limits
* 0: very short, 1.5us (exception: 6us at 2.4 kbaud)
* pulse width saves more than 90% of the transmitted IR power.
*/
-MODULE_PARM(sirpulse, "i");
-MODULE_PARM_DESC(sirpulse, "SIR pulse width tuning");
static int sirpulse = 1; /* default is 3/16 bittime */
+module_param(sirpulse, int, 0);
+MODULE_PARM_DESC(sirpulse, "SIR pulse width tuning");
/* qos_mtt_bits: encoded min-turn-time value we require the peer device
* to use before transmitting to us. "Type 1" (per-station)
* pretty common HP HDLS-1100 requires 1 msec - so lets use this.
*/
-MODULE_PARM(qos_mtt_bits, "i");
-MODULE_PARM_DESC(qos_mtt_bits, "IrLAP bitfield representing min-turn-time");
static int qos_mtt_bits = 0x07; /* default is 1 ms or more */
+module_param(qos_mtt_bits, int, 0);
+MODULE_PARM_DESC(qos_mtt_bits, "IrLAP bitfield representing min-turn-time");
/********************************************************/
unsigned i;
seq_printf(seq, "\n%s (vid/did: %04x/%04x)\n",
- PCIDEV_NAME(pdev), (int)pdev->vendor, (int)pdev->device);
+ pci_name(pdev), (int)pdev->vendor, (int)pdev->device);
seq_printf(seq, "pci-power-state: %u\n", (unsigned) pdev->current_state);
seq_printf(seq, "resources: irq=%u / io=0x%04x / dma_mask=0x%016Lx\n",
pdev->irq, (unsigned)pci_resource_start(pdev, 0), (unsigned long long)pdev->dma_mask);
if (rd->buf == NULL
|| !(busaddr = pci_map_single(pdev, rd->buf, len, dir))) {
if (rd->buf) {
- ERROR("%s: failed to create PCI-MAP for %p",
- __FUNCTION__, rd->buf);
+ IRDA_ERROR("%s: failed to create PCI-MAP for %p",
+ __FUNCTION__, rd->buf);
kfree(rd->buf);
rd->buf = NULL;
}
rd_set_addr_status(rd, 0, 0);
if (busaddr)
pci_unmap_single(r->pdev, busaddr, r->len, r->dir);
- if (rd->buf)
- kfree(rd->buf);
+ kfree(rd->buf);
}
kfree(r);
return 0;
ringarea = pci_alloc_consistent(idev->pdev, HW_RING_AREA_SIZE, &idev->busaddr);
if (!ringarea) {
- ERROR("%s: insufficient memory for descriptor rings\n", __FUNCTION__);
+ IRDA_ERROR("%s: insufficient memory for descriptor rings\n",
+ __FUNCTION__);
goto out;
}
memset(ringarea, 0, HW_RING_AREA_SIZE);
}
if (!rd->skb) {
- WARNING("%s: rx packet lost\n", __FUNCTION__);
+ IRDA_WARNING("%s: rx packet lost\n", __FUNCTION__);
ret |= VLSI_RX_DROP;
goto done;
}
for (rd = ring_last(r); rd != NULL; rd = ring_put(r)) {
if (rd_is_active(rd)) {
- WARNING("%s: driver bug: rx descr race with hw\n",
- __FUNCTION__);
+ IRDA_WARNING("%s: driver bug: rx descr race with hw\n",
+ __FUNCTION__);
vlsi_ring_debug(r);
break;
}
if (ring_first(r) == NULL) {
/* we are in big trouble, if this should ever happen */
- ERROR("%s: rx ring exhausted!\n", __FUNCTION__);
+ IRDA_ERROR("%s: rx ring exhausted!\n", __FUNCTION__);
vlsi_ring_debug(r);
}
else
config = IRCFG_SIR | IRCFG_SIRFILT | IRCFG_RXANY;
switch(baudrate) {
default:
- WARNING("%s: undefined baudrate %d - fallback to 9600!\n",
- __FUNCTION__, baudrate);
+ IRDA_WARNING("%s: undefined baudrate %d - fallback to 9600!\n",
+ __FUNCTION__, baudrate);
baudrate = 9600;
/* fallthru */
case 2400:
config ^= IRENABLE_SIR_ON;
if (config != (IRENABLE_PHYANDCLOCK|IRENABLE_ENRXST)) {
- WARNING("%s: failed to set %s mode!\n", __FUNCTION__,
+ IRDA_WARNING("%s: failed to set %s mode!\n", __FUNCTION__,
(mode==IFF_SIR)?"SIR":((mode==IFF_MIR)?"MIR":"FIR"));
ret = -1;
}
else {
if (inw(iobase+VLSI_PIO_PHYCTL) != nphyctl) {
- WARNING("%s: failed to apply baudrate %d\n",
- __FUNCTION__, baudrate);
+ IRDA_WARNING("%s: failed to apply baudrate %d\n",
+ __FUNCTION__, baudrate);
ret = -1;
}
else {
|| (now.tv_sec==ready.tv_sec && now.tv_usec>=ready.tv_usec))
break;
udelay(100);
- /* must not sleep here - we are called under xmit_lock! */
+ /* must not sleep here - called under netif_tx_lock! */
}
}
*/
if (len >= r->len-5)
- WARNING("%s: possible buffer overflow with SIR wrapping!\n",
- __FUNCTION__);
+ IRDA_WARNING("%s: possible buffer overflow with SIR wrapping!\n",
+ __FUNCTION__);
}
else {
/* hw deals with MIR/FIR mode wrapping */
drop_unlock:
spin_unlock_irqrestore(&idev->lock, flags);
drop:
- WARNING("%s: dropping packet - %s\n", __FUNCTION__, msg);
+ IRDA_WARNING("%s: dropping packet - %s\n", __FUNCTION__, msg);
dev_kfree_skb_any(skb);
idev->stats.tx_errors++;
idev->stats.tx_dropped++;
}
if (count < 3) {
if (clksrc == 1) { /* explicitly asked for PLL hence bail out */
- ERROR("%s: no PLL or failed to lock!\n", __FUNCTION__);
+ IRDA_ERROR("%s: no PLL or failed to lock!\n",
+ __FUNCTION__);
clkctl = CLKCTL_CLKSTP;
pci_write_config_byte(pdev, VLSI_PCI_CLKCTL, clkctl);
return -1;
/* start the clock and clean the registers */
if (vlsi_start_clock(pdev)) {
- ERROR("%s: no valid clock source\n", __FUNCTION__);
+ IRDA_ERROR("%s: no valid clock source\n", __FUNCTION__);
return -1;
}
iobase = ndev->base_addr;
idev->new_baud = idev->baud; /* keep current baudrate */
if (vlsi_start_hw(idev))
- ERROR("%s: failed to restart hw - %s(%s) unusable!\n",
- __FUNCTION__, PCIDEV_NAME(idev->pdev), ndev->name);
+ IRDA_ERROR("%s: failed to restart hw - %s(%s) unusable!\n",
+ __FUNCTION__, pci_name(idev->pdev), ndev->name);
else
netif_start_queue(ndev);
}
irq->ifr_receiving = (fifocnt!=0) ? 1 : 0;
break;
default:
- WARNING("%s: notsupp - cmd=%04x\n", __FUNCTION__, cmd);
+ IRDA_WARNING("%s: notsupp - cmd=%04x\n",
+ __FUNCTION__, cmd);
ret = -EOPNOTSUPP;
}
/********************************************************/
-static irqreturn_t vlsi_interrupt(int irq, void *dev_instance,
- struct pt_regs *regs)
+static irqreturn_t vlsi_interrupt(int irq, void *dev_instance)
{
struct net_device *ndev = dev_instance;
vlsi_irda_dev_t *idev = ndev->priv;
spin_unlock_irqrestore(&idev->lock,flags);
if (boguscount <= 0)
- MESSAGE("%s: too much work in interrupt!\n", __FUNCTION__);
+ IRDA_MESSAGE("%s: too much work in interrupt!\n",
+ __FUNCTION__);
return IRQ_RETVAL(handled);
}
char hwname[32];
if (pci_request_regions(idev->pdev, drivername)) {
- WARNING("%s: io resource busy\n", __FUNCTION__);
+ IRDA_WARNING("%s: io resource busy\n", __FUNCTION__);
goto errout;
}
ndev->base_addr = pci_resource_start(idev->pdev,0);
outb(IRINTR_INT_MASK, ndev->base_addr+VLSI_PIO_IRINTR);
- if (request_irq(ndev->irq, vlsi_interrupt, SA_SHIRQ,
+ if (request_irq(ndev->irq, vlsi_interrupt, IRQF_SHARED,
drivername, ndev)) {
- WARNING("%s: couldn't get IRQ: %d\n", __FUNCTION__, ndev->irq);
+ IRDA_WARNING("%s: couldn't get IRQ: %d\n",
+ __FUNCTION__, ndev->irq);
goto errout_io;
}
netif_start_queue(ndev);
- MESSAGE("%s: device %s operational\n", __FUNCTION__, ndev->name);
+ IRDA_MESSAGE("%s: device %s operational\n", __FUNCTION__, ndev->name);
return 0;
pci_release_regions(idev->pdev);
- MESSAGE("%s: device %s stopped\n", __FUNCTION__, ndev->name);
+ IRDA_MESSAGE("%s: device %s stopped\n", __FUNCTION__, ndev->name);
return 0;
}
if (pci_set_dma_mask(pdev,DMA_MASK_USED_BY_HW)
|| pci_set_dma_mask(pdev,DMA_MASK_MSTRPAGE)) {
- ERROR("%s: aborting due to PCI BM-DMA address limitations\n", __FUNCTION__);
+ IRDA_ERROR("%s: aborting due to PCI BM-DMA address limitations\n", __FUNCTION__);
return -1;
}
else
pdev->current_state = 0; /* hw must be running now */
- MESSAGE("%s: IrDA PCI controller %s detected\n",
- drivername, PCIDEV_NAME(pdev));
+ IRDA_MESSAGE("%s: IrDA PCI controller %s detected\n",
+ drivername, pci_name(pdev));
if ( !pci_resource_start(pdev,0)
|| !(pci_resource_flags(pdev,0) & IORESOURCE_IO) ) {
- ERROR("%s: bar 0 invalid", __FUNCTION__);
+ IRDA_ERROR("%s: bar 0 invalid", __FUNCTION__);
goto out_disable;
}
ndev = alloc_irdadev(sizeof(*idev));
if (ndev==NULL) {
- ERROR("%s: Unable to allocate device memory.\n", __FUNCTION__);
+ IRDA_ERROR("%s: Unable to allocate device memory.\n",
+ __FUNCTION__);
goto out_disable;
}
goto out_freedev;
if (register_netdev(ndev) < 0) {
- ERROR("%s: register_netdev failed\n", __FUNCTION__);
+ IRDA_ERROR("%s: register_netdev failed\n", __FUNCTION__);
goto out_freedev;
}
ent = create_proc_entry(ndev->name, S_IFREG|S_IRUGO, vlsi_proc_root);
if (!ent) {
- WARNING("%s: failed to create proc entry\n", __FUNCTION__);
+ IRDA_WARNING("%s: failed to create proc entry\n",
+ __FUNCTION__);
} else {
ent->data = ndev;
ent->proc_fops = VLSI_PROC_FOPS;
}
idev->proc_entry = ent;
}
- MESSAGE("%s: registered device %s\n", drivername, ndev->name);
+ IRDA_MESSAGE("%s: registered device %s\n", drivername, ndev->name);
pci_set_drvdata(pdev, ndev);
up(&idev->sem);
vlsi_irda_dev_t *idev;
if (!ndev) {
- ERROR("%s: lost netdevice?\n", drivername);
+ IRDA_ERROR("%s: lost netdevice?\n", drivername);
return;
}
pci_set_drvdata(pdev, NULL);
- MESSAGE("%s: %s removed\n", drivername, PCIDEV_NAME(pdev));
+ IRDA_MESSAGE("%s: %s removed\n", drivername, pci_name(pdev));
}
#ifdef CONFIG_PM
*/
-static int vlsi_irda_suspend(struct pci_dev *pdev, u32 state)
+static int vlsi_irda_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct net_device *ndev = pci_get_drvdata(pdev);
vlsi_irda_dev_t *idev;
- if (state < 1 || state > 3 ) {
- ERROR("%s - %s: invalid pm state request: %u\n",
- __FUNCTION__, PCIDEV_NAME(pdev), state);
- return 0;
- }
if (!ndev) {
- ERROR("%s - %s: no netdevice \n", __FUNCTION__, PCIDEV_NAME(pdev));
+ IRDA_ERROR("%s - %s: no netdevice \n",
+ __FUNCTION__, pci_name(pdev));
return 0;
}
idev = ndev->priv;
down(&idev->sem);
if (pdev->current_state != 0) { /* already suspended */
- if (state > pdev->current_state) { /* simply go deeper */
- pci_set_power_state(pdev,state);
- pdev->current_state = state;
+ if (state.event > pdev->current_state) { /* simply go deeper */
+ pci_set_power_state(pdev, pci_choose_state(pdev, state));
+ pdev->current_state = state.event;
}
else
- ERROR("%s - %s: invalid suspend request %u -> %u\n",
- __FUNCTION__, PCIDEV_NAME(pdev), pdev->current_state, state);
+ IRDA_ERROR("%s - %s: invalid suspend request %u -> %u\n", __FUNCTION__, pci_name(pdev), pdev->current_state, state.event);
up(&idev->sem);
return 0;
}
if (netif_running(ndev)) {
netif_device_detach(ndev);
vlsi_stop_hw(idev);
- pci_save_state(pdev, idev->cfg_space);
+ pci_save_state(pdev);
if (!idev->new_baud)
/* remember speed settings to restore on resume */
idev->new_baud = idev->baud;
}
- pci_set_power_state(pdev,state);
- pdev->current_state = state;
+ pci_set_power_state(pdev, pci_choose_state(pdev, state));
+ pdev->current_state = state.event;
idev->resume_ok = 1;
up(&idev->sem);
return 0;
vlsi_irda_dev_t *idev;
if (!ndev) {
- ERROR("%s - %s: no netdevice \n", __FUNCTION__, PCIDEV_NAME(pdev));
+ IRDA_ERROR("%s - %s: no netdevice \n",
+ __FUNCTION__, pci_name(pdev));
return 0;
}
idev = ndev->priv;
down(&idev->sem);
if (pdev->current_state == 0) {
up(&idev->sem);
- WARNING("%s - %s: already resumed\n", __FUNCTION__, PCIDEV_NAME(pdev));
+ IRDA_WARNING("%s - %s: already resumed\n",
+ __FUNCTION__, pci_name(pdev));
return 0;
}
- pci_set_power_state(pdev, 0);
- pdev->current_state = 0;
+ pci_set_power_state(pdev, PCI_D0);
+ pdev->current_state = PM_EVENT_ON;
if (!idev->resume_ok) {
/* should be obsolete now - but used to happen due to:
* now we explicitly set pdev->current_state = 0 after enabling the
* device and independently resume_ok should catch any garbage config.
*/
- WARNING("%s - hm, nothing to resume?\n", __FUNCTION__);
+ IRDA_WARNING("%s - hm, nothing to resume?\n", __FUNCTION__);
up(&idev->sem);
return 0;
}
if (netif_running(ndev)) {
- pci_restore_state(pdev, idev->cfg_space);
+ pci_restore_state(pdev);
vlsi_start_hw(idev);
netif_device_attach(ndev);
}
int i, ret;
if (clksrc < 0 || clksrc > 3) {
- ERROR("%s: invalid clksrc=%d\n", drivername, clksrc);
+ IRDA_ERROR("%s: invalid clksrc=%d\n", drivername, clksrc);
return -1;
}
case 64:
break;
default:
- WARNING("%s: invalid %s ringsize %d, using default=8",
- drivername, (i)?"rx":"tx", ringsize[i]);
+ IRDA_WARNING("%s: invalid %s ringsize %d, using default=8", drivername, (i)?"rx":"tx", ringsize[i]);
ringsize[i] = 8;
break;
}
sirpulse = !!sirpulse;
- /* create_proc_entry returns NULL if !CONFIG_PROC_FS.
+ /* proc_mkdir returns NULL if !CONFIG_PROC_FS.
* Failure to create the procfs entry is handled like running
* without procfs - it's not required for the driver to work.
*/
- vlsi_proc_root = create_proc_entry(PROC_DIR, S_IFDIR, 0);
+ vlsi_proc_root = proc_mkdir(PROC_DIR, NULL);
if (vlsi_proc_root) {
/* protect registered procdir against module removal.
* Because we are in the module init path there's no race
vlsi_proc_root->owner = THIS_MODULE;
}
- ret = pci_module_init(&vlsi_irda_driver);
+ ret = pci_register_driver(&vlsi_irda_driver);
if (ret && vlsi_proc_root)
- remove_proc_entry(PROC_DIR, 0);
+ remove_proc_entry(PROC_DIR, NULL);
return ret;
}
{
pci_unregister_driver(&vlsi_irda_driver);
if (vlsi_proc_root)
- remove_proc_entry(PROC_DIR, 0);
+ remove_proc_entry(PROC_DIR, NULL);
}
module_init(vlsi_mod_init);
git://git.onelab.eu / linux-2.6.git / blobdiff