1/* 2 * Wireless USB Host Controller 3 * Common infrastructure for WHCI and HWA WUSB-HC drivers 4 * 5 * 6 * Copyright (C) 2005-2006 Intel Corporation 7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License version 11 * 2 as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 21 * 02110-1301, USA. 22 * 23 * 24 * This driver implements parts common to all Wireless USB Host 25 * Controllers (struct wusbhc, embedding a struct usb_hcd) and is used 26 * by: 27 * 28 * - hwahc: HWA, USB-dongle that implements a Wireless USB host 29 * controller, (Wireless USB 1.0 Host-Wire-Adapter specification). 30 * 31 * - whci: WHCI, a PCI card with a wireless host controller 32 * (Wireless Host Controller Interface 1.0 specification). 33 * 34 * Check out the Design-overview.txt file in the source documentation 35 * for other details on the implementation. 36 * 37 * Main blocks: 38 * 39 * rh Root Hub emulation (part of the HCD glue) 40 * 41 * devconnect Handle all the issues related to device connection, 42 * authentication, disconnection, timeout, reseting, 43 * keepalives, etc. 44 * 45 * mmc MMC IE broadcasting handling 46 * 47 * A host controller driver just initializes its stuff and as part of 48 * that, creates a 'struct wusbhc' instance that handles all the 49 * common WUSB mechanisms. Links in the function ops that are specific 50 * to it and then registers the host controller. Ready to run. 51 */ 52 53#ifndef __WUSBHC_H__ 54#define __WUSBHC_H__ 55 56#include <linux/usb.h> 57#include <linux/list.h> 58#include <linux/mutex.h> 59#include <linux/kref.h> 60#include <linux/workqueue.h> 61#include <linux/usb/hcd.h> 62#include <linux/uwb.h> 63#include <linux/usb/wusb.h> 64 65/* 66 * Time from a WUSB channel stop request to the last transmitted MMC. 67 * 68 * This needs to be > 4.096 ms in case no MMCs can be transmitted in 69 * zone 0. 70 */ 71#define WUSB_CHANNEL_STOP_DELAY_MS 8 72#define WUSB_RETRY_COUNT_MAX 15 73#define WUSB_RETRY_COUNT_INFINITE 0 74 75/** 76 * Wireless USB device 77 * 78 * Describe a WUSB device connected to the cluster. This struct 79 * belongs to the 'struct wusb_port' it is attached to and it is 80 * responsible for putting and clearing the pointer to it. 81 * 82 * Note this "complements" the 'struct usb_device' that the usb_hcd 83 * keeps for each connected USB device. However, it extends some 84 * information that is not available (there is no hcpriv ptr in it!) 85 * *and* most importantly, it's life cycle is different. It is created 86 * as soon as we get a DN_Connect (connect request notification) from 87 * the device through the WUSB host controller; the USB stack doesn't 88 * create the device until we authenticate it. FIXME: this will 89 * change. 90 * 91 * @bos: This is allocated when the BOS descriptors are read from 92 * the device and freed upon the wusb_dev struct dying. 93 * @wusb_cap_descr: points into @bos, and has been verified to be size 94 * safe. 95 */ 96struct wusb_dev { 97 struct kref refcnt; 98 struct wusbhc *wusbhc; 99 struct list_head cack_node; /* Connect-Ack list */ 100 struct list_head rekey_node; /* GTK rekey list */ 101 u8 port_idx; 102 u8 addr; 103 u8 beacon_type:4; 104 struct usb_encryption_descriptor ccm1_etd; 105 struct wusb_ckhdid cdid; 106 unsigned long entry_ts; 107 struct usb_bos_descriptor *bos; 108 struct usb_wireless_cap_descriptor *wusb_cap_descr; 109 struct uwb_mas_bm availability; 110 struct work_struct devconnect_acked_work; 111 struct usb_device *usb_dev; 112}; 113 114#define WUSB_DEV_ADDR_UNAUTH 0x80 115 116static inline void wusb_dev_init(struct wusb_dev *wusb_dev) 117{ 118 kref_init(&wusb_dev->refcnt); 119 /* no need to init the cack_node */ 120} 121 122extern void wusb_dev_destroy(struct kref *_wusb_dev); 123 124static inline struct wusb_dev *wusb_dev_get(struct wusb_dev *wusb_dev) 125{ 126 kref_get(&wusb_dev->refcnt); 127 return wusb_dev; 128} 129 130static inline void wusb_dev_put(struct wusb_dev *wusb_dev) 131{ 132 kref_put(&wusb_dev->refcnt, wusb_dev_destroy); 133} 134 135/** 136 * Wireless USB Host Controller root hub "fake" ports 137 * (state and device information) 138 * 139 * Wireless USB is wireless, so there are no ports; but we 140 * fake'em. Each RC can connect a max of devices at the same time 141 * (given in the Wireless Adapter descriptor, bNumPorts or WHCI's 142 * caps), referred to in wusbhc->ports_max. 143 * 144 * See rh.c for more information. 145 * 146 * The @status and @change use the same bits as in USB2.0[11.24.2.7], 147 * so we don't have to do much when getting the port's status. 148 * 149 * WUSB1.0[7.1], USB2.0[11.24.2.7.1,fig 11-10], 150 * include/linux/usb_ch9.h (#define USB_PORT_STAT_*) 151 */ 152struct wusb_port { 153 u16 status; 154 u16 change; 155 struct wusb_dev *wusb_dev; /* connected device's info */ 156 u32 ptk_tkid; 157}; 158 159/** 160 * WUSB Host Controller specifics 161 * 162 * All fields that are common to all Wireless USB controller types 163 * (HWA and WHCI) are grouped here. Host Controller 164 * functions/operations that only deal with general Wireless USB HC 165 * issues use this data type to refer to the host. 166 * 167 * @usb_hcd Instantiation of a USB host controller 168 * (initialized by upper layer [HWA=HC or WHCI]. 169 * 170 * @dev Device that implements this; initialized by the 171 * upper layer (HWA-HC, WHCI...); this device should 172 * have a refcount. 173 * 174 * @trust_timeout After this time without hearing for device 175 * activity, we consider the device gone and we have to 176 * re-authenticate. 177 * 178 * Can be accessed w/o locking--however, read to a 179 * local variable then use. 180 * 181 * @chid WUSB Cluster Host ID: this is supposed to be a 182 * unique value that doesn't change across reboots (so 183 * that your devices do not require re-association). 184 * 185 * Read/Write protected by @mutex 186 * 187 * @dev_info This array has ports_max elements. It is used to 188 * give the HC information about the WUSB devices (see 189 * 'struct wusb_dev_info'). 190 * 191 * For HWA we need to allocate it in heap; for WHCI it 192 * needs to be permanently mapped, so we keep it for 193 * both and make it easy. Call wusbhc->dev_info_set() 194 * to update an entry. 195 * 196 * @ports_max Number of simultaneous device connections (fake 197 * ports) this HC will take. Read-only. 198 * 199 * @port Array of port status for each fake root port. Guaranteed to 200 * always be the same length during device existence 201 * [this allows for some unlocked but referenced reading]. 202 * 203 * @mmcies_max Max number of Information Elements this HC can send 204 * in its MMC. Read-only. 205 * 206 * @start Start the WUSB channel. 207 * 208 * @stop Stop the WUSB channel after the specified number of 209 * milliseconds. Channel Stop IEs should be transmitted 210 * as required by [WUSB] 4.16.2.1. 211 * 212 * @mmcie_add HC specific operation (WHCI or HWA) for adding an 213 * MMCIE. 214 * 215 * @mmcie_rm HC specific operation (WHCI or HWA) for removing an 216 * MMCIE. 217 * 218 * @set_ptk: Set the PTK and enable encryption for a device. Or, if 219 * the supplied key is NULL, disable encryption for that 220 * device. 221 * 222 * @set_gtk: Set the GTK to be used for all future broadcast packets 223 * (i.e., MMCs). With some hardware, setting the GTK may start 224 * MMC transmission. 225 * 226 * NOTE: 227 * 228 * - If wusb_dev->usb_dev is not NULL, then usb_dev is valid 229 * (wusb_dev has a refcount on it). Likewise, if usb_dev->wusb_dev 230 * is not NULL, usb_dev->wusb_dev is valid (usb_dev keeps a 231 * refcount on it). 232 * 233 * Most of the times when you need to use it, it will be non-NULL, 234 * so there is no real need to check for it (wusb_dev will 235 * disappear before usb_dev). 236 * 237 * - The following fields need to be filled out before calling 238 * wusbhc_create(): ports_max, mmcies_max, mmcie_{add,rm}. 239 * 240 * - there is no wusbhc_init() method, we do everything in 241 * wusbhc_create(). 242 * 243 * - Creation is done in two phases, wusbhc_create() and 244 * wusbhc_create_b(); b are the parts that need to be called after 245 * calling usb_hcd_add(&wusbhc->usb_hcd). 246 */ 247struct wusbhc { 248 struct usb_hcd usb_hcd; /* HAS TO BE 1st */ 249 struct device *dev; 250 struct uwb_rc *uwb_rc; 251 struct uwb_pal pal; 252 253 unsigned trust_timeout; /* in jiffies */ 254 struct wusb_ckhdid chid; 255 uint8_t phy_rate; 256 uint8_t dnts_num_slots; 257 uint8_t dnts_interval; 258 uint8_t retry_count; 259 struct wuie_host_info *wuie_host_info; 260 261 struct mutex mutex; /* locks everything else */ 262 u16 cluster_id; /* Wireless USB Cluster ID */ 263 struct wusb_port *port; /* Fake port status handling */ 264 struct wusb_dev_info *dev_info; /* for Set Device Info mgmt */ 265 u8 ports_max; 266 unsigned active:1; /* currently xmit'ing MMCs */ 267 struct wuie_keep_alive keep_alive_ie; /* protected by mutex */ 268 struct delayed_work keep_alive_timer; 269 struct list_head cack_list; /* Connect acknowledging */ 270 size_t cack_count; /* protected by 'mutex' */ 271 struct wuie_connect_ack cack_ie; 272 struct uwb_rsv *rsv; /* cluster bandwidth reservation */ 273 274 struct mutex mmcie_mutex; /* MMC WUIE handling */ 275 struct wuie_hdr **mmcie; /* WUIE array */ 276 u8 mmcies_max; 277 /* FIXME: make wusbhc_ops? */ 278 int (*start)(struct wusbhc *wusbhc); 279 void (*stop)(struct wusbhc *wusbhc, int delay); 280 int (*mmcie_add)(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt, 281 u8 handle, struct wuie_hdr *wuie); 282 int (*mmcie_rm)(struct wusbhc *wusbhc, u8 handle); 283 int (*dev_info_set)(struct wusbhc *, struct wusb_dev *wusb_dev); 284 int (*bwa_set)(struct wusbhc *wusbhc, s8 stream_index, 285 const struct uwb_mas_bm *); 286 int (*set_ptk)(struct wusbhc *wusbhc, u8 port_idx, 287 u32 tkid, const void *key, size_t key_size); 288 int (*set_gtk)(struct wusbhc *wusbhc, 289 u32 tkid, const void *key, size_t key_size); 290 int (*set_num_dnts)(struct wusbhc *wusbhc, u8 interval, u8 slots); 291 292 struct { 293 struct usb_key_descriptor descr; 294 u8 data[16]; /* GTK key data */ 295 } __attribute__((packed)) gtk; 296 u8 gtk_index; 297 u32 gtk_tkid; 298 299 /* workqueue for WUSB security related tasks. */ 300 struct workqueue_struct *wq_security; 301 struct work_struct gtk_rekey_work; 302 303 struct usb_encryption_descriptor *ccm1_etd; 304}; 305 306#define usb_hcd_to_wusbhc(u) container_of((u), struct wusbhc, usb_hcd) 307 308 309extern int wusbhc_create(struct wusbhc *); 310extern int wusbhc_b_create(struct wusbhc *); 311extern void wusbhc_b_destroy(struct wusbhc *); 312extern void wusbhc_destroy(struct wusbhc *); 313extern int wusb_dev_sysfs_add(struct wusbhc *, struct usb_device *, 314 struct wusb_dev *); 315extern void wusb_dev_sysfs_rm(struct wusb_dev *); 316extern int wusbhc_sec_create(struct wusbhc *); 317extern int wusbhc_sec_start(struct wusbhc *); 318extern void wusbhc_sec_stop(struct wusbhc *); 319extern void wusbhc_sec_destroy(struct wusbhc *); 320extern void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb, 321 int status); 322void wusbhc_reset_all(struct wusbhc *wusbhc); 323 324int wusbhc_pal_register(struct wusbhc *wusbhc); 325void wusbhc_pal_unregister(struct wusbhc *wusbhc); 326 327/* 328 * Return @usb_dev's @usb_hcd (properly referenced) or NULL if gone 329 * 330 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr) 331 * 332 * This is a safe assumption as @usb_dev->bus is referenced all the 333 * time during the @usb_dev life cycle. 334 */ 335static inline 336struct usb_hcd *usb_hcd_get_by_usb_dev(struct usb_device *usb_dev) 337{ 338 struct usb_hcd *usb_hcd; 339 usb_hcd = container_of(usb_dev->bus, struct usb_hcd, self); 340 return usb_get_hcd(usb_hcd); 341} 342 343/* 344 * Increment the reference count on a wusbhc. 345 * 346 * @wusbhc's life cycle is identical to that of the underlying usb_hcd. 347 */ 348static inline struct wusbhc *wusbhc_get(struct wusbhc *wusbhc) 349{ 350 return usb_get_hcd(&wusbhc->usb_hcd) ? wusbhc : NULL; 351} 352 353/* 354 * Return the wusbhc associated to a @usb_dev 355 * 356 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr) 357 * 358 * @returns: wusbhc for @usb_dev; NULL if the @usb_dev is being torn down. 359 * WARNING: referenced at the usb_hcd level, unlocked 360 * 361 * FIXME: move offline 362 */ 363static inline struct wusbhc *wusbhc_get_by_usb_dev(struct usb_device *usb_dev) 364{ 365 struct wusbhc *wusbhc = NULL; 366 struct usb_hcd *usb_hcd; 367 if (usb_dev->devnum > 1 && !usb_dev->wusb) { 368 /* but root hubs */ 369 dev_err(&usb_dev->dev, "devnum %d wusb %d\n", usb_dev->devnum, 370 usb_dev->wusb); 371 BUG_ON(usb_dev->devnum > 1 && !usb_dev->wusb); 372 } 373 usb_hcd = usb_hcd_get_by_usb_dev(usb_dev); 374 if (usb_hcd == NULL) 375 return NULL; 376 BUG_ON(usb_hcd->wireless == 0); 377 return wusbhc = usb_hcd_to_wusbhc(usb_hcd); 378} 379 380 381static inline void wusbhc_put(struct wusbhc *wusbhc) 382{ 383 usb_put_hcd(&wusbhc->usb_hcd); 384} 385 386int wusbhc_start(struct wusbhc *wusbhc); 387void wusbhc_stop(struct wusbhc *wusbhc); 388extern int wusbhc_chid_set(struct wusbhc *, const struct wusb_ckhdid *); 389 390/* Device connect handling */ 391extern int wusbhc_devconnect_create(struct wusbhc *); 392extern void wusbhc_devconnect_destroy(struct wusbhc *); 393extern int wusbhc_devconnect_start(struct wusbhc *wusbhc); 394extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc); 395extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr, 396 struct wusb_dn_hdr *dn_hdr, size_t size); 397extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port); 398extern int wusb_usb_ncb(struct notifier_block *nb, unsigned long val, 399 void *priv); 400extern int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev, 401 u8 addr); 402 403/* Wireless USB fake Root Hub methods */ 404extern int wusbhc_rh_create(struct wusbhc *); 405extern void wusbhc_rh_destroy(struct wusbhc *); 406 407extern int wusbhc_rh_status_data(struct usb_hcd *, char *); 408extern int wusbhc_rh_control(struct usb_hcd *, u16, u16, u16, char *, u16); 409extern int wusbhc_rh_start_port_reset(struct usb_hcd *, unsigned); 410 411/* MMC handling */ 412extern int wusbhc_mmcie_create(struct wusbhc *); 413extern void wusbhc_mmcie_destroy(struct wusbhc *); 414extern int wusbhc_mmcie_set(struct wusbhc *, u8 interval, u8 repeat_cnt, 415 struct wuie_hdr *); 416extern void wusbhc_mmcie_rm(struct wusbhc *, struct wuie_hdr *); 417 418/* Bandwidth reservation */ 419int wusbhc_rsv_establish(struct wusbhc *wusbhc); 420void wusbhc_rsv_terminate(struct wusbhc *wusbhc); 421 422/* 423 * I've always said 424 * I wanted a wedding in a church... 425 * 426 * but lately I've been thinking about 427 * the Botanical Gardens. 428 * 429 * We could do it by the tulips. 430 * It'll be beautiful 431 * 432 * --Security! 433 */ 434extern int wusb_dev_sec_add(struct wusbhc *, struct usb_device *, 435 struct wusb_dev *); 436extern void wusb_dev_sec_rm(struct wusb_dev *) ; 437extern int wusb_dev_4way_handshake(struct wusbhc *, struct wusb_dev *, 438 struct wusb_ckhdid *ck); 439void wusbhc_gtk_rekey(struct wusbhc *wusbhc); 440int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev); 441 442 443/* WUSB Cluster ID handling */ 444extern u8 wusb_cluster_id_get(void); 445extern void wusb_cluster_id_put(u8); 446 447/* 448 * wusb_port_by_idx - return the port associated to a zero-based port index 449 * 450 * NOTE: valid without locking as long as wusbhc is referenced (as the 451 * number of ports doesn't change). The data pointed to has to 452 * be verified though :) 453 */ 454static inline struct wusb_port *wusb_port_by_idx(struct wusbhc *wusbhc, 455 u8 port_idx) 456{ 457 return &wusbhc->port[port_idx]; 458} 459 460/* 461 * wusb_port_no_to_idx - Convert port number (per usb_dev->portnum) to 462 * a port_idx. 463 * 464 * USB stack USB ports are 1 based!! 465 * 466 * NOTE: only valid for WUSB devices!!! 467 */ 468static inline u8 wusb_port_no_to_idx(u8 port_no) 469{ 470 return port_no - 1; 471} 472 473extern struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *, 474 struct usb_device *); 475 476/* 477 * Return a referenced wusb_dev given a @usb_dev 478 * 479 * Returns NULL if the usb_dev is being torn down. 480 * 481 * FIXME: move offline 482 */ 483static inline 484struct wusb_dev *wusb_dev_get_by_usb_dev(struct usb_device *usb_dev) 485{ 486 struct wusbhc *wusbhc; 487 struct wusb_dev *wusb_dev; 488 wusbhc = wusbhc_get_by_usb_dev(usb_dev); 489 if (wusbhc == NULL) 490 return NULL; 491 mutex_lock(&wusbhc->mutex); 492 wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev); 493 mutex_unlock(&wusbhc->mutex); 494 wusbhc_put(wusbhc); 495 return wusb_dev; 496} 497 498/* Misc */ 499 500extern struct workqueue_struct *wusbd; 501#endif /* #ifndef __WUSBHC_H__ */ 502