54380da343a530ab4a4513eef7501d9e52b6d487
[linux-2.6.git] / drivers / misc / tifm_7xx1.c
1 /*
2  *  tifm_7xx1.c - TI FlashMedia driver
3  *
4  *  Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  */
11
12 #include <linux/tifm.h>
13 #include <linux/dma-mapping.h>
14
15 #define DRIVER_NAME "tifm_7xx1"
16 #define DRIVER_VERSION "0.8"
17
18 #define TIFM_IRQ_ENABLE           0x80000000
19 #define TIFM_IRQ_SOCKMASK(x)      (x)
20 #define TIFM_IRQ_CARDMASK(x)      ((x) << 8)
21 #define TIFM_IRQ_FIFOMASK(x)      ((x) << 16)
22 #define TIFM_IRQ_SETALL           0xffffffff
23
24 static void tifm_7xx1_dummy_eject(struct tifm_adapter *fm,
25                                   struct tifm_dev *sock)
26 {
27 }
28
29 static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
30 {
31         unsigned long flags;
32
33         spin_lock_irqsave(&fm->lock, flags);
34         fm->socket_change_set |= 1 << sock->socket_id;
35         tifm_queue_work(&fm->media_switcher);
36         spin_unlock_irqrestore(&fm->lock, flags);
37 }
38
39 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id)
40 {
41         struct tifm_adapter *fm = dev_id;
42         struct tifm_dev *sock;
43         unsigned int irq_status, cnt;
44
45         spin_lock(&fm->lock);
46         irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
47         if (irq_status == 0 || irq_status == (~0)) {
48                 spin_unlock(&fm->lock);
49                 return IRQ_NONE;
50         }
51
52         if (irq_status & TIFM_IRQ_ENABLE) {
53                 writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
54
55                 for (cnt = 0; cnt < fm->num_sockets; cnt++) {
56                         sock = fm->sockets[cnt];
57                         if (sock) {
58                                 if ((irq_status >> cnt) & TIFM_IRQ_FIFOMASK(1))
59                                         sock->data_event(sock);
60                                 if ((irq_status >> cnt) & TIFM_IRQ_CARDMASK(1))
61                                         sock->card_event(sock);
62                         }
63                 }
64
65                 fm->socket_change_set |= irq_status
66                                          & ((1 << fm->num_sockets) - 1);
67         }
68         writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
69
70         if (fm->finish_me)
71                 complete_all(fm->finish_me);
72         else if (!fm->socket_change_set)
73                 writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
74         else
75                 tifm_queue_work(&fm->media_switcher);
76
77         spin_unlock(&fm->lock);
78         return IRQ_HANDLED;
79 }
80
81 static unsigned char tifm_7xx1_toggle_sock_power(char __iomem *sock_addr)
82 {
83         unsigned int s_state;
84         int cnt;
85
86         writel(0x0e00, sock_addr + SOCK_CONTROL);
87
88         for (cnt = 16; cnt <= 256; cnt <<= 1) {
89                 if (!(TIFM_SOCK_STATE_POWERED
90                       & readl(sock_addr + SOCK_PRESENT_STATE)))
91                         break;
92
93                 msleep(cnt);
94         }
95
96         s_state = readl(sock_addr + SOCK_PRESENT_STATE);
97         if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
98                 return 0;
99
100         writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED,
101                sock_addr + SOCK_CONTROL);
102
103         /* xd needs some extra time before power on */
104         if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7)
105             == TIFM_TYPE_XD)
106                 msleep(40);
107
108         writel((s_state & TIFM_CTRL_POWER_MASK) | 0x0c00,
109                sock_addr + SOCK_CONTROL);
110         /* wait for power to stabilize */
111         msleep(20);
112         for (cnt = 16; cnt <= 256; cnt <<= 1) {
113                 if ((TIFM_SOCK_STATE_POWERED
114                      & readl(sock_addr + SOCK_PRESENT_STATE)))
115                         break;
116
117                 msleep(cnt);
118         }
119
120         writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
121                sock_addr + SOCK_CONTROL);
122
123         return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
124 }
125
126 inline static void tifm_7xx1_sock_power_off(char __iomem *sock_addr)
127 {
128         writel((~TIFM_CTRL_POWER_MASK) & readl(sock_addr + SOCK_CONTROL),
129                sock_addr + SOCK_CONTROL);
130 }
131
132 inline static char __iomem *
133 tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num)
134 {
135         return base_addr + ((sock_num + 1) << 10);
136 }
137
138 static void tifm_7xx1_switch_media(struct work_struct *work)
139 {
140         struct tifm_adapter *fm = container_of(work, struct tifm_adapter,
141                                                media_switcher);
142         struct tifm_dev *sock;
143         char __iomem *sock_addr;
144         unsigned long flags;
145         unsigned char media_id;
146         unsigned int socket_change_set, cnt;
147
148         spin_lock_irqsave(&fm->lock, flags);
149         socket_change_set = fm->socket_change_set;
150         fm->socket_change_set = 0;
151
152         dev_dbg(fm->dev.parent, "checking media set %x\n",
153                 socket_change_set);
154
155         if (!socket_change_set) {
156                 spin_unlock_irqrestore(&fm->lock, flags);
157                 return;
158         }
159
160         for (cnt = 0; cnt < fm->num_sockets; cnt++) {
161                 if (!(socket_change_set & (1 << cnt)))
162                         continue;
163                 sock = fm->sockets[cnt];
164                 if (sock) {
165                         printk(KERN_INFO
166                                "%s : demand removing card from socket %u:%u\n",
167                                fm->dev.bus_id, fm->id, cnt);
168                         fm->sockets[cnt] = NULL;
169                         sock_addr = sock->addr;
170                         spin_unlock_irqrestore(&fm->lock, flags);
171                         device_unregister(&sock->dev);
172                         spin_lock_irqsave(&fm->lock, flags);
173                         tifm_7xx1_sock_power_off(sock_addr);
174                         writel(0x0e00, sock_addr + SOCK_CONTROL);
175                 }
176
177                 spin_unlock_irqrestore(&fm->lock, flags);
178
179                 media_id = tifm_7xx1_toggle_sock_power(
180                                 tifm_7xx1_sock_addr(fm->addr, cnt));
181
182                 // tifm_alloc_device will check if media_id is valid
183                 sock = tifm_alloc_device(fm, cnt, media_id);
184                 if (sock) {
185                         sock->addr = tifm_7xx1_sock_addr(fm->addr, cnt);
186
187                         if (!device_register(&sock->dev)) {
188                                 spin_lock_irqsave(&fm->lock, flags);
189                                 if (!fm->sockets[cnt]) {
190                                         fm->sockets[cnt] = sock;
191                                         sock = NULL;
192                                 }
193                                 spin_unlock_irqrestore(&fm->lock, flags);
194                         }
195                         if (sock)
196                                 tifm_free_device(&sock->dev);
197                 }
198                 spin_lock_irqsave(&fm->lock, flags);
199         }
200
201         writel(TIFM_IRQ_FIFOMASK(socket_change_set)
202                | TIFM_IRQ_CARDMASK(socket_change_set),
203                fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
204
205         writel(TIFM_IRQ_FIFOMASK(socket_change_set)
206                | TIFM_IRQ_CARDMASK(socket_change_set),
207                fm->addr + FM_SET_INTERRUPT_ENABLE);
208
209         writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
210         spin_unlock_irqrestore(&fm->lock, flags);
211 }
212
213 #ifdef CONFIG_PM
214
215 static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
216 {
217         struct tifm_adapter *fm = pci_get_drvdata(dev);
218         int cnt;
219
220         dev_dbg(&dev->dev, "suspending host\n");
221
222         for (cnt = 0; cnt < fm->num_sockets; cnt++) {
223                 if (fm->sockets[cnt])
224                         tifm_7xx1_sock_power_off(fm->sockets[cnt]->addr);
225         }
226
227         pci_save_state(dev);
228         pci_enable_wake(dev, pci_choose_state(dev, state), 0);
229         pci_disable_device(dev);
230         pci_set_power_state(dev, pci_choose_state(dev, state));
231         return 0;
232 }
233
234 static int tifm_7xx1_resume(struct pci_dev *dev)
235 {
236         struct tifm_adapter *fm = pci_get_drvdata(dev);
237         int rc;
238         unsigned int good_sockets = 0, bad_sockets = 0;
239         unsigned long flags;
240         unsigned char new_ids[fm->num_sockets];
241         DECLARE_COMPLETION_ONSTACK(finish_resume);
242
243         pci_set_power_state(dev, PCI_D0);
244         pci_restore_state(dev);
245         rc = pci_enable_device(dev);
246         if (rc)
247                 return rc;
248         pci_set_master(dev);
249
250         dev_dbg(&dev->dev, "resuming host\n");
251
252         for (rc = 0; rc < fm->num_sockets; rc++)
253                 new_ids[rc] = tifm_7xx1_toggle_sock_power(
254                                         tifm_7xx1_sock_addr(fm->addr, rc));
255         spin_lock_irqsave(&fm->lock, flags);
256         for (rc = 0; rc < fm->num_sockets; rc++) {
257                 if (fm->sockets[rc]) {
258                         if (fm->sockets[rc]->type == new_ids[rc])
259                                 good_sockets |= 1 << rc;
260                         else
261                                 bad_sockets |= 1 << rc;
262                 }
263         }
264
265         writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
266                fm->addr + FM_SET_INTERRUPT_ENABLE);
267         dev_dbg(&dev->dev, "change sets on resume: good %x, bad %x\n",
268                 good_sockets, bad_sockets);
269
270         fm->socket_change_set = 0;
271         if (good_sockets) {
272                 fm->finish_me = &finish_resume;
273                 spin_unlock_irqrestore(&fm->lock, flags);
274                 rc = wait_for_completion_timeout(&finish_resume, HZ);
275                 dev_dbg(&dev->dev, "wait returned %d\n", rc);
276                 writel(TIFM_IRQ_FIFOMASK(good_sockets)
277                        | TIFM_IRQ_CARDMASK(good_sockets),
278                        fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
279                 writel(TIFM_IRQ_FIFOMASK(good_sockets)
280                        | TIFM_IRQ_CARDMASK(good_sockets),
281                        fm->addr + FM_SET_INTERRUPT_ENABLE);
282                 spin_lock_irqsave(&fm->lock, flags);
283                 fm->finish_me = NULL;
284                 fm->socket_change_set ^= good_sockets & fm->socket_change_set;
285         }
286
287         fm->socket_change_set |= bad_sockets;
288         if (fm->socket_change_set)
289                 tifm_queue_work(&fm->media_switcher);
290
291         spin_unlock_irqrestore(&fm->lock, flags);
292         writel(TIFM_IRQ_ENABLE,
293                fm->addr + FM_SET_INTERRUPT_ENABLE);
294
295         return 0;
296 }
297
298 #else
299
300 #define tifm_7xx1_suspend NULL
301 #define tifm_7xx1_resume NULL
302
303 #endif /* CONFIG_PM */
304
305 static int tifm_7xx1_probe(struct pci_dev *dev,
306                            const struct pci_device_id *dev_id)
307 {
308         struct tifm_adapter *fm;
309         int pci_dev_busy = 0;
310         int rc;
311
312         rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
313         if (rc)
314                 return rc;
315
316         rc = pci_enable_device(dev);
317         if (rc)
318                 return rc;
319
320         pci_set_master(dev);
321
322         rc = pci_request_regions(dev, DRIVER_NAME);
323         if (rc) {
324                 pci_dev_busy = 1;
325                 goto err_out;
326         }
327
328         pci_intx(dev, 1);
329
330         fm = tifm_alloc_adapter(dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM
331                                 ? 4 : 2, &dev->dev);
332         if (!fm) {
333                 rc = -ENOMEM;
334                 goto err_out_int;
335         }
336
337         INIT_WORK(&fm->media_switcher, tifm_7xx1_switch_media);
338         fm->eject = tifm_7xx1_eject;
339         pci_set_drvdata(dev, fm);
340
341         fm->addr = ioremap(pci_resource_start(dev, 0),
342                            pci_resource_len(dev, 0));
343         if (!fm->addr)
344                 goto err_out_free;
345
346         rc = request_irq(dev->irq, tifm_7xx1_isr, IRQF_SHARED, DRIVER_NAME, fm);
347         if (rc)
348                 goto err_out_unmap;
349
350         rc = tifm_add_adapter(fm);
351         if (rc)
352                 goto err_out_irq;
353
354         writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
355                fm->addr + FM_SET_INTERRUPT_ENABLE);
356         return 0;
357
358 err_out_irq:
359         free_irq(dev->irq, fm);
360 err_out_unmap:
361         iounmap(fm->addr);
362 err_out_free:
363         pci_set_drvdata(dev, NULL);
364         tifm_free_adapter(fm);
365 err_out_int:
366         pci_intx(dev, 0);
367         pci_release_regions(dev);
368 err_out:
369         if (!pci_dev_busy)
370                 pci_disable_device(dev);
371         return rc;
372 }
373
374 static void tifm_7xx1_remove(struct pci_dev *dev)
375 {
376         struct tifm_adapter *fm = pci_get_drvdata(dev);
377         int cnt;
378
379         fm->eject = tifm_7xx1_dummy_eject;
380         writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
381         mmiowb();
382         free_irq(dev->irq, fm);
383
384         tifm_remove_adapter(fm);
385
386         for (cnt = 0; cnt < fm->num_sockets; cnt++)
387                 tifm_7xx1_sock_power_off(tifm_7xx1_sock_addr(fm->addr, cnt));
388
389         pci_set_drvdata(dev, NULL);
390
391         iounmap(fm->addr);
392         pci_intx(dev, 0);
393         pci_release_regions(dev);
394
395         pci_disable_device(dev);
396         tifm_free_adapter(fm);
397 }
398
399 static struct pci_device_id tifm_7xx1_pci_tbl [] = {
400         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11_FM, PCI_ANY_ID,
401           PCI_ANY_ID, 0, 0, 0 }, /* xx21 - the one I have */
402         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12_FM, PCI_ANY_ID,
403           PCI_ANY_ID, 0, 0, 0 },
404         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX20_FM, PCI_ANY_ID,
405           PCI_ANY_ID, 0, 0, 0 },
406         { }
407 };
408
409 static struct pci_driver tifm_7xx1_driver = {
410         .name = DRIVER_NAME,
411         .id_table = tifm_7xx1_pci_tbl,
412         .probe = tifm_7xx1_probe,
413         .remove = tifm_7xx1_remove,
414         .suspend = tifm_7xx1_suspend,
415         .resume = tifm_7xx1_resume,
416 };
417
418 static int __init tifm_7xx1_init(void)
419 {
420         return pci_register_driver(&tifm_7xx1_driver);
421 }
422
423 static void __exit tifm_7xx1_exit(void)
424 {
425         pci_unregister_driver(&tifm_7xx1_driver);
426 }
427
428 MODULE_AUTHOR("Alex Dubov");
429 MODULE_DESCRIPTION("TI FlashMedia host driver");
430 MODULE_LICENSE("GPL");
431 MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
432 MODULE_VERSION(DRIVER_VERSION);
433
434 module_init(tifm_7xx1_init);
435 module_exit(tifm_7xx1_exit);