bc60e2fc3c2cc8e6342a74403cdd2b5687b7c8a0
[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 #include <linux/freezer.h>
15
16 #define DRIVER_NAME "tifm_7xx1"
17 #define DRIVER_VERSION "0.7"
18
19 static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
20 {
21         unsigned long flags;
22
23         spin_lock_irqsave(&fm->lock, flags);
24         fm->socket_change_set |= 1 << sock->socket_id;
25         wake_up_all(&fm->change_set_notify);
26         spin_unlock_irqrestore(&fm->lock, flags);
27 }
28
29 static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id)
30 {
31         struct tifm_adapter *fm = dev_id;
32         struct tifm_dev *sock;
33         unsigned int irq_status;
34         unsigned int sock_irq_status, cnt;
35
36         spin_lock(&fm->lock);
37         irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
38         if (irq_status == 0 || irq_status == (~0)) {
39                 spin_unlock(&fm->lock);
40                 return IRQ_NONE;
41         }
42
43         if (irq_status & TIFM_IRQ_ENABLE) {
44                 writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
45
46                 for (cnt = 0; cnt < fm->num_sockets; cnt++) {
47                         sock = fm->sockets[cnt];
48                         sock_irq_status = (irq_status >> cnt)
49                                           & (TIFM_IRQ_FIFOMASK(1)
50                                              | TIFM_IRQ_CARDMASK(1));
51
52                         if (sock && sock_irq_status)
53                                 sock->signal_irq(sock, sock_irq_status);
54                 }
55
56                 fm->socket_change_set |= irq_status
57                                          & ((1 << fm->num_sockets) - 1);
58         }
59         writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
60
61         if (!fm->socket_change_set)
62                 writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
63         else
64                 wake_up_all(&fm->change_set_notify);
65
66         spin_unlock(&fm->lock);
67         return IRQ_HANDLED;
68 }
69
70 static tifm_media_id tifm_7xx1_toggle_sock_power(char __iomem *sock_addr,
71                                                  int is_x2)
72 {
73         unsigned int s_state;
74         int cnt;
75
76         writel(0x0e00, sock_addr + SOCK_CONTROL);
77
78         for (cnt = 0; cnt < 100; cnt++) {
79                 if (!(TIFM_SOCK_STATE_POWERED
80                       & readl(sock_addr + SOCK_PRESENT_STATE)))
81                         break;
82                 msleep(10);
83         }
84
85         s_state = readl(sock_addr + SOCK_PRESENT_STATE);
86         if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
87                 return FM_NULL;
88
89         if (is_x2) {
90                 writel((s_state & 7) | 0x0c00, sock_addr + SOCK_CONTROL);
91         } else {
92                 // SmartMedia cards need extra 40 msec
93                 if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) == 1)
94                         msleep(40);
95                 writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED,
96                        sock_addr + SOCK_CONTROL);
97                 msleep(10);
98                 writel((s_state & 0x7) | 0x0c00 | TIFM_CTRL_LED,
99                         sock_addr + SOCK_CONTROL);
100         }
101
102         for (cnt = 0; cnt < 100; cnt++) {
103                 if ((TIFM_SOCK_STATE_POWERED
104                      & readl(sock_addr + SOCK_PRESENT_STATE)))
105                         break;
106                 msleep(10);
107         }
108
109         if (!is_x2)
110                 writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
111                        sock_addr + SOCK_CONTROL);
112
113         return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
114 }
115
116 inline static char __iomem *
117 tifm_7xx1_sock_addr(char __iomem *base_addr, unsigned int sock_num)
118 {
119         return base_addr + ((sock_num + 1) << 10);
120 }
121
122 static int tifm_7xx1_switch_media(void *data)
123 {
124         struct tifm_adapter *fm = data;
125         unsigned long flags;
126         tifm_media_id media_id;
127         char *card_name = "xx";
128         int cnt, rc;
129         struct tifm_dev *sock;
130         unsigned int socket_change_set;
131
132         while (1) {
133                 rc = wait_event_interruptible(fm->change_set_notify,
134                                               fm->socket_change_set);
135                 if (rc == -ERESTARTSYS)
136                         try_to_freeze();
137
138                 spin_lock_irqsave(&fm->lock, flags);
139                 socket_change_set = fm->socket_change_set;
140                 fm->socket_change_set = 0;
141
142                 dev_dbg(fm->dev, "checking media set %x\n",
143                         socket_change_set);
144
145                 if (kthread_should_stop())
146                         socket_change_set = (1 << fm->num_sockets) - 1;
147                 spin_unlock_irqrestore(&fm->lock, flags);
148
149                 if (!socket_change_set)
150                         continue;
151
152                 spin_lock_irqsave(&fm->lock, flags);
153                 for (cnt = 0; cnt < fm->num_sockets; cnt++) {
154                         if (!(socket_change_set & (1 << cnt)))
155                                 continue;
156                         sock = fm->sockets[cnt];
157                         if (sock) {
158                                 printk(KERN_INFO DRIVER_NAME
159                                        ": demand removing card from socket %d\n",
160                                        cnt);
161                                 fm->sockets[cnt] = NULL;
162                                 spin_unlock_irqrestore(&fm->lock, flags);
163                                 device_unregister(&sock->dev);
164                                 spin_lock_irqsave(&fm->lock, flags);
165                                 writel(0x0e00,
166                                        tifm_7xx1_sock_addr(fm->addr, cnt)
167                                        + SOCK_CONTROL);
168                         }
169                         if (kthread_should_stop())
170                                 continue;
171
172                         spin_unlock_irqrestore(&fm->lock, flags);
173                         media_id = tifm_7xx1_toggle_sock_power(
174                                         tifm_7xx1_sock_addr(fm->addr, cnt),
175                                         fm->num_sockets == 2);
176                         if (media_id) {
177                                 sock = tifm_alloc_device(fm);
178                                 if (sock) {
179                                         sock->addr = tifm_7xx1_sock_addr(fm->addr,
180                                                                          cnt);
181                                         sock->media_id = media_id;
182                                         sock->socket_id = cnt;
183                                         switch (media_id) {
184                                         case 1:
185                                                 card_name = "xd";
186                                                 break;
187                                         case 2:
188                                                 card_name = "ms";
189                                                 break;
190                                         case 3:
191                                                 card_name = "sd";
192                                                 break;
193                                         default:
194                                                 tifm_free_device(&sock->dev);
195                                                 spin_lock_irqsave(&fm->lock, flags);
196                                                 continue;
197                                         }
198                                         snprintf(sock->dev.bus_id, BUS_ID_SIZE,
199                                                  "tifm_%s%u:%u", card_name,
200                                                  fm->id, cnt);
201                                         printk(KERN_INFO DRIVER_NAME
202                                                ": %s card detected in socket %d\n",
203                                                card_name, cnt);
204                                         if (!device_register(&sock->dev)) {
205                                                 spin_lock_irqsave(&fm->lock, flags);
206                                                 if (!fm->sockets[cnt]) {
207                                                         fm->sockets[cnt] = sock;
208                                                         sock = NULL;
209                                                 }
210                                                 spin_unlock_irqrestore(&fm->lock, flags);
211                                         }
212                                         if (sock)
213                                                 tifm_free_device(&sock->dev);
214                                 }
215                                 spin_lock_irqsave(&fm->lock, flags);
216                         }
217                 }
218
219                 if (!kthread_should_stop()) {
220                         writel(TIFM_IRQ_FIFOMASK(socket_change_set)
221                                | TIFM_IRQ_CARDMASK(socket_change_set),
222                                fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
223                         writel(TIFM_IRQ_FIFOMASK(socket_change_set)
224                                | TIFM_IRQ_CARDMASK(socket_change_set),
225                                fm->addr + FM_SET_INTERRUPT_ENABLE);
226                         writel(TIFM_IRQ_ENABLE,
227                                fm->addr + FM_SET_INTERRUPT_ENABLE);
228                         spin_unlock_irqrestore(&fm->lock, flags);
229                 } else {
230                         for (cnt = 0; cnt < fm->num_sockets; cnt++) {
231                                 if (fm->sockets[cnt])
232                                         fm->socket_change_set |= 1 << cnt;
233                         }
234                         if (!fm->socket_change_set) {
235                                 spin_unlock_irqrestore(&fm->lock, flags);
236                                 return 0;
237                         } else {
238                                 spin_unlock_irqrestore(&fm->lock, flags);
239                         }
240                 }
241         }
242         return 0;
243 }
244
245 #ifdef CONFIG_PM
246
247 static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
248 {
249         dev_dbg(&dev->dev, "suspending host\n");
250
251         pci_save_state(dev);
252         pci_enable_wake(dev, pci_choose_state(dev, state), 0);
253         pci_disable_device(dev);
254         pci_set_power_state(dev, pci_choose_state(dev, state));
255         return 0;
256 }
257
258 static int tifm_7xx1_resume(struct pci_dev *dev)
259 {
260         struct tifm_adapter *fm = pci_get_drvdata(dev);
261         int cnt, rc;
262         unsigned long flags;
263         tifm_media_id new_ids[fm->num_sockets];
264
265         pci_set_power_state(dev, PCI_D0);
266         pci_restore_state(dev);
267         rc = pci_enable_device(dev);
268         if (rc)
269                 return rc;
270         pci_set_master(dev);
271
272         dev_dbg(&dev->dev, "resuming host\n");
273
274         for (cnt = 0; cnt < fm->num_sockets; cnt++)
275                 new_ids[cnt] = tifm_7xx1_toggle_sock_power(
276                                         tifm_7xx1_sock_addr(fm->addr, cnt),
277                                         fm->num_sockets == 2);
278         spin_lock_irqsave(&fm->lock, flags);
279         fm->socket_change_set = 0;
280         for (cnt = 0; cnt < fm->num_sockets; cnt++) {
281                 if (fm->sockets[cnt]) {
282                         if (fm->sockets[cnt]->media_id == new_ids[cnt])
283                                 fm->socket_change_set |= 1 << cnt;
284
285                         fm->sockets[cnt]->media_id = new_ids[cnt];
286                 }
287         }
288
289         writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
290                fm->addr + FM_SET_INTERRUPT_ENABLE);
291         if (!fm->socket_change_set) {
292                 spin_unlock_irqrestore(&fm->lock, flags);
293                 return 0;
294         } else {
295                 fm->socket_change_set = 0;
296                 spin_unlock_irqrestore(&fm->lock, flags);
297         }
298
299         wait_event_timeout(fm->change_set_notify, fm->socket_change_set, HZ);
300
301         spin_lock_irqsave(&fm->lock, flags);
302         writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
303                | TIFM_IRQ_CARDMASK(fm->socket_change_set),
304                fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
305         writel(TIFM_IRQ_FIFOMASK(fm->socket_change_set)
306                | TIFM_IRQ_CARDMASK(fm->socket_change_set),
307                fm->addr + FM_SET_INTERRUPT_ENABLE);
308         writel(TIFM_IRQ_ENABLE,
309                fm->addr + FM_SET_INTERRUPT_ENABLE);
310         fm->socket_change_set = 0;
311
312         spin_unlock_irqrestore(&fm->lock, flags);
313         return 0;
314 }
315
316 #else
317
318 #define tifm_7xx1_suspend NULL
319 #define tifm_7xx1_resume NULL
320
321 #endif /* CONFIG_PM */
322
323 static int tifm_7xx1_probe(struct pci_dev *dev,
324                            const struct pci_device_id *dev_id)
325 {
326         struct tifm_adapter *fm;
327         int pci_dev_busy = 0;
328         int rc;
329
330         rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
331         if (rc)
332                 return rc;
333
334         rc = pci_enable_device(dev);
335         if (rc)
336                 return rc;
337
338         pci_set_master(dev);
339
340         rc = pci_request_regions(dev, DRIVER_NAME);
341         if (rc) {
342                 pci_dev_busy = 1;
343                 goto err_out;
344         }
345
346         pci_intx(dev, 1);
347
348         fm = tifm_alloc_adapter();
349         if (!fm) {
350                 rc = -ENOMEM;
351                 goto err_out_int;
352         }
353
354         fm->dev = &dev->dev;
355         fm->num_sockets = (dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM)
356                           ? 4 : 2;
357         fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->num_sockets,
358                               GFP_KERNEL);
359         if (!fm->sockets)
360                 goto err_out_free;
361
362         fm->eject = tifm_7xx1_eject;
363         pci_set_drvdata(dev, fm);
364
365         fm->addr = ioremap(pci_resource_start(dev, 0),
366                            pci_resource_len(dev, 0));
367         if (!fm->addr)
368                 goto err_out_free;
369
370         rc = request_irq(dev->irq, tifm_7xx1_isr, IRQF_SHARED, DRIVER_NAME, fm);
371         if (rc)
372                 goto err_out_unmap;
373
374         init_waitqueue_head(&fm->change_set_notify);
375         rc = tifm_add_adapter(fm, tifm_7xx1_switch_media);
376         if (rc)
377                 goto err_out_irq;
378
379         writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
380         writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
381                fm->addr + FM_SET_INTERRUPT_ENABLE);
382         wake_up_process(fm->media_switcher);
383         return 0;
384
385 err_out_irq:
386         free_irq(dev->irq, fm);
387 err_out_unmap:
388         iounmap(fm->addr);
389 err_out_free:
390         pci_set_drvdata(dev, NULL);
391         tifm_free_adapter(fm);
392 err_out_int:
393         pci_intx(dev, 0);
394         pci_release_regions(dev);
395 err_out:
396         if (!pci_dev_busy)
397                 pci_disable_device(dev);
398         return rc;
399 }
400
401 static void tifm_7xx1_remove(struct pci_dev *dev)
402 {
403         struct tifm_adapter *fm = pci_get_drvdata(dev);
404         unsigned long flags;
405
406         writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
407         mmiowb();
408         free_irq(dev->irq, fm);
409
410         spin_lock_irqsave(&fm->lock, flags);
411         fm->socket_change_set = (1 << fm->num_sockets) - 1;
412         spin_unlock_irqrestore(&fm->lock, flags);
413
414         kthread_stop(fm->media_switcher);
415
416         tifm_remove_adapter(fm);
417
418         pci_set_drvdata(dev, NULL);
419
420         iounmap(fm->addr);
421         pci_intx(dev, 0);
422         pci_release_regions(dev);
423
424         pci_disable_device(dev);
425         tifm_free_adapter(fm);
426 }
427
428 static struct pci_device_id tifm_7xx1_pci_tbl [] = {
429         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11_FM, PCI_ANY_ID,
430           PCI_ANY_ID, 0, 0, 0 }, /* xx21 - the one I have */
431         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12_FM, PCI_ANY_ID,
432           PCI_ANY_ID, 0, 0, 0 },
433         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX20_FM, PCI_ANY_ID,
434           PCI_ANY_ID, 0, 0, 0 },
435         { }
436 };
437
438 static struct pci_driver tifm_7xx1_driver = {
439         .name = DRIVER_NAME,
440         .id_table = tifm_7xx1_pci_tbl,
441         .probe = tifm_7xx1_probe,
442         .remove = tifm_7xx1_remove,
443         .suspend = tifm_7xx1_suspend,
444         .resume = tifm_7xx1_resume,
445 };
446
447 static int __init tifm_7xx1_init(void)
448 {
449         return pci_register_driver(&tifm_7xx1_driver);
450 }
451
452 static void __exit tifm_7xx1_exit(void)
453 {
454         pci_unregister_driver(&tifm_7xx1_driver);
455 }
456
457 MODULE_AUTHOR("Alex Dubov");
458 MODULE_DESCRIPTION("TI FlashMedia host driver");
459 MODULE_LICENSE("GPL");
460 MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
461 MODULE_VERSION(DRIVER_VERSION);
462
463 module_init(tifm_7xx1_init);
464 module_exit(tifm_7xx1_exit);