2 * Sony MemoryStick Pro storage support
4 * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com>
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.
10 * Special thanks to Carlos Corbacho for providing various MemoryStick cards
11 * that made this driver possible.
15 #include <linux/blkdev.h>
16 #include <linux/idr.h>
17 #include <linux/hdreg.h>
18 #include <linux/kthread.h>
19 #include <linux/delay.h>
20 #include <linux/slab.h>
21 #include <linux/mutex.h>
22 #include <linux/memstick.h>
24 #define DRIVER_NAME "mspro_block"
26 static DEFINE_MUTEX(mspro_block_mutex
);
28 module_param(major
, int, 0644);
30 #define MSPRO_BLOCK_MAX_SEGS 32
31 #define MSPRO_BLOCK_MAX_PAGES ((2 << 16) - 1)
33 #define MSPRO_BLOCK_SIGNATURE 0xa5c3
34 #define MSPRO_BLOCK_MAX_ATTRIBUTES 41
36 #define MSPRO_BLOCK_PART_SHIFT 3
39 MSPRO_BLOCK_ID_SYSINFO
= 0x10,
40 MSPRO_BLOCK_ID_MODELNAME
= 0x15,
41 MSPRO_BLOCK_ID_MBR
= 0x20,
42 MSPRO_BLOCK_ID_PBR16
= 0x21,
43 MSPRO_BLOCK_ID_PBR32
= 0x22,
44 MSPRO_BLOCK_ID_SPECFILEVALUES1
= 0x25,
45 MSPRO_BLOCK_ID_SPECFILEVALUES2
= 0x26,
46 MSPRO_BLOCK_ID_DEVINFO
= 0x30
49 struct mspro_sys_attr
{
54 struct device_attribute dev_attr
;
57 struct mspro_attr_entry
{
61 unsigned char reserved
[3];
62 } __attribute__((packed
));
64 struct mspro_attribute
{
66 unsigned short version
;
68 unsigned char reserved
[11];
69 struct mspro_attr_entry entries
[];
70 } __attribute__((packed
));
72 struct mspro_sys_info
{
74 unsigned char reserved0
;
77 __be16 user_block_count
;
79 unsigned char reserved1
[2];
80 unsigned char assembly_date
[8];
82 unsigned char assembly_maker_code
;
83 unsigned char assembly_model_code
[3];
84 __be16 memory_maker_code
;
85 __be16 memory_model_code
;
86 unsigned char reserved2
[4];
89 __be16 controller_number
;
90 __be16 controller_function
;
93 unsigned char ms_sub_class
;
94 unsigned char reserved3
[4];
95 unsigned char interface_type
;
96 __be16 controller_code
;
97 unsigned char format_type
;
98 unsigned char reserved4
;
99 unsigned char device_type
;
100 unsigned char reserved5
[7];
101 unsigned char mspro_id
[16];
102 unsigned char reserved6
[16];
103 } __attribute__((packed
));
106 unsigned char boot_partition
;
107 unsigned char start_head
;
108 unsigned char start_sector
;
109 unsigned char start_cylinder
;
110 unsigned char partition_type
;
111 unsigned char end_head
;
112 unsigned char end_sector
;
113 unsigned char end_cylinder
;
114 unsigned int start_sectors
;
115 unsigned int sectors_per_partition
;
116 } __attribute__((packed
));
118 struct mspro_specfile
{
122 unsigned char reserved
[10];
125 unsigned short cluster
;
127 } __attribute__((packed
));
129 struct mspro_devinfo
{
132 __be16 bytes_per_track
;
133 __be16 bytes_per_sector
;
134 __be16 sectors_per_track
;
135 unsigned char reserved
[6];
136 } __attribute__((packed
));
138 struct mspro_block_data
{
139 struct memstick_dev
*card
;
140 unsigned int usage_count
;
142 struct gendisk
*disk
;
143 struct request_queue
*queue
;
144 struct request
*block_req
;
147 unsigned short page_size
;
148 unsigned short cylinders
;
149 unsigned short heads
;
150 unsigned short sectors_per_track
;
152 unsigned char system
;
153 unsigned char read_only
:1,
158 unsigned char transfer_cmd
;
160 int (*mrq_handler
)(struct memstick_dev
*card
,
161 struct memstick_request
**mrq
);
163 struct attribute_group attr_group
;
165 struct scatterlist req_sg
[MSPRO_BLOCK_MAX_SEGS
];
166 unsigned int seg_count
;
167 unsigned int current_seg
;
168 unsigned int current_page
;
171 static DEFINE_IDR(mspro_block_disk_idr
);
172 static DEFINE_MUTEX(mspro_block_disk_lock
);
174 static int mspro_block_complete_req(struct memstick_dev
*card
, int error
);
176 /*** Block device ***/
178 static int mspro_block_bd_open(struct block_device
*bdev
, fmode_t mode
)
180 struct gendisk
*disk
= bdev
->bd_disk
;
181 struct mspro_block_data
*msb
= disk
->private_data
;
184 mutex_lock(&mspro_block_mutex
);
185 mutex_lock(&mspro_block_disk_lock
);
187 if (msb
&& msb
->card
) {
189 if ((mode
& FMODE_WRITE
) && msb
->read_only
)
195 mutex_unlock(&mspro_block_disk_lock
);
196 mutex_unlock(&mspro_block_mutex
);
202 static int mspro_block_disk_release(struct gendisk
*disk
)
204 struct mspro_block_data
*msb
= disk
->private_data
;
205 int disk_id
= MINOR(disk_devt(disk
)) >> MSPRO_BLOCK_PART_SHIFT
;
207 mutex_lock(&mspro_block_disk_lock
);
210 if (msb
->usage_count
)
213 if (!msb
->usage_count
) {
215 disk
->private_data
= NULL
;
216 idr_remove(&mspro_block_disk_idr
, disk_id
);
221 mutex_unlock(&mspro_block_disk_lock
);
226 static int mspro_block_bd_release(struct gendisk
*disk
, fmode_t mode
)
229 mutex_lock(&mspro_block_mutex
);
230 ret
= mspro_block_disk_release(disk
);
231 mutex_unlock(&mspro_block_mutex
);
235 static int mspro_block_bd_getgeo(struct block_device
*bdev
,
236 struct hd_geometry
*geo
)
238 struct mspro_block_data
*msb
= bdev
->bd_disk
->private_data
;
240 geo
->heads
= msb
->heads
;
241 geo
->sectors
= msb
->sectors_per_track
;
242 geo
->cylinders
= msb
->cylinders
;
247 static const struct block_device_operations ms_block_bdops
= {
248 .open
= mspro_block_bd_open
,
249 .release
= mspro_block_bd_release
,
250 .getgeo
= mspro_block_bd_getgeo
,
254 /*** Information ***/
256 static struct mspro_sys_attr
*mspro_from_sysfs_attr(struct attribute
*attr
)
258 struct device_attribute
*dev_attr
259 = container_of(attr
, struct device_attribute
, attr
);
260 return container_of(dev_attr
, struct mspro_sys_attr
, dev_attr
);
263 static const char *mspro_block_attr_name(unsigned char tag
)
266 case MSPRO_BLOCK_ID_SYSINFO
:
267 return "attr_sysinfo";
268 case MSPRO_BLOCK_ID_MODELNAME
:
269 return "attr_modelname";
270 case MSPRO_BLOCK_ID_MBR
:
272 case MSPRO_BLOCK_ID_PBR16
:
274 case MSPRO_BLOCK_ID_PBR32
:
276 case MSPRO_BLOCK_ID_SPECFILEVALUES1
:
277 return "attr_specfilevalues1";
278 case MSPRO_BLOCK_ID_SPECFILEVALUES2
:
279 return "attr_specfilevalues2";
280 case MSPRO_BLOCK_ID_DEVINFO
:
281 return "attr_devinfo";
287 typedef ssize_t (*sysfs_show_t
)(struct device
*dev
,
288 struct device_attribute
*attr
,
291 static ssize_t
mspro_block_attr_show_default(struct device
*dev
,
292 struct device_attribute
*attr
,
295 struct mspro_sys_attr
*s_attr
= container_of(attr
,
296 struct mspro_sys_attr
,
301 for (cnt
= 0; cnt
< s_attr
->size
; cnt
++) {
302 if (cnt
&& !(cnt
% 16)) {
307 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "%02x ",
308 ((unsigned char *)s_attr
->data
)[cnt
]);
313 static ssize_t
mspro_block_attr_show_sysinfo(struct device
*dev
,
314 struct device_attribute
*attr
,
317 struct mspro_sys_attr
*x_attr
= container_of(attr
,
318 struct mspro_sys_attr
,
320 struct mspro_sys_info
*x_sys
= x_attr
->data
;
322 int date_tz
= 0, date_tz_f
= 0;
324 if (x_sys
->assembly_date
[0] > 0x80U
) {
325 date_tz
= (~x_sys
->assembly_date
[0]) + 1;
326 date_tz_f
= date_tz
& 3;
330 } else if (x_sys
->assembly_date
[0] < 0x80U
) {
331 date_tz
= x_sys
->assembly_date
[0];
332 date_tz_f
= date_tz
& 3;
337 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "class: %x\n",
339 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "block size: %x\n",
340 be16_to_cpu(x_sys
->block_size
));
341 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "block count: %x\n",
342 be16_to_cpu(x_sys
->block_count
));
343 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "user block count: %x\n",
344 be16_to_cpu(x_sys
->user_block_count
));
345 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "page size: %x\n",
346 be16_to_cpu(x_sys
->page_size
));
347 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "assembly date: "
348 "GMT%+d:%d %04u-%02u-%02u %02u:%02u:%02u\n",
350 be16_to_cpup((__be16
*)&x_sys
->assembly_date
[1]),
351 x_sys
->assembly_date
[3], x_sys
->assembly_date
[4],
352 x_sys
->assembly_date
[5], x_sys
->assembly_date
[6],
353 x_sys
->assembly_date
[7]);
354 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "serial number: %x\n",
355 be32_to_cpu(x_sys
->serial_number
));
356 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
,
357 "assembly maker code: %x\n",
358 x_sys
->assembly_maker_code
);
359 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "assembly model code: "
360 "%02x%02x%02x\n", x_sys
->assembly_model_code
[0],
361 x_sys
->assembly_model_code
[1],
362 x_sys
->assembly_model_code
[2]);
363 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "memory maker code: %x\n",
364 be16_to_cpu(x_sys
->memory_maker_code
));
365 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "memory model code: %x\n",
366 be16_to_cpu(x_sys
->memory_model_code
));
367 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "vcc: %x\n",
369 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "vpp: %x\n",
371 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "controller number: %x\n",
372 be16_to_cpu(x_sys
->controller_number
));
373 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
,
374 "controller function: %x\n",
375 be16_to_cpu(x_sys
->controller_function
));
376 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start sector: %x\n",
377 be16_to_cpu(x_sys
->start_sector
));
378 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "unit size: %x\n",
379 be16_to_cpu(x_sys
->unit_size
));
380 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "sub class: %x\n",
381 x_sys
->ms_sub_class
);
382 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "interface type: %x\n",
383 x_sys
->interface_type
);
384 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "controller code: %x\n",
385 be16_to_cpu(x_sys
->controller_code
));
386 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "format type: %x\n",
388 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "device type: %x\n",
390 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "mspro id: %s\n",
395 static ssize_t
mspro_block_attr_show_modelname(struct device
*dev
,
396 struct device_attribute
*attr
,
399 struct mspro_sys_attr
*s_attr
= container_of(attr
,
400 struct mspro_sys_attr
,
403 return scnprintf(buffer
, PAGE_SIZE
, "%s", (char *)s_attr
->data
);
406 static ssize_t
mspro_block_attr_show_mbr(struct device
*dev
,
407 struct device_attribute
*attr
,
410 struct mspro_sys_attr
*x_attr
= container_of(attr
,
411 struct mspro_sys_attr
,
413 struct mspro_mbr
*x_mbr
= x_attr
->data
;
416 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "boot partition: %x\n",
417 x_mbr
->boot_partition
);
418 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start head: %x\n",
420 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start sector: %x\n",
421 x_mbr
->start_sector
);
422 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start cylinder: %x\n",
423 x_mbr
->start_cylinder
);
424 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "partition type: %x\n",
425 x_mbr
->partition_type
);
426 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "end head: %x\n",
428 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "end sector: %x\n",
430 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "end cylinder: %x\n",
431 x_mbr
->end_cylinder
);
432 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start sectors: %x\n",
433 x_mbr
->start_sectors
);
434 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
,
435 "sectors per partition: %x\n",
436 x_mbr
->sectors_per_partition
);
440 static ssize_t
mspro_block_attr_show_specfile(struct device
*dev
,
441 struct device_attribute
*attr
,
444 struct mspro_sys_attr
*x_attr
= container_of(attr
,
445 struct mspro_sys_attr
,
447 struct mspro_specfile
*x_spfile
= x_attr
->data
;
448 char name
[9], ext
[4];
451 memcpy(name
, x_spfile
->name
, 8);
453 memcpy(ext
, x_spfile
->ext
, 3);
456 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "name: %s\n", name
);
457 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "ext: %s\n", ext
);
458 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "attribute: %x\n",
460 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "time: %d:%d:%d\n",
461 x_spfile
->time
>> 11,
462 (x_spfile
->time
>> 5) & 0x3f,
463 (x_spfile
->time
& 0x1f) * 2);
464 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "date: %d-%d-%d\n",
465 (x_spfile
->date
>> 9) + 1980,
466 (x_spfile
->date
>> 5) & 0xf,
467 x_spfile
->date
& 0x1f);
468 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "start cluster: %x\n",
470 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "size: %x\n",
475 static ssize_t
mspro_block_attr_show_devinfo(struct device
*dev
,
476 struct device_attribute
*attr
,
479 struct mspro_sys_attr
*x_attr
= container_of(attr
,
480 struct mspro_sys_attr
,
482 struct mspro_devinfo
*x_devinfo
= x_attr
->data
;
485 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "cylinders: %x\n",
486 be16_to_cpu(x_devinfo
->cylinders
));
487 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "heads: %x\n",
488 be16_to_cpu(x_devinfo
->heads
));
489 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "bytes per track: %x\n",
490 be16_to_cpu(x_devinfo
->bytes_per_track
));
491 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "bytes per sector: %x\n",
492 be16_to_cpu(x_devinfo
->bytes_per_sector
));
493 rc
+= scnprintf(buffer
+ rc
, PAGE_SIZE
- rc
, "sectors per track: %x\n",
494 be16_to_cpu(x_devinfo
->sectors_per_track
));
498 static sysfs_show_t
mspro_block_attr_show(unsigned char tag
)
501 case MSPRO_BLOCK_ID_SYSINFO
:
502 return mspro_block_attr_show_sysinfo
;
503 case MSPRO_BLOCK_ID_MODELNAME
:
504 return mspro_block_attr_show_modelname
;
505 case MSPRO_BLOCK_ID_MBR
:
506 return mspro_block_attr_show_mbr
;
507 case MSPRO_BLOCK_ID_SPECFILEVALUES1
:
508 case MSPRO_BLOCK_ID_SPECFILEVALUES2
:
509 return mspro_block_attr_show_specfile
;
510 case MSPRO_BLOCK_ID_DEVINFO
:
511 return mspro_block_attr_show_devinfo
;
513 return mspro_block_attr_show_default
;
517 /*** Protocol handlers ***/
520 * Functions prefixed with "h_" are protocol callbacks. They can be called from
521 * interrupt context. Return value of 0 means that request processing is still
522 * ongoing, while special error value of -EAGAIN means that current request is
523 * finished (and request processor should come back some time later).
526 static int h_mspro_block_req_init(struct memstick_dev
*card
,
527 struct memstick_request
**mrq
)
529 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
531 *mrq
= &card
->current_mrq
;
532 card
->next_request
= msb
->mrq_handler
;
536 static int h_mspro_block_default(struct memstick_dev
*card
,
537 struct memstick_request
**mrq
)
539 return mspro_block_complete_req(card
, (*mrq
)->error
);
542 static int h_mspro_block_default_bad(struct memstick_dev
*card
,
543 struct memstick_request
**mrq
)
548 static int h_mspro_block_get_ro(struct memstick_dev
*card
,
549 struct memstick_request
**mrq
)
551 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
553 if (!(*mrq
)->error
) {
554 if ((*mrq
)->data
[offsetof(struct ms_status_register
, status0
)]
555 & MEMSTICK_STATUS0_WP
)
561 return mspro_block_complete_req(card
, (*mrq
)->error
);
564 static int h_mspro_block_wait_for_ced(struct memstick_dev
*card
,
565 struct memstick_request
**mrq
)
567 dev_dbg(&card
->dev
, "wait for ced: value %x\n", (*mrq
)->data
[0]);
569 if (!(*mrq
)->error
) {
570 if ((*mrq
)->data
[0] & (MEMSTICK_INT_CMDNAK
| MEMSTICK_INT_ERR
))
571 (*mrq
)->error
= -EFAULT
;
572 else if (!((*mrq
)->data
[0] & MEMSTICK_INT_CED
))
576 return mspro_block_complete_req(card
, (*mrq
)->error
);
579 static int h_mspro_block_transfer_data(struct memstick_dev
*card
,
580 struct memstick_request
**mrq
)
582 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
583 unsigned char t_val
= 0;
584 struct scatterlist t_sg
= { 0 };
588 return mspro_block_complete_req(card
, (*mrq
)->error
);
590 switch ((*mrq
)->tpc
) {
591 case MS_TPC_WRITE_REG
:
592 memstick_init_req(*mrq
, MS_TPC_SET_CMD
, &msb
->transfer_cmd
, 1);
593 (*mrq
)->need_card_int
= 1;
596 t_val
= (*mrq
)->int_reg
;
597 memstick_init_req(*mrq
, MS_TPC_GET_INT
, NULL
, 1);
598 if (msb
->caps
& MEMSTICK_CAP_AUTO_GET_INT
)
602 t_val
= (*mrq
)->data
[0];
604 if (t_val
& (MEMSTICK_INT_CMDNAK
| MEMSTICK_INT_ERR
)) {
605 t_val
= MSPRO_CMD_STOP
;
606 memstick_init_req(*mrq
, MS_TPC_SET_CMD
, &t_val
, 1);
607 card
->next_request
= h_mspro_block_default
;
611 if (msb
->current_page
612 == (msb
->req_sg
[msb
->current_seg
].length
614 msb
->current_page
= 0;
617 if (msb
->current_seg
== msb
->seg_count
) {
618 if (t_val
& MEMSTICK_INT_CED
) {
619 return mspro_block_complete_req(card
,
623 = h_mspro_block_wait_for_ced
;
624 memstick_init_req(*mrq
, MS_TPC_GET_INT
,
631 if (!(t_val
& MEMSTICK_INT_BREQ
)) {
632 memstick_init_req(*mrq
, MS_TPC_GET_INT
, NULL
, 1);
636 t_offset
= msb
->req_sg
[msb
->current_seg
].offset
;
637 t_offset
+= msb
->current_page
* msb
->page_size
;
640 nth_page(sg_page(&(msb
->req_sg
[msb
->current_seg
])),
641 t_offset
>> PAGE_SHIFT
),
642 msb
->page_size
, offset_in_page(t_offset
));
644 memstick_init_req_sg(*mrq
, msb
->data_dir
== READ
645 ? MS_TPC_READ_LONG_DATA
646 : MS_TPC_WRITE_LONG_DATA
,
648 (*mrq
)->need_card_int
= 1;
650 case MS_TPC_READ_LONG_DATA
:
651 case MS_TPC_WRITE_LONG_DATA
:
653 if (msb
->caps
& MEMSTICK_CAP_AUTO_GET_INT
) {
654 t_val
= (*mrq
)->int_reg
;
657 memstick_init_req(*mrq
, MS_TPC_GET_INT
, NULL
, 1);
666 /*** Data transfer ***/
668 static int mspro_block_issue_req(struct memstick_dev
*card
, int chunk
)
670 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
673 struct mspro_param_register param
;
677 msb
->current_page
= 0;
678 msb
->current_seg
= 0;
679 msb
->seg_count
= blk_rq_map_sg(msb
->block_req
->q
,
683 if (!msb
->seg_count
) {
684 chunk
= __blk_end_request_cur(msb
->block_req
, -ENOMEM
);
688 t_sec
= blk_rq_pos(msb
->block_req
) << 9;
689 sector_div(t_sec
, msb
->page_size
);
691 count
= blk_rq_bytes(msb
->block_req
);
692 count
/= msb
->page_size
;
694 param
.system
= msb
->system
;
695 param
.data_count
= cpu_to_be16(count
);
696 param
.data_address
= cpu_to_be32((uint32_t)t_sec
);
699 msb
->data_dir
= rq_data_dir(msb
->block_req
);
700 msb
->transfer_cmd
= msb
->data_dir
== READ
701 ? MSPRO_CMD_READ_DATA
702 : MSPRO_CMD_WRITE_DATA
;
704 dev_dbg(&card
->dev
, "data transfer: cmd %x, "
705 "lba %x, count %x\n", msb
->transfer_cmd
,
706 be32_to_cpu(param
.data_address
), count
);
708 card
->next_request
= h_mspro_block_req_init
;
709 msb
->mrq_handler
= h_mspro_block_transfer_data
;
710 memstick_init_req(&card
->current_mrq
, MS_TPC_WRITE_REG
,
711 ¶m
, sizeof(param
));
712 memstick_new_req(card
->host
);
716 dev_dbg(&card
->dev
, "blk_fetch\n");
717 msb
->block_req
= blk_fetch_request(msb
->queue
);
718 if (!msb
->block_req
) {
719 dev_dbg(&card
->dev
, "issue end\n");
723 dev_dbg(&card
->dev
, "trying again\n");
728 static int mspro_block_complete_req(struct memstick_dev
*card
, int error
)
730 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
732 unsigned int t_len
= 0;
735 spin_lock_irqsave(&msb
->q_lock
, flags
);
736 dev_dbg(&card
->dev
, "complete %d, %d\n", msb
->has_request
? 1 : 0,
739 if (msb
->has_request
) {
740 /* Nothing to do - not really an error */
741 if (error
== -EAGAIN
)
744 if (error
|| (card
->current_mrq
.tpc
== MSPRO_CMD_STOP
)) {
745 if (msb
->data_dir
== READ
) {
746 for (cnt
= 0; cnt
< msb
->current_seg
; cnt
++)
747 t_len
+= msb
->req_sg
[cnt
].length
750 if (msb
->current_page
)
751 t_len
+= msb
->current_page
- 1;
753 t_len
*= msb
->page_size
;
756 t_len
= blk_rq_bytes(msb
->block_req
);
758 dev_dbg(&card
->dev
, "transferred %x (%d)\n", t_len
, error
);
761 t_len
= blk_rq_cur_bytes(msb
->block_req
);
763 chunk
= __blk_end_request(msb
->block_req
, error
, t_len
);
765 error
= mspro_block_issue_req(card
, chunk
);
770 msb
->has_request
= 0;
776 card
->next_request
= h_mspro_block_default_bad
;
777 complete_all(&card
->mrq_complete
);
779 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
783 static void mspro_block_stop(struct memstick_dev
*card
)
785 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
790 spin_lock_irqsave(&msb
->q_lock
, flags
);
791 if (!msb
->has_request
) {
792 blk_stop_queue(msb
->queue
);
795 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
800 wait_for_completion(&card
->mrq_complete
);
804 static void mspro_block_start(struct memstick_dev
*card
)
806 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
809 spin_lock_irqsave(&msb
->q_lock
, flags
);
810 blk_start_queue(msb
->queue
);
811 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
814 static int mspro_block_prepare_req(struct request_queue
*q
, struct request
*req
)
816 if (req
->cmd_type
!= REQ_TYPE_FS
&&
817 req
->cmd_type
!= REQ_TYPE_BLOCK_PC
) {
818 blk_dump_rq_flags(req
, "MSPro unsupported request");
822 req
->cmd_flags
|= REQ_DONTPREP
;
827 static void mspro_block_submit_req(struct request_queue
*q
)
829 struct memstick_dev
*card
= q
->queuedata
;
830 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
831 struct request
*req
= NULL
;
833 if (msb
->has_request
)
837 while ((req
= blk_fetch_request(q
)) != NULL
)
838 __blk_end_request_all(req
, -ENODEV
);
843 msb
->has_request
= 1;
844 if (mspro_block_issue_req(card
, 0))
845 msb
->has_request
= 0;
848 /*** Initialization ***/
850 static int mspro_block_wait_for_ced(struct memstick_dev
*card
)
852 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
854 card
->next_request
= h_mspro_block_req_init
;
855 msb
->mrq_handler
= h_mspro_block_wait_for_ced
;
856 memstick_init_req(&card
->current_mrq
, MS_TPC_GET_INT
, NULL
, 1);
857 memstick_new_req(card
->host
);
858 wait_for_completion(&card
->mrq_complete
);
859 return card
->current_mrq
.error
;
862 static int mspro_block_set_interface(struct memstick_dev
*card
,
863 unsigned char sys_reg
)
865 struct memstick_host
*host
= card
->host
;
866 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
867 struct mspro_param_register param
= {
874 card
->next_request
= h_mspro_block_req_init
;
875 msb
->mrq_handler
= h_mspro_block_default
;
876 memstick_init_req(&card
->current_mrq
, MS_TPC_WRITE_REG
, ¶m
,
878 memstick_new_req(host
);
879 wait_for_completion(&card
->mrq_complete
);
880 return card
->current_mrq
.error
;
883 static int mspro_block_switch_interface(struct memstick_dev
*card
)
885 struct memstick_host
*host
= card
->host
;
886 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
890 if (msb
->caps
& MEMSTICK_CAP_PAR4
)
891 rc
= mspro_block_set_interface(card
, MEMSTICK_SYS_PAR4
);
897 "%s: could not switch to 4-bit mode, error %d\n",
898 dev_name(&card
->dev
), rc
);
902 msb
->system
= MEMSTICK_SYS_PAR4
;
903 host
->set_param(host
, MEMSTICK_INTERFACE
, MEMSTICK_PAR4
);
904 printk(KERN_INFO
"%s: switching to 4-bit parallel mode\n",
905 dev_name(&card
->dev
));
907 if (msb
->caps
& MEMSTICK_CAP_PAR8
) {
908 rc
= mspro_block_set_interface(card
, MEMSTICK_SYS_PAR8
);
911 msb
->system
= MEMSTICK_SYS_PAR8
;
912 host
->set_param(host
, MEMSTICK_INTERFACE
,
915 "%s: switching to 8-bit parallel mode\n",
916 dev_name(&card
->dev
));
919 "%s: could not switch to 8-bit mode, error %d\n",
920 dev_name(&card
->dev
), rc
);
923 card
->next_request
= h_mspro_block_req_init
;
924 msb
->mrq_handler
= h_mspro_block_default
;
925 memstick_init_req(&card
->current_mrq
, MS_TPC_GET_INT
, NULL
, 1);
926 memstick_new_req(card
->host
);
927 wait_for_completion(&card
->mrq_complete
);
928 rc
= card
->current_mrq
.error
;
932 "%s: interface error, trying to fall back to serial\n",
933 dev_name(&card
->dev
));
934 msb
->system
= MEMSTICK_SYS_SERIAL
;
935 host
->set_param(host
, MEMSTICK_POWER
, MEMSTICK_POWER_OFF
);
937 host
->set_param(host
, MEMSTICK_POWER
, MEMSTICK_POWER_ON
);
938 host
->set_param(host
, MEMSTICK_INTERFACE
, MEMSTICK_SERIAL
);
940 rc
= memstick_set_rw_addr(card
);
942 rc
= mspro_block_set_interface(card
, msb
->system
);
946 rc
= mspro_block_wait_for_ced(card
);
950 if (msb
->caps
& MEMSTICK_CAP_PAR8
) {
951 msb
->caps
&= ~MEMSTICK_CAP_PAR8
;
959 /* Memory allocated for attributes by this function should be freed by
960 * mspro_block_data_clear, no matter if the initialization process succeded
963 static int mspro_block_read_attributes(struct memstick_dev
*card
)
965 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
966 struct mspro_param_register param
= {
967 .system
= msb
->system
,
968 .data_count
= cpu_to_be16(1),
972 struct mspro_attribute
*attr
= NULL
;
973 struct mspro_sys_attr
*s_attr
= NULL
;
974 unsigned char *buffer
= NULL
;
975 int cnt
, rc
, attr_count
;
977 unsigned short page_count
;
979 attr
= kmalloc(msb
->page_size
, GFP_KERNEL
);
983 sg_init_one(&msb
->req_sg
[0], attr
, msb
->page_size
);
985 msb
->current_seg
= 0;
986 msb
->current_page
= 0;
987 msb
->data_dir
= READ
;
988 msb
->transfer_cmd
= MSPRO_CMD_READ_ATRB
;
990 card
->next_request
= h_mspro_block_req_init
;
991 msb
->mrq_handler
= h_mspro_block_transfer_data
;
992 memstick_init_req(&card
->current_mrq
, MS_TPC_WRITE_REG
, ¶m
,
994 memstick_new_req(card
->host
);
995 wait_for_completion(&card
->mrq_complete
);
996 if (card
->current_mrq
.error
) {
997 rc
= card
->current_mrq
.error
;
1001 if (be16_to_cpu(attr
->signature
) != MSPRO_BLOCK_SIGNATURE
) {
1002 printk(KERN_ERR
"%s: unrecognized device signature %x\n",
1003 dev_name(&card
->dev
), be16_to_cpu(attr
->signature
));
1008 if (attr
->count
> MSPRO_BLOCK_MAX_ATTRIBUTES
) {
1009 printk(KERN_WARNING
"%s: way too many attribute entries\n",
1010 dev_name(&card
->dev
));
1011 attr_count
= MSPRO_BLOCK_MAX_ATTRIBUTES
;
1013 attr_count
= attr
->count
;
1015 msb
->attr_group
.attrs
= kzalloc((attr_count
+ 1)
1016 * sizeof(struct attribute
),
1018 if (!msb
->attr_group
.attrs
) {
1022 msb
->attr_group
.name
= "media_attributes";
1024 buffer
= kmalloc(msb
->page_size
, GFP_KERNEL
);
1029 memcpy(buffer
, (char *)attr
, msb
->page_size
);
1032 for (cnt
= 0; cnt
< attr_count
; ++cnt
) {
1033 s_attr
= kzalloc(sizeof(struct mspro_sys_attr
), GFP_KERNEL
);
1036 goto out_free_buffer
;
1039 msb
->attr_group
.attrs
[cnt
] = &s_attr
->dev_attr
.attr
;
1040 addr
= be32_to_cpu(attr
->entries
[cnt
].address
);
1041 rc
= be32_to_cpu(attr
->entries
[cnt
].size
);
1042 dev_dbg(&card
->dev
, "adding attribute %d: id %x, address %x, "
1043 "size %x\n", cnt
, attr
->entries
[cnt
].id
, addr
, rc
);
1044 s_attr
->id
= attr
->entries
[cnt
].id
;
1045 if (mspro_block_attr_name(s_attr
->id
))
1046 snprintf(s_attr
->name
, sizeof(s_attr
->name
), "%s",
1047 mspro_block_attr_name(attr
->entries
[cnt
].id
));
1049 snprintf(s_attr
->name
, sizeof(s_attr
->name
),
1050 "attr_x%02x", attr
->entries
[cnt
].id
);
1052 sysfs_attr_init(&s_attr
->dev_attr
.attr
);
1053 s_attr
->dev_attr
.attr
.name
= s_attr
->name
;
1054 s_attr
->dev_attr
.attr
.mode
= S_IRUGO
;
1055 s_attr
->dev_attr
.show
= mspro_block_attr_show(s_attr
->id
);
1061 s_attr
->data
= kmalloc(rc
, GFP_KERNEL
);
1062 if (!s_attr
->data
) {
1064 goto out_free_buffer
;
1067 if (((addr
/ msb
->page_size
)
1068 == be32_to_cpu(param
.data_address
))
1069 && (((addr
+ rc
- 1) / msb
->page_size
)
1070 == be32_to_cpu(param
.data_address
))) {
1071 memcpy(s_attr
->data
, buffer
+ addr
% msb
->page_size
,
1076 if (page_count
<= (rc
/ msb
->page_size
)) {
1078 page_count
= (rc
/ msb
->page_size
) + 1;
1079 buffer
= kmalloc(page_count
* msb
->page_size
,
1087 param
.system
= msb
->system
;
1088 param
.data_count
= cpu_to_be16((rc
/ msb
->page_size
) + 1);
1089 param
.data_address
= cpu_to_be32(addr
/ msb
->page_size
);
1090 param
.tpc_param
= 0;
1092 sg_init_one(&msb
->req_sg
[0], buffer
,
1093 be16_to_cpu(param
.data_count
) * msb
->page_size
);
1095 msb
->current_seg
= 0;
1096 msb
->current_page
= 0;
1097 msb
->data_dir
= READ
;
1098 msb
->transfer_cmd
= MSPRO_CMD_READ_ATRB
;
1100 dev_dbg(&card
->dev
, "reading attribute pages %x, %x\n",
1101 be32_to_cpu(param
.data_address
),
1102 be16_to_cpu(param
.data_count
));
1104 card
->next_request
= h_mspro_block_req_init
;
1105 msb
->mrq_handler
= h_mspro_block_transfer_data
;
1106 memstick_init_req(&card
->current_mrq
, MS_TPC_WRITE_REG
,
1107 (char *)¶m
, sizeof(param
));
1108 memstick_new_req(card
->host
);
1109 wait_for_completion(&card
->mrq_complete
);
1110 if (card
->current_mrq
.error
) {
1111 rc
= card
->current_mrq
.error
;
1112 goto out_free_buffer
;
1115 memcpy(s_attr
->data
, buffer
+ addr
% msb
->page_size
, rc
);
1126 static int mspro_block_init_card(struct memstick_dev
*card
)
1128 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1129 struct memstick_host
*host
= card
->host
;
1132 msb
->system
= MEMSTICK_SYS_SERIAL
;
1133 card
->reg_addr
.r_offset
= offsetof(struct mspro_register
, status
);
1134 card
->reg_addr
.r_length
= sizeof(struct ms_status_register
);
1135 card
->reg_addr
.w_offset
= offsetof(struct mspro_register
, param
);
1136 card
->reg_addr
.w_length
= sizeof(struct mspro_param_register
);
1138 if (memstick_set_rw_addr(card
))
1141 msb
->caps
= host
->caps
;
1144 rc
= mspro_block_wait_for_ced(card
);
1148 rc
= mspro_block_switch_interface(card
);
1152 dev_dbg(&card
->dev
, "card activated\n");
1153 if (msb
->system
!= MEMSTICK_SYS_SERIAL
)
1154 msb
->caps
|= MEMSTICK_CAP_AUTO_GET_INT
;
1156 card
->next_request
= h_mspro_block_req_init
;
1157 msb
->mrq_handler
= h_mspro_block_get_ro
;
1158 memstick_init_req(&card
->current_mrq
, MS_TPC_READ_REG
, NULL
,
1159 sizeof(struct ms_status_register
));
1160 memstick_new_req(card
->host
);
1161 wait_for_completion(&card
->mrq_complete
);
1162 if (card
->current_mrq
.error
)
1163 return card
->current_mrq
.error
;
1165 dev_dbg(&card
->dev
, "card r/w status %d\n", msb
->read_only
? 0 : 1);
1167 msb
->page_size
= 512;
1168 rc
= mspro_block_read_attributes(card
);
1172 dev_dbg(&card
->dev
, "attributes loaded\n");
1177 static int mspro_block_init_disk(struct memstick_dev
*card
)
1179 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1180 struct memstick_host
*host
= card
->host
;
1181 struct mspro_devinfo
*dev_info
= NULL
;
1182 struct mspro_sys_info
*sys_info
= NULL
;
1183 struct mspro_sys_attr
*s_attr
= NULL
;
1185 u64 limit
= BLK_BOUNCE_HIGH
;
1186 unsigned long capacity
;
1188 if (host
->dev
.dma_mask
&& *(host
->dev
.dma_mask
))
1189 limit
= *(host
->dev
.dma_mask
);
1191 for (rc
= 0; msb
->attr_group
.attrs
[rc
]; ++rc
) {
1192 s_attr
= mspro_from_sysfs_attr(msb
->attr_group
.attrs
[rc
]);
1194 if (s_attr
->id
== MSPRO_BLOCK_ID_DEVINFO
)
1195 dev_info
= s_attr
->data
;
1196 else if (s_attr
->id
== MSPRO_BLOCK_ID_SYSINFO
)
1197 sys_info
= s_attr
->data
;
1200 if (!dev_info
|| !sys_info
)
1203 msb
->cylinders
= be16_to_cpu(dev_info
->cylinders
);
1204 msb
->heads
= be16_to_cpu(dev_info
->heads
);
1205 msb
->sectors_per_track
= be16_to_cpu(dev_info
->sectors_per_track
);
1207 msb
->page_size
= be16_to_cpu(sys_info
->unit_size
);
1209 if (!idr_pre_get(&mspro_block_disk_idr
, GFP_KERNEL
))
1212 mutex_lock(&mspro_block_disk_lock
);
1213 rc
= idr_get_new(&mspro_block_disk_idr
, card
, &disk_id
);
1214 mutex_unlock(&mspro_block_disk_lock
);
1219 if ((disk_id
<< MSPRO_BLOCK_PART_SHIFT
) > 255) {
1221 goto out_release_id
;
1224 msb
->disk
= alloc_disk(1 << MSPRO_BLOCK_PART_SHIFT
);
1227 goto out_release_id
;
1230 msb
->queue
= blk_init_queue(mspro_block_submit_req
, &msb
->q_lock
);
1236 msb
->queue
->queuedata
= card
;
1237 blk_queue_prep_rq(msb
->queue
, mspro_block_prepare_req
);
1239 blk_queue_bounce_limit(msb
->queue
, limit
);
1240 blk_queue_max_hw_sectors(msb
->queue
, MSPRO_BLOCK_MAX_PAGES
);
1241 blk_queue_max_segments(msb
->queue
, MSPRO_BLOCK_MAX_SEGS
);
1242 blk_queue_max_segment_size(msb
->queue
,
1243 MSPRO_BLOCK_MAX_PAGES
* msb
->page_size
);
1245 msb
->disk
->major
= major
;
1246 msb
->disk
->first_minor
= disk_id
<< MSPRO_BLOCK_PART_SHIFT
;
1247 msb
->disk
->fops
= &ms_block_bdops
;
1248 msb
->usage_count
= 1;
1249 msb
->disk
->private_data
= msb
;
1250 msb
->disk
->queue
= msb
->queue
;
1251 msb
->disk
->driverfs_dev
= &card
->dev
;
1253 sprintf(msb
->disk
->disk_name
, "mspblk%d", disk_id
);
1255 blk_queue_logical_block_size(msb
->queue
, msb
->page_size
);
1257 capacity
= be16_to_cpu(sys_info
->user_block_count
);
1258 capacity
*= be16_to_cpu(sys_info
->block_size
);
1259 capacity
*= msb
->page_size
>> 9;
1260 set_capacity(msb
->disk
, capacity
);
1261 dev_dbg(&card
->dev
, "capacity set %ld\n", capacity
);
1263 add_disk(msb
->disk
);
1268 put_disk(msb
->disk
);
1270 mutex_lock(&mspro_block_disk_lock
);
1271 idr_remove(&mspro_block_disk_idr
, disk_id
);
1272 mutex_unlock(&mspro_block_disk_lock
);
1276 static void mspro_block_data_clear(struct mspro_block_data
*msb
)
1279 struct mspro_sys_attr
*s_attr
;
1281 if (msb
->attr_group
.attrs
) {
1282 for (cnt
= 0; msb
->attr_group
.attrs
[cnt
]; ++cnt
) {
1283 s_attr
= mspro_from_sysfs_attr(msb
->attr_group
1285 kfree(s_attr
->data
);
1288 kfree(msb
->attr_group
.attrs
);
1294 static int mspro_block_check_card(struct memstick_dev
*card
)
1296 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1298 return (msb
->active
== 1);
1301 static int mspro_block_probe(struct memstick_dev
*card
)
1303 struct mspro_block_data
*msb
;
1306 msb
= kzalloc(sizeof(struct mspro_block_data
), GFP_KERNEL
);
1309 memstick_set_drvdata(card
, msb
);
1311 spin_lock_init(&msb
->q_lock
);
1313 rc
= mspro_block_init_card(card
);
1318 rc
= sysfs_create_group(&card
->dev
.kobj
, &msb
->attr_group
);
1322 rc
= mspro_block_init_disk(card
);
1324 card
->check
= mspro_block_check_card
;
1325 card
->stop
= mspro_block_stop
;
1326 card
->start
= mspro_block_start
;
1330 sysfs_remove_group(&card
->dev
.kobj
, &msb
->attr_group
);
1332 memstick_set_drvdata(card
, NULL
);
1333 mspro_block_data_clear(msb
);
1338 static void mspro_block_remove(struct memstick_dev
*card
)
1340 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1341 unsigned long flags
;
1343 spin_lock_irqsave(&msb
->q_lock
, flags
);
1345 blk_start_queue(msb
->queue
);
1346 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
1348 del_gendisk(msb
->disk
);
1349 dev_dbg(&card
->dev
, "mspro block remove\n");
1351 blk_cleanup_queue(msb
->queue
);
1354 sysfs_remove_group(&card
->dev
.kobj
, &msb
->attr_group
);
1356 mutex_lock(&mspro_block_disk_lock
);
1357 mspro_block_data_clear(msb
);
1358 mutex_unlock(&mspro_block_disk_lock
);
1360 mspro_block_disk_release(msb
->disk
);
1361 memstick_set_drvdata(card
, NULL
);
1366 static int mspro_block_suspend(struct memstick_dev
*card
, pm_message_t state
)
1368 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1369 unsigned long flags
;
1371 spin_lock_irqsave(&msb
->q_lock
, flags
);
1372 blk_stop_queue(msb
->queue
);
1374 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
1379 static int mspro_block_resume(struct memstick_dev
*card
)
1381 struct mspro_block_data
*msb
= memstick_get_drvdata(card
);
1382 unsigned long flags
;
1385 #ifdef CONFIG_MEMSTICK_UNSAFE_RESUME
1387 struct mspro_block_data
*new_msb
;
1388 struct memstick_host
*host
= card
->host
;
1389 struct mspro_sys_attr
*s_attr
, *r_attr
;
1392 mutex_lock(&host
->lock
);
1393 new_msb
= kzalloc(sizeof(struct mspro_block_data
), GFP_KERNEL
);
1399 new_msb
->card
= card
;
1400 memstick_set_drvdata(card
, new_msb
);
1401 if (mspro_block_init_card(card
))
1404 for (cnt
= 0; new_msb
->attr_group
.attrs
[cnt
]
1405 && msb
->attr_group
.attrs
[cnt
]; ++cnt
) {
1406 s_attr
= mspro_from_sysfs_attr(new_msb
->attr_group
.attrs
[cnt
]);
1407 r_attr
= mspro_from_sysfs_attr(msb
->attr_group
.attrs
[cnt
]);
1409 if (s_attr
->id
== MSPRO_BLOCK_ID_SYSINFO
1410 && r_attr
->id
== s_attr
->id
) {
1411 if (memcmp(s_attr
->data
, r_attr
->data
, s_attr
->size
))
1420 memstick_set_drvdata(card
, msb
);
1421 mspro_block_data_clear(new_msb
);
1424 mutex_unlock(&host
->lock
);
1426 #endif /* CONFIG_MEMSTICK_UNSAFE_RESUME */
1428 spin_lock_irqsave(&msb
->q_lock
, flags
);
1429 blk_start_queue(msb
->queue
);
1430 spin_unlock_irqrestore(&msb
->q_lock
, flags
);
1436 #define mspro_block_suspend NULL
1437 #define mspro_block_resume NULL
1439 #endif /* CONFIG_PM */
1441 static struct memstick_device_id mspro_block_id_tbl
[] = {
1442 {MEMSTICK_MATCH_ALL
, MEMSTICK_TYPE_PRO
, MEMSTICK_CATEGORY_STORAGE_DUO
,
1443 MEMSTICK_CLASS_DUO
},
1448 static struct memstick_driver mspro_block_driver
= {
1450 .name
= DRIVER_NAME
,
1451 .owner
= THIS_MODULE
1453 .id_table
= mspro_block_id_tbl
,
1454 .probe
= mspro_block_probe
,
1455 .remove
= mspro_block_remove
,
1456 .suspend
= mspro_block_suspend
,
1457 .resume
= mspro_block_resume
1460 static int __init
mspro_block_init(void)
1464 rc
= register_blkdev(major
, DRIVER_NAME
);
1466 printk(KERN_ERR DRIVER_NAME
": failed to register "
1467 "major %d, error %d\n", major
, rc
);
1473 rc
= memstick_register_driver(&mspro_block_driver
);
1475 unregister_blkdev(major
, DRIVER_NAME
);
1479 static void __exit
mspro_block_exit(void)
1481 memstick_unregister_driver(&mspro_block_driver
);
1482 unregister_blkdev(major
, DRIVER_NAME
);
1483 idr_destroy(&mspro_block_disk_idr
);
1486 module_init(mspro_block_init
);
1487 module_exit(mspro_block_exit
);
1489 MODULE_LICENSE("GPL");
1490 MODULE_AUTHOR("Alex Dubov");
1491 MODULE_DESCRIPTION("Sony MemoryStickPro block device driver");
1492 MODULE_DEVICE_TABLE(memstick
, mspro_block_id_tbl
);