arch/sparc/include/asm/vio.h

   1 #ifndef _SPARC64_VIO_H
   2 #define _SPARC64_VIO_H
   3
   4 #include <linux/kernel.h>
   5 #include <linux/device.h>
   6 #include <linux/mod_devicetable.h>
   7 #include <linux/timer.h>
   8 #include <linux/spinlock.h>
   9 #include <linux/completion.h>
  10 #include <linux/list.h>
  11 #include <linux/log2.h>
  12
  13 #include <asm/ldc.h>
  14 #include <asm/mdesc.h>
  15
  16 struct vio_msg_tag {
  17         u8                      type;
  18 #define VIO_TYPE_CTRL           0x01
  19 #define VIO_TYPE_DATA           0x02
  20 #define VIO_TYPE_ERR            0x04
  21
  22         u8                      stype;
  23 #define VIO_SUBTYPE_INFO        0x01
  24 #define VIO_SUBTYPE_ACK         0x02
  25 #define VIO_SUBTYPE_NACK        0x04
  26
  27         u16                     stype_env;
  28 #define VIO_VER_INFO            0x0001
  29 #define VIO_ATTR_INFO           0x0002
  30 #define VIO_DRING_REG           0x0003
  31 #define VIO_DRING_UNREG         0x0004
  32 #define VIO_RDX                 0x0005
  33 #define VIO_PKT_DATA            0x0040
  34 #define VIO_DESC_DATA           0x0041
  35 #define VIO_DRING_DATA          0x0042
  36 #define VNET_MCAST_INFO         0x0101
  37
  38         u32             sid;
  39 };
  40
  41 struct vio_rdx {
  42         struct vio_msg_tag      tag;
  43         u64                     resv[6];
  44 };
  45
  46 struct vio_ver_info {
  47         struct vio_msg_tag      tag;
  48         u16                     major;
  49         u16                     minor;
  50         u8                      dev_class;
  51 #define VDEV_NETWORK            0x01
  52 #define VDEV_NETWORK_SWITCH     0x02
  53 #define VDEV_DISK               0x03
  54 #define VDEV_DISK_SERVER        0x04
  55
  56         u8                      resv1[3];
  57         u64                     resv2[5];
  58 };
  59
  60 struct vio_dring_register {
  61         struct vio_msg_tag      tag;
  62         u64                     dring_ident;
  63         u32                     num_descr;
  64         u32                     descr_size;
  65         u16                     options;
  66 #define VIO_TX_DRING            0x0001
  67 #define VIO_RX_DRING            0x0002
  68 #define VIO_RX_DRING_DATA       0x0004
  69         u16                     resv;
  70         u32                     num_cookies;
  71         struct ldc_trans_cookie cookies[0];
  72 };
  73
  74 struct vio_dring_unregister {
  75         struct vio_msg_tag      tag;
  76         u64                     dring_ident;
  77         u64                     resv[5];
  78 };
  79
  80 /* Data transfer modes */
  81 #define VIO_PKT_MODE            0x01 /* Packet based transfer   */
  82 #define VIO_DESC_MODE           0x02 /* In-band descriptors     */
  83 #define VIO_DRING_MODE          0x03 /* Descriptor rings        */
  84 /* in vers >= 1.2, VIO_DRING_MODE is 0x04 and transfer mode is a bitmask */
  85 #define VIO_NEW_DRING_MODE      0x04
  86
  87 struct vio_dring_data {
  88         struct vio_msg_tag      tag;
  89         u64                     seq;
  90         u64                     dring_ident;
  91         u32                     start_idx;
  92         u32                     end_idx;
  93         u8                      state;
  94 #define VIO_DRING_ACTIVE        0x01
  95 #define VIO_DRING_STOPPED       0x02
  96
  97         u8                      __pad1;
  98         u16                     __pad2;
  99         u32                     __pad3;
 100         u64                     __par4[2];
 101 };
 102
 103 struct vio_dring_hdr {
 104         u8                      state;
 105 #define VIO_DESC_FREE           0x01
 106 #define VIO_DESC_READY          0x02
 107 #define VIO_DESC_ACCEPTED       0x03
 108 #define VIO_DESC_DONE           0x04
 109         u8                      ack;
 110 #define VIO_ACK_ENABLE          0x01
 111 #define VIO_ACK_DISABLE         0x00
 112
 113         u16                     __pad1;
 114         u32                     __pad2;
 115 };
 116
 117 /* VIO disk specific structures and defines */
 118 struct vio_disk_attr_info {
 119         struct vio_msg_tag      tag;
 120         u8                      xfer_mode;
 121         u8                      vdisk_type;
 122 #define VD_DISK_TYPE_SLICE      0x01 /* Slice in block device   */
 123 #define VD_DISK_TYPE_DISK       0x02 /* Entire block device     */
 124         u8                      vdisk_mtype;            /* v1.1 */
 125 #define VD_MEDIA_TYPE_FIXED     0x01 /* Fixed device */
 126 #define VD_MEDIA_TYPE_CD        0x02 /* CD Device    */
 127 #define VD_MEDIA_TYPE_DVD       0x03 /* DVD Device   */
 128         u8                      resv1;
 129         u32                     vdisk_block_size;
 130         u64                     operations;
 131         u64                     vdisk_size;             /* v1.1 */
 132         u64                     max_xfer_size;
 133         u32                     phys_block_size;        /* v1.2 */
 134         u32                     resv2;
 135         u64                     resv3[1];
 136 };
 137
 138 struct vio_disk_desc {
 139         struct vio_dring_hdr    hdr;
 140         u64                     req_id;
 141         u8                      operation;
 142 #define VD_OP_BREAD             0x01 /* Block read                      */
 143 #define VD_OP_BWRITE            0x02 /* Block write                     */
 144 #define VD_OP_FLUSH             0x03 /* Flush disk contents             */
 145 #define VD_OP_GET_WCE           0x04 /* Get write-cache status          */
 146 #define VD_OP_SET_WCE           0x05 /* Enable/disable write-cache      */
 147 #define VD_OP_GET_VTOC          0x06 /* Get VTOC                        */
 148 #define VD_OP_SET_VTOC          0x07 /* Set VTOC                        */
 149 #define VD_OP_GET_DISKGEOM      0x08 /* Get disk geometry               */
 150 #define VD_OP_SET_DISKGEOM      0x09 /* Set disk geometry               */
 151 #define VD_OP_SCSICMD           0x0a /* SCSI control command            */
 152 #define VD_OP_GET_DEVID         0x0b /* Get device ID                   */
 153 #define VD_OP_GET_EFI           0x0c /* Get EFI                         */
 154 #define VD_OP_SET_EFI           0x0d /* Set EFI                         */
 155         u8                      slice;
 156         u16                     resv1;
 157         u32                     status;
 158         u64                     offset;
 159         u64                     size;
 160         u32                     ncookies;
 161         u32                     resv2;
 162         struct ldc_trans_cookie cookies[0];
 163 };
 164
 165 #define VIO_DISK_VNAME_LEN      8
 166 #define VIO_DISK_ALABEL_LEN     128
 167 #define VIO_DISK_NUM_PART       8
 168
 169 struct vio_disk_vtoc {
 170         u8                      volume_name[VIO_DISK_VNAME_LEN];
 171         u16                     sector_size;
 172         u16                     num_partitions;
 173         u8                      ascii_label[VIO_DISK_ALABEL_LEN];
 174         struct {
 175                 u16             id;
 176                 u16             perm_flags;
 177                 u32             resv;
 178                 u64             start_block;
 179                 u64             num_blocks;
 180         } partitions[VIO_DISK_NUM_PART];
 181 };
 182
 183 struct vio_disk_geom {
 184         u16                     num_cyl; /* Num data cylinders          */
 185         u16                     alt_cyl; /* Num alternate cylinders     */
 186         u16                     beg_cyl; /* Cyl off of fixed head area  */
 187         u16                     num_hd;  /* Num heads                   */
 188         u16                     num_sec; /* Num sectors                 */
 189         u16                     ifact;   /* Interleave factor           */
 190         u16                     apc;     /* Alts per cylinder (SCSI)    */
 191         u16                     rpm;     /* Revolutions per minute      */
 192         u16                     phy_cyl; /* Num physical cylinders      */
 193         u16                     wr_skip; /* Num sects to skip, writes   */
 194         u16                     rd_skip; /* Num sects to skip, writes   */
 195 };
 196
 197 struct vio_disk_devid {
 198         u16                     resv;
 199         u16                     type;
 200         u32                     len;
 201         char                    id[0];
 202 };
 203
 204 struct vio_disk_efi {
 205         u64                     lba;
 206         u64                     len;
 207         char                    data[0];
 208 };
 209
 210 /* VIO net specific structures and defines */
 211 struct vio_net_attr_info {
 212         struct vio_msg_tag      tag;
 213         u8                      xfer_mode;
 214         u8                      addr_type;
 215 #define VNET_ADDR_ETHERMAC      0x01
 216         u16                     ack_freq;
 217         u8                      plnk_updt;
 218 #define PHYSLINK_UPDATE_NONE            0x00
 219 #define PHYSLINK_UPDATE_STATE           0x01
 220 #define PHYSLINK_UPDATE_STATE_ACK       0x02
 221 #define PHYSLINK_UPDATE_STATE_NACK      0x03
 222         u8                      options;
 223         u16                     resv1;
 224         u64                     addr;
 225         u64                     mtu;
 226         u16                     cflags;
 227 #define VNET_LSO_IPV4_CAPAB             0x0001
 228         u16                     ipv4_lso_maxlen;
 229         u32                     resv2;
 230         u64                     resv3[2];
 231 };
 232
 233 #define VNET_NUM_MCAST          7
 234
 235 struct vio_net_mcast_info {
 236         struct vio_msg_tag      tag;
 237         u8                      set;
 238         u8                      count;
 239         u8                      mcast_addr[VNET_NUM_MCAST * 6];
 240         u32                     resv;
 241 };
 242
 243 struct vio_net_desc {
 244         struct vio_dring_hdr    hdr;
 245         u32                     size;
 246         u32                     ncookies;
 247         struct ldc_trans_cookie cookies[0];
 248 };
 249
 250 struct vio_net_dext {
 251         u8              flags;
 252 #define VNET_PKT_HASH                   0x01
 253 #define VNET_PKT_HCK_IPV4_HDRCKSUM      0x02
 254 #define VNET_PKT_HCK_FULLCKSUM          0x04
 255 #define VNET_PKT_IPV4_LSO               0x08
 256 #define VNET_PKT_HCK_IPV4_HDRCKSUM_OK   0x10
 257 #define VNET_PKT_HCK_FULLCKSUM_OK       0x20
 258
 259         u8              vnet_hashval;
 260         u16             ipv4_lso_mss;
 261         u32             resv3;
 262 };
 263
 264 static inline struct vio_net_dext *vio_net_ext(struct vio_net_desc *desc)
 265 {
 266         return (struct vio_net_dext *)&desc->cookies[2];
 267 }
 268
 269 #define VIO_MAX_RING_COOKIES    24
 270
 271 struct vio_dring_state {
 272         u64                     ident;
 273         void                    *base;
 274         u64                     snd_nxt;
 275         u64                     rcv_nxt;
 276         u32                     entry_size;
 277         u32                     num_entries;
 278         u32                     prod;
 279         u32                     cons;
 280         u32                     pending;
 281         int                     ncookies;
 282         struct ldc_trans_cookie cookies[VIO_MAX_RING_COOKIES];
 283 };
 284
 285 static inline void *vio_dring_cur(struct vio_dring_state *dr)
 286 {
 287         return dr->base + (dr->entry_size * dr->prod);
 288 }
 289
 290 static inline void *vio_dring_entry(struct vio_dring_state *dr,
 291                                     unsigned int index)
 292 {
 293         return dr->base + (dr->entry_size * index);
 294 }
 295
 296 static inline u32 vio_dring_avail(struct vio_dring_state *dr,
 297                                   unsigned int ring_size)
 298 {
 299         return (dr->pending -
 300                 ((dr->prod - dr->cons) & (ring_size - 1)) - 1);
 301 }
 302
 303 static inline u32 vio_dring_next(struct vio_dring_state *dr, u32 index)
 304 {
 305         if (++index == dr->num_entries)
 306                 index = 0;
 307         return index;
 308 }
 309
 310 static inline u32 vio_dring_prev(struct vio_dring_state *dr, u32 index)
 311 {
 312         if (index == 0)
 313                 return dr->num_entries - 1;
 314         else
 315                 return index - 1;
 316 }
 317
 318 #define VIO_MAX_TYPE_LEN        32
 319 #define VIO_MAX_COMPAT_LEN      64
 320
 321 struct vio_dev {
 322         u64                     mp;
 323         struct device_node      *dp;
 324
 325         char                    type[VIO_MAX_TYPE_LEN];
 326         char                    compat[VIO_MAX_COMPAT_LEN];
 327         int                     compat_len;
 328
 329         u64                     dev_no;
 330
 331         unsigned long           channel_id;
 332
 333         unsigned int            tx_irq;
 334         unsigned int            rx_irq;
 335         u64                     rx_ino;
 336
 337         struct device           dev;
 338 };
 339
 340 struct vio_driver {
 341         const char                      *name;
 342         struct list_head                node;
 343         const struct vio_device_id      *id_table;
 344         int (*probe)(struct vio_dev *dev, const struct vio_device_id *id);
 345         int (*remove)(struct vio_dev *dev);
 346         void (*shutdown)(struct vio_dev *dev);
 347         unsigned long                   driver_data;
 348         struct device_driver            driver;
 349 };
 350
 351 struct vio_version {
 352         u16             major;
 353         u16             minor;
 354 };
 355
 356 struct vio_driver_state;
 357 struct vio_driver_ops {
 358         int     (*send_attr)(struct vio_driver_state *vio);
 359         int     (*handle_attr)(struct vio_driver_state *vio, void *pkt);
 360         void    (*handshake_complete)(struct vio_driver_state *vio);
 361 };
 362
 363 struct vio_completion {
 364         struct completion       com;
 365         int                     err;
 366         int                     waiting_for;
 367 };
 368
 369 struct vio_driver_state {
 370         /* Protects VIO handshake and, optionally, driver private state.  */
 371         spinlock_t              lock;
 372
 373         struct ldc_channel      *lp;
 374
 375         u32                     _peer_sid;
 376         u32                     _local_sid;
 377         struct vio_dring_state  drings[2];
 378 #define VIO_DRIVER_TX_RING      0
 379 #define VIO_DRIVER_RX_RING      1
 380
 381         u8                      hs_state;
 382 #define VIO_HS_INVALID          0x00
 383 #define VIO_HS_GOTVERS          0x01
 384 #define VIO_HS_GOT_ATTR         0x04
 385 #define VIO_HS_SENT_DREG        0x08
 386 #define VIO_HS_SENT_RDX         0x10
 387 #define VIO_HS_GOT_RDX_ACK      0x20
 388 #define VIO_HS_GOT_RDX          0x40
 389 #define VIO_HS_SENT_RDX_ACK     0x80
 390 #define VIO_HS_COMPLETE         (VIO_HS_GOT_RDX_ACK | VIO_HS_SENT_RDX_ACK)
 391
 392         u8                      dev_class;
 393
 394         u8                      dr_state;
 395 #define VIO_DR_STATE_TXREG      0x01
 396 #define VIO_DR_STATE_RXREG      0x02
 397 #define VIO_DR_STATE_TXREQ      0x10
 398 #define VIO_DR_STATE_RXREQ      0x20
 399
 400         u8                      debug;
 401 #define VIO_DEBUG_HS            0x01
 402 #define VIO_DEBUG_DATA          0x02
 403
 404         void                    *desc_buf;
 405         unsigned int            desc_buf_len;
 406
 407         struct vio_completion   *cmp;
 408
 409         struct vio_dev          *vdev;
 410
 411         struct timer_list       timer;
 412
 413         struct vio_version      ver;
 414
 415         struct vio_version      *ver_table;
 416         int                     ver_table_entries;
 417
 418         char                    *name;
 419
 420         struct vio_driver_ops   *ops;
 421 };
 422
 423 static inline bool vio_version_before(struct vio_driver_state *vio,
 424                                       u16 major, u16 minor)
 425 {
 426         u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
 427         u32 want = (u32)major << 16 | minor;
 428
 429         return have < want;
 430 }
 431
 432 static inline bool vio_version_after(struct vio_driver_state *vio,
 433                                       u16 major, u16 minor)
 434 {
 435         u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
 436         u32 want = (u32)major << 16 | minor;
 437
 438         return have > want;
 439 }
 440
 441 static inline bool vio_version_after_eq(struct vio_driver_state *vio,
 442                                         u16 major, u16 minor)
 443 {
 444         u32 have = (u32)vio->ver.major << 16 | vio->ver.minor;
 445         u32 want = (u32)major << 16 | minor;
 446
 447         return have >= want;
 448 }
 449
 450 #define viodbg(TYPE, f, a...) \
 451 do {    if (vio->debug & VIO_DEBUG_##TYPE) \
 452                 printk(KERN_INFO "vio: ID[%lu] " f, \
 453                        vio->vdev->channel_id, ## a); \
 454 } while (0)
 455
 456 int __vio_register_driver(struct vio_driver *drv, struct module *owner,
 457                                  const char *mod_name);
 458 /*
 459  * vio_register_driver must be a macro so that KBUILD_MODNAME can be expanded
 460  */
 461 #define vio_register_driver(driver)             \
 462         __vio_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 463 void vio_unregister_driver(struct vio_driver *drv);
 464
 465 static inline struct vio_driver *to_vio_driver(struct device_driver *drv)
 466 {
 467         return container_of(drv, struct vio_driver, driver);
 468 }
 469
 470 static inline struct vio_dev *to_vio_dev(struct device *dev)
 471 {
 472         return container_of(dev, struct vio_dev, dev);
 473 }
 474
 475 int vio_ldc_send(struct vio_driver_state *vio, void *data, int len);
 476 void vio_link_state_change(struct vio_driver_state *vio, int event);
 477 void vio_conn_reset(struct vio_driver_state *vio);
 478 int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt);
 479 int vio_validate_sid(struct vio_driver_state *vio,
 480                      struct vio_msg_tag *tp);
 481 u32 vio_send_sid(struct vio_driver_state *vio);
 482 int vio_ldc_alloc(struct vio_driver_state *vio,
 483                   struct ldc_channel_config *base_cfg, void *event_arg);
 484 void vio_ldc_free(struct vio_driver_state *vio);
 485 int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
 486                     u8 dev_class, struct vio_version *ver_table,
 487                     int ver_table_size, struct vio_driver_ops *ops,
 488                     char *name);
 489
 490 void vio_port_up(struct vio_driver_state *vio);
 491 int vio_set_intr(unsigned long dev_ino, int state);
 492
 493 #endif /* _SPARC64_VIO_H */