memstick: initial commit for Sony MemoryStick support
[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_dummy_has_ms_pif(struct tifm_adapter *fm,
306                                       struct tifm_dev *sock)
307 {
308         return 0;
309 }
310
311 static int tifm_7xx1_has_ms_pif(struct tifm_adapter *fm, struct tifm_dev *sock)
312 {
313         if (((fm->num_sockets == 4) && (sock->socket_id == 2))
314             || ((fm->num_sockets == 2) && (sock->socket_id == 0)))
315                 return 1;
316
317         return 0;
318 }
319
320 static int tifm_7xx1_probe(struct pci_dev *dev,
321                            const struct pci_device_id *dev_id)
322 {
323         struct tifm_adapter *fm;
324         int pci_dev_busy = 0;
325         int rc;
326
327         rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
328         if (rc)
329                 return rc;
330
331         rc = pci_enable_device(dev);
332         if (rc)
333                 return rc;
334
335         pci_set_master(dev);
336
337         rc = pci_request_regions(dev, DRIVER_NAME);
338         if (rc) {
339                 pci_dev_busy = 1;
340                 goto err_out;
341         }
342
343         pci_intx(dev, 1);
344
345         fm = tifm_alloc_adapter(dev->device == PCI_DEVICE_ID_TI_XX21_XX11_FM
346                                 ? 4 : 2, &dev->dev);
347         if (!fm) {
348                 rc = -ENOMEM;
349                 goto err_out_int;
350         }
351
352         INIT_WORK(&fm->media_switcher, tifm_7xx1_switch_media);
353         fm->eject = tifm_7xx1_eject;
354         fm->has_ms_pif = tifm_7xx1_has_ms_pif;
355         pci_set_drvdata(dev, fm);
356
357         fm->addr = ioremap(pci_resource_start(dev, 0),
358                            pci_resource_len(dev, 0));
359         if (!fm->addr)
360                 goto err_out_free;
361
362         rc = request_irq(dev->irq, tifm_7xx1_isr, IRQF_SHARED, DRIVER_NAME, fm);
363         if (rc)
364                 goto err_out_unmap;
365
366         rc = tifm_add_adapter(fm);
367         if (rc)
368                 goto err_out_irq;
369
370         writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SOCKMASK((1 << fm->num_sockets) - 1),
371                fm->addr + FM_SET_INTERRUPT_ENABLE);
372         return 0;
373
374 err_out_irq:
375         free_irq(dev->irq, fm);
376 err_out_unmap:
377         iounmap(fm->addr);
378 err_out_free:
379         pci_set_drvdata(dev, NULL);
380         tifm_free_adapter(fm);
381 err_out_int:
382         pci_intx(dev, 0);
383         pci_release_regions(dev);
384 err_out:
385         if (!pci_dev_busy)
386                 pci_disable_device(dev);
387         return rc;
388 }
389
390 static void tifm_7xx1_remove(struct pci_dev *dev)
391 {
392         struct tifm_adapter *fm = pci_get_drvdata(dev);
393         int cnt;
394
395         fm->eject = tifm_7xx1_dummy_eject;
396         fm->has_ms_pif = tifm_7xx1_dummy_has_ms_pif;
397         writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
398         mmiowb();
399         free_irq(dev->irq, fm);
400
401         tifm_remove_adapter(fm);
402
403         for (cnt = 0; cnt < fm->num_sockets; cnt++)
404                 tifm_7xx1_sock_power_off(tifm_7xx1_sock_addr(fm->addr, cnt));
405
406         pci_set_drvdata(dev, NULL);
407
408         iounmap(fm->addr);
409         pci_intx(dev, 0);
410         pci_release_regions(dev);
411
412         pci_disable_device(dev);
413         tifm_free_adapter(fm);
414 }
415
416 static struct pci_device_id tifm_7xx1_pci_tbl [] = {
417         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11_FM, PCI_ANY_ID,
418           PCI_ANY_ID, 0, 0, 0 }, /* xx21 - the one I have */
419         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12_FM, PCI_ANY_ID,
420           PCI_ANY_ID, 0, 0, 0 },
421         { PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX20_FM, PCI_ANY_ID,
422           PCI_ANY_ID, 0, 0, 0 },
423         { }
424 };
425
426 static struct pci_driver tifm_7xx1_driver = {
427         .name = DRIVER_NAME,
428         .id_table = tifm_7xx1_pci_tbl,
429         .probe = tifm_7xx1_probe,
430         .remove = tifm_7xx1_remove,
431         .suspend = tifm_7xx1_suspend,
432         .resume = tifm_7xx1_resume,
433 };
434
435 static int __init tifm_7xx1_init(void)
436 {
437         return pci_register_driver(&tifm_7xx1_driver);
438 }
439
440 static void __exit tifm_7xx1_exit(void)
441 {
442         pci_unregister_driver(&tifm_7xx1_driver);
443 }
444
445 MODULE_AUTHOR("Alex Dubov");
446 MODULE_DESCRIPTION("TI FlashMedia host driver");
447 MODULE_LICENSE("GPL");
448 MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
449 MODULE_VERSION(DRIVER_VERSION);
450
451 module_init(tifm_7xx1_init);
452 module_exit(tifm_7xx1_exit);