include/linux/memstick.h

   1 /*
   2  *  Sony MemoryStick support
   3  *
   4  *  Copyright (C) 2007 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 #ifndef _MEMSTICK_H
  13 #define _MEMSTICK_H
  14
  15 #include <linux/workqueue.h>
  16 #include <linux/scatterlist.h>
  17 #include <linux/device.h>
  18
  19 /*** Hardware based structures ***/
  20
  21 struct ms_status_register {
  22         unsigned char reserved;
  23         unsigned char interrupt;
  24 #define MEMSTICK_INT_CMDNAK             0x0001
  25 #define MEMSTICK_INT_IOREQ              0x0008
  26 #define MEMSTICK_INT_IOBREQ             0x0010
  27 #define MEMSTICK_INT_BREQ               0x0020
  28 #define MEMSTICK_INT_ERR                0x0040
  29 #define MEMSTICK_INT_CED                0x0080
  30
  31         unsigned char status0;
  32 #define MEMSTICK_STATUS0_WP             0x0001
  33 #define MEMSTICK_STATUS0_SL             0x0002
  34 #define MEMSTICK_STATUS0_BF             0x0010
  35 #define MEMSTICK_STATUS0_BE             0x0020
  36 #define MEMSTICK_STATUS0_FB0            0x0040
  37 #define MEMSTICK_STATUS0_MB             0x0080
  38
  39         unsigned char status1;
  40 #define MEMSTICK_STATUS1_UCFG           0x0001
  41 #define MEMSTICK_STATUS1_FGER           0x0002
  42 #define MEMSTICK_STATUS1_UCEX           0x0004
  43 #define MEMSTICK_STATUS1_EXER           0x0008
  44 #define MEMSTICK_STATUS1_UCDT           0x0010
  45 #define MEMSTICK_STATUS1_DTER           0x0020
  46 #define MEMSTICK_STATUS1_FBI            0x0040
  47 #define MEMSTICK_STATUS1_MB             0x0080
  48 } __attribute__((packed));
  49
  50 struct ms_id_register {
  51         unsigned char type;
  52         unsigned char if_mode;
  53         unsigned char category;
  54         unsigned char class;
  55 } __attribute__((packed));
  56
  57 struct ms_param_register {
  58         unsigned char system;
  59 #define MEMSTICK_SYS_ATEN 0xc0
  60 #define MEMSTICK_SYS_BAMD 0x80
  61 #define MEMSTICK_SYS_PAM  0x08
  62
  63         unsigned char block_address_msb;
  64         unsigned short block_address;
  65         unsigned char cp;
  66 #define MEMSTICK_CP_BLOCK               0x0000
  67 #define MEMSTICK_CP_PAGE                0x0020
  68 #define MEMSTICK_CP_EXTRA               0x0040
  69 #define MEMSTICK_CP_OVERWRITE           0x0080
  70
  71         unsigned char page_address;
  72 } __attribute__((packed));
  73
  74 struct ms_extra_data_register {
  75         unsigned char  overwrite_flag;
  76 #define MEMSTICK_OVERWRITE_UPDATA       0x0010
  77 #define MEMSTICK_OVERWRITE_PAGE         0x0060
  78 #define MEMSTICK_OVERWRITE_BLOCK        0x0080
  79
  80         unsigned char  management_flag;
  81 #define MEMSTICK_MANAGEMENT_SYSTEM      0x0004
  82 #define MEMSTICK_MANAGEMENT_TRANS_TABLE 0x0008
  83 #define MEMSTICK_MANAGEMENT_COPY        0x0010
  84 #define MEMSTICK_MANAGEMENT_ACCESS      0x0020
  85
  86         unsigned short logical_address;
  87 } __attribute__((packed));
  88
  89 struct ms_register {
  90         struct ms_status_register     status;
  91         struct ms_id_register         id;
  92         unsigned char                 reserved[8];
  93         struct ms_param_register      param;
  94         struct ms_extra_data_register extra_data;
  95 } __attribute__((packed));
  96
  97 struct mspro_param_register {
  98         unsigned char  system;
  99 #define MEMSTICK_SYS_SERIAL 0x80
 100 #define MEMSTICK_SYS_PAR4   0x00
 101 #define MEMSTICK_SYS_PAR8   0x40
 102
 103         unsigned short data_count;
 104         unsigned int   data_address;
 105         unsigned char  tpc_param;
 106 } __attribute__((packed));
 107
 108 struct mspro_io_info_register {
 109         unsigned char version;
 110         unsigned char io_category;
 111         unsigned char current_req;
 112         unsigned char card_opt_info;
 113         unsigned char rdy_wait_time;
 114 } __attribute__((packed));
 115
 116 struct mspro_io_func_register {
 117         unsigned char func_enable;
 118         unsigned char func_select;
 119         unsigned char func_intmask;
 120         unsigned char transfer_mode;
 121 } __attribute__((packed));
 122
 123 struct mspro_io_cmd_register {
 124         unsigned short tpc_param;
 125         unsigned short data_count;
 126         unsigned int   data_address;
 127 } __attribute__((packed));
 128
 129 struct mspro_register {
 130         struct ms_status_register     status;
 131         struct ms_id_register         id;
 132         unsigned char                 reserved0[8];
 133         struct mspro_param_register   param;
 134         unsigned char                 reserved1[8];
 135         struct mspro_io_info_register io_info;
 136         struct mspro_io_func_register io_func;
 137         unsigned char                 reserved2[7];
 138         struct mspro_io_cmd_register  io_cmd;
 139         unsigned char                 io_int;
 140         unsigned char                 io_int_func;
 141 } __attribute__((packed));
 142
 143 struct ms_register_addr {
 144         unsigned char r_offset;
 145         unsigned char r_length;
 146         unsigned char w_offset;
 147         unsigned char w_length;
 148 } __attribute__((packed));
 149
 150 enum {
 151         MS_TPC_READ_MG_STATUS   = 0x01,
 152         MS_TPC_READ_LONG_DATA   = 0x02,
 153         MS_TPC_READ_SHORT_DATA  = 0x03,
 154         MS_TPC_READ_MG_DATA     = 0x03,
 155         MS_TPC_READ_REG         = 0x04,
 156         MS_TPC_READ_QUAD_DATA   = 0x05,
 157         MS_TPC_READ_IO_DATA     = 0x05,
 158         MS_TPC_GET_INT          = 0x07,
 159         MS_TPC_SET_RW_REG_ADRS  = 0x08,
 160         MS_TPC_EX_SET_CMD       = 0x09,
 161         MS_TPC_WRITE_QUAD_DATA  = 0x0a,
 162         MS_TPC_WRITE_IO_DATA    = 0x0a,
 163         MS_TPC_WRITE_REG        = 0x0b,
 164         MS_TPC_WRITE_SHORT_DATA = 0x0c,
 165         MS_TPC_WRITE_MG_DATA    = 0x0c,
 166         MS_TPC_WRITE_LONG_DATA  = 0x0d,
 167         MS_TPC_SET_CMD          = 0x0e
 168 };
 169
 170 enum {
 171         MS_CMD_BLOCK_END       = 0x33,
 172         MS_CMD_RESET           = 0x3c,
 173         MS_CMD_BLOCK_WRITE     = 0x55,
 174         MS_CMD_SLEEP           = 0x5a,
 175         MS_CMD_BLOCK_ERASE     = 0x99,
 176         MS_CMD_BLOCK_READ      = 0xaa,
 177         MS_CMD_CLEAR_BUF       = 0xc3,
 178         MS_CMD_FLASH_STOP      = 0xcc,
 179         MS_CMD_LOAD_ID         = 0x60,
 180         MS_CMD_CMP_ICV         = 0x7f,
 181         MSPRO_CMD_FORMAT       = 0x10,
 182         MSPRO_CMD_SLEEP        = 0x11,
 183         MSPRO_CMD_WAKEUP       = 0x12,
 184         MSPRO_CMD_READ_DATA    = 0x20,
 185         MSPRO_CMD_WRITE_DATA   = 0x21,
 186         MSPRO_CMD_READ_ATRB    = 0x24,
 187         MSPRO_CMD_STOP         = 0x25,
 188         MSPRO_CMD_ERASE        = 0x26,
 189         MSPRO_CMD_READ_QUAD    = 0x27,
 190         MSPRO_CMD_WRITE_QUAD   = 0x28,
 191         MSPRO_CMD_SET_IBD      = 0x46,
 192         MSPRO_CMD_GET_IBD      = 0x47,
 193         MSPRO_CMD_IN_IO_DATA   = 0xb0,
 194         MSPRO_CMD_OUT_IO_DATA  = 0xb1,
 195         MSPRO_CMD_READ_IO_ATRB = 0xb2,
 196         MSPRO_CMD_IN_IO_FIFO   = 0xb3,
 197         MSPRO_CMD_OUT_IO_FIFO  = 0xb4,
 198         MSPRO_CMD_IN_IOM       = 0xb5,
 199         MSPRO_CMD_OUT_IOM      = 0xb6,
 200 };
 201
 202 /*** Driver structures and functions ***/
 203
 204 #define MEMSTICK_PART_SHIFT 3
 205
 206 enum memstick_param { MEMSTICK_POWER = 1, MEMSTICK_INTERFACE };
 207
 208 #define MEMSTICK_POWER_OFF 0
 209 #define MEMSTICK_POWER_ON  1
 210
 211 #define MEMSTICK_SERIAL   0
 212 #define MEMSTICK_PAR4     1
 213 #define MEMSTICK_PAR8     2
 214
 215 struct memstick_host;
 216 struct memstick_driver;
 217
 218 #define MEMSTICK_MATCH_ALL            0x01
 219
 220 #define MEMSTICK_TYPE_LEGACY          0xff
 221 #define MEMSTICK_TYPE_DUO             0x00
 222 #define MEMSTICK_TYPE_PRO             0x01
 223
 224 #define MEMSTICK_CATEGORY_STORAGE     0xff
 225 #define MEMSTICK_CATEGORY_STORAGE_DUO 0x00
 226
 227 #define MEMSTICK_CLASS_GENERIC        0xff
 228 #define MEMSTICK_CLASS_GENERIC_DUO    0x00
 229
 230
 231 struct memstick_device_id {
 232         unsigned char match_flags;
 233         unsigned char type;
 234         unsigned char category;
 235         unsigned char class;
 236 };
 237
 238 struct memstick_request {
 239         unsigned char tpc;
 240         unsigned char data_dir:1,
 241                       need_card_int:1,
 242                       get_int_reg:1,
 243                       long_data:1;
 244         unsigned char int_reg;
 245         int           error;
 246         union {
 247                 struct scatterlist sg;
 248                 struct {
 249                         unsigned char data_len;
 250                         unsigned char data[15];
 251                 };
 252         };
 253 };
 254
 255 struct memstick_dev {
 256         struct memstick_device_id id;
 257         struct memstick_host     *host;
 258         struct ms_register_addr  reg_addr;
 259         struct completion        mrq_complete;
 260         struct memstick_request  current_mrq;
 261
 262         /* Check that media driver is still willing to operate the device. */
 263         int                      (*check)(struct memstick_dev *card);
 264         /* Get next request from the media driver.                         */
 265         int                      (*next_request)(struct memstick_dev *card,
 266                                                  struct memstick_request **mrq);
 267
 268         struct device            dev;
 269 };
 270
 271 struct memstick_host {
 272         struct mutex        lock;
 273         unsigned int        id;
 274         unsigned int        caps;
 275 #define MEMSTICK_CAP_AUTO_GET_INT  1
 276 #define MEMSTICK_CAP_PAR4          2
 277 #define MEMSTICK_CAP_PAR8          4
 278
 279         struct work_struct  media_checker;
 280         struct class_device cdev;
 281
 282         struct memstick_dev *card;
 283         unsigned int        retries;
 284
 285         /* Notify the host that some requests are pending. */
 286         void                (*request)(struct memstick_host *host);
 287         /* Set host IO parameters (power, clock, etc).     */
 288         void                (*set_param)(struct memstick_host *host,
 289                                          enum memstick_param param,
 290                                          int value);
 291         unsigned long       private[0] ____cacheline_aligned;
 292 };
 293
 294 struct memstick_driver {
 295         struct memstick_device_id *id_table;
 296         int                       (*probe)(struct memstick_dev *card);
 297         void                      (*remove)(struct memstick_dev *card);
 298         int                       (*suspend)(struct memstick_dev *card,
 299                                              pm_message_t state);
 300         int                       (*resume)(struct memstick_dev *card);
 301
 302         struct device_driver      driver;
 303 };
 304
 305 int memstick_register_driver(struct memstick_driver *drv);
 306 void memstick_unregister_driver(struct memstick_driver *drv);
 307
 308 struct memstick_host *memstick_alloc_host(unsigned int extra,
 309                                           struct device *dev);
 310
 311 int memstick_add_host(struct memstick_host *host);
 312 void memstick_remove_host(struct memstick_host *host);
 313 void memstick_free_host(struct memstick_host *host);
 314 void memstick_detect_change(struct memstick_host *host);
 315 void memstick_suspend_host(struct memstick_host *host);
 316 void memstick_resume_host(struct memstick_host *host);
 317
 318 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
 319                           struct scatterlist *sg);
 320 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
 321                        void *buf, size_t length);
 322 int memstick_next_req(struct memstick_host *host,
 323                       struct memstick_request **mrq);
 324 void memstick_new_req(struct memstick_host *host);
 325
 326 int memstick_set_rw_addr(struct memstick_dev *card);
 327
 328 static inline void *memstick_priv(struct memstick_host *host)
 329 {
 330         return (void *)host->private;
 331 }
 332
 333 static inline void *memstick_get_drvdata(struct memstick_dev *card)
 334 {
 335         return dev_get_drvdata(&card->dev);
 336 }
 337
 338 static inline void memstick_set_drvdata(struct memstick_dev *card, void *data)
 339 {
 340         dev_set_drvdata(&card->dev, data);
 341 }
 342
 343 #endif