?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypto: crc32c - Use Intel CRC32 instruction
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / memstick / host / jmb38x_ms.c
blob3485c63d20b04c0793be29f07d4fffd38f9de457
1 /*
2 * jmb38x_ms.c - JMicron jmb38x MemoryStick card reader
3 *
4 * Copyright (C) 2008 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/spinlock.h>
13 #include <linux/interrupt.h>
14 #include <linux/pci.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/delay.h>
17 #include <linux/highmem.h>
18 #include <linux/memstick.h>
19
20 #define DRIVER_NAME "jmb38x_ms"
21
22 static int no_dma;
23 module_param(no_dma, bool, 0644);
24
25 enum {
26 DMA_ADDRESS = 0x00,
27 BLOCK = 0x04,
28 DMA_CONTROL = 0x08,
29 TPC_P0 = 0x0c,
30 TPC_P1 = 0x10,
31 TPC = 0x14,
32 HOST_CONTROL = 0x18,
33 DATA = 0x1c,
34 STATUS = 0x20,
35 INT_STATUS = 0x24,
36 INT_STATUS_ENABLE = 0x28,
37 INT_SIGNAL_ENABLE = 0x2c,
38 TIMER = 0x30,
39 TIMER_CONTROL = 0x34,
40 PAD_OUTPUT_ENABLE = 0x38,
41 PAD_PU_PD = 0x3c,
42 CLOCK_DELAY = 0x40,
43 ADMA_ADDRESS = 0x44,
44 CLOCK_CONTROL = 0x48,
45 LED_CONTROL = 0x4c,
46 VERSION = 0x50
47 };
48
49 struct jmb38x_ms_host {
50 struct jmb38x_ms *chip;
51 void __iomem *addr;
52 spinlock_t lock;
53 struct tasklet_struct notify;
54 int id;
55 char host_id[32];
56 int irq;
57 unsigned int block_pos;
58 unsigned long timeout_jiffies;
59 struct timer_list timer;
60 struct memstick_request *req;
61 unsigned char cmd_flags;
62 unsigned char io_pos;
63 unsigned int io_word[2];
64 };
65
66 struct jmb38x_ms {
67 struct pci_dev *pdev;
68 int host_cnt;
69 struct memstick_host *hosts[];
70 };
71
72 #define BLOCK_COUNT_MASK 0xffff0000
73 #define BLOCK_SIZE_MASK 0x00000fff
74
75 #define DMA_CONTROL_ENABLE 0x00000001
76
77 #define TPC_DATA_SEL 0x00008000
78 #define TPC_DIR 0x00004000
79 #define TPC_WAIT_INT 0x00002000
80 #define TPC_GET_INT 0x00000800
81 #define TPC_CODE_SZ_MASK 0x00000700
82 #define TPC_DATA_SZ_MASK 0x00000007
83
84 #define HOST_CONTROL_RESET_REQ 0x00008000
85 #define HOST_CONTROL_REI 0x00004000
86 #define HOST_CONTROL_LED 0x00000400
87 #define HOST_CONTROL_FAST_CLK 0x00000200
88 #define HOST_CONTROL_RESET 0x00000100
89 #define HOST_CONTROL_POWER_EN 0x00000080
90 #define HOST_CONTROL_CLOCK_EN 0x00000040
91 #define HOST_CONTROL_IF_SHIFT 4
92
93 #define HOST_CONTROL_IF_SERIAL 0x0
94 #define HOST_CONTROL_IF_PAR4 0x1
95 #define HOST_CONTROL_IF_PAR8 0x3
96
97 #define STATUS_BUSY 0x00080000
98 #define STATUS_MS_DAT7 0x00040000
99 #define STATUS_MS_DAT6 0x00020000
100 #define STATUS_MS_DAT5 0x00010000
101 #define STATUS_MS_DAT4 0x00008000
102 #define STATUS_MS_DAT3 0x00004000
103 #define STATUS_MS_DAT2 0x00002000
104 #define STATUS_MS_DAT1 0x00001000
105 #define STATUS_MS_DAT0 0x00000800
106 #define STATUS_HAS_MEDIA 0x00000400
107 #define STATUS_FIFO_EMPTY 0x00000200
108 #define STATUS_FIFO_FULL 0x00000100
109 #define STATUS_MS_CED 0x00000080
110 #define STATUS_MS_ERR 0x00000040
111 #define STATUS_MS_BRQ 0x00000020
112 #define STATUS_MS_CNK 0x00000001
113
114 #define INT_STATUS_TPC_ERR 0x00080000
115 #define INT_STATUS_CRC_ERR 0x00040000
116 #define INT_STATUS_TIMER_TO 0x00020000
117 #define INT_STATUS_HSK_TO 0x00010000
118 #define INT_STATUS_ANY_ERR 0x00008000
119 #define INT_STATUS_FIFO_WRDY 0x00000080
120 #define INT_STATUS_FIFO_RRDY 0x00000040
121 #define INT_STATUS_MEDIA_OUT 0x00000010
122 #define INT_STATUS_MEDIA_IN 0x00000008
123 #define INT_STATUS_DMA_BOUNDARY 0x00000004
124 #define INT_STATUS_EOTRAN 0x00000002
125 #define INT_STATUS_EOTPC 0x00000001
126
127 #define INT_STATUS_ALL 0x000f801f
128
129 #define PAD_OUTPUT_ENABLE_MS 0x0F3F
130
131 #define PAD_PU_PD_OFF 0x7FFF0000
132 #define PAD_PU_PD_ON_MS_SOCK0 0x5f8f0000
133 #define PAD_PU_PD_ON_MS_SOCK1 0x0f0f0000
134
135 #define CLOCK_CONTROL_40MHZ 0x00000001
136 #define CLOCK_CONTROL_50MHZ 0x00000002
137 #define CLOCK_CONTROL_60MHZ 0x00000008
138 #define CLOCK_CONTROL_62_5MHZ 0x0000000c
139 #define CLOCK_CONTROL_OFF 0x00000000
140
141 enum {
142 CMD_READY = 0x01,
143 FIFO_READY = 0x02,
144 REG_DATA = 0x04,
145 DMA_DATA = 0x08
146 };
147
148 static unsigned int jmb38x_ms_read_data(struct jmb38x_ms_host *host,
149 unsigned char *buf, unsigned int length)
150 {
151 unsigned int off = 0;
152
153 while (host->io_pos && length) {
154 buf[off++] = host->io_word[0] & 0xff;
155 host->io_word[0] >>= 8;
156 length--;
157 host->io_pos--;
158 }
159
160 if (!length)
161 return off;
162
163 while (!(STATUS_FIFO_EMPTY & readl(host->addr + STATUS))) {
164 if (length < 4)
165 break;
166 *(unsigned int *)(buf + off) = __raw_readl(host->addr + DATA);
167 length -= 4;
168 off += 4;
169 }
170
171 if (length
172 && !(STATUS_FIFO_EMPTY & readl(host->addr + STATUS))) {
173 host->io_word[0] = readl(host->addr + DATA);
174 for (host->io_pos = 4; host->io_pos; --host->io_pos) {
175 buf[off++] = host->io_word[0] & 0xff;
176 host->io_word[0] >>= 8;
177 length--;
178 if (!length)
179 break;
180 }
181 }
182
183 return off;
184 }
185
186 static unsigned int jmb38x_ms_read_reg_data(struct jmb38x_ms_host *host,
187 unsigned char *buf,
188 unsigned int length)
189 {
190 unsigned int off = 0;
191
192 while (host->io_pos > 4 && length) {
193 buf[off++] = host->io_word[0] & 0xff;
194 host->io_word[0] >>= 8;
195 length--;
196 host->io_pos--;
197 }
198
199 if (!length)
200 return off;
201
202 while (host->io_pos && length) {
203 buf[off++] = host->io_word[1] & 0xff;
204 host->io_word[1] >>= 8;
205 length--;
206 host->io_pos--;
207 }
208
209 return off;
210 }
211
212 static unsigned int jmb38x_ms_write_data(struct jmb38x_ms_host *host,
213 unsigned char *buf,
214 unsigned int length)
215 {
216 unsigned int off = 0;
217
218 if (host->io_pos) {
219 while (host->io_pos < 4 && length) {
220 host->io_word[0] |= buf[off++] << (host->io_pos * 8);
221 host->io_pos++;
222 length--;
223 }
224 }
225
226 if (host->io_pos == 4
227 && !(STATUS_FIFO_FULL & readl(host->addr + STATUS))) {
228 writel(host->io_word[0], host->addr + DATA);
229 host->io_pos = 0;
230 host->io_word[0] = 0;
231 } else if (host->io_pos) {
232 return off;
233 }
234
235 if (!length)
236 return off;
237
238 while (!(STATUS_FIFO_FULL & readl(host->addr + STATUS))) {
239 if (length < 4)
240 break;
241
242 __raw_writel(*(unsigned int *)(buf + off),
243 host->addr + DATA);
244 length -= 4;
245 off += 4;
246 }
247
248 switch (length) {
249 case 3:
250 host->io_word[0] |= buf[off + 2] << 16;
251 host->io_pos++;
252 case 2:
253 host->io_word[0] |= buf[off + 1] << 8;
254 host->io_pos++;
255 case 1:
256 host->io_word[0] |= buf[off];
257 host->io_pos++;
258 }
259
260 off += host->io_pos;
261
262 return off;
263 }
264
265 static unsigned int jmb38x_ms_write_reg_data(struct jmb38x_ms_host *host,
266 unsigned char *buf,
267 unsigned int length)
268 {
269 unsigned int off = 0;
270
271 while (host->io_pos < 4 && length) {
272 host->io_word[0] &= ~(0xff << (host->io_pos * 8));
273 host->io_word[0] |= buf[off++] << (host->io_pos * 8);
274 host->io_pos++;
275 length--;
276 }
277
278 if (!length)
279 return off;
280
281 while (host->io_pos < 8 && length) {
282 host->io_word[1] &= ~(0xff << (host->io_pos * 8));
283 host->io_word[1] |= buf[off++] << (host->io_pos * 8);
284 host->io_pos++;
285 length--;
286 }
287
288 return off;
289 }
290
291 static int jmb38x_ms_transfer_data(struct jmb38x_ms_host *host)
292 {
293 unsigned int length;
294 unsigned int off;
295 unsigned int t_size, p_cnt;
296 unsigned char *buf;
297 struct page *pg;
298 unsigned long flags = 0;
299
300 if (host->req->long_data) {
301 length = host->req->sg.length - host->block_pos;
302 off = host->req->sg.offset + host->block_pos;
303 } else {
304 length = host->req->data_len - host->block_pos;
305 off = 0;
306 }
307
308 while (length) {
309 unsigned int uninitialized_var(p_off);
310
311 if (host->req->long_data) {
312 pg = nth_page(sg_page(&host->req->sg),
313 off >> PAGE_SHIFT);
314 p_off = offset_in_page(off);
315 p_cnt = PAGE_SIZE - p_off;
316 p_cnt = min(p_cnt, length);
317
318 local_irq_save(flags);
319 buf = kmap_atomic(pg, KM_BIO_SRC_IRQ) + p_off;
320 } else {
321 buf = host->req->data + host->block_pos;
322 p_cnt = host->req->data_len - host->block_pos;
323 }
324
325 if (host->req->data_dir == WRITE)
326 t_size = !(host->cmd_flags & REG_DATA)
327 ? jmb38x_ms_write_data(host, buf, p_cnt)
328 : jmb38x_ms_write_reg_data(host, buf, p_cnt);
329 else
330 t_size = !(host->cmd_flags & REG_DATA)
331 ? jmb38x_ms_read_data(host, buf, p_cnt)
332 : jmb38x_ms_read_reg_data(host, buf, p_cnt);
333
334 if (host->req->long_data) {
335 kunmap_atomic(buf - p_off, KM_BIO_SRC_IRQ);
336 local_irq_restore(flags);
337 }
338
339 if (!t_size)
340 break;
341 host->block_pos += t_size;
342 length -= t_size;
343 off += t_size;
344 }
345
346 if (!length && host->req->data_dir == WRITE) {
347 if (host->cmd_flags & REG_DATA) {
348 writel(host->io_word[0], host->addr + TPC_P0);
349 writel(host->io_word[1], host->addr + TPC_P1);
350 } else if (host->io_pos) {
351 writel(host->io_word[0], host->addr + DATA);
352 }
353 }
354
355 return length;
356 }
357
358 static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
359 {
360 struct jmb38x_ms_host *host = memstick_priv(msh);
361 unsigned char *data;
362 unsigned int data_len, cmd, t_val;
363
364 if (!(STATUS_HAS_MEDIA & readl(host->addr + STATUS))) {
365 dev_dbg(&msh->dev, "no media status\n");
366 host->req->error = -ETIME;
367 return host->req->error;
368 }
369
370 dev_dbg(&msh->dev, "control %08x\n",
371 readl(host->addr + HOST_CONTROL));
372 dev_dbg(&msh->dev, "status %08x\n", readl(host->addr + INT_STATUS));
373 dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS));
374
375 host->cmd_flags = 0;
376 host->block_pos = 0;
377 host->io_pos = 0;
378 host->io_word[0] = 0;
379 host->io_word[1] = 0;
380
381 cmd = host->req->tpc << 16;
382 cmd |= TPC_DATA_SEL;
383
384 if (host->req->data_dir == READ)
385 cmd |= TPC_DIR;
386 if (host->req->need_card_int)
387 cmd |= TPC_WAIT_INT;
388
389 data = host->req->data;
390
391 if (!no_dma)
392 host->cmd_flags |= DMA_DATA;
393
394 if (host->req->long_data) {
395 data_len = host->req->sg.length;
396 } else {
397 data_len = host->req->data_len;
398 host->cmd_flags &= ~DMA_DATA;
399 }
400
401 if (data_len <= 8) {
402 cmd &= ~(TPC_DATA_SEL | 0xf);
403 host->cmd_flags |= REG_DATA;
404 cmd |= data_len & 0xf;
405 host->cmd_flags &= ~DMA_DATA;
406 }
407
408 if (host->cmd_flags & DMA_DATA) {
409 if (1 != pci_map_sg(host->chip->pdev, &host->req->sg, 1,
410 host->req->data_dir == READ
411 ? PCI_DMA_FROMDEVICE
412 : PCI_DMA_TODEVICE)) {
413 host->req->error = -ENOMEM;
414 return host->req->error;
415 }
416 data_len = sg_dma_len(&host->req->sg);
417 writel(sg_dma_address(&host->req->sg),
418 host->addr + DMA_ADDRESS);
419 writel(((1 << 16) & BLOCK_COUNT_MASK)
420 | (data_len & BLOCK_SIZE_MASK),
421 host->addr + BLOCK);
422 writel(DMA_CONTROL_ENABLE, host->addr + DMA_CONTROL);
423 } else if (!(host->cmd_flags & REG_DATA)) {
424 writel(((1 << 16) & BLOCK_COUNT_MASK)
425 | (data_len & BLOCK_SIZE_MASK),
426 host->addr + BLOCK);
427 t_val = readl(host->addr + INT_STATUS_ENABLE);
428 t_val |= host->req->data_dir == READ
429 ? INT_STATUS_FIFO_RRDY
430 : INT_STATUS_FIFO_WRDY;
431
432 writel(t_val, host->addr + INT_STATUS_ENABLE);
433 writel(t_val, host->addr + INT_SIGNAL_ENABLE);
434 } else {
435 cmd &= ~(TPC_DATA_SEL | 0xf);
436 host->cmd_flags |= REG_DATA;
437 cmd |= data_len & 0xf;
438
439 if (host->req->data_dir == WRITE) {
440 jmb38x_ms_transfer_data(host);
441 writel(host->io_word[0], host->addr + TPC_P0);
442 writel(host->io_word[1], host->addr + TPC_P1);
443 }
444 }
445
446 mod_timer(&host->timer, jiffies + host->timeout_jiffies);
447 writel(HOST_CONTROL_LED | readl(host->addr + HOST_CONTROL),
448 host->addr + HOST_CONTROL);
449 host->req->error = 0;
450
451 writel(cmd, host->addr + TPC);
452 dev_dbg(&msh->dev, "executing TPC %08x, len %x\n", cmd, data_len);
453
454 return 0;
455 }
456
457 static void jmb38x_ms_complete_cmd(struct memstick_host *msh, int last)
458 {
459 struct jmb38x_ms_host *host = memstick_priv(msh);
460 unsigned int t_val = 0;
461 int rc;
462
463 del_timer(&host->timer);
464
465 dev_dbg(&msh->dev, "c control %08x\n",
466 readl(host->addr + HOST_CONTROL));
467 dev_dbg(&msh->dev, "c status %08x\n",
468 readl(host->addr + INT_STATUS));
469 dev_dbg(&msh->dev, "c hstatus %08x\n", readl(host->addr + STATUS));
470
471 host->req->int_reg = readl(host->addr + STATUS) & 0xff;
472
473 writel(0, host->addr + BLOCK);
474 writel(0, host->addr + DMA_CONTROL);
475
476 if (host->cmd_flags & DMA_DATA) {
477 pci_unmap_sg(host->chip->pdev, &host->req->sg, 1,
478 host->req->data_dir == READ
479 ? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
480 } else {
481 t_val = readl(host->addr + INT_STATUS_ENABLE);
482 if (host->req->data_dir == READ)
483 t_val &= ~INT_STATUS_FIFO_RRDY;
484 else
485 t_val &= ~INT_STATUS_FIFO_WRDY;
486
487 writel(t_val, host->addr + INT_STATUS_ENABLE);
488 writel(t_val, host->addr + INT_SIGNAL_ENABLE);
489 }
490
491 writel((~HOST_CONTROL_LED) & readl(host->addr + HOST_CONTROL),
492 host->addr + HOST_CONTROL);
493
494 if (!last) {
495 do {
496 rc = memstick_next_req(msh, &host->req);
497 } while (!rc && jmb38x_ms_issue_cmd(msh));
498 } else {
499 do {
500 rc = memstick_next_req(msh, &host->req);
501 if (!rc)
502 host->req->error = -ETIME;
503 } while (!rc);
504 }
505 }
506
507 static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
508 {
509 struct memstick_host *msh = dev_id;
510 struct jmb38x_ms_host *host = memstick_priv(msh);
511 unsigned int irq_status;
512
513 spin_lock(&host->lock);
514 irq_status = readl(host->addr + INT_STATUS);
515 dev_dbg(&host->chip->pdev->dev, "irq_status = %08x\n", irq_status);
516 if (irq_status == 0 || irq_status == (~0)) {
517 spin_unlock(&host->lock);
518 return IRQ_NONE;
519 }
520
521 if (host->req) {
522 if (irq_status & INT_STATUS_ANY_ERR) {
523 if (irq_status & INT_STATUS_CRC_ERR)
524 host->req->error = -EILSEQ;
525 else
526 host->req->error = -ETIME;
527 } else {
528 if (host->cmd_flags & DMA_DATA) {
529 if (irq_status & INT_STATUS_EOTRAN)
530 host->cmd_flags |= FIFO_READY;
531 } else {
532 if (irq_status & (INT_STATUS_FIFO_RRDY
533 | INT_STATUS_FIFO_WRDY))
534 jmb38x_ms_transfer_data(host);
535
536 if (irq_status & INT_STATUS_EOTRAN) {
537 jmb38x_ms_transfer_data(host);
538 host->cmd_flags |= FIFO_READY;
539 }
540 }
541
542 if (irq_status & INT_STATUS_EOTPC) {
543 host->cmd_flags |= CMD_READY;
544 if (host->cmd_flags & REG_DATA) {
545 if (host->req->data_dir == READ) {
546 host->io_word[0]
547 = readl(host->addr
548 + TPC_P0);
549 host->io_word[1]
550 = readl(host->addr
551 + TPC_P1);
552 host->io_pos = 8;
553
554 jmb38x_ms_transfer_data(host);
555 }
556 host->cmd_flags |= FIFO_READY;
557 }
558 }
559 }
560 }
561
562 if (irq_status & (INT_STATUS_MEDIA_IN | INT_STATUS_MEDIA_OUT)) {
563 dev_dbg(&host->chip->pdev->dev, "media changed\n");
564 memstick_detect_change(msh);
565 }
566
567 writel(irq_status, host->addr + INT_STATUS);
568
569 if (host->req
570 && (((host->cmd_flags & CMD_READY)
571 && (host->cmd_flags & FIFO_READY))
572 || host->req->error))
573 jmb38x_ms_complete_cmd(msh, 0);
574
575 spin_unlock(&host->lock);
576 return IRQ_HANDLED;
577 }
578
579 static void jmb38x_ms_abort(unsigned long data)
580 {
581 struct memstick_host *msh = (struct memstick_host *)data;
582 struct jmb38x_ms_host *host = memstick_priv(msh);
583 unsigned long flags;
584
585 dev_dbg(&host->chip->pdev->dev, "abort\n");
586 spin_lock_irqsave(&host->lock, flags);
587 if (host->req) {
588 host->req->error = -ETIME;
589 jmb38x_ms_complete_cmd(msh, 0);
590 }
591 spin_unlock_irqrestore(&host->lock, flags);
592 }
593
594 static void jmb38x_ms_req_tasklet(unsigned long data)
595 {
596 struct memstick_host *msh = (struct memstick_host *)data;
597 struct jmb38x_ms_host *host = memstick_priv(msh);
598 unsigned long flags;
599 int rc;
600
601 spin_lock_irqsave(&host->lock, flags);
602 if (!host->req) {
603 do {
604 rc = memstick_next_req(msh, &host->req);
605 dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
606 } while (!rc && jmb38x_ms_issue_cmd(msh));
607 }
608 spin_unlock_irqrestore(&host->lock, flags);
609 }
610
611 static void jmb38x_ms_dummy_submit(struct memstick_host *msh)
612 {
613 return;
614 }
615
616 static void jmb38x_ms_submit_req(struct memstick_host *msh)
617 {
618 struct jmb38x_ms_host *host = memstick_priv(msh);
619
620 tasklet_schedule(&host->notify);
621 }
622
623 static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
624 {
625 int cnt;
626
627 writel(HOST_CONTROL_RESET_REQ | HOST_CONTROL_CLOCK_EN
628 | readl(host->addr + HOST_CONTROL),
629 host->addr + HOST_CONTROL);
630 mmiowb();
631
632 for (cnt = 0; cnt < 20; ++cnt) {
633 if (!(HOST_CONTROL_RESET_REQ
634 & readl(host->addr + HOST_CONTROL)))
635 goto reset_next;
636
637 ndelay(20);
638 }
639 dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
640 return -EIO;
641
642 reset_next:
643 writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
644 | readl(host->addr + HOST_CONTROL),
645 host->addr + HOST_CONTROL);
646 mmiowb();
647
648 for (cnt = 0; cnt < 20; ++cnt) {
649 if (!(HOST_CONTROL_RESET
650 & readl(host->addr + HOST_CONTROL)))
651 goto reset_ok;
652
653 ndelay(20);
654 }
655 dev_dbg(&host->chip->pdev->dev, "reset timeout\n");
656 return -EIO;
657
658 reset_ok:
659 mmiowb();
660 writel(INT_STATUS_ALL, host->addr + INT_SIGNAL_ENABLE);
661 writel(INT_STATUS_ALL, host->addr + INT_STATUS_ENABLE);
662 return 0;
663 }
664
665 static int jmb38x_ms_set_param(struct memstick_host *msh,
666 enum memstick_param param,
667 int value)
668 {
669 struct jmb38x_ms_host *host = memstick_priv(msh);
670 unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
671 unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
672 int rc = 0;
673
674 switch (param) {
675 case MEMSTICK_POWER:
676 if (value == MEMSTICK_POWER_ON) {
677 rc = jmb38x_ms_reset(host);
678 if (rc)
679 return rc;
680
681 host_ctl = 7;
682 host_ctl |= HOST_CONTROL_POWER_EN
683 | HOST_CONTROL_CLOCK_EN;
684 writel(host_ctl, host->addr + HOST_CONTROL);
685
686 writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
687 : PAD_PU_PD_ON_MS_SOCK0,
688 host->addr + PAD_PU_PD);
689
690 writel(PAD_OUTPUT_ENABLE_MS,
691 host->addr + PAD_OUTPUT_ENABLE);
692
693 msleep(10);
694 dev_dbg(&host->chip->pdev->dev, "power on\n");
695 } else if (value == MEMSTICK_POWER_OFF) {
696 host_ctl &= ~(HOST_CONTROL_POWER_EN
697 | HOST_CONTROL_CLOCK_EN);
698 writel(host_ctl, host->addr + HOST_CONTROL);
699 writel(0, host->addr + PAD_OUTPUT_ENABLE);
700 writel(PAD_PU_PD_OFF, host->addr + PAD_PU_PD);
701 dev_dbg(&host->chip->pdev->dev, "power off\n");
702 } else
703 return -EINVAL;
704 break;
705 case MEMSTICK_INTERFACE:
706 host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
707
708 if (value == MEMSTICK_SERIAL) {
709 host_ctl &= ~HOST_CONTROL_FAST_CLK;
710 host_ctl |= HOST_CONTROL_IF_SERIAL
711 << HOST_CONTROL_IF_SHIFT;
712 host_ctl |= HOST_CONTROL_REI;
713 clock_ctl = CLOCK_CONTROL_40MHZ;
714 clock_delay = 0;
715 } else if (value == MEMSTICK_PAR4) {
716 host_ctl |= HOST_CONTROL_FAST_CLK;
717 host_ctl |= HOST_CONTROL_IF_PAR4
718 << HOST_CONTROL_IF_SHIFT;
719 host_ctl &= ~HOST_CONTROL_REI;
720 clock_ctl = CLOCK_CONTROL_40MHZ;
721 clock_delay = 4;
722 } else if (value == MEMSTICK_PAR8) {
723 host_ctl |= HOST_CONTROL_FAST_CLK;
724 host_ctl |= HOST_CONTROL_IF_PAR8
725 << HOST_CONTROL_IF_SHIFT;
726 host_ctl &= ~HOST_CONTROL_REI;
727 clock_ctl = CLOCK_CONTROL_60MHZ;
728 clock_delay = 0;
729 } else
730 return -EINVAL;
731 writel(host_ctl, host->addr + HOST_CONTROL);
732 writel(clock_ctl, host->addr + CLOCK_CONTROL);
733 writel(clock_delay, host->addr + CLOCK_DELAY);
734 break;
735 };
736 return 0;
737 }
738
739 #ifdef CONFIG_PM
740
741 static int jmb38x_ms_suspend(struct pci_dev *dev, pm_message_t state)
742 {
743 struct jmb38x_ms *jm = pci_get_drvdata(dev);
744 int cnt;
745
746 for (cnt = 0; cnt < jm->host_cnt; ++cnt) {
747 if (!jm->hosts[cnt])
748 break;
749 memstick_suspend_host(jm->hosts[cnt]);
750 }
751
752 pci_save_state(dev);
753 pci_enable_wake(dev, pci_choose_state(dev, state), 0);
754 pci_disable_device(dev);
755 pci_set_power_state(dev, pci_choose_state(dev, state));
756 return 0;
757 }
758
759 static int jmb38x_ms_resume(struct pci_dev *dev)
760 {
761 struct jmb38x_ms *jm = pci_get_drvdata(dev);
762 int rc;
763
764 pci_set_power_state(dev, PCI_D0);
765 pci_restore_state(dev);
766 rc = pci_enable_device(dev);
767 if (rc)
768 return rc;
769 pci_set_master(dev);
770
771 pci_read_config_dword(dev, 0xac, &rc);
772 pci_write_config_dword(dev, 0xac, rc | 0x00470000);
773
774 for (rc = 0; rc < jm->host_cnt; ++rc) {
775 if (!jm->hosts[rc])
776 break;
777 memstick_resume_host(jm->hosts[rc]);
778 memstick_detect_change(jm->hosts[rc]);
779 }
780
781 return 0;
782 }
783
784 #else
785
786 #define jmb38x_ms_suspend NULL
787 #define jmb38x_ms_resume NULL
788
789 #endif /* CONFIG_PM */
790
791 static int jmb38x_ms_count_slots(struct pci_dev *pdev)
792 {
793 int cnt, rc = 0;
794
795 for (cnt = 0; cnt < PCI_ROM_RESOURCE; ++cnt) {
796 if (!(IORESOURCE_MEM & pci_resource_flags(pdev, cnt)))
797 break;
798
799 if (256 != pci_resource_len(pdev, cnt))
800 break;
801
802 ++rc;
803 }
804 return rc;
805 }
806
807 static struct memstick_host *jmb38x_ms_alloc_host(struct jmb38x_ms *jm, int cnt)
808 {
809 struct memstick_host *msh;
810 struct jmb38x_ms_host *host;
811
812 msh = memstick_alloc_host(sizeof(struct jmb38x_ms_host),
813 &jm->pdev->dev);
814 if (!msh)
815 return NULL;
816
817 host = memstick_priv(msh);
818 host->chip = jm;
819 host->addr = ioremap(pci_resource_start(jm->pdev, cnt),
820 pci_resource_len(jm->pdev, cnt));
821 if (!host->addr)
822 goto err_out_free;
823
824 spin_lock_init(&host->lock);
825 host->id = cnt;
826 snprintf(host->host_id, sizeof(host->host_id), DRIVER_NAME ":slot%d",
827 host->id);
828 host->irq = jm->pdev->irq;
829 host->timeout_jiffies = msecs_to_jiffies(1000);
830
831 tasklet_init(&host->notify, jmb38x_ms_req_tasklet, (unsigned long)msh);
832 msh->request = jmb38x_ms_submit_req;
833 msh->set_param = jmb38x_ms_set_param;
834
835 msh->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;
836
837 setup_timer(&host->timer, jmb38x_ms_abort, (unsigned long)msh);
838
839 if (!request_irq(host->irq, jmb38x_ms_isr, IRQF_SHARED, host->host_id,
840 msh))
841 return msh;
842
843 iounmap(host->addr);
844 err_out_free:
845 kfree(msh);
846 return NULL;
847 }
848
849 static void jmb38x_ms_free_host(struct memstick_host *msh)
850 {
851 struct jmb38x_ms_host *host = memstick_priv(msh);
852
853 free_irq(host->irq, msh);
854 iounmap(host->addr);
855 memstick_free_host(msh);
856 }
857
858 static int jmb38x_ms_probe(struct pci_dev *pdev,
859 const struct pci_device_id *dev_id)
860 {
861 struct jmb38x_ms *jm;
862 int pci_dev_busy = 0;
863 int rc, cnt;
864
865 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
866 if (rc)
867 return rc;
868
869 rc = pci_enable_device(pdev);
870 if (rc)
871 return rc;
872
873 pci_set_master(pdev);
874
875 rc = pci_request_regions(pdev, DRIVER_NAME);
876 if (rc) {
877 pci_dev_busy = 1;
878 goto err_out;
879 }
880
881 pci_read_config_dword(pdev, 0xac, &rc);
882 pci_write_config_dword(pdev, 0xac, rc | 0x00470000);
883
884 cnt = jmb38x_ms_count_slots(pdev);
885 if (!cnt) {
886 rc = -ENODEV;
887 pci_dev_busy = 1;
888 goto err_out;
889 }
890
891 jm = kzalloc(sizeof(struct jmb38x_ms)
892 + cnt * sizeof(struct memstick_host *), GFP_KERNEL);
893 if (!jm) {
894 rc = -ENOMEM;
895 goto err_out_int;
896 }
897
898 jm->pdev = pdev;
899 jm->host_cnt = cnt;
900 pci_set_drvdata(pdev, jm);
901
902 for (cnt = 0; cnt < jm->host_cnt; ++cnt) {
903 jm->hosts[cnt] = jmb38x_ms_alloc_host(jm, cnt);
904 if (!jm->hosts[cnt])
905 break;
906
907 rc = memstick_add_host(jm->hosts[cnt]);
908
909 if (rc) {
910 jmb38x_ms_free_host(jm->hosts[cnt]);
911 jm->hosts[cnt] = NULL;
912 break;
913 }
914 }
915
916 if (cnt)
917 return 0;
918
919 rc = -ENODEV;
920
921 pci_set_drvdata(pdev, NULL);
922 kfree(jm);
923 err_out_int:
924 pci_release_regions(pdev);
925 err_out:
926 if (!pci_dev_busy)
927 pci_disable_device(pdev);
928 return rc;
929 }
930
931 static void jmb38x_ms_remove(struct pci_dev *dev)
932 {
933 struct jmb38x_ms *jm = pci_get_drvdata(dev);
934 struct jmb38x_ms_host *host;
935 int cnt;
936 unsigned long flags;
937
938 for (cnt = 0; cnt < jm->host_cnt; ++cnt) {
939 if (!jm->hosts[cnt])
940 break;
941
942 host = memstick_priv(jm->hosts[cnt]);
943
944 jm->hosts[cnt]->request = jmb38x_ms_dummy_submit;
945 tasklet_kill(&host->notify);
946 writel(0, host->addr + INT_SIGNAL_ENABLE);
947 writel(0, host->addr + INT_STATUS_ENABLE);
948 mmiowb();
949 dev_dbg(&jm->pdev->dev, "interrupts off\n");
950 spin_lock_irqsave(&host->lock, flags);
951 if (host->req) {
952 host->req->error = -ETIME;
953 jmb38x_ms_complete_cmd(jm->hosts[cnt], 1);
954 }
955 spin_unlock_irqrestore(&host->lock, flags);
956
957 memstick_remove_host(jm->hosts[cnt]);
958 dev_dbg(&jm->pdev->dev, "host removed\n");
959
960 jmb38x_ms_free_host(jm->hosts[cnt]);
961 }
962
963 pci_set_drvdata(dev, NULL);
964 pci_release_regions(dev);
965 pci_disable_device(dev);
966 kfree(jm);
967 }
968
969 static struct pci_device_id jmb38x_ms_id_tbl [] = {
970 { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB38X_MS, PCI_ANY_ID,
971 PCI_ANY_ID, 0, 0, 0 },
972 { }
973 };
974
975 static struct pci_driver jmb38x_ms_driver = {
976 .name = DRIVER_NAME,
977 .id_table = jmb38x_ms_id_tbl,
978 .probe = jmb38x_ms_probe,
979 .remove = jmb38x_ms_remove,
980 .suspend = jmb38x_ms_suspend,
981 .resume = jmb38x_ms_resume
982 };
983
984 static int __init jmb38x_ms_init(void)
985 {
986 return pci_register_driver(&jmb38x_ms_driver);
987 }
988
989 static void __exit jmb38x_ms_exit(void)
990 {
991 pci_unregister_driver(&jmb38x_ms_driver);
992 }
993
994 MODULE_AUTHOR("Alex Dubov");
995 MODULE_DESCRIPTION("JMicron jmb38x MemoryStick driver");
996 MODULE_LICENSE("GPL");
997 MODULE_DEVICE_TABLE(pci, jmb38x_ms_id_tbl);
998
999 module_init(jmb38x_ms_init);
1000 module_exit(jmb38x_ms_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree