forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
427 lines
11 KiB
427 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* tifm_7xx1.c - TI FlashMedia driver |
|
* |
|
* Copyright (C) 2006 Alex Dubov <[email protected]> |
|
*/ |
|
|
|
#include <linux/tifm.h> |
|
#include <linux/dma-mapping.h> |
|
#include <linux/module.h> |
|
|
|
#define DRIVER_NAME "tifm_7xx1" |
|
#define DRIVER_VERSION "0.8" |
|
|
|
#define TIFM_IRQ_ENABLE 0x80000000 |
|
#define TIFM_IRQ_SOCKMASK(x) (x) |
|
#define TIFM_IRQ_CARDMASK(x) ((x) << 8) |
|
#define TIFM_IRQ_FIFOMASK(x) ((x) << 16) |
|
#define TIFM_IRQ_SETALL 0xffffffff |
|
|
|
static void tifm_7xx1_dummy_eject(struct tifm_adapter *fm, |
|
struct tifm_dev *sock) |
|
{ |
|
} |
|
|
|
static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock) |
|
{ |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&fm->lock, flags); |
|
fm->socket_change_set |= 1 << sock->socket_id; |
|
tifm_queue_work(&fm->media_switcher); |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
} |
|
|
|
static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id) |
|
{ |
|
struct tifm_adapter *fm = dev_id; |
|
struct tifm_dev *sock; |
|
unsigned int irq_status, cnt; |
|
|
|
spin_lock(&fm->lock); |
|
irq_status = readl(fm->addr + FM_INTERRUPT_STATUS); |
|
if (irq_status == 0 || irq_status == (~0)) { |
|
spin_unlock(&fm->lock); |
|
return IRQ_NONE; |
|
} |
|
|
|
if (irq_status & TIFM_IRQ_ENABLE) { |
|
writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE); |
|
|
|
for (cnt = 0; cnt < fm->num_sockets; cnt++) { |
|
sock = fm->sockets[cnt]; |
|
if (sock) { |
|
if ((irq_status >> cnt) & TIFM_IRQ_FIFOMASK(1)) |
|
sock->data_event(sock); |
|
if ((irq_status >> cnt) & TIFM_IRQ_CARDMASK(1)) |
|
sock->card_event(sock); |
|
} |
|
} |
|
|
|
fm->socket_change_set |= irq_status |
|
& ((1 << fm->num_sockets) - 1); |
|
} |
|
writel(irq_status, fm->addr + FM_INTERRUPT_STATUS); |
|
|
|
if (fm->finish_me) |
|
complete_all(fm->finish_me); |
|
else if (!fm->socket_change_set) |
|
writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
else |
|
tifm_queue_work(&fm->media_switcher); |
|
|
|
spin_unlock(&fm->lock); |
|
return IRQ_HANDLED; |
|
} |
|
|
|
static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr) |
|
{ |
|
unsigned int s_state; |
|
int cnt; |
|
|
|
writel(0x0e00, sock_addr + SOCK_CONTROL); |
|
|
|
for (cnt = 16; cnt <= 256; cnt <<= 1) { |
|
if (!(TIFM_SOCK_STATE_POWERED |
|
& readl(sock_addr + SOCK_PRESENT_STATE))) |
|
break; |
|
|
|
msleep(cnt); |
|
} |
|
|
|
s_state = readl(sock_addr + SOCK_PRESENT_STATE); |
|
if (!(TIFM_SOCK_STATE_OCCUPIED & s_state)) |
|
return 0; |
|
|
|
writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED, |
|
sock_addr + SOCK_CONTROL); |
|
|
|
/* xd needs some extra time before power on */ |
|
if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) |
|
== TIFM_TYPE_XD) |
|
msleep(40); |
|
|
|
writel((s_state & TIFM_CTRL_POWER_MASK) | 0x0c00, |
|
sock_addr + SOCK_CONTROL); |
|
/* wait for power to stabilize */ |
|
msleep(20); |
|
for (cnt = 16; cnt <= 256; cnt <<= 1) { |
|
if ((TIFM_SOCK_STATE_POWERED |
|
& readl(sock_addr + SOCK_PRESENT_STATE))) |
|
break; |
|
|
|
msleep(cnt); |
|
} |
|
|
|
writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED), |
|
sock_addr + SOCK_CONTROL); |
|
|
|
return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7; |
|
} |
|
|
|
inline static void tifm_7xx1_sock_power_off(char __iomem *sock_addr) |
|
{ |
|
writel((~TIFM_CTRL_POWER_MASK) & readl(sock_addr + SOCK_CONTROL), |
|
sock_addr + SOCK_CONTROL); |
|
} |
|
|
|
inline static char __iomem * |
|
tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num) |
|
{ |
|
return base_addr + ((sock_num + 1) << 10); |
|
} |
|
|
|
static void tifm_7xx1_switch_media(struct work_struct *work) |
|
{ |
|
struct tifm_adapter *fm = container_of(work, struct tifm_adapter, |
|
media_switcher); |
|
struct tifm_dev *sock; |
|
char __iomem *sock_addr; |
|
unsigned long flags; |
|
unsigned char media_id; |
|
unsigned int socket_change_set, cnt; |
|
|
|
spin_lock_irqsave(&fm->lock, flags); |
|
socket_change_set = fm->socket_change_set; |
|
fm->socket_change_set = 0; |
|
|
|
dev_dbg(fm->dev.parent, "checking media set %x\n", |
|
socket_change_set); |
|
|
|
if (!socket_change_set) { |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
return; |
|
} |
|
|
|
for (cnt = 0; cnt < fm->num_sockets; cnt++) { |
|
if (!(socket_change_set & (1 << cnt))) |
|
continue; |
|
sock = fm->sockets[cnt]; |
|
if (sock) { |
|
printk(KERN_INFO |
|
"%s : demand removing card from socket %u:%u\n", |
|
dev_name(&fm->dev), fm->id, cnt); |
|
fm->sockets[cnt] = NULL; |
|
sock_addr = sock->addr; |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
device_unregister(&sock->dev); |
|
spin_lock_irqsave(&fm->lock, flags); |
|
tifm_7xx1_sock_power_off(sock_addr); |
|
writel(0x0e00, sock_addr + SOCK_CONTROL); |
|
} |
|
|
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
|
|
media_id = tifm_7xx1_toggle_sock_power( |
|
tifm_7xx1_sock_addr(fm->addr, cnt)); |
|
|
|
// tifm_alloc_device will check if media_id is valid |
|
sock = tifm_alloc_device(fm, cnt, media_id); |
|
if (sock) { |
|
sock->addr = tifm_7xx1_sock_addr(fm->addr, cnt); |
|
|
|
if (!device_register(&sock->dev)) { |
|
spin_lock_irqsave(&fm->lock, flags); |
|
if (!fm->sockets[cnt]) { |
|
fm->sockets[cnt] = sock; |
|
sock = NULL; |
|
} |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
} |
|
if (sock) |
|
tifm_free_device(&sock->dev); |
|
} |
|
spin_lock_irqsave(&fm->lock, flags); |
|
} |
|
|
|
writel(TIFM_IRQ_FIFOMASK(socket_change_set) |
|
| TIFM_IRQ_CARDMASK(socket_change_set), |
|
fm->addr + FM_CLEAR_INTERRUPT_ENABLE); |
|
|
|
writel(TIFM_IRQ_FIFOMASK(socket_change_set) |
|
| TIFM_IRQ_CARDMASK(socket_change_set), |
|
fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
|
|
writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
} |
|
|
|
static int __maybe_unused tifm_7xx1_suspend(struct device *dev_d) |
|
{ |
|
struct pci_dev *dev = to_pci_dev(dev_d); |
|
struct tifm_adapter *fm = pci_get_drvdata(dev); |
|
int cnt; |
|
|
|
dev_dbg(&dev->dev, "suspending host\n"); |
|
|
|
for (cnt = 0; cnt < fm->num_sockets; cnt++) { |
|
if (fm->sockets[cnt]) |
|
tifm_7xx1_sock_power_off(fm->sockets[cnt]->addr); |
|
} |
|
|
|
device_wakeup_disable(dev_d); |
|
return 0; |
|
} |
|
|
|
static int __maybe_unused tifm_7xx1_resume(struct device *dev_d) |
|
{ |
|
struct pci_dev *dev = to_pci_dev(dev_d); |
|
struct tifm_adapter *fm = pci_get_drvdata(dev); |
|
int rc; |
|
unsigned long timeout; |
|
unsigned int good_sockets = 0, bad_sockets = 0; |
|
unsigned long flags; |
|
/* Maximum number of entries is 4 */ |
|
unsigned char new_ids[4]; |
|
DECLARE_COMPLETION_ONSTACK(finish_resume); |
|
|
|
if (WARN_ON(fm->num_sockets > ARRAY_SIZE(new_ids))) |
|
return -ENXIO; |
|
|
|
pci_set_master(dev); |
|
|
|
dev_dbg(&dev->dev, "resuming host\n"); |
|
|
|
for (rc = 0; rc < fm->num_sockets; rc++) |
|
new_ids[rc] = tifm_7xx1_toggle_sock_power( |
|
tifm_7xx1_sock_addr(fm->addr, rc)); |
|
spin_lock_irqsave(&fm->lock, flags); |
|
for (rc = 0; rc < fm->num_sockets; rc++) { |
|
if (fm->sockets[rc]) { |
|
if (fm->sockets[rc]->type == new_ids[rc]) |
|
good_sockets |= 1 << rc; |
|
else |
|
bad_sockets |= 1 << rc; |
|
} |
|
} |
|
|
|
writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1), |
|
fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
dev_dbg(&dev->dev, "change sets on resume: good %x, bad %x\n", |
|
good_sockets, bad_sockets); |
|
|
|
fm->socket_change_set = 0; |
|
if (good_sockets) { |
|
fm->finish_me = &finish_resume; |
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
timeout = wait_for_completion_timeout(&finish_resume, HZ); |
|
dev_dbg(&dev->dev, "wait returned %lu\n", timeout); |
|
writel(TIFM_IRQ_FIFOMASK(good_sockets) |
|
| TIFM_IRQ_CARDMASK(good_sockets), |
|
fm->addr + FM_CLEAR_INTERRUPT_ENABLE); |
|
writel(TIFM_IRQ_FIFOMASK(good_sockets) |
|
| TIFM_IRQ_CARDMASK(good_sockets), |
|
fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
spin_lock_irqsave(&fm->lock, flags); |
|
fm->finish_me = NULL; |
|
fm->socket_change_set ^= good_sockets & fm->socket_change_set; |
|
} |
|
|
|
fm->socket_change_set |= bad_sockets; |
|
if (fm->socket_change_set) |
|
tifm_queue_work(&fm->media_switcher); |
|
|
|
spin_unlock_irqrestore(&fm->lock, flags); |
|
writel(TIFM_IRQ_ENABLE, |
|
fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
|
|
return 0; |
|
} |
|
|
|
static int tifm_7xx1_dummy_has_ms_pif(struct tifm_adapter *fm, |
|
struct tifm_dev *sock) |
|
{ |
|
return 0; |
|
} |
|
|
|
static int tifm_7xx1_has_ms_pif(struct tifm_adapter *fm, struct tifm_dev *sock) |
|
{ |
|
if (((fm->num_sockets == 4) && (sock->socket_id == 2)) |
|
|| ((fm->num_sockets == 2) && (sock->socket_id == 0))) |
|
return 1; |
|
|
|
return 0; |
|
} |
|
|
|
static int tifm_7xx1_probe(struct pci_dev *dev, |
|
const struct pci_device_id *dev_id) |
|
{ |
|
struct tifm_adapter *fm; |
|
int pci_dev_busy = 0; |
|
int rc; |
|
|
|
rc = pci_set_dma_mask(dev, DMA_BIT_MASK(32)); |
|
if (rc) |
|
return rc; |
|
|
|
rc = pci_enable_device(dev); |
|
if (rc) |
|
return rc; |
|
|
|
pci_set_master(dev); |
|
|
|
rc = pci_request_regions(dev, DRIVER_NAME); |
|
if (rc) { |
|
pci_dev_busy = 1; |
|
goto err_out; |
|
} |
|
|
|
pci_intx(dev, 1); |
|
|
|
fm = tifm_alloc_adapter(dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM |
|
? 4 : 2, &dev->dev); |
|
if (!fm) { |
|
rc = -ENOMEM; |
|
goto err_out_int; |
|
} |
|
|
|
INIT_WORK(&fm->media_switcher, tifm_7xx1_switch_media); |
|
fm->eject = tifm_7xx1_eject; |
|
fm->has_ms_pif = tifm_7xx1_has_ms_pif; |
|
pci_set_drvdata(dev, fm); |
|
|
|
fm->addr = pci_ioremap_bar(dev, 0); |
|
if (!fm->addr) { |
|
rc = -ENODEV; |
|
goto err_out_free; |
|
} |
|
|
|
rc = request_irq(dev->irq, tifm_7xx1_isr, IRQF_SHARED, DRIVER_NAME, fm); |
|
if (rc) |
|
goto err_out_unmap; |
|
|
|
rc = tifm_add_adapter(fm); |
|
if (rc) |
|
goto err_out_irq; |
|
|
|
writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1), |
|
fm->addr + FM_CLEAR_INTERRUPT_ENABLE); |
|
writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1), |
|
fm->addr + FM_SET_INTERRUPT_ENABLE); |
|
return 0; |
|
|
|
err_out_irq: |
|
free_irq(dev->irq, fm); |
|
err_out_unmap: |
|
iounmap(fm->addr); |
|
err_out_free: |
|
tifm_free_adapter(fm); |
|
err_out_int: |
|
pci_intx(dev, 0); |
|
pci_release_regions(dev); |
|
err_out: |
|
if (!pci_dev_busy) |
|
pci_disable_device(dev); |
|
return rc; |
|
} |
|
|
|
static void tifm_7xx1_remove(struct pci_dev *dev) |
|
{ |
|
struct tifm_adapter *fm = pci_get_drvdata(dev); |
|
int cnt; |
|
|
|
fm->eject = tifm_7xx1_dummy_eject; |
|
fm->has_ms_pif = tifm_7xx1_dummy_has_ms_pif; |
|
writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE); |
|
free_irq(dev->irq, fm); |
|
|
|
tifm_remove_adapter(fm); |
|
|
|
for (cnt = 0; cnt < fm->num_sockets; cnt++) |
|
tifm_7xx1_sock_power_off(tifm_7xx1_sock_addr(fm->addr, cnt)); |
|
|
|
iounmap(fm->addr); |
|
pci_intx(dev, 0); |
|
pci_release_regions(dev); |
|
|
|
pci_disable_device(dev); |
|
tifm_free_adapter(fm); |
|
} |
|
|
|
static const struct pci_device_id tifm_7xx1_pci_tbl[] = { |
|
{ PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11_FM, PCI_ANY_ID, |
|
PCI_ANY_ID, 0, 0, 0 }, /* xx21 - the one I have */ |
|
{ PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12_FM, PCI_ANY_ID, |
|
PCI_ANY_ID, 0, 0, 0 }, |
|
{ PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX20_FM, PCI_ANY_ID, |
|
PCI_ANY_ID, 0, 0, 0 }, |
|
{ } |
|
}; |
|
|
|
static SIMPLE_DEV_PM_OPS(tifm_7xx1_pm_ops, tifm_7xx1_suspend, tifm_7xx1_resume); |
|
|
|
static struct pci_driver tifm_7xx1_driver = { |
|
.name = DRIVER_NAME, |
|
.id_table = tifm_7xx1_pci_tbl, |
|
.probe = tifm_7xx1_probe, |
|
.remove = tifm_7xx1_remove, |
|
.driver.pm = &tifm_7xx1_pm_ops, |
|
}; |
|
|
|
module_pci_driver(tifm_7xx1_driver); |
|
MODULE_AUTHOR("Alex Dubov"); |
|
MODULE_DESCRIPTION("TI FlashMedia host driver"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl); |
|
MODULE_VERSION(DRIVER_VERSION);
|
|
|